498 lines
20 KiB
Go
498 lines
20 KiB
Go
package pump_parser
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/shopspring/decimal"
|
|
)
|
|
|
|
func raydiumV4Parser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
|
|
if !tx.rawTx.accountList[instruction.ProgramIDIndex].Equals(raydiumV4Program) {
|
|
return nil, increaseOffset(offset), fmt.Errorf("raydiumv4 instruction not found, offset, %d, %d", offset[0], offset[1])
|
|
}
|
|
|
|
decode := instruction.Data
|
|
if len(decode) < 1 {
|
|
return nil, increaseOffset(offset), fmt.Errorf("raydiumv4 program instruction data too short, offset, %d, %d", offset[0], offset[1])
|
|
}
|
|
|
|
discriminator := decode[0]
|
|
|
|
switch discriminator {
|
|
case raydiumV4InitializePoolDiscriminator:
|
|
return raydiumv4InitializeParser(tx, instruction, innerInstructions, offset)
|
|
case raydiumV4AddLiquidityDiscriminator:
|
|
return raydiumv4AddLiquidityParser(tx, instruction, innerInstructions, offset)
|
|
case raydiumV4RemoveLiquidityDiscriminator:
|
|
return raydiumv4RemoveLiquidityParser(tx, instruction, innerInstructions, offset)
|
|
case raydiumV4WithdrawPNLDiscriminator:
|
|
return raydiumv4WithdrawPNLParser(tx, instruction, innerInstructions, offset)
|
|
case raydiumV4SwapBaseInDiscriminator, raydiumV4SwapBaseOutDiscriminator:
|
|
return raydiumv4SwapParser(tx, instruction, innerInstructions, offset)
|
|
case raydiumV4SwapBaseInV2Discriminator, raydiumV4SwapBaseOutV2Discriminator:
|
|
return raydiumv4SwapV2Parser(tx, instruction, innerInstructions, offset)
|
|
|
|
default:
|
|
return nil, increaseOffset(offset), InstructionIgnoredError
|
|
}
|
|
}
|
|
|
|
func raydiumv4InitializeParser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
|
|
accountsLen := len(instruction.Accounts)
|
|
if accountsLen != 21 {
|
|
return nil, increaseOffset(offset), fmt.Errorf("invalid number of accounts for raydiumv4 initialize instruction, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
var entryContract = tx.rawTx.accountList[tx.rawTx.Transaction.Message.Instructions[offset[0]].ProgramIDIndex]
|
|
//who := tx.rawTx.accountList[instruction.Accounts[accountsLen-1]]
|
|
user := tx.rawTx.accountList[instruction.Accounts[accountsLen-4]]
|
|
baseVaultIdx := instruction.Accounts[10]
|
|
quoteVaultIdx := instruction.Accounts[11]
|
|
|
|
baseTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, baseVaultIdx)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get base vault balance after tx: %v", err)
|
|
}
|
|
quoteTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, quoteVaultIdx)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get quote vault balance after tx: %v", err)
|
|
}
|
|
baseReserve, _ := decimal.NewFromString(baseTokenbalance.UITokenAmount.Amount)
|
|
quoteReserve, _ := decimal.NewFromString(quoteTokenbalance.UITokenAmount.Amount)
|
|
offset[1] += 30
|
|
return []Swap{
|
|
{
|
|
Program: SolProgramRaydiumV4,
|
|
Event: "create",
|
|
Pool: tx.rawTx.accountList[instruction.Accounts[4]],
|
|
BaseMint: baseTokenbalance.MintAccount,
|
|
QuoteMint: quoteTokenbalance.MintAccount,
|
|
BaseTokenProgram: baseTokenbalance.ProgramIDAccount,
|
|
QuoteTokenProgram: quoteTokenbalance.ProgramIDAccount,
|
|
Creator: user,
|
|
BaseMintDecimals: uint8(baseTokenbalance.UITokenAmount.Decimals),
|
|
QuoteMintDecimals: uint8(quoteTokenbalance.UITokenAmount.Decimals),
|
|
User: user,
|
|
BaseReserve: baseReserve,
|
|
QuoteReserve: quoteReserve,
|
|
EntryContract: entryContract,
|
|
},
|
|
}, offset, nil
|
|
}
|
|
|
|
func raydiumv4AddLiquidityParser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
|
|
accountsLen := len(instruction.Accounts)
|
|
if accountsLen != 14 && accountsLen != 15 {
|
|
return nil, increaseOffset(offset), fmt.Errorf("invalid number of accounts for raydiumv4 add liquidity instruction, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
var entryContract = tx.rawTx.accountList[tx.rawTx.Transaction.Message.Instructions[offset[0]].ProgramIDIndex]
|
|
|
|
baseVaultAccountIndex := instruction.Accounts[6]
|
|
quoteVaultAccountIndex := instruction.Accounts[7]
|
|
|
|
userBaseVaultAccountIndex := instruction.Accounts[9]
|
|
userQuoteVaultAccountIndex := instruction.Accounts[10]
|
|
|
|
baseTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, baseVaultAccountIndex)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get base vault balance after tx: %v", err)
|
|
}
|
|
quoteTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, quoteVaultAccountIndex)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get quote vault balance after tx: %v", err)
|
|
}
|
|
inners, err := getInnerInstructions(innerInstructions, offset[1])
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), err
|
|
}
|
|
var nextIndex int
|
|
var baseFound, quoteFound bool
|
|
var baseAmount, quoteAmount decimal.Decimal
|
|
for i, inner := range inners {
|
|
from, to, amount, err := parseTokenTransfer(tx.rawTx, inner)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if from.Equals(tx.rawTx.accountList[userBaseVaultAccountIndex]) && to.Equals(tx.rawTx.accountList[baseVaultAccountIndex]) && !baseFound {
|
|
baseAmount = decimal.NewFromUint64(amount)
|
|
baseFound = true
|
|
} else if from.Equals(tx.rawTx.accountList[userQuoteVaultAccountIndex]) && to.Equals(tx.rawTx.accountList[quoteVaultAccountIndex]) && !quoteFound {
|
|
quoteAmount = decimal.NewFromUint64(amount)
|
|
quoteFound = true
|
|
}
|
|
if baseFound && quoteFound {
|
|
nextIndex = i + 1
|
|
break
|
|
}
|
|
}
|
|
if !baseFound || !quoteFound {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to find token transfer inner instruction for add liquidity, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
offset[1] += uint(nextIndex + 1)
|
|
baseReserve, _ := decimal.NewFromString(baseTokenbalance.UITokenAmount.Amount)
|
|
quoteReserve, _ := decimal.NewFromString(quoteTokenbalance.UITokenAmount.Amount)
|
|
return []Swap{
|
|
{
|
|
Program: SolProgramRaydiumV4,
|
|
Event: "remove_liquidity",
|
|
Pool: tx.rawTx.accountList[instruction.Accounts[1]],
|
|
BaseMint: baseTokenbalance.MintAccount,
|
|
QuoteMint: quoteTokenbalance.MintAccount,
|
|
BaseTokenProgram: baseTokenbalance.ProgramIDAccount,
|
|
QuoteTokenProgram: quoteTokenbalance.ProgramIDAccount,
|
|
User: tx.rawTx.accountList[instruction.Accounts[12]],
|
|
BaseMintDecimals: uint8(baseTokenbalance.UITokenAmount.Decimals),
|
|
QuoteMintDecimals: uint8(quoteTokenbalance.UITokenAmount.Decimals),
|
|
BaseReserve: baseReserve,
|
|
QuoteReserve: quoteReserve,
|
|
BaseAmount: baseAmount,
|
|
QuoteAmount: quoteAmount,
|
|
EntryContract: entryContract,
|
|
},
|
|
}, offset, nil
|
|
}
|
|
|
|
func raydiumv4RemoveLiquidityParser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
|
|
accountsLen := len(instruction.Accounts)
|
|
const AccountLen = 20
|
|
if accountsLen != AccountLen && accountsLen != AccountLen+1 && accountsLen != AccountLen+2 && accountsLen != AccountLen+3 {
|
|
return nil, increaseOffset(offset), fmt.Errorf("invalid number of accounts for raydiumv4 add liquidity instruction, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
var entryContract = tx.rawTx.accountList[tx.rawTx.Transaction.Message.Instructions[offset[0]].ProgramIDIndex]
|
|
baseVaultAccountIndex := instruction.Accounts[6]
|
|
quoteVaultAccountIndex := instruction.Accounts[7]
|
|
userBaseVaultAccountIndex := instruction.Accounts[14]
|
|
userQuoteVaultAccountIndex := instruction.Accounts[16]
|
|
|
|
if accountsLen == AccountLen+2 || accountsLen == AccountLen+3 {
|
|
userBaseVaultAccountIndex = instruction.Accounts[16]
|
|
userQuoteVaultAccountIndex = instruction.Accounts[17]
|
|
}
|
|
|
|
baseTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, baseVaultAccountIndex)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get base vault balance after tx: %v", err)
|
|
}
|
|
quoteTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, quoteVaultAccountIndex)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get quote vault balance after tx: %v", err)
|
|
}
|
|
inners, err := getInnerInstructions(innerInstructions, offset[1])
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), err
|
|
}
|
|
var nextIndex int
|
|
var baseFound, quoteFound bool
|
|
var baseAmount, quoteAmount decimal.Decimal
|
|
for i, inner := range inners {
|
|
from, to, amount, err := parseTokenTransfer(tx.rawTx, inner)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if to.Equals(tx.rawTx.accountList[userBaseVaultAccountIndex]) && from.Equals(tx.rawTx.accountList[baseVaultAccountIndex]) && !baseFound {
|
|
baseAmount = decimal.NewFromUint64(amount)
|
|
baseFound = true
|
|
} else if to.Equals(tx.rawTx.accountList[userQuoteVaultAccountIndex]) && from.Equals(tx.rawTx.accountList[quoteVaultAccountIndex]) && !quoteFound {
|
|
quoteAmount = decimal.NewFromUint64(amount)
|
|
quoteFound = true
|
|
}
|
|
if baseFound && quoteFound {
|
|
nextIndex = i + 1
|
|
break
|
|
}
|
|
}
|
|
if !baseFound || !quoteFound {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to find token transfer inner instruction for add liquidity, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
offset[1] += uint(nextIndex + 1)
|
|
baseReserve, _ := decimal.NewFromString(baseTokenbalance.UITokenAmount.Amount)
|
|
quoteReserve, _ := decimal.NewFromString(quoteTokenbalance.UITokenAmount.Amount)
|
|
return []Swap{
|
|
{
|
|
Program: SolProgramRaydiumV4,
|
|
Event: "remove_liquidity",
|
|
Pool: tx.rawTx.accountList[instruction.Accounts[1]],
|
|
BaseMint: baseTokenbalance.MintAccount,
|
|
QuoteMint: quoteTokenbalance.MintAccount,
|
|
BaseTokenProgram: baseTokenbalance.ProgramIDAccount,
|
|
QuoteTokenProgram: quoteTokenbalance.ProgramIDAccount,
|
|
User: tx.rawTx.accountList[0],
|
|
BaseMintDecimals: uint8(baseTokenbalance.UITokenAmount.Decimals),
|
|
QuoteMintDecimals: uint8(quoteTokenbalance.UITokenAmount.Decimals),
|
|
BaseReserve: baseReserve,
|
|
QuoteReserve: quoteReserve,
|
|
BaseAmount: baseAmount,
|
|
QuoteAmount: quoteAmount,
|
|
EntryContract: entryContract,
|
|
},
|
|
}, offset, nil
|
|
}
|
|
|
|
func raydiumv4WithdrawPNLParser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
|
|
accountsLen := len(instruction.Accounts)
|
|
if accountsLen != 17 && accountsLen != 18 {
|
|
return nil, increaseOffset(offset), fmt.Errorf("invalid number of accounts for raydiumv4 WithdrawPNL instruction, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
var entryContract = tx.rawTx.accountList[tx.rawTx.Transaction.Message.Instructions[offset[0]].ProgramIDIndex]
|
|
|
|
baseVaultAccountIndex := instruction.Accounts[5]
|
|
quoteVaultAccountIndex := instruction.Accounts[6]
|
|
userBaseVaultAccountIndex := instruction.Accounts[7]
|
|
userQuoteVaultAccountIndex := instruction.Accounts[8]
|
|
|
|
baseTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, baseVaultAccountIndex)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get base vault balance after tx: %v", err)
|
|
}
|
|
quoteTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, quoteVaultAccountIndex)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get quote vault balance after tx: %v", err)
|
|
}
|
|
inners, err := getInnerInstructions(innerInstructions, offset[1])
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), err
|
|
}
|
|
var nextIndex int
|
|
var baseFound, quoteFound bool
|
|
var baseAmount, quoteAmount decimal.Decimal
|
|
for i, inner := range inners {
|
|
from, to, amount, err := parseTokenTransfer(tx.rawTx, inner)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if to.Equals(tx.rawTx.accountList[userBaseVaultAccountIndex]) && from.Equals(tx.rawTx.accountList[baseVaultAccountIndex]) && !baseFound {
|
|
baseAmount = decimal.NewFromUint64(amount)
|
|
baseFound = true
|
|
} else if to.Equals(tx.rawTx.accountList[userQuoteVaultAccountIndex]) && from.Equals(tx.rawTx.accountList[quoteVaultAccountIndex]) && !quoteFound {
|
|
quoteAmount = decimal.NewFromUint64(amount)
|
|
quoteFound = true
|
|
}
|
|
if baseFound && quoteFound {
|
|
nextIndex = i + 1
|
|
break
|
|
}
|
|
}
|
|
if !baseFound || !quoteFound {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to find token transfer inner instruction for with pnl, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
offset[1] += uint(nextIndex + 1)
|
|
|
|
baseReserve, _ := decimal.NewFromString(baseTokenbalance.UITokenAmount.Amount)
|
|
quoteReserve, _ := decimal.NewFromString(quoteTokenbalance.UITokenAmount.Amount)
|
|
return []Swap{
|
|
{
|
|
Program: SolProgramRaydiumV4,
|
|
Event: "remove_liquidity",
|
|
Pool: tx.rawTx.accountList[instruction.Accounts[1]],
|
|
BaseMint: baseTokenbalance.MintAccount,
|
|
QuoteMint: quoteTokenbalance.MintAccount,
|
|
BaseTokenProgram: baseTokenbalance.ProgramIDAccount,
|
|
QuoteTokenProgram: quoteTokenbalance.ProgramIDAccount,
|
|
User: tx.rawTx.accountList[instruction.Accounts[9]],
|
|
BaseMintDecimals: uint8(baseTokenbalance.UITokenAmount.Decimals),
|
|
QuoteMintDecimals: uint8(quoteTokenbalance.UITokenAmount.Decimals),
|
|
BaseReserve: baseReserve,
|
|
QuoteReserve: quoteReserve,
|
|
BaseAmount: baseAmount,
|
|
QuoteAmount: quoteAmount,
|
|
EntryContract: entryContract,
|
|
},
|
|
}, offset, nil
|
|
}
|
|
|
|
func raydiumv4SwapParser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
|
|
accountsLen := len(instruction.Accounts)
|
|
if accountsLen != 17 && accountsLen != 18 {
|
|
return nil, increaseOffset(offset), fmt.Errorf("invalid number of accounts for raydiumv4 swap instruction, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
user := tx.rawTx.accountList[instruction.Accounts[accountsLen-1]]
|
|
userSrcIdx := instruction.Accounts[accountsLen-3]
|
|
userDestIdx := instruction.Accounts[accountsLen-2]
|
|
vaultBaseIdx := instruction.Accounts[4]
|
|
vaultQuoteIdx := instruction.Accounts[5]
|
|
if accountsLen == 18 {
|
|
vaultBaseIdx = instruction.Accounts[5]
|
|
vaultQuoteIdx = instruction.Accounts[6]
|
|
}
|
|
var entryContract = tx.rawTx.accountList[tx.rawTx.Transaction.Message.Instructions[offset[0]].ProgramIDIndex]
|
|
|
|
ammAccount := tx.rawTx.accountList[instruction.Accounts[1]]
|
|
|
|
userSourceTokenAccount := tx.rawTx.accountList[userSrcIdx]
|
|
userDestinationTokenAccount := tx.rawTx.accountList[userDestIdx]
|
|
baseTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, vaultBaseIdx)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get base vault balance after tx: %v", err)
|
|
}
|
|
quoteTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, vaultQuoteIdx)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get quote vault balance after tx: %v", err)
|
|
}
|
|
inners, err := getInnerInstructions(innerInstructions, offset[1])
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), err
|
|
}
|
|
var nextIndex int
|
|
var srcFound, destFound bool
|
|
var baseAmount, quoteAmount decimal.Decimal
|
|
var event string
|
|
for i, inner := range inners {
|
|
from, to, amount, err := parseTokenTransfer(tx.rawTx, inner)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if from.Equals(userSourceTokenAccount) && !srcFound {
|
|
if to.Equals(tx.rawTx.accountList[vaultBaseIdx]) {
|
|
event = "sell"
|
|
baseAmount = decimal.NewFromUint64(amount)
|
|
srcFound = true
|
|
} else if to.Equals(tx.rawTx.accountList[vaultQuoteIdx]) {
|
|
event = "buy"
|
|
quoteAmount = decimal.NewFromUint64(amount)
|
|
srcFound = true
|
|
}
|
|
} else if to.Equals(userDestinationTokenAccount) && !destFound {
|
|
if from.Equals(tx.rawTx.accountList[vaultQuoteIdx]) {
|
|
event = "sell"
|
|
quoteAmount = decimal.NewFromUint64(amount)
|
|
destFound = true
|
|
} else if from.Equals(tx.rawTx.accountList[vaultBaseIdx]) {
|
|
event = "buy"
|
|
baseAmount = decimal.NewFromUint64(amount)
|
|
destFound = true
|
|
}
|
|
|
|
}
|
|
if srcFound && destFound {
|
|
nextIndex = i + 1
|
|
break
|
|
}
|
|
}
|
|
if !srcFound || !destFound {
|
|
return nil, increaseOffset(offset), fmt.Errorf("raydiumv4 failed to find token transfer inner instruction for swap, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
offset[1] += uint(nextIndex + 1)
|
|
userBase := getAccountBalanceAfterTx(tx.rawTx, userSrcIdx)
|
|
userQuote := getAccountBalanceAfterTx(tx.rawTx, userDestIdx)
|
|
baseReserve, _ := decimal.NewFromString(baseTokenbalance.UITokenAmount.Amount)
|
|
quoteReserve, _ := decimal.NewFromString(quoteTokenbalance.UITokenAmount.Amount)
|
|
|
|
return []Swap{
|
|
{
|
|
Program: SolProgramRaydiumV4,
|
|
Event: event,
|
|
Pool: ammAccount,
|
|
BaseMint: baseTokenbalance.MintAccount,
|
|
QuoteMint: quoteTokenbalance.MintAccount,
|
|
BaseTokenProgram: baseTokenbalance.ProgramIDAccount,
|
|
QuoteTokenProgram: quoteTokenbalance.ProgramIDAccount,
|
|
BaseMintDecimals: uint8(baseTokenbalance.UITokenAmount.Decimals),
|
|
QuoteMintDecimals: uint8(quoteTokenbalance.UITokenAmount.Decimals),
|
|
User: user,
|
|
BaseAmount: baseAmount,
|
|
QuoteAmount: quoteAmount,
|
|
BaseReserve: baseReserve,
|
|
QuoteReserve: quoteReserve,
|
|
Mayhem: false,
|
|
UserBaseBalance: userBase,
|
|
UserQuoteBalance: userQuote,
|
|
EntryContract: entryContract,
|
|
},
|
|
}, offset, nil
|
|
}
|
|
|
|
func raydiumv4SwapV2Parser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
|
|
accountsLen := len(instruction.Accounts)
|
|
if accountsLen != 8 {
|
|
return nil, increaseOffset(offset), fmt.Errorf("invalid number of accounts for raydiumv4 swapv2 instruction, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
var entryContract = tx.rawTx.accountList[tx.rawTx.Transaction.Message.Instructions[offset[0]].ProgramIDIndex]
|
|
|
|
ammAccount := tx.rawTx.accountList[instruction.Accounts[1]]
|
|
user := tx.rawTx.accountList[instruction.Accounts[7]]
|
|
userSourceTokenAccount := tx.rawTx.accountList[instruction.Accounts[5]]
|
|
userDestinationTokenAccount := tx.rawTx.accountList[instruction.Accounts[6]]
|
|
baseVaultIdx := instruction.Accounts[3]
|
|
quoteVaultIdx := instruction.Accounts[4]
|
|
|
|
baseTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, baseVaultIdx)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get base vault balance after tx: %v", err)
|
|
}
|
|
quoteTokenbalance, err := getTokenBalanceAfterTx(tx.rawTx, quoteVaultIdx)
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), fmt.Errorf("failed to get quote vault balance after tx: %v", err)
|
|
}
|
|
inners, err := getInnerInstructions(innerInstructions, offset[1])
|
|
if err != nil {
|
|
return nil, increaseOffset(offset), err
|
|
}
|
|
|
|
var nextIndex int
|
|
var srcFound, destFound bool
|
|
var baseAmount, quoteAmount decimal.Decimal
|
|
var event string
|
|
for i, inner := range inners {
|
|
from, to, amount, err := parseTokenTransfer(tx.rawTx, inner)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if from.Equals(userSourceTokenAccount) && !srcFound {
|
|
if to.Equals(tx.rawTx.accountList[baseVaultIdx]) {
|
|
event = "sell"
|
|
baseAmount = decimal.NewFromUint64(amount)
|
|
srcFound = true
|
|
} else if to.Equals(tx.rawTx.accountList[quoteVaultIdx]) {
|
|
event = "buy"
|
|
quoteAmount = decimal.NewFromUint64(amount)
|
|
srcFound = true
|
|
}
|
|
} else if to.Equals(userDestinationTokenAccount) && !destFound {
|
|
if from.Equals(tx.rawTx.accountList[quoteVaultIdx]) {
|
|
event = "sell"
|
|
quoteAmount = decimal.NewFromUint64(amount)
|
|
destFound = true
|
|
} else if from.Equals(tx.rawTx.accountList[baseVaultIdx]) {
|
|
event = "buy"
|
|
baseAmount = decimal.NewFromUint64(amount)
|
|
destFound = true
|
|
}
|
|
}
|
|
if srcFound && destFound {
|
|
nextIndex = i + 1
|
|
break
|
|
}
|
|
}
|
|
if !srcFound || !destFound {
|
|
return nil, increaseOffset(offset), fmt.Errorf("raydiumv4 failed to find token transfer inner instruction for swapv2, offset %d, %d", offset[0], offset[1])
|
|
}
|
|
offset[1] += uint(nextIndex + 1)
|
|
|
|
userBase := getAccountBalanceAfterTx(tx.rawTx, instruction.Accounts[5])
|
|
userQuote := getAccountBalanceAfterTx(tx.rawTx, instruction.Accounts[6])
|
|
baseReserve, _ := decimal.NewFromString(baseTokenbalance.UITokenAmount.Amount)
|
|
quoteReserve, _ := decimal.NewFromString(quoteTokenbalance.UITokenAmount.Amount)
|
|
|
|
return []Swap{
|
|
{
|
|
Program: SolProgramRaydiumV4,
|
|
Event: event,
|
|
Pool: ammAccount,
|
|
BaseMint: baseTokenbalance.MintAccount,
|
|
QuoteMint: quoteTokenbalance.MintAccount,
|
|
BaseTokenProgram: baseTokenbalance.ProgramIDAccount,
|
|
QuoteTokenProgram: quoteTokenbalance.ProgramIDAccount,
|
|
BaseMintDecimals: uint8(baseTokenbalance.UITokenAmount.Decimals),
|
|
QuoteMintDecimals: uint8(quoteTokenbalance.UITokenAmount.Decimals),
|
|
User: user,
|
|
BaseAmount: baseAmount,
|
|
QuoteAmount: quoteAmount,
|
|
BaseReserve: baseReserve,
|
|
QuoteReserve: quoteReserve,
|
|
Mayhem: false,
|
|
UserBaseBalance: userBase,
|
|
UserQuoteBalance: userQuote,
|
|
EntryContract: entryContract,
|
|
},
|
|
}, offset, nil
|
|
}
|