OnChain Labs DEX v2 decoder

carbon-onchain-labs-dex-v2-decoder decodes the instructions, accounts and events of the OnChain Labs DEX v2 program (proVF4pMXVaYqmy4NjniPh4pqKNfMmsihgd4wdkCX3u): 19 instructions, 1 account type, 6 events. 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, OKX DEX. 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 OnChain Labs DEX v2 transactions from the public RPC and prints every decoded Swap instruction. Add the dependencies:

cargo add carbon-core@2.0.0 carbon-onchain-labs-dex-v2-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_onchain_labs_dex_v2_decoder::{
        instructions::OnchainLabsDexV2Instruction, OnchainLabsDexV2Decoder, 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(OnchainLabsDexV2Decoder, InstructionLogger)
        .build()?
        .run()
        .await
}

struct InstructionLogger;

impl Processor<InstructionProcessorInputType<'_, OnchainLabsDexV2Instruction>> for InstructionLogger {
    async fn process(
        &mut self,
        input: &InstructionProcessorInputType<'_, OnchainLabsDexV2Instruction>,
    ) -> CarbonResult<()> {
        let signature = input.metadata.transaction_metadata.signature;
        if let OnchainLabsDexV2Instruction::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 OnchainLabsDexV2Instruction::CpiEvent { data: CpiEvent::SwapCpiEvent2(event), .. } (import instructions::CpiEvent); see Events. If CpiEvent never arrives, the program logs its events with emit! instead: decode them with decode_log_events.

Decode accounts#

The transaction crawler emits transactions only. To decode accounts, use a datasource that emits account updates. This program subscribes to the program's accounts with programSubscribe on the public WebSocket endpoint and prints every decoded TokenLedger account as it changes. Add the datasource and the Solana RPC types it takes:

cargo add carbon-rpc-program-subscribe-datasource@2.0.0 solana-client@4.2.2

use {
    carbon_core::{
        account::AccountProcessorInputType, error::CarbonResult, pipeline::Pipeline,
        processor::Processor,
    },
    carbon_log_metrics::LogMetrics,
    carbon_onchain_labs_dex_v2_decoder::{
        accounts::OnchainLabsDexV2Account, OnchainLabsDexV2Decoder, PROGRAM_ID,
    },
    carbon_rpc_program_subscribe_datasource::{Filters, RpcProgramSubscribe},
    solana_client::rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig, UiAccountEncoding},
    std::sync::Arc,
};

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

    // Streams every change to an account owned by the program (programSubscribe).
    let config = RpcProgramAccountsConfig {
        account_config: RpcAccountInfoConfig {
            encoding: Some(UiAccountEncoding::Base64),
            ..Default::default()
        },
        ..Default::default()
    };
    let datasource = RpcProgramSubscribe::new(
        "wss://api.mainnet-beta.solana.com".to_string(),
        Filters::new(PROGRAM_ID, Some(config)),
    );

    Pipeline::builder()
        .datasource(datasource)
        .metrics(Arc::new(LogMetrics::new()))
        .account(OnchainLabsDexV2Decoder, AccountLogger)
        .build()?
        .run()
        .await
}

struct AccountLogger;

impl Processor<AccountProcessorInputType<'_, OnchainLabsDexV2Account>> for AccountLogger {
    async fn process(
        &mut self,
        input: &AccountProcessorInputType<'_, OnchainLabsDexV2Account>,
    ) -> CarbonResult<()> {
        let OnchainLabsDexV2Account::TokenLedger(token_ledger) = &input.decoded_account.data;
        println!("token_ledger {}: {token_ledger:?}", input.metadata.pubkey);
        Ok(())
    }
}

RUST_LOG=info cargo run

Each update to a TokenLedger account prints its address and decoded fields; the program runs until you stop it. Cargo resolves solana-client to 4.2.2, the exact version the datasource pins, so both use the same RpcProgramAccountsConfig type. To load every existing account once instead of streaming changes, see load account state.

Instructions#

Variants of OnchainLabsDexV2Instruction. Each is OnchainLabsDexV2Instruction::<Variant> { program_id, data, accounts }, where data and accounts are the types listed under the variant, exported from carbon_onchain_labs_dex_v2_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 proVF4pMXVaYqmy4NjniPh4pqKNfMmsihgd4wdkCX3u.
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:

InitTokenLedger#

Discriminator 9d74423b89b4319d · data InitTokenLedger · accounts InitTokenLedgerInstructionAccounts.

Required accounts: 3; extras go to remaining.

Fields of InitTokenLedgerInstructionAccounts, in account order:

ProxySwap#

Discriminator 132c829448382cee · data ProxySwap · accounts ProxySwapInstructionAccounts.

Required accounts: 14; extras go to remaining.

Fields of ProxySwapInstructionAccounts, in account order:

SetTokenLedger#

Discriminator e455b9704e4f4d02 · data SetTokenLedger · accounts SetTokenLedgerInstructionAccounts.

No data fields.

Required accounts: 2; extras go to remaining.

Fields of SetTokenLedgerInstructionAccounts, in account order:

Swap#

Discriminator f8c69e91e17587c8 · data Swap · accounts SwapInstructionAccounts.

Required accounts: 7; extras go to remaining.

Fields of SwapInstructionAccounts, in account order:

SwapTob#

Discriminator aa2955b184501f35 · data SwapTob · accounts SwapTobInstructionAccounts.

Required accounts: 16; extras go to remaining.

Fields of SwapTobInstructionAccounts, in account order:

SwapTobEnhanced#

Discriminator be9ca9b0959aa16c · data SwapTobEnhanced · accounts SwapTobEnhancedInstructionAccounts.

Required accounts: 16; extras go to remaining.

Fields of SwapTobEnhancedInstructionAccounts, in account order:

SwapTobV2#

From the program's IDL:

Used to support commission distribution between parent and child nodes in
TOB business

Discriminator 4801d7f2084b36d8 · data SwapTobV2 · accounts SwapTobV2InstructionAccounts.

Required accounts: 17; extras go to remaining.

Fields of SwapTobV2InstructionAccounts, in account order:

SwapTobWithReceiver#

Discriminator dfaad8eacc06f119 · data SwapTobWithReceiver · accounts SwapTobWithReceiverInstructionAccounts.

Required accounts: 17; extras go to remaining.

Fields of SwapTobWithReceiverInstructionAccounts, in account order:

SwapTobWithReceiverTokenLedger#

Discriminator ef5d0acaa1867f82 · data SwapTobWithReceiverTokenLedger · accounts SwapTobWithReceiverTokenLedgerInstructionAccounts.

Required accounts: 18; extras go to remaining.

Fields of SwapTobWithReceiverTokenLedgerInstructionAccounts, in account order:

SwapTobWithTokenLedger#

Discriminator 245c93db1ab09f5a · data SwapTobWithTokenLedger · accounts SwapTobWithTokenLedgerInstructionAccounts.

Required accounts: 17; extras go to remaining.

Fields of SwapTobWithTokenLedgerInstructionAccounts, in account order:

SwapToc#

Discriminator bbc9d433109bec3c · data SwapToc · accounts SwapTocInstructionAccounts.

Required accounts: 16; extras go to remaining.

Fields of SwapTocInstructionAccounts, in account order:

SwapTocV2#

From the program's IDL:

Used to support commission distribution between parent and child nodes in
TOC business

Discriminator 7fd66bbd175a2f68 · data SwapTocV2 · accounts SwapTocV2InstructionAccounts.

Required accounts: 17; extras go to remaining.

Fields of SwapTocV2InstructionAccounts, in account order:

WrapUnwrap#

Discriminator dc658bf929be76c7 · data WrapUnwrap · accounts WrapUnwrapInstructionAccounts.

Required accounts: 12; extras go to remaining.

Fields of WrapUnwrapInstructionAccounts, in account order:

WrapUnwrapWithReceiver#

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 7b192f86e9a7abaa · data WrapUnwrapWithReceiver · accounts WrapUnwrapWithReceiverInstructionAccounts.

Required accounts: 13; extras go to remaining.

Fields of WrapUnwrapWithReceiverInstructionAccounts, 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:

Accounts#

Variants of OnchainLabsDexV2Account. Each wraps a boxed struct from carbon_onchain_labs_dex_v2_decoder::accounts::<module>. decode_account only considers accounts owned by PROGRAM_ID and returns the first variant that matches.

TokenLedger#

Discriminator 9cf709bc366c554d · accounts::token_ledger::TokenLedger.

Events#

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

SwapCpiEvent2#

Discriminator 155ee035dce8c15e · events::swap_cpi_event2::SwapCpiEvent2Event.

SwapEvent#

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

SwapTobV2CpiEvent2#

Discriminator f469b85a3ca52421 · events::swap_tob_v2_cpi_event2::SwapTobV2CpiEvent2Event.

SwapTocV2CpiEvent2#

Discriminator 6610b53ec947d429 · events::swap_toc_v2_cpi_event2::SwapTocV2CpiEvent2Event.

SwapWithFeesCpiEvent2#

Discriminator 0c86265da7972a45 · events::swap_with_fees_cpi_event2::SwapWithFeesCpiEvent2Event.

SwapWithFeesCpiEventEnhanced2#

Discriminator 544fdbf7da9cdbb1 · events::swap_with_fees_cpi_event_enhanced2::SwapWithFeesCpiEventEnhanced2Event.

Types#

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

Dex#

Enum types::Dex.

PlatformFeeWrapUnwrapArgs#

Struct types::PlatformFeeWrapUnwrapArgs.

Route#

Struct types::Route.

SwapArgs#

Struct types::SwapArgs.

SwapArgsTokenLedger#

From the program's IDL:

Swap args for token-ledger swaps: no amount_in parameter.
amount_in is derived on-chain from token_ledger delta.

Struct types::SwapArgsTokenLedger.

SwapCpiEvent2#

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

SwapEvent#

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

SwapTobV2CpiEvent2#

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

SwapTocV2CpiEvent2#

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

SwapWithFeesCpiEvent2#

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

SwapWithFeesCpiEventEnhanced2#

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