435 lines
14 KiB
Go
435 lines
14 KiB
Go
|
package pump_parser
|
||
|
|
|
||
|
|
import (
|
||
|
|
"bytes"
|
||
|
|
"context"
|
||
|
|
"encoding/json"
|
||
|
|
"os"
|
||
|
|
"path/filepath"
|
||
|
|
"testing"
|
||
|
|
|
||
|
|
"github.com/gagliardetto/solana-go"
|
||
|
|
"github.com/gagliardetto/solana-go/rpc"
|
||
|
|
"github.com/shopspring/decimal"
|
||
|
|
)
|
||
|
|
|
||
|
|
func TestRawTxBinaryRoundTripRealFixture(t *testing.T) {
|
||
|
|
original := mustLoadRawTxFixture(t, "testdata/rpc/4sj82GCLtgTDExq7B8YrBsrrqPcE4FqT5Y1gKWmE4cHMDxs7wkCV1hik73dSZ99gZm3K4wyBZQ6U8Nmf48rM9Jri.json")
|
||
|
|
|
||
|
|
encoded, err := EncodeRawTxBinary(original)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("EncodeRawTxBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
decoded, err := DecodeRawTxBinary(encoded)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("DecodeRawTxBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
assertRawTxAccountAccess(t, decoded)
|
||
|
|
if decoded.TxHash() != original.TxHash() {
|
||
|
|
t.Fatalf("TxHash = %s, want %s", decoded.TxHash(), original.TxHash())
|
||
|
|
}
|
||
|
|
if decoded.Slot != original.Slot {
|
||
|
|
t.Fatalf("Slot = %d, want %d", decoded.Slot, original.Slot)
|
||
|
|
}
|
||
|
|
if decoded.IndexWithinBlock != original.IndexWithinBlock {
|
||
|
|
t.Fatalf("IndexWithinBlock = %d, want %d", decoded.IndexWithinBlock, original.IndexWithinBlock)
|
||
|
|
}
|
||
|
|
if len(decoded.Meta.PostTokenBalances) != len(original.Meta.PostTokenBalances) {
|
||
|
|
t.Fatalf("PostTokenBalances len = %d, want %d", len(decoded.Meta.PostTokenBalances), len(original.Meta.PostTokenBalances))
|
||
|
|
}
|
||
|
|
if len(decoded.Meta.PostTokenBalances) > 0 {
|
||
|
|
got := decoded.Meta.PostTokenBalances[0]
|
||
|
|
want := original.Meta.PostTokenBalances[0]
|
||
|
|
if got.AccountIndex != want.AccountIndex {
|
||
|
|
t.Fatalf("token balance account index = %d, want %d", got.AccountIndex, want.AccountIndex)
|
||
|
|
}
|
||
|
|
wantMint := want.MintAccount
|
||
|
|
if wantMint.IsZero() && want.Mint != "" {
|
||
|
|
var err error
|
||
|
|
wantMint, err = solana.PublicKeyFromBase58(want.Mint)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("parse want mint: %v", err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if got.MintAccount != wantMint {
|
||
|
|
t.Fatalf("token balance mint = %s, want %s", got.MintAccount, wantMint)
|
||
|
|
}
|
||
|
|
if got.UITokenAmount.Decimals != want.UITokenAmount.Decimals {
|
||
|
|
t.Fatalf("token balance decimals = %d, want %d", got.UITokenAmount.Decimals, want.UITokenAmount.Decimals)
|
||
|
|
}
|
||
|
|
if got.UITokenAmount.Amount != want.UITokenAmount.Amount {
|
||
|
|
t.Fatalf("token balance amount = %s, want %s", got.UITokenAmount.Amount, want.UITokenAmount.Amount)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestRawTxsBinaryBatchAndStreamRoundTrip(t *testing.T) {
|
||
|
|
tx1 := mustLoadRawTxFixture(t, "testdata/rpc/4sj82GCLtgTDExq7B8YrBsrrqPcE4FqT5Y1gKWmE4cHMDxs7wkCV1hik73dSZ99gZm3K4wyBZQ6U8Nmf48rM9Jri.json")
|
||
|
|
tx2 := mustLoadRawTxFixture(t, "testdata/rpc/43EouSYkeVmLBZSKW1KptiQcAVvB6KX49wjztjgzkQ9iU38A6fF68k77bNy9Wn6fwjykqYsPorUKj8m6SFY7naf1.json")
|
||
|
|
tx2.BlockTime = tx1.BlockTime
|
||
|
|
original := []RawTx{*tx1, *tx2}
|
||
|
|
|
||
|
|
encoded, err := EncodeRawTxsBinary(original)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("EncodeRawTxsBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
decoded, err := DecodeRawTxsBinary(encoded)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("DecodeRawTxsBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
if len(decoded) != len(original) {
|
||
|
|
t.Fatalf("DecodeRawTxsBinary len = %d, want %d", len(decoded), len(original))
|
||
|
|
}
|
||
|
|
for i := range decoded {
|
||
|
|
assertRawTxAccountAccess(t, decoded[i])
|
||
|
|
if decoded[i].TxHash() != original[i].TxHash() {
|
||
|
|
t.Fatalf("decoded[%d].TxHash = %s, want %s", i, decoded[i].TxHash(), original[i].TxHash())
|
||
|
|
}
|
||
|
|
if decoded[i].BlockTime != original[i].BlockTime {
|
||
|
|
t.Fatalf("decoded[%d].BlockTime = %d, want %d", i, decoded[i].BlockTime, original[i].BlockTime)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var streamed int
|
||
|
|
for decodedTx, err := range DecodeRawTxsBinaryReader(bytes.NewReader(encoded)) {
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("DecodeRawTxsBinaryReader() error = %v", err)
|
||
|
|
}
|
||
|
|
assertRawTxAccountAccess(t, decodedTx)
|
||
|
|
streamed++
|
||
|
|
}
|
||
|
|
if streamed != len(original) {
|
||
|
|
t.Fatalf("streamed tx count = %d, want %d", streamed, len(original))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestRawTxBlocksBinaryRoundTrip(t *testing.T) {
|
||
|
|
tx1 := mustLoadRawTxFixture(t, "testdata/rpc/4sj82GCLtgTDExq7B8YrBsrrqPcE4FqT5Y1gKWmE4cHMDxs7wkCV1hik73dSZ99gZm3K4wyBZQ6U8Nmf48rM9Jri.json")
|
||
|
|
tx2 := mustLoadRawTxFixture(t, "testdata/rpc/43EouSYkeVmLBZSKW1KptiQcAVvB6KX49wjztjgzkQ9iU38A6fF68k77bNy9Wn6fwjykqYsPorUKj8m6SFY7naf1.json")
|
||
|
|
blocks := [][]RawTx{{*tx1}, {*tx2}}
|
||
|
|
|
||
|
|
encoded, err := EncodeRawTxBlocksBinary(blocks)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("EncodeRawTxBlocksBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
decoded, err := DecodeRawTxBlocksBinary(encoded)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("DecodeRawTxBlocksBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
if len(decoded) != len(blocks) {
|
||
|
|
t.Fatalf("block count = %d, want %d", len(decoded), len(blocks))
|
||
|
|
}
|
||
|
|
for blockIndex := range decoded {
|
||
|
|
if len(decoded[blockIndex]) != len(blocks[blockIndex]) {
|
||
|
|
t.Fatalf("block[%d] tx count = %d, want %d", blockIndex, len(decoded[blockIndex]), len(blocks[blockIndex]))
|
||
|
|
}
|
||
|
|
for txIndex := range decoded[blockIndex] {
|
||
|
|
assertRawTxAccountAccess(t, decoded[blockIndex][txIndex])
|
||
|
|
if decoded[blockIndex][txIndex].TxHash() != blocks[blockIndex][txIndex].TxHash() {
|
||
|
|
t.Fatalf("block[%d].tx[%d] hash mismatch", blockIndex, txIndex)
|
||
|
|
}
|
||
|
|
if decoded[blockIndex][txIndex].BlockTime != blocks[blockIndex][txIndex].BlockTime {
|
||
|
|
t.Fatalf("block[%d].tx[%d] block time = %d, want %d", blockIndex, txIndex, decoded[blockIndex][txIndex].BlockTime, blocks[blockIndex][txIndex].BlockTime)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestRawTxBinaryPreservesAccountListHelperBehavior(t *testing.T) {
|
||
|
|
owner := mustPubKey("SysvarRent111111111111111111111111111111111")
|
||
|
|
mint := solana.WrappedSol
|
||
|
|
tokenProgram := solana.TokenProgramID
|
||
|
|
ata, _, err := solana.FindProgramAddress([][]byte{
|
||
|
|
owner[:],
|
||
|
|
tokenProgram[:],
|
||
|
|
mint[:],
|
||
|
|
}, solana.SPLAssociatedTokenAccountProgramID)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("find ata: %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
original := &RawTx{
|
||
|
|
accountList: []solana.PublicKey{owner, ata, mint, tokenProgram},
|
||
|
|
BlockTime: 1710000000,
|
||
|
|
Slot: 123,
|
||
|
|
IndexWithinBlock: 7,
|
||
|
|
Transaction: Transaction{Signatures: []solana.Signature{{1, 2, 3}}},
|
||
|
|
Meta: Meta{
|
||
|
|
PreBalances: []uint64{2_000_000_000, 0, 0, 0},
|
||
|
|
PostBalances: []uint64{1_500_000_000, 0, 0, 0},
|
||
|
|
PreTokenBalances: []TokenBalance{{
|
||
|
|
AccountIndex: 1,
|
||
|
|
MintAccount: mint,
|
||
|
|
OwnerAccount: &owner,
|
||
|
|
ProgramIDAccount: tokenProgram,
|
||
|
|
UITokenAmount: UITokenAmount{
|
||
|
|
Amount: "100",
|
||
|
|
Decimals: 9,
|
||
|
|
UIAmount: 0.0000001,
|
||
|
|
UIAmountString: "0.0000001",
|
||
|
|
},
|
||
|
|
}},
|
||
|
|
PostTokenBalances: []TokenBalance{{
|
||
|
|
AccountIndex: 1,
|
||
|
|
MintAccount: mint,
|
||
|
|
OwnerAccount: &owner,
|
||
|
|
ProgramIDAccount: tokenProgram,
|
||
|
|
UITokenAmount: UITokenAmount{
|
||
|
|
Amount: "250",
|
||
|
|
Decimals: 9,
|
||
|
|
UIAmount: 0.00000025,
|
||
|
|
UIAmountString: "0.00000025",
|
||
|
|
},
|
||
|
|
}},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
binaryForm, err := NewRawTxBinary(original)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("NewRawTxBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
if len(binaryForm.Meta.TokenBalances) != 1 {
|
||
|
|
t.Fatalf("binary token balance count = %d, want 1", len(binaryForm.Meta.TokenBalances))
|
||
|
|
}
|
||
|
|
if got := binaryForm.Meta.TokenBalances[0]; !got.HasPreAmount || !got.HasPostAmount || got.PreAmount != "100" || got.PostAmount != "250" {
|
||
|
|
t.Fatalf("merged binary token balance = %+v", got)
|
||
|
|
}
|
||
|
|
|
||
|
|
encoded, err := EncodeRawTxBinary(original)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("EncodeRawTxBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
decoded, err := DecodeRawTxBinary(encoded)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("DecodeRawTxBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, tx := range []*RawTx{original, decoded} {
|
||
|
|
if got, err := GetSolAfterTx(tx, 0); err != nil || got != 1_500_000_000 {
|
||
|
|
t.Fatalf("GetSolAfterTx() = %d, %v; want 1500000000, nil", got, err)
|
||
|
|
}
|
||
|
|
balance, err := getTokenBalanceAfterTx(tx, 1)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("getTokenBalanceAfterTx() error = %v", err)
|
||
|
|
}
|
||
|
|
if balance.UITokenAmount.Amount != "250" {
|
||
|
|
t.Fatalf("getTokenBalanceAfterTx amount = %s, want 250", balance.UITokenAmount.Amount)
|
||
|
|
}
|
||
|
|
if got := getAccountBalanceAfterTx(tx, 1); !got.Equal(decimal.NewFromInt(250)) {
|
||
|
|
t.Fatalf("getAccountBalanceAfterTx() = %s, want 250", got)
|
||
|
|
}
|
||
|
|
if got := GetTokenBalanceAfterTx(tx, 0, tokenProgram, mint); !got.Equal(decimal.NewFromInt(250)) {
|
||
|
|
t.Fatalf("GetTokenBalanceAfterTx() = %s, want 250", got)
|
||
|
|
}
|
||
|
|
ataBalance, err := getAtaByOwner(tx, owner, mint)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("getAtaByOwner() error = %v", err)
|
||
|
|
}
|
||
|
|
if ataBalance.AccountIndex != 1 {
|
||
|
|
t.Fatalf("getAtaByOwner account index = %d, want 1", ataBalance.AccountIndex)
|
||
|
|
}
|
||
|
|
ataIndex, err := getAtaIdxByOwner(tx, owner, mint)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("getAtaIdxByOwner() error = %v", err)
|
||
|
|
}
|
||
|
|
if ataIndex != 1 {
|
||
|
|
t.Fatalf("getAtaIdxByOwner() = %d, want 1", ataIndex)
|
||
|
|
}
|
||
|
|
change, changeAtaIndex := tokenBalanceChange(tx, 0, tokenProgram, mint)
|
||
|
|
if !change.Equal(decimal.NewFromInt(150)) || changeAtaIndex != 1 {
|
||
|
|
t.Fatalf("tokenBalanceChange() = (%s, %d), want (150, 1)", change, changeAtaIndex)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestRawTxBinaryTokenBalanceAmountSupportsUint256(t *testing.T) {
|
||
|
|
owner := mustPubKey("SysvarRent111111111111111111111111111111111")
|
||
|
|
mint := solana.WrappedSol
|
||
|
|
tokenProgram := solana.TokenProgramID
|
||
|
|
amount := "340282366920938463463374607431768211455"
|
||
|
|
original := &RawTx{
|
||
|
|
accountList: []solana.PublicKey{owner, mint, tokenProgram},
|
||
|
|
Transaction: Transaction{
|
||
|
|
Signatures: []solana.Signature{{1, 2, 3}},
|
||
|
|
},
|
||
|
|
Meta: Meta{
|
||
|
|
PreBalances: []uint64{1},
|
||
|
|
PostBalances: []uint64{1},
|
||
|
|
PostTokenBalances: []TokenBalance{{
|
||
|
|
AccountIndex: 0,
|
||
|
|
MintAccount: mint,
|
||
|
|
OwnerAccount: &owner,
|
||
|
|
ProgramIDAccount: tokenProgram,
|
||
|
|
UITokenAmount: UITokenAmount{
|
||
|
|
Amount: amount,
|
||
|
|
Decimals: 9,
|
||
|
|
},
|
||
|
|
}},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
encoded, err := EncodeRawTxBinary(original)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("EncodeRawTxBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
decoded, err := DecodeRawTxBinary(encoded)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("DecodeRawTxBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
got := decoded.Meta.PostTokenBalances[0].UITokenAmount
|
||
|
|
if got.Amount != amount {
|
||
|
|
t.Fatalf("Amount = %s, want %s", got.Amount, amount)
|
||
|
|
}
|
||
|
|
if got.UIAmountString != "340282366920938463463374607431.768211455" {
|
||
|
|
t.Fatalf("UIAmountString = %s", got.UIAmountString)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestRawTxBlocksBinarySaveSlots414696178To414696182(t *testing.T) {
|
||
|
|
rpcURL := os.Getenv("RAWTX_BINARY_RPC_URL")
|
||
|
|
if rpcURL == "" {
|
||
|
|
t.Skip("set RAWTX_BINARY_RPC_URL to run RPC-backed rawtx-binary block save test")
|
||
|
|
}
|
||
|
|
|
||
|
|
const startSlot uint64 = 414696178
|
||
|
|
const endSlot uint64 = 414696182
|
||
|
|
|
||
|
|
client := rpc.New(rpcURL)
|
||
|
|
rewards := false
|
||
|
|
version := uint64(0)
|
||
|
|
blocks := make([][]RawTx, 0, endSlot-startSlot+1)
|
||
|
|
totalTx := 0
|
||
|
|
filteredVote := 0
|
||
|
|
for slot := startSlot; slot <= endSlot; slot++ {
|
||
|
|
block, err := client.GetBlockWithOpts(context.Background(), slot, &rpc.GetBlockOpts{
|
||
|
|
TransactionDetails: rpc.TransactionDetailsFull,
|
||
|
|
Rewards: &rewards,
|
||
|
|
Commitment: rpc.CommitmentFinalized,
|
||
|
|
Encoding: solana.EncodingBase64,
|
||
|
|
MaxSupportedTransactionVersion: &version,
|
||
|
|
})
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("get block %d: %v", slot, err)
|
||
|
|
}
|
||
|
|
var blockTime uint64
|
||
|
|
if block.BlockTime != nil {
|
||
|
|
blockTime = uint64(*block.BlockTime)
|
||
|
|
}
|
||
|
|
|
||
|
|
rawTxs := make([]RawTx, 0, len(block.Transactions))
|
||
|
|
for i, tx := range block.Transactions {
|
||
|
|
totalTx++
|
||
|
|
rawTx, err := FromRpcTransactionWithMeta(tx, &blockTime, slot, int64(i))
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("slot %d tx[%d] convert: %v", slot, i, err)
|
||
|
|
}
|
||
|
|
if rawTxBinaryIsVoteTx(rawTx) {
|
||
|
|
filteredVote++
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
rawTxs = append(rawTxs, *rawTx)
|
||
|
|
}
|
||
|
|
blocks = append(blocks, rawTxs)
|
||
|
|
}
|
||
|
|
|
||
|
|
encoded, err := EncodeRawTxBlocksBinary(blocks)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("EncodeRawTxBlocksBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
outputPath := os.Getenv("RAWTX_BINARY_OUT")
|
||
|
|
if outputPath == "" {
|
||
|
|
outputPath = filepath.Join("testdata", "rawtx-binary", "rawtx-blocks-414696178-414696182.prbs")
|
||
|
|
}
|
||
|
|
if err := os.MkdirAll(filepath.Dir(outputPath), 0o755); err != nil {
|
||
|
|
t.Fatalf("create rawtx binary output dir: %v", err)
|
||
|
|
}
|
||
|
|
if err := os.WriteFile(outputPath, encoded, 0o644); err != nil {
|
||
|
|
t.Fatalf("write rawtx binary: %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
decoded, err := DecodeRawTxBlocksBinary(encoded)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("DecodeRawTxBlocksBinary() error = %v", err)
|
||
|
|
}
|
||
|
|
if len(decoded) != len(blocks) {
|
||
|
|
t.Fatalf("decoded block count = %d, want %d", len(decoded), len(blocks))
|
||
|
|
}
|
||
|
|
savedTx := 0
|
||
|
|
for blockIndex := range decoded {
|
||
|
|
if len(decoded[blockIndex]) != len(blocks[blockIndex]) {
|
||
|
|
t.Fatalf("decoded block[%d] tx count = %d, want %d", blockIndex, len(decoded[blockIndex]), len(blocks[blockIndex]))
|
||
|
|
}
|
||
|
|
for txIndex := range decoded[blockIndex] {
|
||
|
|
assertRawTxAccountAccess(t, decoded[blockIndex][txIndex])
|
||
|
|
if rawTxBinaryIsVoteTx(decoded[blockIndex][txIndex]) {
|
||
|
|
t.Fatalf("decoded block[%d].tx[%d] is vote tx", blockIndex, txIndex)
|
||
|
|
}
|
||
|
|
savedTx++
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if savedTx == 0 {
|
||
|
|
t.Fatal("saved tx count is zero")
|
||
|
|
}
|
||
|
|
t.Logf("saved rawtx binary: path=%s bytes=%d total_tx=%d saved_tx=%d filtered_vote=%d", outputPath, len(encoded), totalTx, savedTx, filteredVote)
|
||
|
|
}
|
||
|
|
|
||
|
|
func mustLoadRawTxFixture(t *testing.T, path string) *RawTx {
|
||
|
|
t.Helper()
|
||
|
|
raw, err := os.ReadFile(path)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("read fixture: %v", err)
|
||
|
|
}
|
||
|
|
var response RPCResponse
|
||
|
|
if err := json.Unmarshal(raw, &response); err != nil {
|
||
|
|
t.Fatalf("unmarshal fixture: %v", err)
|
||
|
|
}
|
||
|
|
return &response.Result
|
||
|
|
}
|
||
|
|
|
||
|
|
func assertRawTxAccountAccess(t *testing.T, tx *RawTx) {
|
||
|
|
t.Helper()
|
||
|
|
accounts := tx.GetAccountList()
|
||
|
|
if len(accounts) == 0 {
|
||
|
|
t.Fatal("decoded account list is empty")
|
||
|
|
}
|
||
|
|
for _, instr := range tx.Transaction.Message.Instructions {
|
||
|
|
if instr.ProgramIDIndex < 0 || instr.ProgramIDIndex >= len(accounts) {
|
||
|
|
t.Fatalf("instruction program id index %d out of range %d", instr.ProgramIDIndex, len(accounts))
|
||
|
|
}
|
||
|
|
for _, accountIndex := range instr.Accounts {
|
||
|
|
if accountIndex < 0 || accountIndex >= len(accounts) {
|
||
|
|
t.Fatalf("instruction account index %d out of range %d", accountIndex, len(accounts))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for _, inner := range tx.Meta.InnerInstructions {
|
||
|
|
for _, instr := range inner.Instructions {
|
||
|
|
if instr.ProgramIDIndex < 0 || instr.ProgramIDIndex >= len(accounts) {
|
||
|
|
t.Fatalf("inner instruction program id index %d out of range %d", instr.ProgramIDIndex, len(accounts))
|
||
|
|
}
|
||
|
|
for _, accountIndex := range instr.Accounts {
|
||
|
|
if accountIndex < 0 || accountIndex >= len(accounts) {
|
||
|
|
t.Fatalf("inner instruction account index %d out of range %d", accountIndex, len(accounts))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func rawTxBinaryIsVoteTx(tx *RawTx) bool {
|
||
|
|
if tx == nil {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
accountList := tx.GetAccountList()
|
||
|
|
for _, instr := range tx.Transaction.Message.Instructions {
|
||
|
|
if instr.ProgramIDIndex >= 0 && instr.ProgramIDIndex < len(accountList) && accountList[instr.ProgramIDIndex] == solana.VoteProgramID {
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false
|
||
|
|
}
|