OKX DEX decoder

carbon-okx-dex-decoder decodes the instructions, accounts and events of the OKX DEX program (6m2CDdhRgxpH4WjvdzxAYbGxwdGUz5MziiL5jek2kBma): 14 instructions, 2 events. It decodes no accounts: OkxDexAccount has no variants. It is generated with Codama from the program's IDL; see decoders for how decoders plug into a pipeline.

Other aggregator and routing decoders: DFlow Aggregator v4, Jupiter Swap, OnChain Labs DEX v2. To decode several in one pipeline, see aggregator and routing decoders.

The serde feature derives Serialize/Deserialize on every type, postgres adds tables and processors for Postgres, and graphql adds a schema for the GraphQL server.

Usage#

This program crawls recent OKX DEX transactions from the public RPC and prints every decoded Swap instruction. Add the dependencies:

cargo add carbon-core@2.0.0 carbon-okx-dex-decoder@2.0.0 carbon-rpc-transaction-crawler-datasource@2.0.0 carbon-log-metrics@2.0.0 env_logger tokio --features tokio/full

use {
    carbon_core::{
        error::CarbonResult, instruction::InstructionProcessorInputType, pipeline::Pipeline,
        processor::Processor,
    },
    carbon_log_metrics::LogMetrics,
    carbon_okx_dex_decoder::{instructions::OkxDexInstruction, OkxDexDecoder, PROGRAM_ID},
    carbon_rpc_transaction_crawler_datasource::{ConnectionConfig, Filters, RpcTransactionCrawler},
    std::sync::Arc,
};

#[tokio::main]
async fn main() -> CarbonResult<()> {
    env_logger::init();

    // Fetches the program's recent transactions over JSON-RPC, newest first.
    let datasource = RpcTransactionCrawler::new(
        "https://api.mainnet-beta.solana.com".to_string(),
        PROGRAM_ID,
        ConnectionConfig::default(),
        Filters::new(None, None, None),
        None,
    );

    Pipeline::builder()
        .datasource(datasource)
        .metrics(Arc::new(LogMetrics::new()))
        .instruction(OkxDexDecoder, InstructionLogger)
        .build()?
        .run()
        .await
}

struct InstructionLogger;

impl Processor<InstructionProcessorInputType<'_, OkxDexInstruction>> for InstructionLogger {
    async fn process(
        &mut self,
        input: &InstructionProcessorInputType<'_, OkxDexInstruction>,
    ) -> CarbonResult<()> {
        let signature = input.metadata.transaction_metadata.signature;
        if let OkxDexInstruction::Swap { data, accounts, .. } = input.decoded_instruction {
            println!("swap {signature}: {data:?} payer={}", accounts.payer);
        }
        Ok(())
    }
}

RUST_LOG=info cargo run

Each Swap instruction prints one line with the transaction signature and the decoded Swap data. The public endpoint rate-limits requests, so the first lines can take a while; use your own RPC URL for anything beyond a test. See stream with RPC for the crawler options.

Events published with Anchor's emit_cpi! arrive as the CpiEvent instruction. Match them with OkxDexInstruction::CpiEvent { data: CpiEvent::SwapEvent(event), .. } (import instructions::CpiEvent); see Events. If CpiEvent never arrives, the program logs its events with emit! instead: decode them with decode_log_events.

Instructions#

Variants of OkxDexInstruction. Each is OkxDexInstruction::<Variant> { program_id, data, accounts }, where data and accounts are the types listed under the variant, exported from carbon_okx_dex_decoder::instructions. Discriminators are the leading bytes of the instruction data, in hex.

How an instruction decodes. The decoder returns a variant only when all of these hold; otherwise the instruction is skipped and no processor is called:

1. The instruction's program ID is 6m2CDdhRgxpH4WjvdzxAYbGxwdGUz5MziiL5jek2kBma.
2. The data starts with the variant's discriminator, and the rest deserializes into its data type.
3. The instruction has at least as many accounts as the variant requires (the "Required accounts" count under each variant).

Accounts. They are matched by position, in the order listed. An account marked optional is None only when the instruction ends before it; Anchor programs pass the program ID as a placeholder for an omitted optional account, so check for Some(PROGRAM_ID) too. Accounts after the listed ones are in accounts.remaining as AccountMetas. The decoder doesn't record whether an account signed or was writable: read that from input.raw_instruction.accounts[i].is_signer and .is_writable, which follow the same order. It doesn't check signer, writable, owner or PDA constraints either; the program enforced those when the transaction executed, so a decoded instruction from a successful transaction already satisfied them.

Claim#

Discriminator 3ec6d6c1d59f6cd2 · data Claim · accounts ClaimInstructionAccounts.

No data fields.

Required accounts: 8 (9 listed); extras go to remaining.

Fields of ClaimInstructionAccounts, in account order:

ClaimCashbackPumpfun#

Discriminator 5301f57dc9cfd1f9 · data ClaimCashbackPumpfun · accounts ClaimCashbackPumpfunInstructionAccounts.

No data fields.

Required accounts: 7; extras go to remaining.

Fields of ClaimCashbackPumpfunInstructionAccounts, in account order:

ClaimCashbackPumpswap#

Discriminator fdf2b0add94e6419 · data ClaimCashbackPumpswap · accounts ClaimCashbackPumpswapInstructionAccounts.

No data fields.

Required accounts: 11; extras go to remaining.

Fields of ClaimCashbackPumpswapInstructionAccounts, in account order:

CreateTokenAccount#

Discriminator 93f17b64f484ae76 · data CreateTokenAccount · accounts CreateTokenAccountInstructionAccounts.

Required accounts: 6; extras go to remaining.

Fields of CreateTokenAccountInstructionAccounts, in account order:

CreateTokenAccountWithSeed#

Discriminator 7dbfef8c420809e4 · data CreateTokenAccountWithSeed · accounts CreateTokenAccountWithSeedInstructionAccounts.

Required accounts: 6; extras go to remaining.

Fields of CreateTokenAccountWithSeedInstructionAccounts, in account order:

ProxySwap#

Discriminator 132c829448382cee · data ProxySwap · accounts ProxySwapInstructionAccounts.

Required accounts: 5 (12 listed); extras go to remaining.

Fields of ProxySwapInstructionAccounts, in account order:

Swap#

Discriminator f8c69e91e17587c8 · data Swap · accounts SwapInstructionAccounts.

Required accounts: 5; extras go to remaining.

Fields of SwapInstructionAccounts, in account order:

SwapTobV3#

Discriminator 0ebf2cf68ee1e09d · data SwapTobV3 · accounts SwapTobV3InstructionAccounts.

Required accounts: 5 (14 listed); extras go to remaining.

Fields of SwapTobV3InstructionAccounts, in account order:

SwapTobV3Enhanced#

Discriminator ec479b44c6620e76 · data SwapTobV3Enhanced · accounts SwapTobV3EnhancedInstructionAccounts.

Required accounts: 5 (14 listed); extras go to remaining.

Fields of SwapTobV3EnhancedInstructionAccounts, in account order:

SwapTobV3WithReceiver#

From the program's IDL:

Swap ToB with optional specified receiver

• For normal token swaps: sol_receiver should be None
• For swap to SOL with custom receiver: sol_receiver should be Some and acc_close_flag must be true

Discriminator 3f72f6833302f71d · data SwapTobV3WithReceiver · accounts SwapTobV3WithReceiverInstructionAccounts.

Required accounts: 5 (15 listed); extras go to remaining.

Fields of SwapTobV3WithReceiverInstructionAccounts, in account order:

SwapV3#

Discriminator f0e02621b01ff1af · data SwapV3 · accounts SwapV3InstructionAccounts.

Required accounts: 5 (14 listed); extras go to remaining.

Fields of SwapV3InstructionAccounts, in account order:

SwapV3WithCpiEvent#

Discriminator b8684f9c6bb6788a · data SwapV3WithCpiEvent · accounts SwapV3WithCpiEventInstructionAccounts.

Required accounts: 16; extras go to remaining.

Fields of SwapV3WithCpiEventInstructionAccounts, in account order:

WrapUnwrapV3#

Discriminator b4b2bf3646080de0 · data WrapUnwrapV3 · accounts WrapUnwrapV3InstructionAccounts.

Required accounts: 10; extras go to remaining.

Fields of WrapUnwrapV3InstructionAccounts, in account order:

WrapUnwrapV3WithReceiver#

From the program's IDL:

Wrap/Unwrap with optional specified receiver

• Wrap (SOL -> WSOL): receiver is WSOL token account (ATA)
• Unwrap (WSOL -> SOL): receiver is system account (EOA)

Transfer amount:

• From fee: amount_in
• To fee: amount_in - fees

Discriminator 46d3bea52f28d55f · data WrapUnwrapV3WithReceiver · accounts WrapUnwrapV3WithReceiverInstructionAccounts.

Required accounts: 11; extras go to remaining.

Fields of WrapUnwrapV3WithReceiverInstructionAccounts, in account order:

CpiEvent#

Anchor self-CPI that carries one of the program's events. data is the CpiEvent enum.

Discriminator e445a52e51cb9a1d · data CpiEvent · accounts CpiEventInstructionAccounts.

Required accounts: 2; extras go to remaining.

Fields of CpiEventInstructionAccounts, in account order:

Events#

Variants of instructions::CpiEvent, decoded from the CpiEvent instruction. Each wraps a struct from carbon_okx_dex_decoder::events::<module>. The discriminator is the 8-byte event discriminator that follows the e445a52e51cb9a1d CPI-event tag.

SwapEvent#

Discriminator 40c6cde8260871e2 · events::swap_event::SwapEventEvent.

SwapWithFeesCpiEvent#

Discriminator bd61430c25d1f71d · events::swap_with_fees_cpi_event::SwapWithFeesCpiEventEvent.

Types#

Types used by the instructions, accounts and events above, exported from carbon_okx_dex_decoder::types.

Dex#

Enum types::Dex.

PlatformFeeWrapUnwrapArgs#

Struct types::PlatformFeeWrapUnwrapArgs.

Route#

Struct types::Route.

SwapArgs#

Struct types::SwapArgs.

SwapEvent#

Struct types::SwapEvent. Same fields as the SwapEvent event.

SwapWithFeesCpiEvent#

Struct types::SwapWithFeesCpiEvent. Same fields as the SwapWithFeesCpiEvent event.