chore: add release pool

fix: photon buy
chore: improve test
2026-01-19 09:35:47 +08:00 · 2026-01-08 16:25:34 +08:00 · 2026-01-08 16:20:17 +08:00 · 2026-01-08 16:07:57 +08:00 · 2026-01-08 15:20:50 +08:00 · 2026-01-08 12:54:21 +08:00
11 changed files with 733 additions and 179 deletions
--- a/cmd/shreder/main.go
+++ b/cmd/shreder/main.go
@@ -61,7 +61,7 @@ func main() {
 				},
 			},
 			// TODO: axiom, gmgn, etc.
-		})
+		}, shreder.BlocksStats(false), shreder.LogParsedStats(true), shreder.ShowTableLoaded(false))
 	if err != nil {
 		panic(err)
 	}
@@ -75,7 +75,6 @@ func main() {
 		<-exitSignal
 		cancel()
 	}()
-
 	// async read from shreder
 	txCh := make(chan shreder.TxSignalBatch, 1000)
 	go func() {
@@ -94,8 +93,8 @@ func main() {
 		case txBatch := <-txCh:
 			//jsonData, _ := json.MarshalIndent(txBatch, "", "  ")
 			for _, tx := range txBatch {
-				if tx.Label == "dflow" {
-					fmt.Println("===============", tx.TxHash, tx.Event, tx.Token0Address, "token:", tx.Token0Amount)
+				if tx.Label == "okxdexroutev2" || tx.Label == "jupiterv6" || tx.Label == "dflow" {
+					fmt.Println("===============", tx.TxHash, tx.Label, tx.Event, tx.Token0Address, "token:", tx.Token0Amount, "parse time:", tx.ParseEnd.Sub(tx.ParseStart))
 				}
 			}
 			//fmt.Println(txBatch[0].TxHash)
--- a/go.mod
+++ b/go.mod
@@ -4,10 +4,13 @@ go 1.25.1

 require (
 	github.com/BlockRazorinc/solana-trader-client-go v0.0.0-20250722092120-44561cb37455
+	github.com/gagliardetto/binary v0.8.0
 	github.com/gagliardetto/solana-go v1.12.0
+	github.com/hashicorp/golang-lru/v2 v2.0.7
 	github.com/mr-tron/base58 v1.2.0
 	github.com/near/borsh-go v0.3.2-0.20220516180422-1ff87d108454
 	github.com/panjf2000/ants/v2 v2.11.4
+	github.com/quic-go/quic-go v0.58.0
 	github.com/shopspring/decimal v1.4.0
 	google.golang.org/grpc v1.75.0
 	google.golang.org/protobuf v1.36.10
@@ -19,10 +22,8 @@ require (
 	github.com/blendle/zapdriver v1.3.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fatih/color v1.9.0 // indirect
-	github.com/gagliardetto/binary v0.8.0 // indirect
 	github.com/gagliardetto/treeout v0.1.4 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.13.6 // indirect
 	github.com/logrusorgru/aurora v2.0.3+incompatible // indirect
@@ -32,7 +33,6 @@ require (
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/mostynb/zstdpool-freelist v0.0.0-20201229113212-927304c0c3b1 // indirect
-	github.com/quic-go/quic-go v0.58.0 // indirect
 	github.com/streamingfast/logging v0.0.0-20230608130331-f22c91403091 // indirect
 	go.mongodb.org/mongo-driver v1.12.2 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
--- a/go.sum
+++ b/go.sum
@@ -88,9 +88,8 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/test-go/testify v1.1.4 h1:Tf9lntrKUMHiXQ07qBScBTSA0dhYQlu83hswqelv1iE=
 github.com/test-go/testify v1.1.4/go.mod h1:rH7cfJo/47vWGdi4GPj16x3/t1xGOj2YxzmNQzk2ghU=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
@@ -118,6 +117,8 @@ go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI=
 go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
+go.uber.org/mock v0.5.2 h1:LbtPTcP8A5k9WPXj54PPPbjcI4Y6lhyOZXn+VS7wNko=
+go.uber.org/mock v0.5.2/go.mod h1:wLlUxC2vVTPTaE3UD51E0BGOAElKrILxhVSDYQLld5o=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
--- a/pkg/shreder/addresstables.go
+++ b/pkg/shreder/addresstables.go
@@ -11,24 +11,33 @@ import (
 	"github.com/panjf2000/ants/v2"
 )

+type TableInfo struct {
+	overErrCount int
+
+	addresses []solana.PublicKey
+}
+
 type AddressTables struct {
+	showTableLoaded bool
+
 	rpcClient *rpc.Client
-	mux       sync.RWMutex
 	loadMux   sync.Mutex
-	tables    *lru.Cache[solana.PublicKey, []solana.PublicKey]
+	tables    *lru.Cache[solana.PublicKey, *TableInfo]
 	loading   map[solana.PublicKey]struct{}

 	pool *ants.Pool
 }

-func NewAddressTables(rpcClient *rpc.Client) *AddressTables {
+func NewAddressTables(rpcClient *rpc.Client, showTableLoaded bool) *AddressTables {
 	pool, _ := ants.NewPool(5, ants.WithPreAlloc(true), ants.WithNonblocking(true))
-	cache, _ := lru.New[solana.PublicKey, []solana.PublicKey](10000)
+	cache, _ := lru.New[solana.PublicKey, *TableInfo](10000)
 	return &AddressTables{
 		rpcClient: rpcClient,
 		tables:    cache,
 		loading:   make(map[solana.PublicKey]struct{}),
 		pool:      pool,
+
+		showTableLoaded: showTableLoaded,
 	}
 }

@@ -54,12 +63,7 @@ func (at *AddressTables) loadAddressTable(tablePubkey solana.PublicKey) ([]solan
 	return addresses, nil

 }
-
-func (at *AddressTables) GetAddressTable(tablePubkey solana.PublicKey, idx []uint8) []solana.PublicKey {
-	at.mux.RLock()
-	addresses, ok := at.tables.Get(tablePubkey)
-	if !ok {
-		at.mux.RUnlock()
+func (at *AddressTables) load(tablePubkey solana.PublicKey) {
 	_ = at.pool.Submit(func() {
 		at.loadMux.Lock()
 		_, loading := at.loading[tablePubkey]
@@ -82,25 +86,55 @@ func (at *AddressTables) GetAddressTable(tablePubkey solana.PublicKey, idx []uin
 		delete(at.loading, tablePubkey)
 		at.loadMux.Unlock()

-			at.mux.Lock()
-			at.tables.Add(tablePubkey, table)
-			total := at.tables.Len()
-			at.mux.Unlock()
-			logger.Info("loadAddressTable", "table", tablePubkey.String(), "table count:", total)
+		at.tables.Add(tablePubkey, &TableInfo{
+			addresses: table,
 		})
+		if at.showTableLoaded {
+			total := at.tables.Len()
+			logger.Info("loadAddressTable", "table", tablePubkey.String(), "table count:", total)
+		}
+	})
+}

+func (at *AddressTables) FillToTx(tx *versionedTransaction, tablePubkey solana.PublicKey, idx []uint8) bool {
+	addresses, ok := at.tables.Get(tablePubkey)
+	if !ok {
+		at.load(tablePubkey)
+		return false
+	}
+
+	for _, i := range idx {
+		if int(i) >= len(addresses.addresses) {
+			logger.Error("over loadAddressTable failed", "idx", i, "table", tablePubkey)
+			addresses.overErrCount++
+			if addresses.overErrCount > 10 {
+				at.load(tablePubkey)
+			}
+			return false
+		}
+		tx.Message.StaticAccountKeys = append(tx.Message.StaticAccountKeys, addresses.addresses[i])
+	}
+	return true
+}
+
+func (at *AddressTables) GetAddressTable(tablePubkey solana.PublicKey, idx []uint8) []solana.PublicKey {
+	addresses, ok := at.tables.Get(tablePubkey)
+	if !ok {
+		at.load(tablePubkey)
 		return nil
 	}
-	at.mux.RUnlock()

 	var result solana.PublicKeySlice = make([]solana.PublicKey, 0, len(idx))
 	for _, i := range idx {
-		if int(i) >= len(addresses) {
+		if int(i) >= len(addresses.addresses) {
 			logger.Error("over loadAddressTable failed", "idx", i, "table", tablePubkey)
-			//todo... update table?
-			continue
+			addresses.overErrCount++
+			if addresses.overErrCount > 10 {
+				at.load(tablePubkey)
 			}
-		result = append(result, addresses[i])
+			break
+		}
+		result = append(result, addresses.addresses[i])
 	}
 	return result
 }
--- a/pkg/shreder/client.go
+++ b/pkg/shreder/client.go
@@ -3,23 +3,61 @@ package shreder
 import (
 	"context"
 	"fmt"
+	"runtime"
+	"time"

 	"github.com/gagliardetto/solana-go/rpc"
+	"github.com/panjf2000/ants/v2"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 )

 type Client struct {
+	enableBlockStats bool
+	enableParseStats bool
+
 	conn         *grpc.ClientConn
 	client       ShrederServiceClient
 	tableLoader  *AddressTables
 	subscription map[string]*SubscribeRequestFilterTransactions
+
+	pool *ants.Pool
+
+	lastSlot     uint64
+	lastSlotTime time.Time
+}
+
+type ClientOpts struct {
+	blockStats      bool
+	showTableLoaded bool
+	logParseStats   bool
+}
+
+type ClientOption func(*ClientOpts)
+
+func ShowTableLoaded(enable bool) ClientOption {
+	return func(opts *ClientOpts) {
+		opts.showTableLoaded = enable
+	}
+}
+
+func BlocksStats(enable bool) ClientOption {
+	return func(opts *ClientOpts) {
+		opts.blockStats = enable
+	}
+}
+
+func LogParsedStats(enable bool) ClientOption {
+	return func(opts *ClientOpts) {
+		opts.logParseStats = enable
+	}
 }

 func NewShrederClient(
 	url string,
 	rpcClient *rpc.Client,
 	subscription map[string]*SubscribeRequestFilterTransactions,
+	options ...ClientOption,
 ) (*Client, func(), error) {
 	if rpcClient == nil {
 		return nil, func() {}, fmt.Errorf("rpc client is nil")
@@ -30,11 +68,29 @@ func NewShrederClient(
 		return nil, func() {}, err
 	}

+	poolSize := runtime.NumCPU()*2 + 2
+	logger.Info("creating shreder client", "url", url, "pool_size", poolSize)
+	pool, err := ants.NewPool(poolSize, ants.WithNonblocking(false))
+	if err != nil {
+		return nil, func() {}, err
+	}
+	o := &ClientOpts{
+		blockStats:      false,
+		showTableLoaded: true,
+		logParseStats:   false,
+	}
+	for _, option := range options {
+		option(o)
+	}
 	s := &Client{
 		conn:         conn,
 		client:       NewShrederServiceClient(conn),
 		subscription: subscription,
-		tableLoader:  NewAddressTables(rpcClient),
+		tableLoader:  NewAddressTables(rpcClient, o.showTableLoaded),
+		pool:         pool,
+
+		enableBlockStats: o.blockStats,
+		enableParseStats: o.logParseStats,
 	}

 	return s, func() {
@@ -45,6 +101,10 @@ func NewShrederClient(
 func (c *Client) Wait() {
 	logger.Debug("waiting for shreder client to stop")

+	if c.pool != nil {
+		c.pool.Release()
+	}
+
 	err := c.conn.Close()
 	if err != nil {
 		logger.Error("failed to close connection: ", "err", err)
@@ -59,6 +119,8 @@ func (c *Client) ReadSync(ctx context.Context, txCh chan<- TxSignalBatch) error
 		return err
 	}

+	logger.Debug("subscribing to transactions")
+
 	err = stream.Send(&SubscribeTransactionsRequest{
 		Transactions: c.subscription,
 	})
@@ -66,26 +128,53 @@ func (c *Client) ReadSync(ctx context.Context, txCh chan<- TxSignalBatch) error
 		return err
 	}

+	// reboot the pool
+	c.pool.Reboot()
+
 	for {
-		response, err := stream.Recv()
+		var response *SubscribeTransactionsResponse
+		response, err = stream.Recv()
 		if err != nil {
-			return err
+			break
 		}

-		txBatch := ParseTransaction(response.Transaction, c.tableLoader)
+		if c.enableBlockStats {
+			slot := response.Transaction.Slot
+			now := time.Now()
+			if c.lastSlotTime.IsZero() || slot > c.lastSlot {
+				if !c.lastSlotTime.IsZero() {
+					logger.Info("block processed", "running", c.pool.Running(), "slot", slot, "prev_slot", c.lastSlot, "delta_ms", now.Sub(c.lastSlotTime).Milliseconds())
+				}
+				c.lastSlot = slot
+				c.lastSlotTime = now
+			}
+		}
+
+		txData := response.Transaction
+
+		err = c.pool.Submit(func() {
+			txBatch := ParseTransaction(txData, c.tableLoader, c.enableParseStats)
 			if len(txBatch) == 0 {
-			continue
+				return
 			}

-		// set fixed source for tx signals
 			for _, tx := range txBatch {
 				tx.Source = "shreder"
 			}

 			select {
 			case <-ctx.Done():
-			return ctx.Err()
+				return
 			case txCh <- txBatch:
 			}
+		})
+		if err != nil {
+			break
 		}
 	}
+
+	// sync waiting for all tasks to complete
+	c.pool.Release()
+
+	return err
+}
--- a/pkg/shreder/dflow.go
+++ b/pkg/shreder/dflow.go
@@ -12,6 +12,7 @@ import (

 var (
 	dflowProgramID     = solana.MustPublicKeyFromBase58("DF1ow4tspfHX9JwWJsAb9epbkA8hmpSEAtxXy1V27QBH")
+	dflowProgramString = dflowProgramID.String()

 	dflowSwapDisc                   = []byte{248, 198, 158, 145, 225, 117, 135, 200}
 	dflowSwap2Disc                  = []byte{65, 75, 63, 76, 235, 91, 91, 136}
@@ -276,10 +277,11 @@ func parseDFlowInstruction(tx *versionedTransaction, instructionIndex int) (*TxS
 	var (
 		srcIdx uint8
 	)
-	for i, acctIdx := range ix.Accounts {
-		if i < 6 {
-			continue
+	if len(ix.Accounts) <= 6 {
+		return nil, nil
 	}
+	accounts := ix.Accounts[5:]
+	for i, acctIdx := range accounts {
 		key, err := getStaticKey(tx.Message.StaticAccountKeys, int(acctIdx))
 		if err != nil {
 			return nil, err
@@ -289,15 +291,15 @@ func parseDFlowInstruction(tx *versionedTransaction, instructionIndex int) (*TxS
 			break
 		}
 	}
-	if srcIdx == 0 || srcIdx+1 >= uint8(len(ix.Accounts)) {
+	if srcIdx == 0 || srcIdx+1 >= uint8(len(accounts)) {
 		return nil, nil
 	}

-	baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(ix.Accounts[srcIdx]))
+	baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx]))
 	if err != nil {
 		return nil, err
 	}
-	quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(ix.Accounts[srcIdx+1]))
+	quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx+1]))
 	if err != nil {
 		return nil, err
 	}
@@ -307,7 +309,6 @@ func parseDFlowInstruction(tx *versionedTransaction, instructionIndex int) (*TxS

 	// Build TxSignal
 	sig := &TxSignal{
-		Label:              "dflow",
 		TxHash:             tx.Signatures[0].String(),
 		Maker:              tx.Message.StaticAccountKeys[0].String(),
 		Program:            "PumpAMM",
--- a/pkg/shreder/juptierv6.go
+++ b/pkg/shreder/juptierv6.go
@@ -935,10 +935,11 @@ func parseJupiterV6Instruction(tx *versionedTransaction, instructionIndex int) (
 		var (
 			srcIdx uint8
 		)
-		for i, acctIdx := range instruction.Accounts {
-			if i < 9 {
-				continue
+		if len(instruction.Accounts) <= 9 {
+			return nil, nil
 		}
+		accounts := instruction.Accounts[8:]
+		for i, acctIdx := range accounts {
 			key, err := getStaticKey(tx.Message.StaticAccountKeys, int(acctIdx))
 			if err != nil {
 				return nil, err
@@ -948,18 +949,18 @@ func parseJupiterV6Instruction(tx *versionedTransaction, instructionIndex int) (
 				break
 			}
 		}
-		if srcIdx == 0 || srcIdx+1 >= uint8(len(instruction.Accounts)) {
+		if srcIdx == 0 || srcIdx+1 >= uint8(len(accounts)) {
 			return nil, nil
 		}

-		baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(instruction.Accounts[srcIdx]))
+		baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx]))
 		if err != nil {
 			return nil, err
 		}
 		if !sourceMint.Equals(baseMint) {
 			return nil, nil
 		}
-		quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(instruction.Accounts[srcIdx+1]))
+		quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx+1]))
 		if err != nil {
 			return nil, err
 		}
@@ -978,10 +979,11 @@ func parseJupiterV6Instruction(tx *versionedTransaction, instructionIndex int) (
 		var (
 			srcIdx uint8
 		)
-		for i, acctIdx := range instruction.Accounts {
-			if i < 12 {
-				continue
+		if len(instruction.Accounts) <= 12 {
+			return nil, nil
 		}
+		accounts := instruction.Accounts[11:]
+		for i, acctIdx := range accounts {
 			key, err := getStaticKey(tx.Message.StaticAccountKeys, int(acctIdx))
 			if err != nil {
 				return nil, err
@@ -991,11 +993,11 @@ func parseJupiterV6Instruction(tx *versionedTransaction, instructionIndex int) (
 				break
 			}
 		}
-		if srcIdx == 0 || srcIdx+1 >= uint8(len(instruction.Accounts)) {
+		if srcIdx == 0 || srcIdx+1 >= uint8(len(accounts)) {
 			return nil, nil
 		}

-		baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(instruction.Accounts[srcIdx]))
+		baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx]))
 		if err != nil {
 			return nil, err
 		}
@@ -1003,7 +1005,7 @@ func parseJupiterV6Instruction(tx *versionedTransaction, instructionIndex int) (
 			return nil, nil
 		}

-		quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(instruction.Accounts[srcIdx+1]))
+		quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx+1]))
 		if err != nil {
 			return nil, err
 		}
@@ -1018,10 +1020,8 @@ func parseJupiterV6Instruction(tx *versionedTransaction, instructionIndex int) (
 			srcIdx uint8
 		)

-		for i, acctIdx := range instruction.Accounts {
-			if i < 9 {
-				continue
-			}
+		accounts := instruction.Accounts[9:]
+		for i, acctIdx := range accounts {
 			key, err := getStaticKey(tx.Message.StaticAccountKeys, int(acctIdx))
 			if err != nil {
 				return nil, err
@@ -1031,15 +1031,15 @@ func parseJupiterV6Instruction(tx *versionedTransaction, instructionIndex int) (
 				break
 			}
 		}
-		if srcIdx == 0 || srcIdx+1 >= uint8(len(instruction.Accounts)) {
+		if srcIdx == 0 || srcIdx+1 >= uint8(len(accounts)) {
 			return nil, nil
 		}
-		sourceMint, err = getStaticKey(tx.Message.StaticAccountKeys, int(instruction.Accounts[srcIdx]))
+		sourceMint, err = getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx]))
 		if err != nil {
 			return nil, err
 		}

-		quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(instruction.Accounts[srcIdx+1]))
+		quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx+1]))
 		if err != nil {
 			return nil, err
 		}
@@ -1049,7 +1049,6 @@ func parseJupiterV6Instruction(tx *versionedTransaction, instructionIndex int) (
 	}

 	signal := &TxSignal{
-		Label:              "jupiterV6",
 		TxHash:             tx.Signatures[0].String(),
 		Maker:              tx.Message.StaticAccountKeys[0].String(),
 		Token0Address:      sourceMint.String(),
--- a/pkg/shreder/okxonchainlab.go
+++ b/pkg/shreder/okxonchainlab.go
@@ -12,6 +12,7 @@ import (

 var (
 	okxDexRouteV2ProgramID       = solana.MustPublicKeyFromBase58("proVF4pMXVaYqmy4NjniPh4pqKNfMmsihgd4wdkCX3u")
+	okxDexRouteV2ProgramIDString = okxDexRouteV2ProgramID.String()

 	okxSwapTobDisc             = []byte{170, 41, 85, 177, 132, 80, 31, 53}
 	okxSwapTobWithReceiverDisc = []byte{223, 170, 216, 234, 204, 6, 241, 25}
@@ -314,10 +315,11 @@ func parseOkxDexRouteV2Instruction(tx *versionedTransaction, instructionIndex in
 	var (
 		srcIdx uint8
 	)
-	for i, acctIdx := range ix.Accounts {
-		if i < 15 {
-			continue
+	if len(ix.Accounts) <= 15 {
+		return nil, nil
 	}
+	accounts := ix.Accounts[14:]
+	for i, acctIdx := range accounts {
 		key, err := getStaticKey(tx.Message.StaticAccountKeys, int(acctIdx))
 		if err != nil {
 			return nil, err
@@ -327,11 +329,11 @@ func parseOkxDexRouteV2Instruction(tx *versionedTransaction, instructionIndex in
 			break
 		}
 	}
-	if srcIdx == 0 || int(srcIdx+1) >= len(ix.Accounts) {
+	if srcIdx == 0 || int(srcIdx+1) >= len(accounts) {
 		return nil, nil
 	}

-	baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(ix.Accounts[srcIdx]))
+	baseMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx]))
 	if err != nil {
 		return nil, err
 	}
@@ -339,7 +341,7 @@ func parseOkxDexRouteV2Instruction(tx *versionedTransaction, instructionIndex in
 		return nil, nil
 	}

-	quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(ix.Accounts[srcIdx+1]))
+	quoteMint, err := getStaticKey(tx.Message.StaticAccountKeys, int(accounts[srcIdx+1]))
 	if err != nil {
 		return nil, err
 	}
@@ -348,7 +350,6 @@ func parseOkxDexRouteV2Instruction(tx *versionedTransaction, instructionIndex in
 	}

 	return &TxSignal{
-		Label:              "okxdexroutev2",
 		TxHash:             tx.Signatures[0].String(),
 		Maker:              tx.Message.StaticAccountKeys[0].String(),
 		Token0Address:      baseMint.String(),
--- a/pkg/shreder/tx.go
+++ b/pkg/shreder/tx.go
@@ -45,13 +45,15 @@ 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"`

 	// parsed values
 	Token0AmountUint64 uint64 `json:"-"`
 	Token1AmountUint64 uint64 `json:"-"`
+
+	ParseStart time.Time `json:"parse_start"`
+	ParseEnd   time.Time `json:"parse_end"`
 }

 func (t *TxSignal) Parse() *TxSignal {
--- a/pkg/shreder/txparser.go
+++ b/pkg/shreder/txparser.go
@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"math/big"
 	"strings"
+	"sync"
+	"time"

 	"github.com/gagliardetto/solana-go"
 	"github.com/mr-tron/base58"
@@ -21,13 +23,11 @@ const (
 // program ids
 var (
 	pumpProgramID = solana.MustPublicKeyFromBase58("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P")
-
 	// has no sell function with pump and pump.amm program
 	azczProgramID = solana.MustPublicKeyFromBase58("AzcZqCRUQgKEg5FTAgY7JacATABEYCEfMbjXEzspLYFB")

 	// only buy function with pump program
 	f5tfProgramID = solana.MustPublicKeyFromBase58("F5tfvbLog9VdGUPqBDTT8rgXvTTcq7e5UiGnupL1zvBq")
-
 	// only pump.fun function
 	photonProgramID = solana.MustPublicKeyFromBase58("BSfD6SHZigAfDWSjzD5Q41jw8LmKwtmjskPH9XW1mrRW")

@@ -45,6 +45,10 @@ var (
 	terminalProgramID = solana.MustPublicKeyFromBase58("term9YPb9mzAsABaqN71A4xdbxHmpBNZavpBiQKZzN3")

 	jupiterV6ProgramID = solana.MustPublicKeyFromBase58("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4")
+
+	gmgnProgramID = solana.MustPublicKeyFromBase58("GMgnVFR8Jb39LoXsEVzb3DvBy3ywCmdmJquHUy1Lrkqb")
+
+	bonkProgramID = solana.MustPublicKeyFromBase58("BBRouter1cVunVXvkcqeKkZQcBK7ruan37PPm3xzWaXD")
 )

 type AccountNotFoundError struct {
@@ -94,6 +98,10 @@ var (
 	terminalBuyTokensIX     = []byte{0xa6, 0x54, 0x14, 0x96, 0x9f, 0x77, 0x59, 0xca}
 	terminalSellTokensIX    = []byte{0xbe, 0x84, 0xa2, 0x96, 0x93, 0x7c, 0xf8, 0x6b}
 	terminalAmmSellTokensIX = []byte{0x40, 0x64, 0x97, 0xb9, 0x16, 0xfa, 0xec, 0xb1}
+
+	gmgnBuyTokensIX = []byte{0x66, 0x06, 0x3d, 0x12, 0x01, 0xda, 0xeb, 0xea}
+
+	bonkBuyAndSellTokensIX = []byte{0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a}
 )

 type compiledInstruction struct {
@@ -118,6 +126,7 @@ type versionedTransaction struct {
 	Signatures []solana.Signature
 	Message    versionedMessage
 	Block      uint64
+	Time       time.Time
 }

 type pumpExtendedSellArgs struct {
@@ -192,15 +201,72 @@ type fjszBuyArgs struct {
 	TokenAmount uint64
 }

+var (
+	versionedPool = sync.Pool{}
+
+	accIdxPool = sync.Pool{}
+)
+
+func requireAccIdxSlice() []uint8 {
+	v := accIdxPool.Get()
+	if v == nil {
+		return make([]uint8, 0, 16)
+	}
+	return v.([]uint8)
+}
+
+func releaseAccIdxSlice(s []uint8) {
+	if s == nil {
+		return
+	}
+	s = s[:0]
+	accIdxPool.Put(s)
+}
+
+func requireVersionedPool() *versionedTransaction {
+	v := versionedPool.Get()
+	if v == nil {
+		return &versionedTransaction{
+			Signatures: make([]solana.Signature, 0, 10),
+			Message: versionedMessage{
+				StaticAccountKeys:   make([]solana.PublicKey, 0, 256),
+				Instructions:        make([]compiledInstruction, 0, 16),
+				AddressTableLookups: make([]addressTableLookup, 0, 10),
+			},
+		}
+	}
+	return v.(*versionedTransaction)
+}
+
+func releaseVersionedPool(v *versionedTransaction) {
+	if v == nil {
+		return
+	}
+	for i := range v.Message.Instructions {
+		releaseAccIdxSlice(v.Message.Instructions[i].Accounts)
+	}
+	for i := range v.Message.AddressTableLookups {
+		releaseAccIdxSlice(v.Message.AddressTableLookups[i].WritableIndexes)
+		releaseAccIdxSlice(v.Message.AddressTableLookups[i].ReadonlyIndexes)
+	}
+	versionedPool.Put(v)
+}
+
 // ParseTransaction mirrors the Rust parse_transaction entry point.
-func ParseTransaction(update *SubscribeUpdateTransaction, loader *AddressTables) []*TxSignal {
+func ParseTransaction(update *SubscribeUpdateTransaction, loader *AddressTables, stats bool) []*TxSignal {
+	var now time.Time
+	if stats {
+		now = time.Now()
+	}
 	versioned, err := toVersionedTransaction(update)
 	if err != nil || versioned == nil || len(versioned.Signatures) == 0 {
 		return nil
 	}
-
+	defer func() {
+		releaseVersionedPool(versioned)
+	}()
 	txHash := versioned.Signatures[0]
-	staticKeys := versioned.Message.StaticAccountKeys
+	// staticKeys := versioned.Message.StaticAccountKeys
 	instructions := versioned.Message.Instructions

 	if loader != nil && len(versioned.Message.AddressTableLookups) > 0 {
@@ -209,85 +275,87 @@ func ParseTransaction(update *SubscribeUpdateTransaction, loader *AddressTables)
 			if len(lookup.WritableIndexes) == 0 {
 				continue
 			}
-			accounts := loader.GetAddressTable(lookup.AccountKey, lookup.WritableIndexes)
-			if len(accounts) != len(lookup.WritableIndexes) {
-				lookupTableOk = false
+			lookupTableOk = loader.FillToTx(versioned, lookup.AccountKey, lookup.WritableIndexes)
+			if !lookupTableOk {
 				break
 			}
-			staticKeys = append(staticKeys, accounts...)
-
 		}
 		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) {
+				lookupTableOk = loader.FillToTx(versioned, lookup.AccountKey, lookup.ReadonlyIndexes)
+				if !lookupTableOk {
 					break
 				}
-				staticKeys = append(staticKeys, accounts...)
 			}
 		}
-		versioned.Message.StaticAccountKeys = staticKeys
+		// versioned.Message.StaticAccountKeys = staticKeys
 	}

-	var parsed []*TxSignal
+	var parsed []*TxSignal = make([]*TxSignal, 0, 3)

 	for i := range instructions {
 		inst := instructions[i]
-		if int(inst.ProgramIDIndex) >= len(staticKeys) {
+		if int(inst.ProgramIDIndex) >= len(versioned.Message.StaticAccountKeys) {
 			continue
 		}

-		programID := staticKeys[inst.ProgramIDIndex]
+		programID := versioned.Message.StaticAccountKeys[inst.ProgramIDIndex]
 		switch programID {
 		case pumpProgramID:
 			txRes, err := parsePumpInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "pump", pumpProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "pump")
 		case azczProgramID:
 			txRes, err := parseAzczInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "azcz", azczProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "azcz")
 		case f5tfProgramID:
 			txRes, err := parseF5tfInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "f5tf", f5tfProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "f5tf")
 		case flasProgramID:
 			txRes, err := parseFlasInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "flas", flasProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "flas")
 		case photonProgramID:
 			txRes, err := parsePhotonInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "photon", photonProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "photon")
 		case pumpAmmProgramID:
 			txRes, err := parsePumpAmmInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "pumpamm", pumpAmmProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "pumpamm")
 		case boboProgramID:
 			txRes, err := parseBoboInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "bobo", boboProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "bobo")
 		case qtkvProgramID:
 			txRes, err := parseQtkvInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "qtkv", qtkvProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "qtkv")
 		case fjszProgramID:
 			txRes, err := parseFjszInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "fjsz", fjszProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "fjsz")
 		case terminalProgramID:
 			txRes, err := parseTermInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "terminal", terminalProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "terminal")
 		case jupiterV6ProgramID:
 			txRes, err := parseJupiterV6Instruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "jupiterv6", jupiterV6ProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "jupiterv6")
 		case okxDexRouteV2ProgramID:
 			txRes, err := parseOkxDexRouteV2Instruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "okxdexroutev2", okxDexRouteV2ProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "okxdexroutev2")
 		case dflowProgramID:
 			txRes, err := parseDFlowInstruction(versioned, i)
-			parsed = appendParsed(parsed, txRes, err, txHash, "dflow", dflowProgramID.String())
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "dflow")
+		case gmgnProgramID:
+			txRes, err := parseGMGNInstruction(versioned, i)
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "gmgn")
+		case bonkProgramID:
+			txRes, err := parseBonkInstruction(versioned, i)
+			parsed = appendParsed(now, parsed, txRes, err, txHash, "bonk")
 		}
 	}

 	return parsed
 }

-func appendParsed(list []*TxSignal, parsed *TxSignal, err error, txHash [64]byte, label string, entryContract string) []*TxSignal {
+func appendParsed(start time.Time, list []*TxSignal, parsed *TxSignal, err error, txHash [64]byte, label string) []*TxSignal {
 	if err != nil {
 		if !strings.HasPrefix(err.Error(), "account index") {
 			logger.Debug("txparser: failed to parse", "label", label, "instruction", err, "tx_hash", base58.Encode(txHash[:]))
@@ -295,7 +363,11 @@ func appendParsed(list []*TxSignal, parsed *TxSignal, err error, txHash [64]byte
 		return list
 	}
 	if parsed != nil {
-		parsed.EntryContract = entryContract
+		parsed.Label = label
+		if !start.IsZero() {
+			parsed.ParseEnd = time.Now()
+			parsed.ParseStart = start
+		}
 		list = append(list, parsed)
 	}
 	return list
@@ -308,47 +380,42 @@ func toVersionedTransaction(update *SubscribeUpdateTransaction) (*versionedTrans

 	protoTx := update.Transaction
 	msg := protoTx.Message
-
-	signatures := make([]solana.Signature, len(protoTx.Signatures))
-	for i, rawSig := range protoTx.Signatures {
-		signatures[i] = solana.SignatureFromBytes(rawSig)
+	versioned := requireVersionedPool()
+	versioned.Signatures = versioned.Signatures[:0]
+	for _, rawSig := range protoTx.Signatures {
+		versioned.Signatures = append(versioned.Signatures, solana.SignatureFromBytes(rawSig))
 	}
-
-	staticKeys := make([]solana.PublicKey, len(msg.AccountKeys))
-	for i, key := range msg.AccountKeys {
-		staticKeys[i] = solana.PublicKeyFromBytes(key)
+	versioned.Message.StaticAccountKeys = versioned.Message.StaticAccountKeys[:0]
+	for _, key := range msg.AccountKeys {
+		versioned.Message.StaticAccountKeys = append(versioned.Message.StaticAccountKeys, solana.PublicKeyFromBytes(key))
 	}
-
-	instructions := make([]compiledInstruction, len(msg.Instructions))
-	for i, instr := range msg.Instructions {
-		accounts := append([]uint8(nil), instr.Accounts...)
-		instructions[i] = compiledInstruction{
+	versioned.Message.Instructions = versioned.Message.Instructions[:0]
+	for _, instr := range msg.Instructions {
+		accounts := requireAccIdxSlice()
+		accounts = append(accounts, instr.Accounts...)
+		versioned.Message.Instructions = append(versioned.Message.Instructions,
+			compiledInstruction{
 				ProgramIDIndex: uint8(instr.ProgramIdIndex),
 				Accounts:       accounts,
 				Data:           instr.Data,
-		}
+			})
 	}

-	lookups := make([]addressTableLookup, len(msg.AddressTableLookups))
-	for i, lookup := range msg.AddressTableLookups {
-		writable := append([]uint8(nil), lookup.WritableIndexes...)
-		readonly := append([]uint8(nil), lookup.ReadonlyIndexes...)
-		lookups[i] = addressTableLookup{
+	versioned.Message.AddressTableLookups = versioned.Message.AddressTableLookups[:0]
+	for _, lookup := range msg.AddressTableLookups {
+		writable := requireAccIdxSlice()
+		writable = append(writable, lookup.WritableIndexes...)
+		readonly := requireAccIdxSlice()
+		readonly = append(readonly, lookup.ReadonlyIndexes...)
+		versioned.Message.AddressTableLookups = append(versioned.Message.AddressTableLookups, addressTableLookup{
 			AccountKey:      solana.PublicKeyFromBytes(lookup.AccountKey),
 			WritableIndexes: writable,
 			ReadonlyIndexes: readonly,
-		}
+		})
 	}

-	return &versionedTransaction{
-		Signatures: signatures,
-		Message: versionedMessage{
-			StaticAccountKeys:   staticKeys,
-			Instructions:        instructions,
-			AddressTableLookups: lookups,
-		},
-		Block: update.GetSlot(),
-	}, nil
+	versioned.Block = update.GetSlot()
+	return versioned, nil
 }

 func formatTokenAmount(amount uint64) decimal.Decimal {
@@ -939,6 +1006,66 @@ func parseFlasBuy(tx *versionedTransaction, instructionIndex int) (*TxSignal, er
 	}, nil
 }

+func parseGMGNInstruction(tx *versionedTransaction, instructionIndex int) (*TxSignal, error) {
+	msg := tx.Message
+	if instructionIndex >= len(msg.Instructions) {
+		return nil, fmt.Errorf("instruction index out of bounds")
+	}
+
+	instruction := msg.Instructions[instructionIndex]
+	if len(instruction.Data) == 0 {
+		return nil, fmt.Errorf("data is empty")
+	}
+	if len(instruction.Data) < 8 {
+		return nil, nil
+	}
+
+	if matchMethod(instruction.Data, gmgnBuyTokensIX) {
+		return parseGMGNBuy(tx, &instruction)
+	}
+	return nil, nil
+}
+
+func parseGMGNBuy(tx *versionedTransaction, instruction *compiledInstruction) (*TxSignal, error) {
+	if len(instruction.Accounts) < 8 {
+		return nil, fmt.Errorf("accounts too short")
+	}
+	if len(instruction.Data) < 24 {
+		return nil, fmt.Errorf("data too short for gmgn buy args, len=%d", len(instruction.Data))
+	}
+
+	staticKeys := tx.Message.StaticAccountKeys
+	mint, err := getStaticKey(staticKeys, int(instruction.Accounts[2]))
+	if err != nil {
+		return nil, err
+	}
+	user, err := getStaticKey(staticKeys, int(instruction.Accounts[6]))
+	if err != nil {
+		return nil, err
+	}
+
+	solAmount := binary.LittleEndian.Uint64(instruction.Data[8:16])
+	tokenAmount := binary.LittleEndian.Uint64(instruction.Data[16:24])
+
+	return &TxSignal{
+		TxHash:             tx.Signatures[0].String(),
+		Label:              "gmgn",
+		Maker:              user.String(),
+		Token0Address:      mint.String(),
+		Token1Address:      wsolMint,
+		Token0Amount:       formatTokenAmount(tokenAmount),
+		Token1Amount:       formatSolAmount(solAmount),
+		Program:            "Pump",
+		Event:              "buy",
+		IsToken2022:        false,
+		IsMayhemMode:       false,
+		ExactSOL:           true,
+		Block:              tx.Block,
+		Token0AmountUint64: tokenAmount,
+		Token1AmountUint64: solAmount,
+	}, nil
+}
+
 func parsePhotonInstruction(tx *versionedTransaction, instructionIndex int) (*TxSignal, error) {
 	msg := tx.Message
 	if instructionIndex >= len(msg.Instructions) {
@@ -999,6 +1126,7 @@ func parsePhotonBuy(tx *versionedTransaction, instruction *compiledInstruction)
 		Event:              "buy",
 		IsToken2022:        false,
 		IsMayhemMode:       false,
+		ExactSOL:           true,
 		Block:              tx.Block,
 		Token0AmountUint64: args.TokenAmount,
 		Token1AmountUint64: solAmount,
@@ -1173,6 +1301,7 @@ func parseTermBuy(tx *versionedTransaction, instruction *compiledInstruction) (*
 		Event:              "buy",
 		IsToken2022:        false,
 		IsMayhemMode:       false,
+		ExactSOL:           true,
 		Block:              tx.Block,
 		Token0AmountUint64: tokenAmount,
 		Token1AmountUint64: solAmount,
@@ -1208,6 +1337,7 @@ func parseTermSell(tx *versionedTransaction, instruction *compiledInstruction) (
 		Event:              "buy",
 		IsToken2022:        false,
 		IsMayhemMode:       false,
+		ExactSOL:           false,
 		Block:              tx.Block,
 		Token0AmountUint64: tokenAmount,
 		Token1AmountUint64: solAmount,
@@ -1580,7 +1710,7 @@ func parseFjszInstruction(tx *versionedTransaction, instructionIndex int) (*TxSi
 	}, nil
 }

-func parseTerminalInstruction(tx *versionedTransaction, instructionIndex int) (*TxSignal, error) {
+func parseBonkInstruction(tx *versionedTransaction, instructionIndex int) (*TxSignal, error) {
 	msg := tx.Message
 	if instructionIndex >= len(msg.Instructions) {
 		return nil, fmt.Errorf("instruction index out of bounds")
@@ -1590,24 +1720,87 @@ func parseTerminalInstruction(tx *versionedTransaction, instructionIndex int) (*
 	if len(instruction.Data) == 0 {
 		return nil, fmt.Errorf("data is empty")
 	}
-	if matchMethod(instruction.Data, terminalBuyTokensIX) {
-		return parseTermBuy(tx, &instruction)
-	} else if matchMethod(instruction.Data, terminalSellTokensIX) {
-		return parseTermSell(tx, &instruction)
-	} else if matchMethod(instruction.Data, terminalAmmSellTokensIX) {
-		return parseTermAmmSell(tx, &instruction)
+
+	if matchMethod(instruction.Data, bonkBuyAndSellTokensIX) {
+		return parseBonkBuyAndSell(tx, &instruction)
 	}

 	return nil, nil
 }

-func indexOf(haystack []uint8, needle uint8) int {
-	for i, v := range haystack {
-		if v == needle {
-			return i
+func parseBonkBuyAndSell(tx *versionedTransaction, instruction *compiledInstruction) (*TxSignal, error) {
+	if len(instruction.Accounts) < 8 {
+		return nil, fmt.Errorf("accounts too short")
 	}
+	staticKeys := tx.Message.StaticAccountKeys
+	programId, err := getStaticKey(staticKeys, int(instruction.Accounts[7]))
+	if err != nil {
+		return nil, err
+	}
+	if programId != pumpProgramID {
+		return nil, nil
+	}
+
+	user, err := getStaticKey(staticKeys, int(instruction.Accounts[0]))
+	if err != nil {
+		return nil, err
+	}
+
+	flagAccount, err := getStaticKey(staticKeys, int(instruction.Accounts[4]))
+	if err != nil {
+		return nil, err
+	}
+
+	amount1 := binary.LittleEndian.Uint64(instruction.Data[17:25])
+	amount2 := binary.LittleEndian.Uint64(instruction.Data[25:33])
+
+	if user == flagAccount {
+		mint, err := getStaticKey(staticKeys, int(instruction.Accounts[6]))
+		if err != nil {
+			return nil, err
+		}
+
+		return &TxSignal{
+			TxHash:             tx.Signatures[0].String(),
+			Label:              "bonk",
+			Maker:              user.String(),
+			Token0Address:      mint.String(),
+			Token1Address:      wsolMint,
+			Token0Amount:       formatTokenAmount(amount2),
+			Token1Amount:       formatSolAmount(amount1),
+			Program:            "Pump",
+			Event:              "buy",
+			IsToken2022:        false,
+			IsMayhemMode:       false,
+			ExactSOL:           true,
+			Block:              tx.Block,
+			Token0AmountUint64: amount2,
+			Token1AmountUint64: amount1,
+		}, nil
+	} else {
+		mint, err := getStaticKey(staticKeys, int(instruction.Accounts[5]))
+		if err != nil {
+			return nil, err
+		}
+
+		return &TxSignal{
+			TxHash:             tx.Signatures[0].String(),
+			Label:              "bonk",
+			Maker:              user.String(),
+			Token0Address:      mint.String(),
+			Token1Address:      wsolMint,
+			Token0Amount:       formatTokenAmount(amount1),
+			Token1Amount:       formatSolAmount(amount2),
+			Program:            "Pump",
+			Event:              "sell",
+			IsToken2022:        false,
+			IsMayhemMode:       false,
+			ExactSOL:           false,
+			Block:              tx.Block,
+			Token0AmountUint64: amount1,
+			Token1AmountUint64: amount2,
+		}, nil
 	}
-	return -1
 }

 func matchMethod(data []byte, methods []byte) bool {
--- a/pkg/shreder/txparser_test.go
+++ b/pkg/shreder/txparser_test.go
@@ -1,9 +1,13 @@
 package shreder

 import (
+	"context"
 	"encoding/hex"
+	"os"
 	"testing"

+	"github.com/gagliardetto/solana-go"
+	"github.com/gagliardetto/solana-go/rpc"
 	"github.com/near/borsh-go"
 )

@@ -54,3 +58,234 @@ func TestDecodeAxiomArgs(t *testing.T) {
 		})
 	}
 }
+
+func toUpdata(slot uint64, tx *solana.Transaction) *SubscribeUpdateTransaction {
+	signatures := make([][]byte, len(tx.Signatures))
+	for i, sig := range tx.Signatures {
+		signatures[i] = sig[:]
+	}
+
+	accountKeys := make([][]byte, len(tx.Message.AccountKeys))
+	for i, key := range tx.Message.AccountKeys {
+		accountKeys[i] = key[:]
+	}
+
+	instructions := make([]*CompiledInstruction, len(tx.Message.Instructions))
+	for i, instr := range tx.Message.Instructions {
+		accounts := make([]byte, len(instr.Accounts))
+		for j, acc := range instr.Accounts {
+			accounts[j] = byte(acc)
+		}
+		instructions[i] = &CompiledInstruction{
+			ProgramIdIndex: uint32(instr.ProgramIDIndex),
+			Accounts:       accounts,
+			Data:           instr.Data[:],
+		}
+	}
+
+	addressTableLookups := make([]*MessageAddressTableLookup, len(tx.Message.AddressTableLookups))
+	for i, lookup := range tx.Message.AddressTableLookups {
+		writable := make([]byte, len(lookup.WritableIndexes))
+		for j, idx := range lookup.WritableIndexes {
+			writable[j] = byte(idx)
+		}
+		readonly := make([]byte, len(lookup.ReadonlyIndexes))
+		for j, idx := range lookup.ReadonlyIndexes {
+			readonly[j] = byte(idx)
+		}
+		addressTableLookups[i] = &MessageAddressTableLookup{
+			AccountKey:      lookup.AccountKey[:],
+			WritableIndexes: writable,
+			ReadonlyIndexes: readonly,
+		}
+	}
+
+	return &SubscribeUpdateTransaction{
+		Transaction: &Transaction{
+			Signatures: signatures,
+			Message: &Message{
+				Header: &MessageHeader{
+					NumRequiredSignatures:       uint32(tx.Message.Header.NumRequiredSignatures),
+					NumReadonlySignedAccounts:   uint32(tx.Message.Header.NumReadonlySignedAccounts),
+					NumReadonlyUnsignedAccounts: uint32(tx.Message.Header.NumReadonlyUnsignedAccounts),
+				},
+				AccountKeys:         accountKeys,
+				RecentBlockhash:     nil, // TODO
+				Instructions:        instructions,
+				Versioned:           false, // TODO
+				AddressTableLookups: addressTableLookups,
+			},
+		},
+		Slot: slot,
+	}
+}
+
+func getTransaction(t *testing.T, client *rpc.Client, signature string) *SubscribeUpdateTransaction {
+	version := uint64(0)
+	tx, err := client.GetTransaction(
+		context.Background(),
+		solana.MustSignatureFromBase58(signature),
+		&rpc.GetTransactionOpts{
+			Commitment:                     rpc.CommitmentFinalized,
+			MaxSupportedTransactionVersion: &version,
+		},
+	)
+	if err != nil {
+		t.Fatalf("failed to get transaction: %v", err)
+	}
+
+	_tx, err := tx.Transaction.GetTransaction()
+	if err != nil {
+		t.Fatalf("failed to get transaction: %v", err)
+	}
+
+	return toUpdata(tx.Slot, _tx)
+}
+
+func TestParseTermBuy(t *testing.T) {
+	rpcUrl := os.Getenv("SOL_RPC_URL")
+	if rpcUrl == "" {
+		t.Fatalf("SOL_RPC_URL is not set")
+	}
+
+	client := rpc.New(rpcUrl)
+	signals := ParseTransaction(
+		getTransaction(t, client, "5Gz1fa4Qhb35bkg9QCMXpxCX5uuNr7WcjcmrwajGZA7kXsvNS9pDnYe12ggWeSqf1nwZbVPob6DkX6fcwbE9ofBR"),
+		nil,
+		false,
+	)
+	if len(signals) != 1 {
+		t.Fatalf("expected 1 signal, got %d", len(signals))
+	}
+
+	signal := signals[0]
+	if signal.Label != "terminal" {
+		t.Fatalf("expected terminal signal, got %s", signal.Label)
+	}
+	if signal.Event != "buy" {
+		t.Fatalf("expected buy event, got %s", signal.Event)
+	}
+	if signal.Maker != "BaLxyjXzATAnfm7cc5AFhWBpiwnsb71THcnofDLTWAPK" {
+		t.Fatalf("expected maker BaLxyjXzATAnfm7cc5AFhWBpiwnsb71THcnofDLTWAPK, got %s", signal.Maker)
+	}
+	if signal.Token0Address != "5Wgv54peXRKDHYHapAELzgNKEPEh9E5Bf3hUR3sTpump" {
+		t.Fatalf("expected token0 address 5Wgv54peXRKDHYHapAELzgNKEPEh9E5Bf3hUR3sTpump, got %s", signal.Token0Address)
+	}
+	if signal.Token0AmountUint64 != 6952026214256 {
+		t.Fatalf("expected token0 amount 6952026214256, got %d", signal.Token0AmountUint64)
+	}
+	if signal.Token1AmountUint64 != 653333333 {
+		t.Fatalf("expected token1 amount 653333333, got %d", signal.Token1AmountUint64)
+	}
+}
+
+func TestParseBonkBuy(t *testing.T) {
+	rpcUrl := os.Getenv("SOL_RPC_URL")
+	if rpcUrl == "" {
+		t.Fatalf("SOL_RPC_URL is not set")
+	}
+
+	client := rpc.New(rpcUrl)
+	signals := ParseTransaction(
+		getTransaction(t, client, "3gHF3TA2aA8rpjdmoEs2vA89vrq9J9NnTTUSXHfE6uXcaYP9cJgLtEUjCmsK9EWAyHEg7cEiepehQf4GFv1272jW"),
+		nil,
+		false,
+	)
+	if len(signals) != 1 {
+		t.Fatalf("expected 1 signal, got %d", len(signals))
+	}
+
+	signal := signals[0]
+	if signal.Label != "bonk" {
+		t.Fatalf("expected bonk signal, got %s", signal.Label)
+	}
+	if signal.Event != "buy" {
+		t.Fatalf("expected buy event, got %s", signal.Event)
+	}
+	if signal.Maker != "BFobdhAbdBteBuDvHUdBthsQqJyMuWnG9SGUheW1Ni2C" {
+		t.Fatalf("expected maker BFobdhAbdBteBuDvHUdBthsQqJyMuWnG9SGUheW1Ni2C, got %s", signal.Maker)
+	}
+	if signal.Token0Address != "Awupo9Jxe1fsc7eEtCEcN9D3PoyReQhc9WEuEAHXpump" {
+		t.Fatalf("expected token0 address Awupo9Jxe1fsc7eEtCEcN9D3PoyReQhc9WEuEAHXpump, got %s", signal.Token0Address)
+	}
+	if signal.Token0AmountUint64 != 8616799656436 {
+		t.Fatalf("expected token0 amount 8616799656436, got %d", signal.Token0AmountUint64)
+	}
+	if signal.Token1AmountUint64 != 495000000 {
+		t.Fatalf("expected token1 amount 495000000, got %d", signal.Token1AmountUint64)
+	}
+}
+
+func TestParseBonkSell(t *testing.T) {
+	rpcUrl := os.Getenv("SOL_RPC_URL")
+	if rpcUrl == "" {
+		t.Fatalf("SOL_RPC_URL is not set")
+	}
+
+	client := rpc.New(rpcUrl)
+	signals := ParseTransaction(
+		getTransaction(t, client, "3XNi6b3j69SSStqLLRQVH5BNGVfEoFxGCzmpdd5FvrY4kmC8T644WGdEhCH9fAdrxWuR2Mtzgywq8K7qetu5MGyb"),
+		nil,
+		false,
+	)
+	if len(signals) != 1 {
+		t.Fatalf("expected 1 signal, got %d", len(signals))
+	}
+
+	signal := signals[0]
+	if signal.Label != "bonk" {
+		t.Fatalf("expected bonk signal, got %s", signal.Label)
+	}
+	if signal.Event != "sell" {
+		t.Fatalf("expected sell event, got %s", signal.Event)
+	}
+	if signal.Maker != "2xTT7XXCEYSCrRb3G4Egc4ZwpCe78qq6r7w6ChZhbTXc" {
+		t.Fatalf("expected maker 2xTT7XXCEYSCrRb3G4Egc4ZwpCe78qq6r7w6ChZhbTXc, got %s", signal.Maker)
+	}
+	if signal.Token0Address != "8pgpJDYuojYXvb8KE4Hv7DCty12FrkqpKChgfHzspump" {
+		t.Fatalf("expected token0 address 8pgpJDYuojYXvb8KE4Hv7DCty12FrkqpKChgfHzspump, got %s", signal.Token0Address)
+	}
+	if signal.Token0AmountUint64 != 6235736929390 {
+		t.Fatalf("expected token0 amount 6235736929390, got %d", signal.Token0AmountUint64)
+	}
+	if signal.Token1AmountUint64 != 1379707703 {
+		t.Fatalf("expected token1 amount 1379707703, got %d", signal.Token1AmountUint64)
+	}
+}
+
+func TestParsePhotonBuy(t *testing.T) {
+	rpcUrl := os.Getenv("SOL_RPC_URL")
+	if rpcUrl == "" {
+		t.Fatalf("SOL_RPC_URL is not set")
+	}
+
+	client := rpc.New(rpcUrl)
+	signals := ParseTransaction(
+		getTransaction(t, client, "4DCEcXAWBxagXoUNGhWsJ7qfxq5SuE5BG2cBDBqAY7sCHkBopaMJu33ZnXnFHqzPMmWxVxq6666KRF4hMHVB33Ux"),
+		nil,
+		false,
+	)
+	if len(signals) != 1 {
+		t.Fatalf("expected 1 signal, got %d", len(signals))
+	}
+
+	signal := signals[0]
+	if signal.Label != "photon" {
+		t.Fatalf("expected terminal signal, got %s", signal.Label)
+	}
+	if signal.Event != "buy" {
+		t.Fatalf("expected buy event, got %s", signal.Event)
+	}
+	if signal.Maker != "8sUm7sLf3Steu6oVyVQqoA9GpFcMRz6YhrAidd4x7g7a" {
+		t.Fatalf("expected maker 8sUm7sLf3Steu6oVyVQqoA9GpFcMRz6YhrAidd4x7g7a, got %s", signal.Maker)
+	}
+	if signal.Token0Address != "jx4PF2MwC7AK9S8dTeYm29hM3vAN8Rtfs2VX4Vz5UVj" {
+		t.Fatalf("expected token0 address jx4PF2MwC7AK9S8dTeYm29hM3vAN8Rtfs2VX4Vz5UVj, got %s", signal.Token0Address)
+	}
+	if signal.Token0AmountUint64 != 1796593710706 {
+		t.Fatalf("expected token0 amount 1796593710706, got %d", signal.Token0AmountUint64)
+	}
+	if signal.Token1AmountUint64 != 1955555553 {
+		t.Fatalf("expected token1 amount 1955555553, got %d", signal.Token1AmountUint64)
+	}
+}
Author	SHA1	Message	Date
samlior	23f37cff2c	chore: add release pool	2026-01-19 09:35:47 +08:00
samlior	6bab10866b	fix: photon buy	2026-01-08 16:25:34 +08:00
samlior	83aa772710	chore: improve test	2026-01-08 16:20:17 +08:00
samlior	da51b19b50	chore: add bonk parser	2026-01-08 16:07:57 +08:00
samlior	f39b89b497	chore: add simple test	2026-01-08 15:20:50 +08:00
samlior	26e07ec52e	chore: add gmgn and remove entry contract	2026-01-08 12:54:21 +08:00
samlior	35c57c3c7a	chore: remove useless	2026-01-08 12:46:58 +08:00
samlior	3e58b62e1f	chore: enable term	2026-01-08 12:44:47 +08:00
thloyi	4c0abc5c34	stats	2026-01-08 11:57:57 +08:00
thloyi	d9aea3e8d7	parallel parsing	2026-01-07 21:15:54 +08:00