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 StablecoinDEX.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 immediately added to the orderbook
2. Orders can be filled (fully or partially) by swaps
3. Flip orders automatically create a new order on the opposite side when fully filled
4. Orders can be cancelled, removing them from the book and refunding escrow

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 with prev and next initialized to 0. The orderbook sets linked-list pointers when inserting.

Errors

• InvalidBidFlipTick — is_bid is true and flip_tick <= tick
• InvalidAskFlipTick — is_bid is false and flip_tick >= tick

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, reducing remaining accordingly.

Errors

• FillAmountExceedsRemaining — fill_amount is greater than remaining

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

• NotAFlipOrder — called on a non-flip order
• OrderNotFullyFilled — remaining is not zero

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 Handler<Order> for OrderHandler

fn t_read(&self) -> Result<Order>

Reads the struct from transient storage.

fn t_write(&mut self, value: Order) -> Result<()>

Writes the struct to transient storage.

fn t_delete(&mut self) -> Result<()>

Deletes the struct from transient storage.

fn read(&self) -> Result<Order>

Reads the value from storage.

fn write(&mut self, value: Order) -> Result<()>

Writes the value to storage.

fn delete(&mut self) -> Result<()>

Deletes the value from storage (sets to zero).

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 for Order

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

Load this type from storage at the given slot.

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

Store this type to storage at the given slot.

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

Delete this type from storage (set to zero).

impl StorableType for Order

const LAYOUT: Layout

Describes how this type is laid out in storage.

const IS_DYNAMIC: bool

Whether this type stores it’s data in its base slot or not.

type Handler = OrderHandler

The handler type that provides storage access for this type.

fn handle(slot: U256, _ctx: LayoutCtx, address: Address) -> Self::Handler

Creates a handler for this type at the given storage location.

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