OpenBook v2 decoder

carbon-openbook-v2-decoder decodes the instructions, accounts and events of the OpenBook v2 program (opnb2LAfJYbRMAHHvqjCwQxanZn7ReEHp1k81EohpZb): 29 instructions, 6 account types, 8 events. It is generated with Codama from the program's IDL; see decoders for how decoders plug into a pipeline.

Other DEX and AMM decoders: BonkSwap, FluxBeam, Gavel, Heaven, Jupiter Limit Order, Jupiter Limit Order v2, Kamino Limit Order, Lifinity AMM v2, Meteora DAMM v2, Meteora DLMM, Meteora Pools, Orca Whirlpools, PancakeSwap, Phoenix v1, PumpSwap, Raydium AMM v4, Raydium CLMM, Raydium CPMM, Raydium Stable Swap, Stabble Stable Swap, Stabble Weighted Swap. To decode several in one pipeline, see dEX and AMM 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 OpenBook v2 transactions from the public RPC and prints every decoded Deposit instruction. Add the dependencies:

cargo add carbon-core@2.0.0 carbon-openbook-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_openbook_v2_decoder::{
        instructions::OpenbookV2Instruction, OpenbookV2Decoder, 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(OpenbookV2Decoder, InstructionLogger)
        .build()?
        .run()
        .await
}

struct InstructionLogger;

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

RUST_LOG=info cargo run

Each Deposit instruction prints one line with the transaction signature and the decoded Deposit 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 OpenbookV2Instruction::CpiEvent { data: CpiEvent::DepositLog(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 Market 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_openbook_v2_decoder::{accounts::OpenbookV2Account, OpenbookV2Decoder, 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(OpenbookV2Decoder, AccountLogger)
        .build()?
        .run()
        .await
}

struct AccountLogger;

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

RUST_LOG=info cargo run

Each update to a Market 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 OpenbookV2Instruction. Each is OpenbookV2Instruction::<Variant> { program_id, data, accounts }, where data and accounts are the types listed under the variant, exported from carbon_openbook_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 opnb2LAfJYbRMAHHvqjCwQxanZn7ReEHp1k81EohpZb.
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.

CancelAllAndPlaceOrders#

From the program's IDL:

Cancel orders and place multiple orders.

Discriminator 809bde3cba28e132 · data CancelAllAndPlaceOrders · accounts CancelAllAndPlaceOrdersInstructionAccounts.

Required accounts: 14; extras go to remaining.

Fields of CancelAllAndPlaceOrdersInstructionAccounts, in account order:

CancelAllOrders#

From the program's IDL:

Cancel up to limit orders, optionally filtering by side

Discriminator c453f3ab1164a08f · data CancelAllOrders · accounts CancelAllOrdersInstructionAccounts.

Required accounts: 5; extras go to remaining.

Fields of CancelAllOrdersInstructionAccounts, in account order:

CancelOrder#

From the program's IDL:

Cancel an order by its order_id.
Note that this doesn't emit an OutEvent because a maker knows that they will be passing in their own
OpenOrdersAccount.

Discriminator 5f81edf00831df84 · data CancelOrder · accounts CancelOrderInstructionAccounts.

Required accounts: 5; extras go to remaining.

Fields of CancelOrderInstructionAccounts, in account order:

CancelOrderByClientOrderId#

From the program's IDL:

Cancel an order by its client_order_id.
Note that this doesn't emit an OutEvent because a maker knows that they will be passing in their own
OpenOrdersAccount.

Discriminator 73b2c908afb77b77 · data CancelOrderByClientOrderId · accounts CancelOrderByClientOrderIdInstructionAccounts.

Required accounts: 5; extras go to remaining.

Fields of CancelOrderByClientOrderIdInstructionAccounts, in account order:

CloseMarket#

From the program's IDL:

Close a Market (only
close_market_admin).

Discriminator 589af8ba300e7bf4 · data CloseMarket · accounts CloseMarketInstructionAccounts.

No data fields.

Required accounts: 7; extras go to remaining.

Fields of CloseMarketInstructionAccounts, in account order:

CloseOpenOrdersAccount#

From the program's IDL:

Close an OpenOrdersAccount.

Discriminator b04a73d236b35b67 · data CloseOpenOrdersAccount · accounts CloseOpenOrdersAccountInstructionAccounts.

No data fields.

Required accounts: 5; extras go to remaining.

Fields of CloseOpenOrdersAccountInstructionAccounts, in account order:

CloseOpenOrdersIndexer#

From the program's IDL:

Close an OpenOrdersIndexer account.

Discriminator 67f9e5e7f7fdc588 · data CloseOpenOrdersIndexer · accounts CloseOpenOrdersIndexerInstructionAccounts.

No data fields.

Required accounts: 4; extras go to remaining.

Fields of CloseOpenOrdersIndexerInstructionAccounts, in account order:

ConsumeEvents#

From the program's IDL:

Process up to limit events.
When a user places a 'take' order, they do not know beforehand which market maker will have placed the 'make' order that they get executed against. This prevents them from passing in a market maker's
OpenOrdersAccount, which is needed to credit/debit the relevant tokens to/from the maker. As such, Openbook uses a 'crank' system, where place_order only emits events, and consume_events handles token settlement.
Currently, there are two types of events:
FillEvents and OutEvents.
A FillEvent is emitted when an order is filled, and it is handled by debiting whatever the taker is selling from the taker and crediting it to the maker, and debiting whatever the taker is buying from the maker and crediting it to the taker. Note that no tokens are moved, these are just debits and credits to each party's
Position. An OutEvent is emitted when a limit order needs to be removed from the book during a place_order invocation, and it is handled by crediting whatever the maker would have sold (quote token in a bid, base token in an ask) back to the maker.

Discriminator dd91b1341f2f3fc9 · data ConsumeEvents · accounts ConsumeEventsInstructionAccounts.

Required accounts: 3; extras go to remaining.

Fields of ConsumeEventsInstructionAccounts, in account order:

ConsumeGivenEvents#

From the program's IDL:

Process the events at the given positions.

Discriminator d1e336046dac2947 · data ConsumeGivenEvents · accounts ConsumeGivenEventsInstructionAccounts.

Required accounts: 3; extras go to remaining.

Fields of ConsumeGivenEventsInstructionAccounts, in account order:

CreateMarket#

From the program's IDL:

Create a Market for a given token pair.

Discriminator 67e261ebc8bcfbfe · data CreateMarket · accounts CreateMarketInstructionAccounts.

Required accounts: 21; extras go to remaining.

Fields of CreateMarketInstructionAccounts, in account order:

CreateOpenOrdersAccount#

From the program's IDL:

Create an OpenOrdersAccount.

Discriminator ccb5afde287dbc47 · data CreateOpenOrdersAccount · accounts CreateOpenOrdersAccountInstructionAccounts.

Required accounts: 7; extras go to remaining.

Fields of CreateOpenOrdersAccountInstructionAccounts, in account order:

CreateOpenOrdersIndexer#

From the program's IDL:

Create an OpenOrdersIndexer account.

Discriminator 404099ffd947f985 · data CreateOpenOrdersIndexer · accounts CreateOpenOrdersIndexerInstructionAccounts.

No data fields.

Required accounts: 4; extras go to remaining.

Fields of CreateOpenOrdersIndexerInstructionAccounts, in account order:

Deposit#

From the program's IDL:

Deposit a certain amount of base and quote lamports into one's
Position.
Makers might wish to deposit, rather than have actual tokens moved for each trade, in order to reduce CUs.

Discriminator f223c68952e1f2b6 · data Deposit · accounts DepositInstructionAccounts.

Required accounts: 8; extras go to remaining.

Fields of DepositInstructionAccounts, in account order:

EditOrder#

From the program's IDL:

Edit an order.

Discriminator fed0761dadf8c846 · data EditOrder · accounts EditOrderInstructionAccounts.

Required accounts: 12; extras go to remaining.

Fields of EditOrderInstructionAccounts, in account order:

EditOrderPegged#

From the program's IDL:

Edit an order pegged.

Discriminator 3ebb7d451add9d85 · data EditOrderPegged · accounts EditOrderPeggedInstructionAccounts.

Required accounts: 12; extras go to remaining.

Fields of EditOrderPeggedInstructionAccounts, in account order:

PlaceOrder#

From the program's IDL:

Place an order.
Different types of orders have different effects on the order book, as described in PlaceOrderType.
price_lots refers to the price in lots: the number of quote lots per base lot. It is ignored for PlaceOrderType::Market orders.
expiry_timestamp is a unix timestamp for when this order should expire. If 0 is passed in, the order will never expire. If the time is in the past, the instruction is skipped. Timestamps in the future are reduced to now + 65,535s.
limit determines the maximum number of orders from the book to fill, and can be used to limit CU spent. When the limit is reached, processing stops and the instruction succeeds.

Discriminator 33c29baf6d82606a · data PlaceOrder · accounts PlaceOrderInstructionAccounts.

Required accounts: 12; extras go to remaining.

Fields of PlaceOrderInstructionAccounts, in account order:

PlaceOrderPegged#

From the program's IDL:

Place an oracle-peg order.

Discriminator 8db9fb3f4a55d291 · data PlaceOrderPegged · accounts PlaceOrderPeggedInstructionAccounts.

Required accounts: 12; extras go to remaining.

Fields of PlaceOrderPeggedInstructionAccounts, in account order:

PlaceOrders#

From the program's IDL:

Place multiple orders

Discriminator 3c3f327b0cc53cbe · data PlaceOrders · accounts PlaceOrdersInstructionAccounts.

Required accounts: 14; extras go to remaining.

Fields of PlaceOrdersInstructionAccounts, in account order:

PlaceTakeOrder#

From the program's IDL:

Place an order that shall take existing liquidity off of the book, not add a new order off the book.
This type of order allows for instant token settlement for the taker.

Discriminator 032c47031ac7cb55 · data PlaceTakeOrder · accounts PlaceTakeOrderInstructionAccounts.

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

Fields of PlaceTakeOrderInstructionAccounts, in account order:

PruneOrders#

From the program's IDL:

Remove orders from the book when the market is expired (only
close_market_admin).

Discriminator 1bd59fbf0c747079 · data PruneOrders · accounts PruneOrdersInstructionAccounts.

Required accounts: 5; extras go to remaining.

Fields of PruneOrdersInstructionAccounts, in account order:

Refill#

From the program's IDL:

Refill a certain amount of base and quote lamports. The amount being passed is the total lamports that the Position will have. Makers might wish to refill, rather than have actual tokens moved for each trade, in order to reduce CUs.

Discriminator 80cf8e0b36e826c9 · data Refill · accounts RefillInstructionAccounts.

Required accounts: 8; extras go to remaining.

Fields of RefillInstructionAccounts, in account order:

SetDelegate#

From the program's IDL:

Update the delegate of an open orders account.

Discriminator f21e2e4c6ceb80b5 · data SetDelegate · accounts SetDelegateInstructionAccounts.

No data fields.

Required accounts: 2 (3 listed); extras go to remaining.

Fields of SetDelegateInstructionAccounts, in account order:

SetMarketExpired#

From the program's IDL:

Set market to expired before pruning orders and closing the market (only
close_market_admin).

Discriminator db52dbec3c73c540 · data SetMarketExpired · accounts SetMarketExpiredInstructionAccounts.

No data fields.

Required accounts: 2; extras go to remaining.

Fields of SetMarketExpiredInstructionAccounts, in account order:

SettleFunds#

From the program's IDL:

Withdraw any available tokens.

Discriminator ee40a3604bab1021 · data SettleFunds · accounts SettleFundsInstructionAccounts.

No data fields.

Required accounts: 12; extras go to remaining.

Fields of SettleFundsInstructionAccounts, in account order:

SettleFundsExpired#

From the program's IDL:

Withdraw any available tokens when the market is expired (only
close_market_admin).

Discriminator 6b123845e43837a4 · data SettleFundsExpired · accounts SettleFundsExpiredInstructionAccounts.

No data fields.

Required accounts: 13; extras go to remaining.

Fields of SettleFundsExpiredInstructionAccounts, in account order:

StubOracleClose#

Discriminator 5c892d032d3c75e0 · data StubOracleClose · accounts StubOracleCloseInstructionAccounts.

No data fields.

Required accounts: 4; extras go to remaining.

Fields of StubOracleCloseInstructionAccounts, in account order:

StubOracleCreate#

Discriminator ac3f65538d4cc7d8 · data StubOracleCreate · accounts StubOracleCreateInstructionAccounts.

Required accounts: 5; extras go to remaining.

Fields of StubOracleCreateInstructionAccounts, in account order:

StubOracleSet#

Discriminator 6dc64f7941caa18e · data StubOracleSet · accounts StubOracleSetInstructionAccounts.

Required accounts: 2; extras go to remaining.

Fields of StubOracleSetInstructionAccounts, in account order:

SweepFees#

From the program's IDL:

Sweep fees, as a Market's admin.

Discriminator afe1624776422294 · data SweepFees · accounts SweepFeesInstructionAccounts.

No data fields.

Required accounts: 6; extras go to remaining.

Fields of SweepFeesInstructionAccounts, 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 OpenbookV2Account. Each wraps a boxed struct from carbon_openbook_v2_decoder::accounts::<module>. decode_account only considers accounts owned by PROGRAM_ID and returns the first variant that matches.

BookSide#

Discriminator 482ce18db2826139 · accounts::book_side::BookSide.

EventHeap#

From the program's IDL:

Container for the different EventTypes.
Events are stored in a fixed-array of nodes. Free nodes are connected by a single-linked list starting at free_head while used nodes form a circular doubly-linked list starting at used_head.

Discriminator 773b3d13a55439af · accounts::event_heap::EventHeap.

Market#

Discriminator dbbed53700e3c69a · accounts::market::Market.

OpenOrdersAccount#

Discriminator ffc24e7b1069d0a5 · accounts::open_orders_account::OpenOrdersAccount.

OpenOrdersIndexer#

Discriminator c35380d5cc5b1396 · accounts::open_orders_indexer::OpenOrdersIndexer.

StubOracle#

Discriminator e0fbfe63b1ae8904 · accounts::stub_oracle::StubOracle.

Events#

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

DepositLog#

Discriminator 8dbaa8fc6c8d485e · events::deposit_log::DepositLogEvent.

FillLog#

Discriminator 9617299498a2d740 · events::fill_log::FillLogEvent.

MarketMetaDataLog#

Discriminator d157d4eca43a3c75 · events::market_meta_data_log::MarketMetaDataLogEvent.

TotalOrderFillEvent#

Discriminator 08eb303aae4c9c69 · events::total_order_fill_event::TotalOrderFillEventEvent.

SetDelegateLog#

Discriminator 3582975c6d399170 · events::set_delegate_log::SetDelegateLogEvent.

SettleFundsLog#

Discriminator 0a32f075ed43e6e9 · events::settle_funds_log::SettleFundsLogEvent.

SweepFeesLog#

Discriminator d2f21a4d5e30ff3d · events::sweep_fees_log::SweepFeesLogEvent.

OpenOrdersPositionLog#

Discriminator c4f99421a8e44906 · events::open_orders_position_log::OpenOrdersPositionLogEvent.

Types#

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

AnyEvent#

Struct types::AnyEvent.

AnyNode#

Struct types::AnyNode.

BookSideOrderTree#

Enum types::BookSideOrderTree.

DepositLog#

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

EventHeapHeader#

Struct types::EventHeapHeader.

EventNode#

Struct types::EventNode.

EventType#

Enum types::EventType.

FillEvent#

Struct types::FillEvent.

FillLog#

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

I80F48#

From the program's IDL:

Nothing in Rust shall use these types. They only exist so that the Anchor
IDL knows about them and typescript can deserialize it.

Struct types::I80F48.

InnerNode#

From the program's IDL:

InnerNodes and LeafNodes compose the binary tree of orders.
Each InnerNode has exactly two children, which are either InnerNodes themselves, or LeafNodes. The children share the top prefix_len bits of key. The left child has a 0 in the next bit, and the right a 1.

Struct types::InnerNode.

LeafNode#

From the program's IDL:

LeafNodes represent an order in the binary tree

Struct types::LeafNode.

MarketMetaDataLog#

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

NodeTag#

Enum types::NodeTag.

NonZeroPubkeyOption#

From the program's IDL:

Like Option, but implemented for Pubkey to be used with zero_copy

Struct types::NonZeroPubkeyOption.

OpenOrder#

Struct types::OpenOrder.

OpenOrdersPositionLog#

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

OracleConfig#

Struct types::OracleConfig.

OracleConfigParams#

Struct types::OracleConfigParams.

OracleType#

Enum types::OracleType.

OrderParams#

Enum types::OrderParams.

OrderState#

Enum types::OrderState.

OrderTreeNodes#

From the program's IDL:

A binary tree on AnyNode::key()
The key encodes the price in the top 64 bits.

Struct types::OrderTreeNodes.

OrderTreeRoot#

Struct types::OrderTreeRoot.

OrderTreeType#

Enum types::OrderTreeType.

OutEvent#

Struct types::OutEvent.

PlaceMultipleOrdersArgs#

Struct types::PlaceMultipleOrdersArgs.

PlaceOrderArgs#

Struct types::PlaceOrderArgs.

PlaceOrderPeggedArgs#

Struct types::PlaceOrderPeggedArgs.

PlaceOrderType#

Enum types::PlaceOrderType.

PlaceTakeOrderArgs#

Struct types::PlaceTakeOrderArgs.

Position#

Struct types::Position.

PostOrderType#

Enum types::PostOrderType.

SelfTradeBehavior#

From the program's IDL:

Self trade behavior controls how taker orders interact with resting limit orders of the same account. This setting has no influence on placing a resting or oracle pegged limit order that does not match immediately, instead it's the responsibility of the user to correctly configure his taker orders.

Enum types::SelfTradeBehavior.

SetDelegateLog#

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

SettleFundsLog#

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

Side#

Enum types::Side.

SideAndOrderTree#

From the program's IDL:

SideAndOrderTree is a storage optimization, so we don't need two bytes for the data

Enum types::SideAndOrderTree.

SweepFeesLog#

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

TotalOrderFillEvent#

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