Getting Started¶

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"

    dexparser "github.com/DefaultPerson/solana-dex-parser-go"
    "github.com/DefaultPerson/solana-dex-parser-go/adapter"
)

const txFile = "tx.json"

func main() {
    // txFile holds the "result" of a getTransaction RPC call made with
    // {"encoding": "json", "maxSupportedTransactionVersion": 1}
    raw, err := os.ReadFile(txFile)
    if err != nil {
        log.Fatal(err)
    }
    var tx adapter.SolanaTransaction
    if err := json.Unmarshal(raw, &tx); err != nil {
        log.Fatal(err)
    }

    parser := dexparser.NewDexParser()
    result := parser.ParseAll(&tx, nil) // nil config: parse everything
    if !result.State {
        log.Fatal(result.Msg)
    }

    fmt.Println("status:", result.TxStatus, "fee:", result.Fee.Amount)
    for _, trade := range result.Trades {
        fmt.Printf("trade: %s %s %s %s -> %s %s\n", trade.AMM, trade.Type,
            trade.InputToken.AmountRaw, trade.InputToken.Mint,
            trade.OutputToken.AmountRaw, trade.OutputToken.Mint)
    }
    for _, event := range result.MemeEvents {
        fmt.Printf("meme: %s %s %s\n", event.Protocol, event.Type, event.BaseMint)
    }
    if result.Tip != nil {
        fmt.Println("tip:", result.Tip.Amount)
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
    "net/http"

    dexparser "github.com/DefaultPerson/solana-dex-parser-go"
    "github.com/DefaultPerson/solana-dex-parser-go/adapter"
)

// getTransaction fetches a confirmed transaction from a Solana RPC node
func getTransaction(rpcURL, signature string) (*adapter.SolanaTransaction, error) {
    request, err := json.Marshal(map[string]interface{}{
        "jsonrpc": "2.0",
        "id":      1,
        "method":  "getTransaction",
        "params": []interface{}{signature, map[string]interface{}{
            "encoding":                       "json",
            "maxSupportedTransactionVersion": 1,
            "commitment":                     "confirmed",
        }},
    })
    if err != nil {
        return nil, err
    }
    resp, err := http.Post(rpcURL, "application/json", bytes.NewReader(request))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var body struct {
        Result *adapter.SolanaTransaction `json:"result"`
        Error  *struct {
            Code    int    `json:"code"`
            Message string `json:"message"`
        } `json:"error"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
        return nil, err
    }
    if body.Error != nil {
        return nil, fmt.Errorf("rpc error %d: %s", body.Error.Code, body.Error.Message)
    }
    if body.Result == nil {
        return nil, fmt.Errorf("transaction %s not found", signature)
    }
    return body.Result, nil
}

func main() {
    signature := "4Cod1cNGv6RboJ7rSB79yeVCR4Lfd25rFgLY3eiPJfTJjTGyYP1r2i1upAYZHQsWDqUbGd1bhTRm1bpSQcpWMnEz"
    tx, err := getTransaction("https://api.mainnet-beta.solana.com", signature)
    if err != nil {
        log.Fatal(err)
    }

    result := dexparser.NewDexParser().ParseAll(tx, nil)
    fmt.Printf("trades: %d, liquidities: %d, meme events: %d, transfers: %d\n",
        len(result.Trades), len(result.Liquidities), len(result.MemeEvents), len(result.Transfers))
}

tx := loadTransaction(txFile)

config := &types.ParseConfig{
    // Trades and the aggregated trade only
    ParseType: types.ParseType{Trade: true, AggregateTrade: true},
    // Only transactions and programs among these
    ProgramIds:    []string{constants.DEX_PROGRAMS.PUMP_FUN.ID},
    TryUnknownDEX: true,
}
result := dexparser.NewDexParser().ParseAll(tx, config)

fmt.Println("trades:", len(result.Trades), "meme events:", len(result.MemeEvents))
if agg := result.AggregateTrade; agg != nil {
    fmt.Println("aggregate:", agg.Type, agg.InputToken.AmountRaw, "->", agg.OutputToken.AmountRaw)
}

config := &types.ParseConfig{
    // Tables you already know: table address -> all its addresses, in order
    AddressLookupTables: map[string][]string{},
    // Called once per transaction for the tables not in AddressLookupTables
    ALTsFetcher: types.NewALTsFetcher(types.FetchFilterAll,
        func(lookups []types.AddressTableLookup) (map[string]*types.LoadedAddresses, error) {
            resolved := make(map[string]*types.LoadedAddresses, len(lookups))
            for _, lookup := range lookups {
                // Load the table lookup.AccountKey (getAccountInfo) and pick
                // the addresses at lookup.WritableIndexes and ReadonlyIndexes
                resolved[lookup.AccountKey] = &types.LoadedAddresses{}
            }
            return resolved, nil
        }),
}
result := shredParser.ParseAll(tx, config)
fmt.Println("unresolved accounts:", result.HasUnresolvedAccounts)

fmt.Println(constants.GetBotName("ZG98FUCjb8mJ824Gbs6RsgVmr1FhXb2oNiJHa2dwmPd"))     // BONKbot
fmt.Println(constants.GetTipProvider("96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5")) // Jito
fmt.Println(constants.IsTradeFeeAccount("96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5"))

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    pb "github.com/rpcpool/yellowstone-grpc/examples/golang/proto"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"

    dexparser "github.com/DefaultPerson/solana-dex-parser-go"
    "github.com/DefaultPerson/solana-dex-parser-go/constants"
    "github.com/DefaultPerson/solana-dex-parser-go/types"
)

// tokenAuth sends the x-token header that most Yellowstone providers require
type tokenAuth struct{ token string }

func (t tokenAuth) GetRequestMetadata(context.Context, ...string) (map[string]string, error) {
    return map[string]string{"x-token": t.token}, nil
}

func (tokenAuth) RequireTransportSecurity() bool { return true }

func main() {
    // Endpoint host:port and token of your provider
    endpoint := os.Getenv("YELLOWSTONE_ENDPOINT")
    token := os.Getenv("YELLOWSTONE_TOKEN")

    conn, err := grpc.NewClient(endpoint,
        grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")),
        grpc.WithPerRPCCredentials(tokenAuth{token}),
    )
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    stream, err := pb.NewGeyserClient(conn).Subscribe(context.Background())
    if err != nil {
        log.Fatal(err)
    }
    failed := false
    commitment := pb.CommitmentLevel_CONFIRMED
    err = stream.Send(&pb.SubscribeRequest{
        Transactions: map[string]*pb.SubscribeRequestFilterTransactions{
            "pumpfun": {
                AccountInclude: []string{constants.DEX_PROGRAMS.PUMP_FUN.ID},
                Failed:         &failed,
            },
        },
        Commitment: &commitment,
    })
    if err != nil {
        log.Fatal(err)
    }

    parser := dexparser.NewDexParser()
    config := &types.ParseConfig{ParseType: types.ParseTradesOnly()}
    for {
        update, err := stream.Recv()
        if err != nil {
            log.Fatal(err)
        }
        txUpdate := update.GetTransaction()
        if txUpdate == nil {
            continue
        }
        tx, err := dexparser.ConvertGeyserTransaction(txUpdate.GetTransaction(), txUpdate.GetSlot(), 0)
        if err != nil {
            log.Println(err)
            continue
        }
        result := parser.ParseAll(tx, config)
        for _, trade := range result.Trades {
            fmt.Printf("%s %s %s: %s %s -> %s %s\n", result.Signature, trade.AMM, trade.Type,
                trade.InputToken.AmountRaw, trade.InputToken.Mint,
                trade.OutputToken.AmountRaw, trade.OutputToken.Mint)
        }
    }
}