114 lines
2.9 KiB
Go
114 lines
2.9 KiB
Go
package pump_parser
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/gagliardetto/solana-go"
|
|
"github.com/shopspring/decimal"
|
|
)
|
|
|
|
var swapPrograms = map[solana.PublicKey]swapParser{
|
|
pumpAmmProgram: pumpAmmParser,
|
|
pumpProgram: pumpParser,
|
|
}
|
|
|
|
var actionPrograms = map[solana.PublicKey]actionParser{
|
|
systemProgram: systemParser,
|
|
budgGetProgram: budgetParser,
|
|
}
|
|
|
|
func ParseRawTx(rawTx *RawTx) (*Tx, error) {
|
|
tx := &Tx{
|
|
rawTx: rawTx,
|
|
}
|
|
err := tx.Parser()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return tx, nil
|
|
}
|
|
|
|
func (tx *Tx) Parser() error {
|
|
if tx.rawTx == nil {
|
|
return errors.New("rawTx is nil")
|
|
}
|
|
accountList := tx.rawTx.getAccountList()
|
|
|
|
tx.TxHash = (*[64]byte)((tx.rawTx.Transaction.Signatures[0][:]))
|
|
tx.Signer = tx.rawTx.GetSigner()
|
|
tx.Block = tx.rawTx.Slot
|
|
tx.BlockIndex = uint64(tx.rawTx.IndexWithinBlock)
|
|
tx.BlockAt = tx.rawTx.BlockTime
|
|
|
|
tx.BeforeSolBalance = decimal.NewFromUint64(tx.rawTx.Meta.PreBalances[0]).Div(decimal.NewFromInt(1e9))
|
|
tx.AfterSOLBalance = decimal.NewFromUint64(tx.rawTx.Meta.PostBalances[0]).Div(decimal.NewFromInt(1e9))
|
|
|
|
tx.Token = make(map[solana.PublicKey]TokenMeta)
|
|
|
|
var innersMap = make(map[int]InnerInstructions)
|
|
for _, inner := range tx.rawTx.Meta.InnerInstructions {
|
|
innersMap[inner.Index] = inner
|
|
}
|
|
for i, instr := range tx.rawTx.Transaction.Message.Instructions {
|
|
programAccount := accountList[instr.ProgramIDIndex]
|
|
if p, exists := swapPrograms[programAccount]; exists {
|
|
swaps, _, err := p(tx, instr, innersMap[i], [2]uint{uint(i), uint(0)})
|
|
if err != nil {
|
|
if errors.Is(err, InstructionIgnoredError) {
|
|
continue
|
|
}
|
|
return err
|
|
}
|
|
tx.Swaps = append(tx.Swaps, swaps...)
|
|
} else if p, exists := actionPrograms[programAccount]; exists {
|
|
_, err := p(tx, instr, innersMap[i], [2]uint{uint(i), uint(0)})
|
|
if err != nil {
|
|
if errors.Is(err, InstructionIgnoredError) {
|
|
continue
|
|
}
|
|
return err
|
|
}
|
|
} else {
|
|
ii := i
|
|
// unknown program, parser inner instructions
|
|
innerLength := len(innersMap[i].Instructions)
|
|
for j := 1; j <= innerLength; {
|
|
innerInstr := innersMap[i].Instructions[j-1]
|
|
innerProgramAccount := accountList[innerInstr.ProgramIDIndex]
|
|
|
|
if p, exists := swapPrograms[innerProgramAccount]; exists {
|
|
swaps, offset, err := p(tx, innerInstr, innersMap[i], [2]uint{uint(i), uint(j)})
|
|
if err != nil {
|
|
if errors.Is(err, InstructionIgnoredError) {
|
|
j = int(offset[1])
|
|
continue
|
|
}
|
|
return err
|
|
}
|
|
tx.Swaps = append(tx.Swaps, swaps...)
|
|
j = int(offset[1])
|
|
ii = int(offset[0])
|
|
} else if p, exists := actionPrograms[innerProgramAccount]; exists {
|
|
offset, err := p(tx, innerInstr, innersMap[i], [2]uint{uint(i), uint(j)})
|
|
if err != nil {
|
|
if errors.Is(err, InstructionIgnoredError) {
|
|
j = int(offset[1])
|
|
continue
|
|
}
|
|
return err
|
|
}
|
|
j = int(offset[1])
|
|
ii = int(offset[0])
|
|
} else {
|
|
j++
|
|
}
|
|
if j > innerLength || ii > i {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|