Struct Orderbook 

pub struct Orderbook {
    pub base: Address,
    pub quote: Address,
    bids: Mapping<i16, TickLevel>,
    asks: Mapping<i16, TickLevel>,
    pub best_bid_tick: i16,
    pub best_ask_tick: i16,
    bid_bitmap: Mapping<i16, U256>,
    ask_bitmap: Mapping<i16, U256>,
}

Orderbook for token pair with price-time priority Uses tick-based pricing with bitmaps for price discovery

Fields

base: Address

Base token address

quote: Address

Quote token address

bids: Mapping<i16, TickLevel>

Bid orders by tick

asks: Mapping<i16, TickLevel>

Ask orders by tick

best_bid_tick: i16

Best bid tick for highest bid price

best_ask_tick: i16

Best ask tick for lowest ask price

bid_bitmap: Mapping<i16, U256>

Mapping of tick index to bid bitmap for price discovery

ask_bitmap: Mapping<i16, U256>

Mapping of tick index to ask bitmap for price discovery

Implementations

impl Orderbook

pub fn new(base: Address, quote: Address) -> Self

Creates a new orderbook for a token pair

pub fn is_initialized(&self) -> bool

Returns true if this orderbook is initialized

pub fn matches_tokens( &self, base_token: Option<Address>, quote_token: Option<Address>, ) -> bool

Returns true if the base and quote tokens match the provided base and quote token options.

pub fn update_best_bid_tick<S: StorageOps>( contract: &mut S, book_key: B256, new_best_bid: i16, ) -> Result<(), TempoPrecompileError>

Update only the best bid tick

pub fn update_best_ask_tick<S: StorageOps>( contract: &mut S, book_key: B256, new_best_ask: i16, ) -> Result<(), TempoPrecompileError>

Update only the best ask tick

pub fn exists<S: StorageOps>( book_key: B256, contract: &mut S, ) -> Result<bool, TempoPrecompileError>

Check if this orderbook exists in storage

pub fn read_tick_level<S: StorageOps>( storage: &mut S, book_key: B256, is_bid: bool, tick: i16, ) -> Result<TickLevel, TempoPrecompileError>

Read a TickLevel at a specific tick

pub fn write_tick_level<S: StorageOps>( storage: &mut S, book_key: B256, is_bid: bool, tick: i16, tick_level: TickLevel, ) -> Result<(), TempoPrecompileError>

Write a TickLevel at a specific tick

pub fn delete_tick_level<S: StorageOps>( storage: &mut S, book_key: B256, is_bid: bool, tick: i16, ) -> Result<(), TempoPrecompileError>

Delete a TickLevel at a specific tick

pub fn set_tick_bit<S: StorageOps>( storage: &mut S, book_key: B256, tick: i16, is_bid: bool, ) -> Result<(), TempoPrecompileError>

Set bit in bitmap to mark tick as active

pub fn clear_tick_bit<S: StorageOps>( storage: &mut S, book_key: B256, tick: i16, is_bid: bool, ) -> Result<(), TempoPrecompileError>

Clear bit in bitmap to mark tick as inactive

pub fn is_tick_initialized<S: StorageOps>( storage: &mut S, book_key: B256, tick: i16, is_bid: bool, ) -> Result<bool, TempoPrecompileError>

Check if a tick is initialized (has orders)

pub fn next_initialized_tick<S: StorageOps>( storage: &mut S, book_key: B256, is_bid: bool, tick: i16, spec: TempoHardfork, ) -> (i16, bool)

Find next initialized ask tick higher than current tick

fn next_initialized_ask_tick<S: StorageOps>( storage: &mut S, book_key: B256, tick: i16, spec: TempoHardfork, ) -> (i16, bool)

Find next initialized ask tick higher than current tick

fn next_initialized_bid_tick<S: StorageOps>( storage: &mut S, book_key: B256, tick: i16, spec: TempoHardfork, ) -> (i16, bool)

Find next initialized bid tick lower than current tick

Trait Implementations

impl Default for Orderbook

fn default() -> Orderbook

Returns the “default value” for a type.

impl From<Orderbook> for Orderbook

fn from(value: Orderbook) -> Self

Converts to this type from the input type.

impl Storable<Storable> for Orderbook

fn load<S: StorageOps>( storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<Self>

Load this type from storage starting at the given base slot.

fn store<S: StorageOps>( &self, storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<()>

Store this type to storage starting at the given base slot.

fn to_evm_words(&self) -> Result<[U256; 7]>

Encode this type to an array of U256 words.

fn from_evm_words(words: [U256; 7]) -> Result<Self>

Decode this type from an array of U256 words.

fn delete<S: StorageOps>( storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<()>

Delete this type from storage (set all slots to zero).

fn validate_layout()

Test helper to ensure LAYOUT and SLOTS are in sync.

impl StorableType for Orderbook

const LAYOUT: Layout

Describes how this type is laid out in storage.

const SLOTS: usize = _

Number of storage slots this type takes.

const BYTES: usize = _

Number of bytes this type takes.

const IS_PACKABLE: bool = _

Whether this type can be packed with adjacent fields.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 176 bytes