1324 lines
39 KiB
Go
1324 lines
39 KiB
Go
package shreder
|
|
|
|
import (
|
|
"context"
|
|
"encoding/hex"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/gagliardetto/solana-go"
|
|
"github.com/gagliardetto/solana-go/rpc"
|
|
)
|
|
|
|
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
|
|
}
|
|
args, err := decodeFlasArgs(data)
|
|
if err != nil {
|
|
t.Fatalf("failed to decode Axiom args: %v", err)
|
|
return
|
|
}
|
|
t.Logf("Decoded Axiom Args: %+v", args)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDecodeAxiomUpdatedRouteMarkers(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
marker []byte
|
|
match func([]byte) bool
|
|
}{
|
|
{name: "pump buy 0021", marker: []byte{0x00, 0x01, 0x21}, match: func(marker []byte) bool { return matchFlasMethod(marker, flasBuyTokensIXs) }},
|
|
{name: "pump buy 001b", marker: []byte{0x00, 0x01, 0x1b}, match: func(marker []byte) bool { return matchFlasMethod(marker, flasBuyTokensIXs) }},
|
|
{name: "pump sell", marker: []byte{0x01, 0x01, 0x1a}, match: func(marker []byte) bool { return matchFlasMethod(marker, flasSellTokensIXs) }},
|
|
{name: "pump amm buy", marker: []byte{0x00, 0x02, 0x1f}, match: func(marker []byte) bool { return matchFlasMethod(marker, flasAmmBuyTokensIXs) }},
|
|
{name: "pump amm sell", marker: []byte{0x01, 0x02, 0x1f}, match: func(marker []byte) bool { return matchFlasMethod(marker, flasAmmSellTokensIXs) }},
|
|
{name: "legacy bonk buy", marker: []byte{0x00, 0x02, 0x07}, match: func(marker []byte) bool { return matchFlasMethod(marker, flasBonkBuyTokensIXs) }},
|
|
{name: "legacy bonk sell", marker: []byte{0x01, 0x02, 0x07}, match: func(marker []byte) bool { return matchFlasMethod(marker, flasBonkSellTokensIXs) }},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
data := make([]byte, 20)
|
|
data[0] = 0
|
|
copy(data[17:20], tt.marker)
|
|
args, err := decodeFlasArgs(data)
|
|
if err != nil {
|
|
t.Fatalf("failed to decode args: %v", err)
|
|
}
|
|
expected := [3]uint8{tt.marker[0], tt.marker[1], tt.marker[2]}
|
|
if args.Placeholder != expected {
|
|
t.Fatalf("expected marker %x, got %x", tt.marker, args.Placeholder)
|
|
}
|
|
if !tt.match(tt.marker) {
|
|
t.Fatalf("marker %x did not match route", tt.marker)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
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)
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "4rm1UFvWqTrBvcCfEzeXEPCeNsXRNhMHRx7AXrEiBwpFMJXNzXPt9zhrpQc1JrUnuBACeo7uRM8W8vKx56TQT7vs"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
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 != "ATEruR96FhZWpZGkKvgzGG3gRL3Cdj6GttHtBsUFeAPE" {
|
|
t.Fatalf("expected maker ATEruR96FhZWpZGkKvgzGG3gRL3Cdj6GttHtBsUFeAPE, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "7nHYtqhR4qq7LHVmC5Pnz7p6Se64i39TfnyM6ZC2pump" {
|
|
t.Fatalf("expected token0 address 7nHYtqhR4qq7LHVmC5Pnz7p6Se64i39TfnyM6ZC2pump, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 4473828190746 {
|
|
t.Fatalf("expected token0 amount 6952026214256, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 250000000 {
|
|
t.Fatalf("expected token1 amount 250000000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
}
|
|
|
|
func TestParseTermSell(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "4oSnHnDSscjmc6XX1rjXCEBavoLR9wkdZvGCAUn928iLWqrCwt2a6mgJpjP4NHqrCboUC82ugrjjEbNGNYAagkue"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
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 != "sell" {
|
|
t.Fatalf("expected sell event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "DjAj23BSiaRJKJziKHwtLexEHRDgL4tEjx4Ye4Gkug2E" {
|
|
t.Fatalf("expected maker DjAj23BSiaRJKJziKHwtLexEHRDgL4tEjx4Ye4Gkug2E, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "5J6TKpfP5SHDaUNAdDg23c31wS3KnfZ3JTfFErt4pump" {
|
|
t.Fatalf("expected token0 address 5J6TKpfP5SHDaUNAdDg23c31wS3KnfZ3JTfFErt4pump, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 6384819151429 {
|
|
t.Fatalf("expected token0 amount 6384819151429, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 243633622 {
|
|
t.Fatalf("expected token1 amount 243633622, 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)
|
|
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "3gHF3TA2aA8rpjdmoEs2vA89vrq9J9NnTTUSXHfE6uXcaYP9cJgLtEUjCmsK9EWAyHEg7cEiepehQf4GFv1272jW"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
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)
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "3XNi6b3j69SSStqLLRQVH5BNGVfEoFxGCzmpdd5FvrY4kmC8T644WGdEhCH9fAdrxWuR2Mtzgywq8K7qetu5MGyb"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
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)
|
|
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "4DCEcXAWBxagXoUNGhWsJ7qfxq5SuE5BG2cBDBqAY7sCHkBopaMJu33ZnXnFHqzPMmWxVxq6666KRF4hMHVB33Ux"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
|
|
func TestParseJupiterV6PumpFunBuy(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "4QF5whXwjx234fMXeH3HrJCy5knFJmKPtgbXys8xKGz1pZypqPvXBr4BoAqXfYn8jLL4HXPY1pcvxCCW1XREFNxd"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "jupiterv6" {
|
|
t.Fatalf("expected jupiterv6 signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "buy" {
|
|
t.Fatalf("expected buy event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "92ySgsZs3rsrUAq2aeEqYacXQQGmz6e4xHPrRGxLDJXb" {
|
|
t.Fatalf("expected maker 92ySgsZs3rsrUAq2aeEqYacXQQGmz6e4xHPrRGxLDJXb, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "5kSWidFwDKPZiNf52TfincpVn8ufvkAfEzZ9pk8Dpump" {
|
|
t.Fatalf("expected token0 address 5kSWidFwDKPZiNf52TfincpVn8ufvkAfEzZ9pk8Dpump, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 2410530637576 {
|
|
t.Fatalf("expected token0 amount 2410530637576, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 380000000 {
|
|
t.Fatalf("expected token1 amount 380000000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if !signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL true, got false")
|
|
}
|
|
}
|
|
|
|
func TestParseJupiterV6PumpFunSell(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "yCnE7ZA8dqB5iAZtwpSN2ar5HXh3gBjgaG2xtnwXDPFyHAm5XFU8642uTZTH5A2iPQ6G9hrj5eEPAJiWrfe38gM"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "jupiterv6" {
|
|
t.Fatalf("expected jupiterv6 signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "sell" {
|
|
t.Fatalf("expected sell event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "CGfWcKKcVQNBCL1vpxXdg6rvfYpQmnS3WkyA22Lk5XnZ" {
|
|
t.Fatalf("expected maker CGfWcKKcVQNBCL1vpxXdg6rvfYpQmnS3WkyA22Lk5XnZ, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "wp8Mwxy7btAD9hNWsfJyoPNJnjXS9fuNG4mnhQZpump" {
|
|
t.Fatalf("expected token0 address wp8Mwxy7btAD9hNWsfJyoPNJnjXS9fuNG4mnhQZpump, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 127531720509990 {
|
|
t.Fatalf("expected token0 amount 127531720509990, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 5296451290 {
|
|
t.Fatalf("expected token1 amount 5296451290, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL false, got true")
|
|
}
|
|
}
|
|
|
|
func TestParseRaydiumLaunchLabBuyExactIn(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "2erxUsE92LdrxhWy6HryUJpvBpVUociu2UY6AGoX7E6orrqm6AYxDzhmub3J9PDPa5CPNwWZBG8rCxKCdquVo2Lc"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "raydiumlaunchlab" {
|
|
t.Fatalf("expected raydiumlaunchlab signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "buy" {
|
|
t.Fatalf("expected buy event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "56JZV81H3XJedVWcV8RTXrn5YD6WW2k2LTGVDGCUwyYb" {
|
|
t.Fatalf("expected maker 56JZV81H3XJedVWcV8RTXrn5YD6WW2k2LTGVDGCUwyYb, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "676zr3qFwy3XUXwVkQVdV9cidSaxcS6SrHga8cK4kKej" {
|
|
t.Fatalf("expected token0 address 676zr3qFwy3XUXwVkQVdV9cidSaxcS6SrHga8cK4kKej, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 15336821188103 {
|
|
t.Fatalf("expected token0 amount 15336821188103, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 1000000000 {
|
|
t.Fatalf("expected token1 amount 1000000000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if !signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL true, got false")
|
|
}
|
|
}
|
|
|
|
func TestParseRaydiumLaunchLabBuyExactOut(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "4x2gArQAezap4RZKK5Tpfu1SNadCsTbjeUYG5KNggoHeGFiZdV1MmrrvXLXvyh2e6C1Gh22ohU4dFAzGw18y6VLT"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "raydiumlaunchlab" {
|
|
t.Fatalf("expected raydiumlaunchlab signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "buy" {
|
|
t.Fatalf("expected buy event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "nya666pQkP3PzWxi7JngU3rRMHuc7zbLK8c8wxQ4qpT" {
|
|
t.Fatalf("expected maker nya666pQkP3PzWxi7JngU3rRMHuc7zbLK8c8wxQ4qpT, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "8ZTAvKJiPqExQYTYXoE2FuCoRFJAmyuEXXb4GbPvbonk" {
|
|
t.Fatalf("expected token0 address 8ZTAvKJiPqExQYTYXoE2FuCoRFJAmyuEXXb4GbPvbonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 2888057167672 {
|
|
t.Fatalf("expected token0 amount 2888057167672, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 159300000 {
|
|
t.Fatalf("expected token1 amount 159300000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL false, got true")
|
|
}
|
|
}
|
|
|
|
func TestParseRaydiumLaunchLabSellExactIn(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("4xBW5fcrR1eityayfv6mrxC7zfQNy89YpqoVmqiTbfRh"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "37LGuUiTnBpagELdwVWtffkbJaLsucbRimnFueKS23EaFdYsjHC42SS3XjyC5tyRaokj5tdwiKYfBqNFAmMbTUgv"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "raydiumlaunchlab" {
|
|
t.Fatalf("expected raydiumlaunchlab signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "sell" {
|
|
t.Fatalf("expected sell event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "7GSDLZHBNnEgYwe8TLLy8iDbnKWaR5NfNVoxvQJ26nux" {
|
|
t.Fatalf("expected maker 7GSDLZHBNnEgYwe8TLLy8iDbnKWaR5NfNVoxvQJ26nux, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "6bs2ECcL1XG5Tw8t3xvpyCsQDunQpdYtDXNyD74bonk" {
|
|
t.Fatalf("expected token0 address 6bs2ECcL1XG5Tw8t3xvpyCsQDunQpdYtDXNyD74bonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 3144872514758 {
|
|
t.Fatalf("expected token0 amount 3144872514758, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 373068521 {
|
|
t.Fatalf("expected token1 amount 373068521, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL false, got true")
|
|
}
|
|
}
|
|
|
|
func TestParseRaydiumLaunchLabSellExactOut(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("DSaHkhDp17UexbZsg2VUnWjEuTwKNCJrnG4LW122ANfd"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "3z8iC9zDLeQzjcLtUnwDT1j9Z5p5rFWXyCcRUhvUCVDTrPJSoZbbULkMTZk2mUUeAX1qaMBZUsPCd59B4KaGooSk"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "raydiumlaunchlab" {
|
|
t.Fatalf("expected raydiumlaunchlab signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "sell" {
|
|
t.Fatalf("expected sell event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "F4RMpjLMJZKmrYBxjpVadty7e326XUziLkYTDtNtpo2e" {
|
|
t.Fatalf("expected maker F4RMpjLMJZKmrYBxjpVadty7e326XUziLkYTDtNtpo2e, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "ByubRkVymfNBoX9DUfUL39Zi6qzqWkTbLviQtx9ktxWv" {
|
|
t.Fatalf("expected token0 address ByubRkVymfNBoX9DUfUL39Zi6qzqWkTbLviQtx9ktxWv, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 594669717336 {
|
|
t.Fatalf("expected token0 amount 594669717336, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 141400000 {
|
|
t.Fatalf("expected token1 amount 141400000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if !signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL true, got false")
|
|
}
|
|
}
|
|
|
|
func TestParseRaydiumLaunchLabCreate(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("J7aYNVkReYKUSEvS79sg2YubtMQMxUetByAFrNw7qZ3G"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "2qi4STgj33b1DydMKvtpqeSVwkcTJHww8ViX9ADMu2TaRz2uSGcVjgDyd9AELnn2N1ojSGy2qnM6uiXJc2vEcLmw"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) == 0 {
|
|
t.Fatalf("expected at least 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "raydiumlaunchlab" {
|
|
t.Fatalf("expected raydiumlaunchlab signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "create" {
|
|
t.Fatalf("expected create event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "F9TNxWymThfvs4kVVmyaBqx8pjxpvP7kScNBqiczeY84" {
|
|
t.Fatalf("expected maker F9TNxWymThfvs4kVVmyaBqx8pjxpvP7kScNBqiczeY84, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "5VvwdKsYUjPTNbEotwDcV48PQEfi42of7TzaLyaybonk" {
|
|
t.Fatalf("expected token0 address 5VvwdKsYUjPTNbEotwDcV48PQEfi42of7TzaLyaybonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.IsToken2022 {
|
|
t.Fatalf("expected IsToken2022 false, got true")
|
|
}
|
|
}
|
|
|
|
func TestParseRaydiumLaunchLabCreate2(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("5Sq6FRoQkRbupnZM1iq9AFeLaSZPbVHgPheVqHD4GzVr"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "3ZofgvJ3vrNRnyGfAFwENSrDAHxVuXhqrL4svwctHuxZHnAengj5SHeEwPJiJFPXYaBcnfrUAk2V4368LVVSEP2W"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) == 0 {
|
|
t.Fatalf("expected at least 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "raydiumlaunchlab" {
|
|
t.Fatalf("expected raydiumlaunchlab signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "create" {
|
|
t.Fatalf("expected create event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "7GhWwhaMgbKiRWxF93Bud6HnHMci6NCLTJyTxG8zFH51" {
|
|
t.Fatalf("expected maker 7GhWwhaMgbKiRWxF93Bud6HnHMci6NCLTJyTxG8zFH51, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "GWeFeDVD75PVGHdLf7HrYJe2BYTiA8J3nVJXSqb4CpoU" {
|
|
t.Fatalf("expected token0 address GWeFeDVD75PVGHdLf7HrYJe2BYTiA8J3nVJXSqb4CpoU, got %s", signal.Token0Address)
|
|
}
|
|
if !signal.IsToken2022 {
|
|
t.Fatalf("expected IsToken2022 true, got false")
|
|
}
|
|
}
|
|
|
|
func manuallyLoadAddressTable(t *testing.T, client *rpc.Client, tablePubkey solana.PublicKey) *AddressTables {
|
|
loader := NewAddressTables(client, false)
|
|
table, err := loader.loadAddressTable(tablePubkey)
|
|
if err != nil {
|
|
t.Fatalf("failed to load address table: %s", err)
|
|
}
|
|
|
|
loader.tables.Add(tablePubkey, &TableInfo{
|
|
addresses: table,
|
|
})
|
|
|
|
return loader
|
|
}
|
|
|
|
func TestParsePumpCreate(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("AXVvmhWaaPtV52jqYuTNqp1xRrkbxhfJfeHQKxq5cbvZ"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "3vUAHpBUoxeoZheo9m3XmufNUWmJWRAN4xZjSqDos71GL6tCKSTmJV6YeMS5XdVAbRAfqQi1rPusjbmEhoam4x9Y"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) == 0 {
|
|
t.Fatalf("expected at least 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "pump" {
|
|
t.Fatalf("expected pump signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "create" {
|
|
t.Fatalf("expected create event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "8oVJLE69qH1i5jotFABcCoaPS38DAyZ7djRg6uuD3Cb7" {
|
|
t.Fatalf("expected maker 8oVJLE69qH1i5jotFABcCoaPS38DAyZ7djRg6uuD3Cb7, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "AtaWsdyfcANLsHNdpYJyFdNvwSQnUzvhRN2MCCP9pump" {
|
|
t.Fatalf("expected token0 address AtaWsdyfcANLsHNdpYJyFdNvwSQnUzvhRN2MCCP9pump, got %s", signal.Token0Address)
|
|
}
|
|
if !signal.IsToken2022 {
|
|
t.Fatalf("expected IsToken2022 true, got false")
|
|
}
|
|
if signal.IsCashbackEnabled {
|
|
t.Fatalf("expected IsCashbackEnabled true, got false")
|
|
}
|
|
}
|
|
|
|
func TestParsePumpCreate2(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "3EKKjtNFzhtQaA9GyPt5UJHLr5mWT2XodaxWoenUrcaPpN8BKm84ATVapdUJcb9sJVFyS4iKD9spGBKfqkSFutea"),
|
|
nil,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) == 0 {
|
|
t.Fatalf("expected at least 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "pump" {
|
|
t.Fatalf("expected pump signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "create" {
|
|
t.Fatalf("expected create event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "5mGqXMqUbJzxQ9aqbBttB4JUfAMqceSTmrtpt6RuPXdC" {
|
|
t.Fatalf("expected maker 5mGqXMqUbJzxQ9aqbBttB4JUfAMqceSTmrtpt6RuPXdC, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "J9Hqi5VddcTNJ2F5EyxSZxC2JpJeymfJXjLhsCVPZpna" {
|
|
t.Fatalf("expected token0 address J9Hqi5VddcTNJ2F5EyxSZxC2JpJeymfJXjLhsCVPZpna, got %s", signal.Token0Address)
|
|
}
|
|
if !signal.IsToken2022 {
|
|
t.Fatalf("expected IsToken2022 true, got false")
|
|
}
|
|
if signal.IsCashbackEnabled {
|
|
t.Fatalf("expected IsCashbackEnabled true, got false")
|
|
}
|
|
}
|
|
|
|
func TestParseFlasBonkBuy(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("7RKtfATWCe98ChuwecNq8XCzAzfoK3DtZTprFsPMGtio"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "5ED51fnabzxsPqjswp7R9qbfuTep7avtsQnsYg4R6w2jc9Ys2mMCXFNNnDNvUUhaREJS5Tz1dSfBL1dufXzDsiaX"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "flas" {
|
|
t.Fatalf("expected flas signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "buy" {
|
|
t.Fatalf("expected buy event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "75KjigN4rgweGMRu5oWY4DBPELpQ1TYsBQAXuzs7hKVA" {
|
|
t.Fatalf("expected maker 75KjigN4rgweGMRu5oWY4DBPELpQ1TYsBQAXuzs7hKVA, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "2aMTnF7Kz9aRhTMmiVuSwbQ9Msrdkgm4RvFoJfZPbonk" {
|
|
t.Fatalf("expected token0 address 2aMTnF7Kz9aRhTMmiVuSwbQ9Msrdkgm4RvFoJfZPbonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 1052495896871 {
|
|
t.Fatalf("expected token0 amount 1052495896871, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 99000000 {
|
|
t.Fatalf("expected token1 amount 99000000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if !signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL true, got false")
|
|
}
|
|
}
|
|
|
|
func TestParseFlasBonkSell(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("7RKtfATWCe98ChuwecNq8XCzAzfoK3DtZTprFsPMGtio"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "2v3qLsnrJ5KqUDqtzXyc3S9vT6cLvXbaVR6vwfhp4ufC4Sg1vmR5xMdxzrtvErq8kiC8g7d5wLAbEMe8NwXJE5MS"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "flas" {
|
|
t.Fatalf("expected flas signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "sell" {
|
|
t.Fatalf("expected sell event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "7rtyqW2yr76Y9iCTvbAzkDdaJU8mbx3ZuzW9sTZ3pV2q" {
|
|
t.Fatalf("expected maker 7rtyqW2yr76Y9iCTvbAzkDdaJU8mbx3ZuzW9sTZ3pV2q, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "2aMTnF7Kz9aRhTMmiVuSwbQ9Msrdkgm4RvFoJfZPbonk" {
|
|
t.Fatalf("expected token0 address 2aMTnF7Kz9aRhTMmiVuSwbQ9Msrdkgm4RvFoJfZPbonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 6413676607028 {
|
|
t.Fatalf("expected token0 amount 6413676607028, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 249361301 {
|
|
t.Fatalf("expected token1 amount 249361301, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL false, got true")
|
|
}
|
|
}
|
|
|
|
func TestParseMaestroBonkBuy(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("HPjn8EFrUcMxqQrdRzJkgXp85cGUHLFVkY4nZ7EUBbir"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "LuGGhtCU5enHY2J8qt5KAZybvQyokxKn4NxkhQfKz6RbkxW1anU9vHfAXeEVsjM49mtPmeyyVKKW1myaAXt6BhJ"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "maestro" {
|
|
t.Fatalf("expected maestro signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "buy" {
|
|
t.Fatalf("expected buy event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "Gyz2QP89RuoFG55V2xVpyGiG7rMya41j1ZbFNbd1WfF9" {
|
|
t.Fatalf("expected maker Gyz2QP89RuoFG55V2xVpyGiG7rMya41j1ZbFNbd1WfF9, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "2aMTnF7Kz9aRhTMmiVuSwbQ9Msrdkgm4RvFoJfZPbonk" {
|
|
t.Fatalf("expected token0 address 2aMTnF7Kz9aRhTMmiVuSwbQ9Msrdkgm4RvFoJfZPbonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 11089351947578 {
|
|
t.Fatalf("expected token0 amount 1052495896871, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 1000000000 {
|
|
t.Fatalf("expected token1 amount 1000000000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if !signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL true, got false")
|
|
}
|
|
}
|
|
|
|
func TestParseMaestroBonkSell(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("HPjn8EFrUcMxqQrdRzJkgXp85cGUHLFVkY4nZ7EUBbir"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "3cXpA8C5uizp1iK8fV8eoxoonT5BcT7G52wN9aRsRwi9pUCUyuDt2FwXVVtbkvocxoAD82ZQWjCaLRgswgcszTHQ"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "maestro" {
|
|
t.Fatalf("expected maestro signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "sell" {
|
|
t.Fatalf("expected sell event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "fwBVjnPQHwrAVWP4VnwbA1Y9BiDWnixJ39G5PA59sZv" {
|
|
t.Fatalf("expected maker fwBVjnPQHwrAVWP4VnwbA1Y9BiDWnixJ39G5PA59sZv, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "9553NoaZEQGYsttrym5w85RQVHhwVi3BfNU9GLfEbonk" {
|
|
t.Fatalf("expected token0 address 9553NoaZEQGYsttrym5w85RQVHhwVi3BfNU9GLfEbonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 11299453877090 {
|
|
t.Fatalf("expected token0 amount 11299453877090, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 892516080 {
|
|
t.Fatalf("expected token1 amount 892516080, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL false, got true")
|
|
}
|
|
}
|
|
|
|
func TestParseBloomRouterBonkBuy(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("3xRUDpys1Yy96y5QVBfhW94ukphuDXHsKh4mTAFofA6S"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "5XEGgHXokNKQpgUUf1zS8LXFRHR7XNBaPiRZxGumFkBH23b3TsTjs6wJ1NRHxf6xRvYBLwXWWJdw7AiNzAAgUzgg"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "bloomrouter" {
|
|
t.Fatalf("expected bloomrouter signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "buy" {
|
|
t.Fatalf("expected buy event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "9ozVSeSsgASFDUjveLNQV697kAavStvpXmKP65oMt2Ji" {
|
|
t.Fatalf("expected maker 9ozVSeSsgASFDUjveLNQV697kAavStvpXmKP65oMt2Ji, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "6qzh89yisR498GsQysqzj69AW9BJc39LWhXtzxudbonk" {
|
|
t.Fatalf("expected token0 address 6qzh89yisR498GsQysqzj69AW9BJc39LWhXtzxudbonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 0 {
|
|
t.Fatalf("expected token0 amount 0, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 1500000000 {
|
|
t.Fatalf("expected token1 amount 1500000000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if !signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL true, got false")
|
|
}
|
|
}
|
|
|
|
func TestParseBloomRouterBonkSell(t *testing.T) {
|
|
rpcUrl := os.Getenv("SOL_RPC_URL")
|
|
if rpcUrl == "" {
|
|
t.Fatalf("SOL_RPC_URL is not set")
|
|
}
|
|
|
|
client := rpc.New(rpcUrl)
|
|
loader := manuallyLoadAddressTable(t, client, solana.MustPublicKeyFromBase58("3xRUDpys1Yy96y5QVBfhW94ukphuDXHsKh4mTAFofA6S"))
|
|
ch := make(chan TxSignal)
|
|
closed := make(chan struct{})
|
|
go func() {
|
|
ParseTransactionForSubscribe(
|
|
context.Background(),
|
|
getTransaction(t, client, "MMdN29CYKDKDurbhUHn51AyyJ5ZEZq1F1TFJTrVYhRT1moaURqXAHJb2pFus4KrXAdAFo5Hr1Jw4bgE2EWeLXf6"),
|
|
loader,
|
|
ch,
|
|
closed,
|
|
)
|
|
}()
|
|
go func() {
|
|
<-closed
|
|
close(ch)
|
|
}()
|
|
signals := make([]TxSignal, 0)
|
|
for signal := range ch {
|
|
signals = append(signals, signal)
|
|
}
|
|
|
|
if len(signals) != 1 {
|
|
t.Fatalf("expected 1 signal, got %d", len(signals))
|
|
}
|
|
|
|
signal := signals[0]
|
|
if signal.Label != "bloomrouter" {
|
|
t.Fatalf("expected bloomrouter signal, got %s", signal.Label)
|
|
}
|
|
if signal.Event != "sell" {
|
|
t.Fatalf("expected sell event, got %s", signal.Event)
|
|
}
|
|
if signal.Maker != "HWiPtESw8pvhQWm1a7vbHg9rsnee13Pmb7dUGVC3f4mZ" {
|
|
t.Fatalf("expected maker HWiPtESw8pvhQWm1a7vbHg9rsnee13Pmb7dUGVC3f4mZ, got %s", signal.Maker)
|
|
}
|
|
if signal.Token0Address != "6Yd5AGP4E4b1prHxJmuHexUToohiNKiQSG2nXvXWbonk" {
|
|
t.Fatalf("expected token0 address 6Yd5AGP4E4b1prHxJmuHexUToohiNKiQSG2nXvXWbonk, got %s", signal.Token0Address)
|
|
}
|
|
if signal.Token0AmountUint64 != 6448480270053 {
|
|
t.Fatalf("expected token0 amount 6448480270053, got %d", signal.Token0AmountUint64)
|
|
}
|
|
if signal.Token1AmountUint64 != 1000 {
|
|
t.Fatalf("expected token1 amount 1000, got %d", signal.Token1AmountUint64)
|
|
}
|
|
if signal.ExactSOL {
|
|
t.Fatalf("expected ExactSOL false, got true")
|
|
}
|
|
}
|