okxv2 parser

cmd/debug_jupv6/main.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"encoding/hex"
+	"fmt"
+	"os"
+)
+
+func main() {
+	hexData := "bb64facc31c4af14be34e6edcc0000006f03a4df67000000b903320000000300000064342100024b00000000dc0500026310270203"
+	b, err := hex.DecodeString(hexData)
+	if err != nil {
+		panic(err)
+	}
+	payload := b[8:]
+
+	off := 0
+	read := func(n int) []byte {
+		if off+n > len(payload) {
+			fmt.Printf("OOB read: off=%d n=%d len=%d\n", off, n, len(payload))
+			os.Exit(1)
+		}
+		out := payload[off : off+n]
+		off += n
+		return out
+	}
+	u8 := func() uint8 { return read(1)[0] }
+	leU16 := func() uint16 {
+		b := read(2)
+		return uint16(b[0]) | uint16(b[1])<<8
+	}
+	leU32 := func() uint32 {
+		b := read(4)
+		return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+	}
+	leU64 := func() uint64 {
+		b := read(8)
+		return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
+			uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+	}
+
+	fmt.Printf("payload len=%d\n", len(payload))
+	amountIn := leU64()
+	quotedOut := leU64()
+	slippage := leU16()
+	platform := leU16()
+	posSlip := leU16()
+	fmt.Printf("in=%d out=%d slip=%d plat=%d pos=%d\n", amountIn, quotedOut, slippage, platform, posSlip)
+
+	planLen := leU32()
+	fmt.Printf("planLen=%d\n", planLen)
+	for i := uint32(0); i < planLen; i++ {
+		swapTag := u8()
+		fmt.Printf("step[%d] swapTag=%d (0x%02x) off=%d\n", i, swapTag, swapTag, off)
+		// payload depends on swapTag; we don't know, so just print next few bytes and stop
+		bps := leU16()
+		inIdx := u8()
+		outIdx := u8()
+		fmt.Printf("  bps=%d inIdx=%d outIdx=%d off=%d\n", bps, inIdx, outIdx, off)
+	}
+	fmt.Printf("done off=%d\n", off)
+}

cmd/shreder/main.go

@@ -37,6 +37,7 @@ func main() {
 					"pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA",
 					"GS4CU59F31iL7aR2Q8zVS8DRrcRnXX1yjQ66TqNVQnaR", //Event Authority
 					"5PHirr8joyTMp9JMm6nW7hNDVyEYdkzDqazxPD7RaTjx", // Fee Config
+					"pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ",  // pump fee program
 				},
 			},
 			"photon": {
@@ -44,6 +45,16 @@ func main() {
 					"BSfD6SHZigAfDWSjzD5Q41jw8LmKwtmjskPH9XW1mrRW",
 				},
 			},
+			"jupiterV6": {
+				AccountRequired: []string{
+					"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
+				},
+			},
+			"okxdexroutev2": {
+				AccountRequired: []string{
+					"proVF4pMXVaYqmy4NjniPh4pqKNfMmsihgd4wdkCX3u",
+				},
+			},
 			// TODO: axiom, gmgn, etc.
 		})
 	if err != nil {
@@ -77,7 +88,16 @@ func main() {
 			return
 		case txBatch := <-txCh:
 			//jsonData, _ := json.MarshalIndent(txBatch, "", "  ")
-			fmt.Println(txBatch[0].TxHash)
+			for _, tx := range txBatch {
+				if tx.Label == "okxdexroutev2" {
+					if tx.Event == "buy" {
+						fmt.Println("===============", tx.TxHash, tx.Event, tx.Token0Address, "token:", tx.Token0Amount, "sol:", tx.Token1Amount)
+					} else if tx.Event == "sell" {
+						fmt.Println("===============", tx.TxHash, tx.Event, tx.Token0Address, "token:", tx.Token0Amount)
+					}
+				}
+			}
+			//fmt.Println(txBatch[0].TxHash)
 		}
 	}
 }

pkg/shreder/addresstables.go

@@ -14,6 +14,7 @@ import (
 type AddressTables struct {
 	rpcClient *rpc.Client
 	mux       sync.RWMutex
+	loadMux   sync.Mutex
 	tables    *lru.Cache[solana.PublicKey, []solana.PublicKey]
 	loading   map[solana.PublicKey]struct{}
 
@@ -21,7 +22,7 @@ type AddressTables struct {
 }
 
 func NewAddressTables(rpcClient *rpc.Client) *AddressTables {
-	pool, _ := ants.NewPool(10, ants.WithPreAlloc(true), ants.WithNonblocking(true))
+	pool, _ := ants.NewPool(5, ants.WithPreAlloc(true), ants.WithNonblocking(true))
 	cache, _ := lru.New[solana.PublicKey, []solana.PublicKey](10000)
 	return &AddressTables{
 		rpcClient: rpcClient,
@@ -60,32 +61,34 @@ func (at *AddressTables) GetAddressTable(tablePubkey solana.PublicKey, idx []uin
 	if !ok {
 		at.mux.RUnlock()
 		_ = at.pool.Submit(func() {
-			at.mux.RLock()
+			at.loadMux.Lock()
 			_, loading := at.loading[tablePubkey]
 			if loading {
-				at.mux.RUnlock()
+				at.loadMux.Unlock()
 				return
 			}
-			at.mux.RUnlock()
-			at.mux.Lock()
 			at.loading[tablePubkey] = struct{}{}
-			at.mux.Unlock()
+			at.loadMux.Unlock()
 
 			table, err := at.loadAddressTable(tablePubkey)
 			if err != nil {
 				logger.Error("loadAddressTable failed", "err", err, "table", tablePubkey)
-				at.mux.Lock()
+				at.loadMux.Lock()
 				delete(at.loading, tablePubkey)
-				at.mux.Unlock()
+				at.loadMux.Unlock()
 				return
 			}
+			at.loadMux.Lock()
+			delete(at.loading, tablePubkey)
+			at.loadMux.Unlock()
+
 			at.mux.Lock()
 			at.tables.Add(tablePubkey, table)
 			total := at.tables.Len()
-			delete(at.loading, tablePubkey)
 			at.mux.Unlock()
 			logger.Info("loadAddressTable", "table", tablePubkey.String(), "table count:", total)
 		})
+
 		return nil
 	}
 	at.mux.RUnlock()
@@ -93,6 +96,8 @@ func (at *AddressTables) GetAddressTable(tablePubkey solana.PublicKey, idx []uin
 	var result solana.PublicKeySlice = make([]solana.PublicKey, 0, len(idx))
 	for _, i := range idx {
 		if int(i) >= len(addresses) {
+			logger.Error("over loadAddressTable failed", "idx", i, "table", tablePubkey)
+			//todo... update table?
 			continue
 		}
 		result = append(result, addresses[i])

pkg/shreder/juptierv6_test.go

@@ -0,0 +1,88 @@
+package shreder
+
+import (
+	"encoding/hex"
+	"testing"
+)
+
+func TestDecodeRouteV2Arg(t *testing.T) {
+	tests := []struct {
+		name    string
+		hexData string
+	}{
+		{
+			name:    "Jupiter V6 RouteV2Arg Test 0",
+			hexData: "bb64facc31c4af14809fd500000000002222e8db1800000064000a000000020000005601fe102700016310270102",
+		},
+		{
+			name:    "Jupiter V6 RouteV2Arg Test 1",
+			hexData: "bb64facc31c4af144ff91634b90000004e6c4d05000000002c013200000003000000520000000000000000102700014f102701024310270203",
+		},
+		{
+			name:    "Jupiter V6 RouteV2Arg Test 2",
+			hexData: "bb64facc31c4af14ba2eafa02c1d0000777a9b2200000000f4010a0000000100000052000000000000000010270001",
+		},
+		{
+			name:    "Jupiter V6 RouteV2Arg Test 3",
+			hexData: "bb64facc31c4af144a3521186b07000030508d0e00000000c201320000000300000052000000000000000010270001740110270102590010270203",
+		},
+		{
+			name:    "Jupiter V6 RouteV2Arg Test 4",
+			hexData: "bb64facc31c4af14092d05050000000013701f198c0100008102380100000300000059011027000168001027010251000000000000000010270203",
+		},
+		{
+			name:    "Jupiter V6 RouteV2Arg Test 5",
+			hexData: "bb64facc31c4af1480969800000000006f44ad39bd0000001202320000000200000068001027000151000000000000000010270102",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			instrData, err := hex.DecodeString(tt.hexData)
+			if err != nil {
+				t.Fatalf("failed to decode hex string: %v", err)
+				return
+			}
+			t.Logf("raw bytes: %x", instrData[8:])
+			args, err := decodeJupiterV6RouteV2Arg(instrData[8:])
+			if err != nil {
+				t.Fatalf("failed to decode jupiter arguments: %v", err)
+				return
+			}
+			t.Logf("decoded args: %+v", args)
+		})
+	}
+
+}
+
+func TestDecodeRouteArg(t *testing.T) {
+	tests := []struct {
+		name    string
+		hexData string
+	}{
+		{
+			name:    "Jupiter V6 RouteArg Test 0",
+			hexData: "e517cb977ae3ad2a030000004f6400014f64010251000000000000000064020340420f00000000005c1c81900e000000640000",
+		},
+		{
+			name:    "Jupiter V6 RouteArg Test 1",
+			hexData: "e517cb977ae3ad2a0200000028640001510000000000000000640102c09ee605000000005e1bc48efa000000d00700",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			instrData, err := hex.DecodeString(tt.hexData)
+			if err != nil {
+				t.Fatalf("failed to decode hex string: %v", err)
+				return
+			}
+			t.Logf("raw bytes: %x", instrData[8:])
+			args, err := decodeJupiterV6RouteArg(instrData[8:])
+			if err != nil {
+				t.Fatalf("failed to decode jupiter arguments: %v", err)
+				return
+			}
+			t.Logf("decoded args: %+v", args)
+		})
+	}
+
+}

pkg/shreder/okxonchainlab.go

@@ -0,0 +1,367 @@
+package shreder
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+
+	bin "github.com/gagliardetto/binary"
+	"github.com/gagliardetto/solana-go"
+	"github.com/shopspring/decimal"
+)
+
+var (
+	okxDexRouteV2ProgramID = solana.MustPublicKeyFromBase58("proVF4pMXVaYqmy4NjniPh4pqKNfMmsihgd4wdkCX3u")
+
+	okxSwapTobDisc             = []byte{170, 41, 85, 177, 132, 80, 31, 53}
+	okxSwapTobWithReceiverDisc = []byte{223, 170, 216, 234, 204, 6, 241, 25}
+	okxSwapTocDisc             = []byte{187, 201, 212, 51, 16, 155, 236, 60}
+	okxSwapTocV2Disc           = []byte{127, 214, 107, 189, 23, 90, 47, 104}
+)
+
+// IDL: SwapArgs { order_id:u64, amount_in:u64, expect_amount_out:u64, slippage:u16, routes: Vec<Route> }
+// IDL: Route { dex: Dex(enum), weight:u16, index:u8 }
+
+type OkxV2Route struct {
+	Dex    OkxV2SwapKind
+	Weight uint16
+	Index  uint8
+}
+
+type OkxV2SwapArgs struct {
+	OrderID         uint64
+	AmountIn        uint64
+	ExpectAmountOut uint64
+	Slippage        uint16
+	Routes          []OkxV2Route
+}
+
+type OkxV2SwapKind uint8
+
+const (
+	OKCV2_SplTokenSwap OkxV2SwapKind = iota
+	OKCV2_StableSwap
+	OKCV2_Whirlpool
+	OKCV2_MeteoraDynamicpool
+	OKCV2_RaydiumSwap
+	OKCV2_RaydiumStableSwap
+	OKCV2_RaydiumClmmSwap
+	OKCV2_AldrinExchangeV1
+	OKCV2_AldrinExchangeV2
+	OKCV2_LifinityV1
+	OKCV2_LifinityV2
+	OKCV2_RaydiumClmmSwapV2
+	OKCV2_FluxBeam
+	OKCV2_MeteoraDlmm
+	OKCV2_RaydiumCpmmSwap
+	OKCV2_OpenBookV2
+	OKCV2_WhirlpoolV2
+	OKCV2_Phoenix
+	OKCV2_ObricV2
+	OKCV2_SanctumAddLiq
+	OKCV2_SanctumRemoveLiq
+	OKCV2_SanctumNonWsolSwap
+	OKCV2_SanctumWsolSwap
+	OKCV2_PumpfunBuy
+	OKCV2_PumpfunSell
+	OKCV2_StabbleSwap
+	OKCV2_SanctumRouter
+	OKCV2_MeteoraVaultDeposit
+	OKCV2_MeteoraVaultWithdraw
+	OKCV2_Saros
+	OKCV2_MeteoraLst
+	OKCV2_Solfi
+	OKCV2_QualiaSwap
+	OKCV2_Zerofi
+	OKCV2_PumpfunammBuy
+	OKCV2_PumpfunammSell
+	OKCV2_Virtuals
+	OKCV2_VertigoBuy
+	OKCV2_VertigoSell
+	OKCV2_PerpetualsAddLiq
+	OKCV2_PerpetualsRemoveLiq
+	OKCV2_PerpetualsSwap
+	OKCV2_RaydiumLaunchpad
+	OKCV2_LetsBonkFun
+	OKCV2_Woofi
+	OKCV2_MeteoraDbc
+	OKCV2_MeteoraDlmmSwap2
+	OKCV2_MeteoraDAMMV2
+	OKCV2_Gavel
+	OKCV2_BoopfunBuy
+	OKCV2_BoopfunSell
+	OKCV2_MeteoraDbc2
+	OKCV2_GooseFX
+	OKCV2_Dooar
+	OKCV2_Numeraire
+	OKCV2_SaberDecimalWrapperDeposit
+	OKCV2_SaberDecimalWrapperWithdraw
+	OKCV2_SarosDlmm
+	OKCV2_OneDexSwap
+	OKCV2_Manifest
+	OKCV2_ByrealClmm
+	OKCV2_PancakeSwapV3Swap
+	OKCV2_PancakeSwapV3SwapV2
+	OKCV2_Tessera
+	OKCV2_SolRfq
+	OKCV2_Humidifi
+	OKCV2_HeavenBuy
+	OKCV2_HeavenSell
+	OKCV2_SolfiV2
+	OKCV2_Goonfi
+	OKCV2_MoonitBuy
+	OKCV2_MoonitSell
+	OKCV2_RaydiumSwapV2
+	OKCV2_Whalestreet
+	OKCV2_SugarMoneyBuy
+	OKCV2_SugarMoneySell
+	OKCV2_MeteoraDAMMV2Swap2
+	OKCV2_AlphaQ
+	OKCV2_FutarchyAmm
+	OKCV2_PumpfunBuy2
+	OKCV2_PumpfunSell2
+	OKCV2_HumidifiSwap2
+	OKCV2_Scorch
+	OKCV2_JupiterLendDeposit
+	OKCV2_JupiterLendRedeem
+	OKCV2_TokkaAmm
+)
+
+func decodeOkxSwapTobSwapArgs(data []byte) (*OkxV2SwapArgs, error) {
+	dec := bin.NewBorshDecoder(data)
+	return decodeOkxV2SwapArgs(dec)
+}
+
+func decodeOkxSwapTobWithReceiverSwapArgs(data []byte) (*OkxV2SwapArgs, error) {
+	dec := bin.NewBorshDecoder(data)
+	return decodeOkxV2SwapArgs(dec)
+}
+
+func decodeOkxSwapTocSwapArgs(data []byte) (*OkxV2SwapArgs, error) {
+	dec := bin.NewBorshDecoder(data)
+	return decodeOkxV2SwapArgs(dec)
+}
+
+func decodeOkxSwapTocV2SwapArgs(data []byte) (*OkxV2SwapArgs, error) {
+	dec := bin.NewBorshDecoder(data)
+	return decodeOkxV2SwapArgs(dec)
+}
+
+func skipOkxV2DexPayload(dec *bin.Decoder, dex OkxV2SwapKind) error {
+	// IMPORTANT: In IDL, Dex is an enum. Most variants have no fields, but some carry payload.
+	// We only need to keep decoding aligned for SwapArgs.routes.
+	switch dex {
+	case OKCV2_SolRfq:
+		// fields: 6*u64 + 2*bool
+		// rfq_id, expected_maker_amount, expected_taker_amount, maker_send_amount,
+		// taker_send_amount, expiry, maker_use_native_sol, taker_use_native_sol
+		if err := dec.SkipBytes(8 * 6); err != nil {
+			return err
+		}
+		return dec.SkipBytes(2)
+	case OKCV2_SugarMoneyBuy, OKCV2_SugarMoneySell:
+		// fields: u8 + u8
+		return dec.SkipBytes(2)
+	case OKCV2_HumidifiSwap2:
+		// fields: u64
+		return dec.SkipBytes(8)
+	case OKCV2_Scorch:
+		// fields: u128 => 16 bytes
+		return dec.SkipBytes(16)
+	default:
+		return nil
+	}
+}
+
+func decodeOkxV2SwapArgs(dec *bin.Decoder) (*OkxV2SwapArgs, error) {
+	out := &OkxV2SwapArgs{}
+	var err error
+
+	if out.OrderID, err = dec.ReadUint64(binary.LittleEndian); err != nil {
+		return nil, fmt.Errorf("read order_id: %w", err)
+	}
+	if out.AmountIn, err = dec.ReadUint64(binary.LittleEndian); err != nil {
+		return nil, fmt.Errorf("read amount_in: %w", err)
+	}
+	if out.ExpectAmountOut, err = dec.ReadUint64(binary.LittleEndian); err != nil {
+		return nil, fmt.Errorf("read expect_amount_out: %w", err)
+	}
+	if out.Slippage, err = dec.ReadUint16(binary.LittleEndian); err != nil {
+		return nil, fmt.Errorf("read slippage: %w", err)
+	}
+
+	// routes: Vec<Route>
+	routesLen, err := dec.ReadUint32(binary.LittleEndian)
+	if err != nil {
+		return nil, fmt.Errorf("read routes len: %w", err)
+	}
+	out.Routes = make([]OkxV2Route, 0, routesLen)
+	for i := uint32(0); i < routesLen; i++ {
+		// Route { dex: Dex(enum tag u8 [+ payload]), weight: u16, index: u8 }
+		tag, err := dec.ReadUint8()
+		if err != nil {
+			return nil, fmt.Errorf("read routes[%d].dex: %w", i, err)
+		}
+		dex := OkxV2SwapKind(tag)
+		if err := skipOkxV2DexPayload(dec, dex); err != nil {
+			return nil, fmt.Errorf("skip routes[%d].dex payload (%d): %w", i, tag, err)
+		}
+		weight, err := dec.ReadUint16(binary.LittleEndian)
+		if err != nil {
+			return nil, fmt.Errorf("read routes[%d].weight: %w", i, err)
+		}
+		idx, err := dec.ReadUint8()
+		if err != nil {
+			return nil, fmt.Errorf("read routes[%d].index: %w", i, err)
+		}
+		out.Routes = append(out.Routes, OkxV2Route{Dex: dex, Weight: weight, Index: idx})
+	}
+
+	return out, nil
+}
+
+type OkxV2SwapSolRfq struct {
+	RfqId               uint64
+	expectedMakerAmount uint64
+	expectedTakerAmount uint64
+	makerSendAmount     uint64
+	takerSendAmount     uint64
+	expiry              uint64
+	makerUseNativeSol   bool
+	takerUseNativeSol   bool
+}
+type OkxV2SwapSugarMoney struct {
+	BondingCurveBump uint8
+
+	BondingCurveSolAssociatedAccountBump uint8
+}
+
+type OkxV2SwapHumidifiSwap2 struct {
+	SwapId uint64
+}
+
+type OkxV2SwapScorch struct {
+	Id [16]byte
+}
+
+func parseOkxDexRouteV2Instruction(tx *versionedTransaction, instructionIndex int) (*TxSignal, error) {
+	msg := tx.Message
+	if instructionIndex >= len(msg.Instructions) {
+		return nil, fmt.Errorf("instruction index out of bounds")
+	}
+	ix := msg.Instructions[instructionIndex]
+	if len(ix.Data) < 8 {
+		return nil, nil
+	}
+	disc := ix.Data[:8]
+	data := ix.Data[8:]
+
+	var (
+		args *OkxV2SwapArgs
+		err  error
+	)
+	switch {
+	case bytes.Equal(disc, okxSwapTobDisc):
+		args, err = decodeOkxSwapTobSwapArgs(data)
+		if err != nil {
+			return nil, fmt.Errorf("decode swap_tob args: %w", err)
+		}
+
+	case bytes.Equal(disc, okxSwapTobWithReceiverDisc):
+		args, err = decodeOkxSwapTobWithReceiverSwapArgs(data)
+		if err != nil {
+			return nil, fmt.Errorf("decode swap_tob_with_receiver args: %w", err)
+		}
+	case bytes.Equal(disc, okxSwapTocDisc):
+		args, err = decodeOkxSwapTocSwapArgs(data)
+		if err != nil {
+			return nil, fmt.Errorf("decode swap_toc args: %w", err)
+		}
+
+	case bytes.Equal(disc, okxSwapTocV2Disc):
+		args, err = decodeOkxSwapTocV2SwapArgs(data)
+		if err != nil {
+			return nil, fmt.Errorf("decode swap_toc_v2 args: %w", err)
+		}
+
+	default:
+		return nil, nil
+	}
+	if len(ix.Accounts) < 15 {
+		return nil, fmt.Errorf("invalid account count: %d", len(ix.Accounts))
+	}
+	var (
+		inputAmount uint64
+		routeCount  int
+	)
+	for _, route := range args.Routes {
+		if route.Index == 1 && (route.Dex == OKCV2_PumpfunammSell ||
+			route.Dex == OKCV2_PumpfunSell2) {
+			routeCount++
+			inputAmount = args.AmountIn * uint64(route.Weight) / 10000
+		}
+	}
+	if routeCount > 1 {
+		logger.Warn("pumpSwapSell at inputIdx=0: multiple instances found", "tx", tx.Signatures[0].String(), "routeCount", routeCount)
+		return nil, nil
+	}
+	if inputAmount == 0 {
+		return nil, nil
+	}
+
+	srcMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(ix.Accounts[3]))
+
+	var (
+		srcIdx uint8
+	)
+	for i, acctIdx := range ix.Accounts {
+		if i < 15 {
+			continue
+		}
+		key, err := getStaticKey(tx.Message.StaticAccountKeys, int(acctIdx))
+		if err != nil {
+			return nil, err
+		}
+		if key.Equals(pumpAmmProgramID) {
+			srcIdx = uint8(i + 6)
+			break
+		}
+	}
+	if srcIdx == 0 || int(srcIdx+1) >= len(ix.Accounts) {
+		return nil, nil
+	}
+
+	baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(ix.Accounts[srcIdx]))
+	if err != nil {
+		return nil, err
+	}
+	if !baseMint.Equals(srcMint) {
+		return nil, nil
+	}
+
+	quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(ix.Accounts[srcIdx+1]))
+	if err != nil {
+		return nil, err
+	}
+	if !quoteMint.Equals(solana.WrappedSol) {
+		return nil, nil
+	}
+
+	return &TxSignal{
+		Label:              "okxdexroutev2",
+		TxHash:             tx.Signatures[0].String(),
+		Maker:              tx.Message.StaticAccountKeys[0].String(),
+		Token0Address:      baseMint.String(),
+		Token1Address:      wsolMint,
+		Token0Amount:       formatTokenAmount(inputAmount),
+		Token1Amount:       decimal.Zero,
+		Event:              "sell",
+		Program:            "PumpAMM",
+		IsProcessed:        false,
+		IsToken2022:        false,
+		IsMayhemMode:       false,
+		ExactSOL:           false,
+		Token0AmountUint64: inputAmount,
+		Token1AmountUint64: 0,
+	}, nil
+}

pkg/shreder/tx.go

@@ -29,6 +29,7 @@ func SetLogLevel(level slog.Level) {
 
 type TxSignal struct {
 	Source        string          `json:"source"`
+	Label         string          `json:"label"`
 	TxHash        string          `json:"tx_hash"`
 	Maker         string          `json:"maker"`
 	Token0Address string          `json:"token0_address"`
@@ -44,6 +45,7 @@ type TxSignal struct {
 	IsToken2022   bool            `json:"is_token2022"`
 	IsMayhemMode  bool            `json:"is_mayhem_mode"`
 	TxFee         decimal.Decimal `json:"tx_fee"`
+	EntryContract string          `json:"entry_contract"`
 
 	ExactSOL bool `json:"exact_in"`
 

pkg/shreder/txparser.go

@@ -5,6 +5,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math/big"
+	"strings"
 
 	"github.com/gagliardetto/solana-go"
 	"github.com/mr-tron/base58"
@@ -42,8 +43,23 @@ var (
 	flasProgramID = solana.MustPublicKeyFromBase58("FLASHX8DrLbgeR8FcfNV1F5krxYcYMUdBkrP1EPBtxB9")
 
 	terminalProgramID = solana.MustPublicKeyFromBase58("term9YPb9mzAsABaqN71A4xdbxHmpBNZavpBiQKZzN3")
+
+	jupiterV6ProgramID = solana.MustPublicKeyFromBase58("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4")
 )
 
+type AccountNotFoundError struct {
+	Index int
+	Len   int
+}
+
+func NewAccountNotFoundError(i, l int) error {
+	return &AccountNotFoundError{i, l}
+}
+
+func (e AccountNotFoundError) Error() string {
+	return fmt.Sprintf("account index %d out of range, len=%d", e.Index, e.Len)
+}
+
 // instruction discriminators
 var (
 	pumpCreateCoinIX   = []byte{24, 30, 200, 40, 5, 28, 7, 119}
@@ -132,9 +148,9 @@ type f5tfBuyArgs struct {
 	TokenAmount uint64
 }
 
-type flasBuyArgs struct {
-	SolAmount   uint64
-	TokenAmount uint64
+type flasArgs struct {
+	Amount1     uint64
+	Amount2     uint64
 	Placeholder [3]uint8
 }
 
@@ -155,16 +171,6 @@ type pumpAmmBuyArgs struct {
 	MaxSolCost uint64
 }
 
-type _6hb1BuyArgs struct {
-	SolAmount   uint64
-	TokenNumber uint64
-}
-
-type _8rsrBuyArgs struct {
-	SolIn    uint64
-	TokenOut uint64
-}
-
 type boboBuyArgs struct {
 	Placeholder1 uint64
 	Placeholder2 uint64
@@ -198,19 +204,32 @@ func ParseTransaction(update *SubscribeUpdateTransaction, loader *AddressTables)
 	instructions := versioned.Message.Instructions
 
 	if loader != nil && len(versioned.Message.AddressTableLookups) > 0 {
-		// currently we only care about photon table lookup
+		lookupTableOk := true
 		for _, lookup := range versioned.Message.AddressTableLookups {
+			if len(lookup.WritableIndexes) == 0 {
+				continue
+			}
 			accounts := loader.GetAddressTable(lookup.AccountKey, lookup.WritableIndexes)
 			if len(accounts) != len(lookup.WritableIndexes) {
+				lookupTableOk = false
 				break
 			}
 			staticKeys = append(staticKeys, accounts...)
-			accounts2 := loader.GetAddressTable(lookup.AccountKey, lookup.ReadonlyIndexes)
-			if len(accounts2) != len(lookup.ReadonlyIndexes) {
-				break
-			}
-			staticKeys = append(staticKeys, accounts2...)
+
 		}
+		if lookupTableOk {
+			for _, lookup := range versioned.Message.AddressTableLookups {
+				if len(lookup.ReadonlyIndexes) == 0 {
+					continue
+				}
+				accounts := loader.GetAddressTable(lookup.AccountKey, lookup.ReadonlyIndexes)
+				if len(accounts) != len(lookup.ReadonlyIndexes) {
+					break
+				}
+				staticKeys = append(staticKeys, accounts...)
+			}
+		}
+		versioned.Message.StaticAccountKeys = staticKeys
 	}
 
 	var parsed []*TxSignal
@@ -225,46 +244,55 @@ func ParseTransaction(update *SubscribeUpdateTransaction, loader *AddressTables)
 		switch programID {
 		case pumpProgramID:
 			txRes, err := parsePumpInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "pump")
+			parsed = appendParsed(parsed, txRes, err, txHash, "pump", pumpProgramID.String())
 		case azczProgramID:
 			txRes, err := parseAzczInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "azcz")
+			parsed = appendParsed(parsed, txRes, err, txHash, "azcz", azczProgramID.String())
 		case f5tfProgramID:
 			txRes, err := parseF5tfInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "f5tf")
+			parsed = appendParsed(parsed, txRes, err, txHash, "f5tf", f5tfProgramID.String())
 		case flasProgramID:
 			txRes, err := parseFlasInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "flas")
+			parsed = appendParsed(parsed, txRes, err, txHash, "flas", flasProgramID.String())
 		case photonProgramID:
 			txRes, err := parsePhotonInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "photon")
+			parsed = appendParsed(parsed, txRes, err, txHash, "photon", photonProgramID.String())
 		case pumpAmmProgramID:
 			txRes, err := parsePumpAmmInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "pumpamm")
+			parsed = appendParsed(parsed, txRes, err, txHash, "pumpamm", pumpAmmProgramID.String())
 		case boboProgramID:
 			txRes, err := parseBoboInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "bobo")
+			parsed = appendParsed(parsed, txRes, err, txHash, "bobo", boboProgramID.String())
 		case qtkvProgramID:
 			txRes, err := parseQtkvInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "qtkv")
+			parsed = appendParsed(parsed, txRes, err, txHash, "qtkv", qtkvProgramID.String())
 		case fjszProgramID:
 			txRes, err := parseFjszInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "fjsz")
+			parsed = appendParsed(parsed, txRes, err, txHash, "fjsz", fjszProgramID.String())
 		case terminalProgramID:
 			txRes, err := parseTermInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "terminal")
+			parsed = appendParsed(parsed, txRes, err, txHash, "terminal", terminalProgramID.String())
+		case jupiterV6ProgramID:
+			txRes, err := parseJupiterV6Instruction(versioned, i)
+			parsed = appendParsed(parsed, txRes, err, txHash, "jupiterv6", jupiterV6ProgramID.String())
+		case okxDexRouteV2ProgramID:
+			txRes, err := parseOkxDexRouteV2Instruction(versioned, i)
+			parsed = appendParsed(parsed, txRes, err, txHash, "okxdexroutev2", okxDexRouteV2ProgramID.String())
 		}
 	}
 
 	return parsed
 }
 
-func appendParsed(list []*TxSignal, parsed *TxSignal, err error, txHash [64]byte, label string) []*TxSignal {
+func appendParsed(list []*TxSignal, parsed *TxSignal, err error, txHash [64]byte, label string, entryContract string) []*TxSignal {
 	if err != nil {
-		logger.Debug("txparser: failed to parse", "label", label, "instruction", err, "tx_hash", base58.Encode(txHash[:]))
+		if !strings.HasPrefix(err.Error(), "account index") {
+			logger.Debug("txparser: failed to parse", "label", label, "instruction", err, "tx_hash", base58.Encode(txHash[:]))
+		}
 		return list
 	}
 	if parsed != nil {
+		parsed.EntryContract = entryContract
 		list = append(list, parsed)
 	}
 	return list
@@ -331,11 +359,8 @@ func formatSolAmount(lamports uint64) decimal.Decimal {
 }
 
 func getStaticKey(static []solana.PublicKey, index int) (solana.PublicKey, error) {
-	if index < 0 {
-		return solana.PublicKey{}, fmt.Errorf("account index %d less then 0", index)
-	}
-	if index >= len(static) {
-		return solana.PublicKey{}, fmt.Errorf("account index %d out of range", index)
+	if index < 0 || index >= len(static) {
+		return solana.PublicKey{}, NewAccountNotFoundError(index, len(static))
 	}
 	return static[index], nil
 }
@@ -381,6 +406,7 @@ func parsePumpCreate(tx *versionedTransaction, instruction *compiledInstruction)
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "pump",
 		Maker:              creator.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -421,6 +447,7 @@ func parsePumpCreateV2(tx *versionedTransaction, instruction *compiledInstructio
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "pump",
 		Maker:              args.Creator.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -484,6 +511,7 @@ func parsePumpBuy(tx *versionedTransaction, instruction *compiledInstruction) (*
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "pump",
 		Maker:              buyer.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -541,6 +569,7 @@ func parsePumpSell(tx *versionedTransaction, instruction *compiledInstruction) (
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "pump",
 		Maker:              seller.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -599,6 +628,7 @@ func parseAzczAmmBuy(tx *versionedTransaction, instructionIndex int) (*TxSignal,
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "azcz",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -642,6 +672,7 @@ func parseAzczBuy(tx *versionedTransaction, instructionIndex int) (*TxSignal, er
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "azcz",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -696,6 +727,7 @@ func parseF5tfInstruction(tx *versionedTransaction, instructionIndex int) (*TxSi
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "f5tf",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -728,10 +760,10 @@ func parseFlasInstruction(tx *versionedTransaction, instructionIndex int) (*TxSi
 		return nil, fmt.Errorf("data too short for args flas instruction, len: %d", len(instruction.Data))
 	}
 	methodData := instruction.Data[17:20]
-	if !matchMethod(methodData, flasBuyTokensIX) {
-		return nil, nil
-	}
-	if matchMethod(methodData, f5tfBuyTokensIX) {
+	//if !matchMethod(methodData, flasBuyTokensIX) {
+	//	return nil, nil
+	//}
+	if matchMethod(methodData, flasBuyTokensIX) {
 		return parseFlasBuy(tx, instructionIndex)
 	} else if matchMethod(methodData, flasSellTokensIX) {
 		return parseFlasSell(tx, instructionIndex)
@@ -759,26 +791,27 @@ func parseFlasAmmSell(tx *versionedTransaction, instructionIndex int) (*TxSignal
 		return nil, err
 	}
 
-	var args flasBuyArgs
+	var args flasArgs
 	if err := borsh.Deserialize(&args, instruction.Data[1:]); err != nil {
 		return nil, fmt.Errorf("failed to parse buy tokens args: %w", err)
 	}
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "flas",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
-		Token0Amount:       decimal.Zero,
-		Token1Amount:       formatSolAmount(args.TokenAmount),
-		Program:            "Pump",
+		Token0Amount:       formatTokenAmount(args.Amount1),
+		Token1Amount:       formatSolAmount(args.Amount2),
+		Program:            "PumpAMM",
 		Event:              "sell",
 		IsToken2022:        false,
 		IsMayhemMode:       false,
-		ExactSOL:           true,
+		ExactSOL:           false,
 		Block:              tx.Block,
-		Token0AmountUint64: 0,
-		Token1AmountUint64: args.TokenAmount,
+		Token0AmountUint64: args.Amount1,
+		Token1AmountUint64: args.Amount2,
 	}, nil
 }
 
@@ -798,26 +831,27 @@ func parseFlasAmmBuy(tx *versionedTransaction, instructionIndex int) (*TxSignal,
 		return nil, err
 	}
 
-	var args flasBuyArgs
+	var args flasArgs
 	if err := borsh.Deserialize(&args, instruction.Data[1:]); err != nil {
 		return nil, fmt.Errorf("failed to parse buy tokens args: %w", err)
 	}
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "flas",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
 		Token0Amount:       decimal.Zero,
-		Token1Amount:       formatSolAmount(args.TokenAmount),
-		Program:            "Pump",
-		Event:              "sell",
+		Token1Amount:       formatSolAmount(args.Amount1),
+		Program:            "PumpAMM",
+		Event:              "buy",
 		IsToken2022:        false,
 		IsMayhemMode:       false,
 		ExactSOL:           true,
 		Block:              tx.Block,
 		Token0AmountUint64: 0,
-		Token1AmountUint64: args.TokenAmount,
+		Token1AmountUint64: args.Amount1,
 	}, nil
 }
 
@@ -837,25 +871,26 @@ func parseFlasSell(tx *versionedTransaction, instructionIndex int) (*TxSignal, e
 		return nil, err
 	}
 
-	var args flasBuyArgs
+	var args flasArgs
 	if err := borsh.Deserialize(&args, instruction.Data[1:]); err != nil {
 		return nil, fmt.Errorf("failed to parse buy tokens args: %w", err)
 	}
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "flas",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
-		Token0Amount:       formatTokenAmount(args.TokenAmount),
-		Token1Amount:       formatSolAmount(args.SolAmount),
+		Token0Amount:       formatTokenAmount(args.Amount1),
+		Token1Amount:       formatSolAmount(args.Amount2),
 		Program:            "Pump",
 		Event:              "sell",
 		IsToken2022:        false,
 		IsMayhemMode:       false,
 		Block:              tx.Block,
-		Token0AmountUint64: args.TokenAmount,
-		Token1AmountUint64: args.SolAmount,
+		Token0AmountUint64: args.Amount1,
+		Token1AmountUint64: args.Amount2,
 	}, nil
 }
 
@@ -874,27 +909,30 @@ func parseFlasBuy(tx *versionedTransaction, instructionIndex int) (*TxSignal, er
 	if err != nil {
 		return nil, err
 	}
-
-	var args flasBuyArgs
+	if len(instruction.Data) > 20 {
+		instruction.Data = instruction.Data[:20]
+	}
+	var args flasArgs
 	if err := borsh.Deserialize(&args, instruction.Data[1:]); err != nil {
 		return nil, fmt.Errorf("failed to parse buy tokens args: %w", err)
 	}
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "flas",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
-		Token0Amount:       formatTokenAmount(args.TokenAmount),
-		Token1Amount:       formatSolAmount(args.SolAmount),
+		Token0Amount:       formatTokenAmount(args.Amount2),
+		Token1Amount:       formatSolAmount(args.Amount1),
 		Program:            "Pump",
 		Event:              "buy",
 		IsToken2022:        false,
 		IsMayhemMode:       false,
 		ExactSOL:           true,
 		Block:              tx.Block,
-		Token0AmountUint64: args.TokenAmount,
-		Token1AmountUint64: args.SolAmount,
+		Token0AmountUint64: args.Amount2,
+		Token1AmountUint64: args.Amount1,
 	}, nil
 }
 
@@ -948,6 +986,7 @@ func parsePhotonBuy(tx *versionedTransaction, instruction *compiledInstruction)
 	solAmount := args.SolAmount * (100000000 - 1234568) / 100000000
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "photon",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -1003,6 +1042,7 @@ func parsePhotonSwap(tx *versionedTransaction, instruction *compiledInstruction)
 	solAmount := args.FromAmount * (100000000 - 1234568) / 100000000
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "photon",
 		Maker:              buyer.String(),
 		Token0Address:      base.String(),
 		Token1Address:      wsolMint,
@@ -1084,6 +1124,7 @@ func parseTermAmmSell(tx *versionedTransaction, instruction *compiledInstruction
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "term",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -1119,6 +1160,7 @@ func parseTermBuy(tx *versionedTransaction, instruction *compiledInstruction) (*
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "term",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -1153,6 +1195,7 @@ func parseTermSell(tx *versionedTransaction, instruction *compiledInstruction) (
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "term",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -1224,6 +1267,7 @@ func parsePumpAmmBuy(tx *versionedTransaction, instruction *compiledInstruction)
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "pumpamm",
 		Maker:              buyer.String(),
 		Token0Address:      base.String(),
 		Token1Address:      wsolMint,
@@ -1270,6 +1314,7 @@ func parsePumpAmmSell(tx *versionedTransaction, instruction *compiledInstruction
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "pumpamm",
 		Maker:              buyer.String(),
 		Token0Address:      base.String(),
 		Token1Address:      wsolMint,
@@ -1323,6 +1368,7 @@ func parseBoboInstruction(tx *versionedTransaction, instructionIndex int) (*TxSi
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "bobo",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -1383,6 +1429,7 @@ func parseQtkvSell(tx *versionedTransaction, instructionIndex int) (*TxSignal, e
 	tokenAmount := binary.LittleEndian.Uint64(instruction.Data[19:25])
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "qtkv",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -1421,6 +1468,7 @@ func parseQtkvAmmSell(tx *versionedTransaction, instructionIndex int) (*TxSignal
 	tokenAmount := binary.LittleEndian.Uint64(instruction.Data[19:25])
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "qtkv",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -1459,6 +1507,7 @@ func parseQtkvBuy(tx *versionedTransaction, instructionIndex int) (*TxSignal, er
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "qtkv",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,
@@ -1512,6 +1561,7 @@ func parseFjszInstruction(tx *versionedTransaction, instructionIndex int) (*TxSi
 
 	return &TxSignal{
 		TxHash:             tx.Signatures[0].String(),
+		Label:              "fjsz",
 		Maker:              user.String(),
 		Token0Address:      mint.String(),
 		Token1Address:      wsolMint,

pkg/shreder/txparser_test.go

@@ -0,0 +1,56 @@
+package shreder
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/near/borsh-go"
+)
+
+func TestDecodeAxiomArgs(t *testing.T) {
+	tests := []struct {
+		name    string
+		hexData string
+	}{
+		{
+			name:    "pump amm sell Test 0",
+			hexData: "00686f08bb1b0000007eb4ac020000000001020200183c",
+		},
+		{
+			name:    "pump amm buy Test 1",
+			hexData: "00c09ee6050000000001c94d882600000000020200323c",
+		},
+		{
+			name:    "pump buy Test 2",
+			hexData: "00d8d3bc0000000000bb7c53f009000000000104185a",
+		},
+		{
+			name:    "pump sell Test 3",
+			hexData: "009bbf69ec08080000830bc61200000000010103a000",
+		},
+		{
+			name:    "pump swap sell Test 4",
+			hexData: "00c98ea7588b0000009adf3b010000000001020200283c",
+		},
+		{
+			name:    "pump swap sell Test 5",
+			hexData: "00d3727f9301000000f9a50b0100000000010202001e00",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			data, err := hex.DecodeString(tt.hexData)
+			if err != nil {
+				t.Fatalf("failed to decode hex string: %v", err)
+				return
+			}
+			var args flasArgs
+			if err := borsh.Deserialize(&args, data[1:]); err != nil {
+				t.Fatalf("failed to decode Axiom args: %v", err)
+				return
+			}
+			t.Logf("Decoded Axiom Args: %+v", args)
+		})
+	}
+}