ShredParser¶

ShredParser decodes DEX instructions from their arguments, without relying on execution results. It is meant for data that arrives before execution, where DexParser has nothing to work with.

Input sources¶

DecodeShredEntries decodes the entries bytes of a ShredStream Entry message (a bincode Vec<Entry>) into transactions (legacy, v0 and v1). They have no meta and Slot 0: set it from Entry.slot. A malformed transaction stops decoding; the transactions before it are returned with the error.

// data is Entry.entries of a SubscribeEntries message, slot is Entry.slot
var data []byte
var slot uint64

txs, err := dexparser.DecodeShredEntries(data)
if err != nil {
    log.Println("partial entry:", err)
}
for _, tx := range txs {
    tx.Slot = slot
    result := shredParser.ParseAll(tx, nil)
    for _, ins := range result.ParsedInstructions {
        fmt.Println(result.Signature, ins.Idx, ins.ProgramName, ins.Action)
    }
}

Example¶

tx := loadTransaction(txFile)
// Pre-execution sources (e.g. Jito ShredStream, see DecodeShredEntries)
// deliver no meta; drop it to see what ShredParser gets from them.
tx.Meta = nil

result := dexparser.NewShredParser().ParseAll(tx, nil)
fmt.Println("status:", result.TxStatus)
for _, ins := range result.ParsedInstructions {
    fmt.Printf("%s %s %s", ins.Idx, ins.ProgramName, ins.Action)
    if t := ins.Trade; t != nil {
        fmt.Printf(": %s %s (%s) -> %s (%s)", t.Type,
            t.InputToken.AmountRaw, ins.InputAmountKind,
            t.OutputToken.AmountRaw, ins.OutputAmountKind)
    }
    fmt.Println()
}

Output:

status: unknown
1 System transfer
3 Pumpfun create
5 Pumpfun buy: BUY 2020000000 (max) -> 67062499999999 (exact)

The buy asks for exactly 67062499999999 tokens and allows at most 2020000000 lamports. DexParser reports what the buyer paid in the same transaction: 2020000000, that is 2000000000 into the bonding curve plus the 1% fee of 20000000 transferred to the fee recipient CebN5WGQ…, which is the trade's Fee. loadTransaction stands for the file reading of the Quick Start; tx is the Pump.fun create + buy 4Cod1cNG….

Result¶

types.ParseShredResult:

types.ParsedShredInstruction has ProgramID, ProgramName, Action (the instruction name), Idx, Accounts, Data (the decoded arguments) and one of Trade, Liquidity, Transfer or MemeEvent.

Semantics¶

• Amounts are instruction arguments, often slippage limits. InputAmountKind and OutputAmountKind tell what the trade's (or meme event's) amounts mean:

• Mints are never guessed. A mint the transaction does not reveal is "", with decimals 0.
• Decimals come from the transaction's token balances or constants.TOKEN_DECIMALS, else 0 (unknown). Pump.fun bonding-curve tokens always have 6.
• Trade type is SWAP when the direction cannot be determined: for Jupiter and DFlow routes whenever a mint is unknown or both are the same (circular arbitrage). Raydium V4 trades with one known mint are BUY for WSOL in and SELL for WSOL out. PumpSwap trades follow the SOL/stablecoin rule too, not the instruction name: a buy in a pool whose base is WSOL and whose quote is a token is SELL.
• Lookup tables: v0 accounts resolve from meta.loadedAddresses, ParseConfig.AddressLookupTables or an ALTsFetcher (see Getting Started). Unresolved accounts are "", and UnresolvedAccounts is set on the instruction (and unresolvedAccounts on the older events).
• Failed transactions (meta.err set) give no instructions and Msg="transaction failed" unless IncludeFailedTxs is set.
• Idx is "N" for outer and "N-M" for inner instructions.
• A nil config means TryUnknownDEX on; ProgramIds and IgnoreProgramIds select programs. ShredParser.ParseAll never returns nil.

Protocols¶

gRPC input¶

Yellowstone gRPC updates are executed transactions: convert them with ConvertGeyserTransaction (see Getting Started). For them DexParser gives executed amounts; ShredParser is useful when you want the signed limits. An update without meta (YellowstoneTransaction.NoMeta, deshred transactions) converts to a transaction without meta, as ShredParser expects for pre-execution input.