Struct Order 

pub struct Order {
    pub order_id: u128,
    pub maker: Address,
    pub book_key: B256,
    pub is_bid: bool,
    pub tick: i16,
    pub amount: u128,
    pub remaining: u128,
    pub prev: u128,
    pub next: u128,
    pub is_flip: bool,
    pub flip_tick: i16,
}

Represents an order in the stablecoin DEX orderbook.

This struct matches the Solidity reference implementation in StablecoinExchange.sol.

Order Types

• Regular orders: Orders with is_flip = false
• Flip orders: Orders with is_flip = true that automatically create a new order on the opposite side when fully filled

Order Lifecycle

1. Order is placed via place() or placeFlip() and added to pending queue
2. At end of block, pending orders are inserted into the active orderbook
3. Orders can be filled (fully or partially) by taker orders
4. Flip orders automatically create a new order on the opposite side when fully filled
5. Orders can be cancelled, removing them from the book

Price-Time Priority

Orders are sorted by price (tick), then by insertion time. The doubly linked list maintains insertion order - orders are added at the tail, so traversing from head to tail gives price-time priority.

Onchain Storage

Orders are stored onchain in doubly linked lists organized by tick. Each tick maintains a FIFO queue of orders using prev and next pointers.

Fields

order_id: u128

Unique identifier for this order

maker: Address

Address of the user who placed this order

book_key: B256

Orderbook key (identifies the trading pair)

is_bid: bool

Whether this is a bid (true) or ask (false) order

tick: i16

Price tick

amount: u128

Original order amount

remaining: u128

Remaining amount to be filled

prev: u128

Previous order ID in the doubly linked list (0 if head)

next: u128

Next order ID in the doubly linked list (0 if tail)

is_flip: bool

Whether this is a flip order

flip_tick: i16

Tick to flip to when fully filled (for flip orders, 0 for regular orders) For bid flips: flip_tick must be > tick For ask flips: flip_tick must be < tick

Implementations

impl Order

pub fn new( order_id: u128, maker: Address, book_key: B256, amount: u128, tick: i16, is_bid: bool, is_flip: bool, flip_tick: i16, ) -> Self

Creates a new order with prev and next initialized to 0.

pub fn new_bid( order_id: u128, maker: Address, book_key: B256, amount: u128, tick: i16, ) -> Self

Creates a new bid order

pub fn new_ask( order_id: u128, maker: Address, book_key: B256, amount: u128, tick: i16, ) -> Self

Creates a new ask order

pub fn new_flip( order_id: u128, maker: Address, book_key: B256, amount: u128, tick: i16, is_bid: bool, flip_tick: i16, ) -> Result<Self, OrderError>

Creates a new flip order.

Note: prev and next are initialized to 0. The orderbook will set these when inserting the order into the linked list.

Errors

Returns an error if flip_tick constraint is violated:

• For bids: flip_tick must be > tick
• For asks: flip_tick must be < tick

pub fn update_remaining<S: StorageOps>( storage: &mut S, order_id: u128, new_remaining: u128, ) -> Result<(), TempoPrecompileError>

Update the order’s remaining value in storage

pub fn update_next_order<S: StorageOps>( storage: &mut S, order_id: u128, new_next: u128, ) -> Result<(), TempoPrecompileError>

pub fn update_prev_order<S: StorageOps>( storage: &mut S, order_id: u128, new_prev: u128, ) -> Result<(), TempoPrecompileError>

pub fn order_id(&self) -> u128

Returns the order ID.

pub fn maker(&self) -> Address

Returns the maker address.

pub fn book_key(&self) -> B256

Returns the orderbook key.

pub fn is_bid(&self) -> bool

Returns whether this is a bid order.

pub fn amount(&self) -> u128

Returns the original amount.

pub fn remaining(&self) -> u128

Returns the remaining amount.

fn remaining_mut(&mut self) -> &mut u128

Returns a mutable reference to the remaining amount.

pub fn tick(&self) -> i16

Returns the tick price.

pub fn is_ask(&self) -> bool

Returns true if this is an ask order (selling base token).

pub fn is_flip(&self) -> bool

Returns true if this is a flip order.

pub fn flip_tick(&self) -> i16

Returns the flip tick.

For non-flip orders, this is always 0. For flip orders, this can be any valid tick value including 0 (peg price).

pub fn prev(&self) -> u128

Returns the previous order ID in the doubly linked list (0 if head).

pub fn next(&self) -> u128

Returns the next order ID in the doubly linked list (0 if tail).

pub fn set_prev(&mut self, prev_id: u128)

Sets the previous order ID in the doubly linked list.

pub fn set_next(&mut self, next_id: u128)

Sets the next order ID in the doubly linked list.

pub fn is_fully_filled(&self) -> bool

Returns true if the order is completely filled (no remaining amount).

pub fn fill(&mut self, fill_amount: u128) -> Result<(), OrderError>

Fills the order by the specified amount.

Errors

Returns an error if fill_amount exceeds remaining amount

pub fn create_flipped_order( &self, new_order_id: u128, ) -> Result<Self, OrderError>

Creates a flipped order from a fully filled flip order.

When a flip order is completely filled, it creates a new order on the opposite side:

• Sides are swapped (bid -> ask, ask -> bid)
• New price = original flip_tick
• New flip_tick = original tick
• Amount is the same as original
• Linked list pointers are reset to 0 (will be set by orderbook on insertion)

Errors

Returns an error if called on a non-flip order or if the order is not fully filled

Trait Implementations

impl Clone for Order

fn clone(&self) -> Order

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Order

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Order> for Order

fn from(value: Order) -> Self

Converts to this type from the input type.

impl PartialEq for Order

fn eq(&self, other: &Order) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Storable<Storable> for Order

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; 6]>

Encode this type to an array of U256 words.

fn from_evm_words(words: [U256; 6]) -> 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 Order

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.

impl Eq for Order

impl StructuralPartialEq for Order

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: 144 bytes