Struct StablecoinExchange 

pub struct StablecoinExchange {
    pub books: <Mapping<B256, Orderbook> as StorableType>::Handler,
    pub orders: <Mapping<u128, Order> as StorableType>::Handler,
    pub balances: <Mapping<Address, Mapping<Address, u128>> as StorableType>::Handler,
    pub active_order_id: <u128 as StorableType>::Handler,
    pub pending_order_id: <u128 as StorableType>::Handler,
    pub book_keys: <Vec<B256> as StorableType>::Handler,
    address: Address,
    storage: StorageCtx,
}

Fields

books: <Mapping<B256, Orderbook> as StorableType>::Handler

orders: <Mapping<u128, Order> as StorableType>::Handler

balances: <Mapping<Address, Mapping<Address, u128>> as StorableType>::Handler

active_order_id: <u128 as StorableType>::Handler

pending_order_id: <u128 as StorableType>::Handler

book_keys: <Vec<B256> as StorableType>::Handler

address: Address

storage: StorageCtx

Implementations

impl StablecoinExchange

pub fn new() -> Self

Creates an instance of the precompile.

Caution: This does not initialize the account, see Self::initialize.

fn __new(address: Address) -> Self

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

fn emit_event(&mut self, event: impl IntoLogData) -> Result<()>

fn emitted_events(&self) -> &Vec<LogData>

Available on crate features test-utils only.

fn assert_emitted_events(&self, expected: Vec<impl IntoLogData>)

Available on crate features test-utils only.

impl StablecoinExchange

pub fn address(&self) -> Address

Stablecoin exchange address

pub fn initialize(&mut self) -> Result<()>

Initializes the contract

This ensures the StablecoinExchange isn’t empty and prevents state clear.

fn get_pending_order_id(&self) -> Result<u128>

Read pending order ID

fn set_pending_order_id(&mut self, order_id: u128) -> Result<()>

Set pending order ID

fn get_active_order_id(&self) -> Result<u128>

Read active order ID

fn set_active_order_id(&mut self, order_id: u128) -> Result<()>

Set active order ID

fn increment_pending_order_id(&mut self) -> Result<u128>

Increment and return the pending order id

pub fn balance_of(&self, user: Address, token: Address) -> Result<u128>

Get user’s balance for a specific token

pub fn min_price(&self) -> u32

Get MIN_PRICE value based on current hardfork

pub fn max_price(&self) -> u32

Get MAX_PRICE value based on current hardfork

fn validate_or_create_pair( &mut self, book: &Orderbook, token: Address, ) -> Result<()>

Validates that a trading pair exists or creates the pair if the chain height is post allegretto hardfork

pub fn get_order(&self, order_id: u128) -> Result<Order>

Fetch order from storage. If the order is currently pending or filled, this function returns StablecoinExchangeError::OrderDoesNotExist

fn set_balance( &mut self, user: Address, token: Address, amount: u128, ) -> Result<()>

Set user’s balance for a specific token

fn increment_balance( &mut self, user: Address, token: Address, amount: u128, ) -> Result<()>

Add to user’s balance

fn sub_balance( &mut self, user: Address, token: Address, amount: u128, ) -> Result<()>

Subtract from user’s balance

fn emit_order_filled( &mut self, order_id: u128, maker: Address, taker: Address, amount_filled: u128, partial_fill: bool, ) -> Result<()>

Emit the appropriate OrderFilled event based on hardfork Pre-Allegretto: emits OrderFilled (without taker) Post-Allegretto: emits OrderFilled (with taker)

fn transfer(&mut self, token: Address, to: Address, amount: u128) -> Result<()>

Transfer tokens, accounting for pathUSD

fn transfer_from( &mut self, token: Address, from: Address, amount: u128, ) -> Result<()>

Transfer tokens from user, accounting for pathUSD

fn decrement_balance_or_transfer_from( &mut self, user: Address, token: Address, amount: u128, ) -> Result<()>

Decrement user’s internal balance or transfer from external wallet

pub fn quote_swap_exact_amount_out( &self, token_in: Address, token_out: Address, amount_out: u128, ) -> Result<u128>

pub fn quote_swap_exact_amount_in( &self, token_in: Address, token_out: Address, amount_in: u128, ) -> Result<u128>

pub fn swap_exact_amount_in( &mut self, sender: Address, token_in: Address, token_out: Address, amount_in: u128, min_amount_out: u128, ) -> Result<u128>

pub fn swap_exact_amount_out( &mut self, sender: Address, token_in: Address, token_out: Address, amount_out: u128, max_amount_in: u128, ) -> Result<u128>

pub fn pair_key(&self, token_a: Address, token_b: Address) -> B256

Generate deterministic key for token pair

pub fn get_price_level( &self, base: Address, tick: i16, is_bid: bool, ) -> Result<TickLevel>

Get price level information

pub fn active_order_id(&self) -> Result<u128>

Get active order ID

pub fn pending_order_id(&self) -> Result<u128>

Get pending order ID

pub fn books(&self, pair_key: B256) -> Result<Orderbook>

Get orderbook by pair key

pub fn get_book_keys(&self) -> Result<Vec<B256>>

Get all book keys

pub fn price_to_tick(&self, price: u32) -> Result<i16>

Convert scaled price to relative tick Post-Moderato: validates price is within [MIN_PRICE, MAX_PRICE] Pre-Moderato: no validation (legacy behavior)

pub fn create_pair(&mut self, base: Address) -> Result<B256>

pub fn place( &mut self, sender: Address, token: Address, amount: u128, is_bid: bool, tick: i16, ) -> Result<u128>

Place a limit order on the orderbook

Only supports placing an order on a pair between a token and its quote token. The order is queued in the pending queue and will be processed at end of block.

Arguments

• token - The token to trade (not the quote token)
• amount - Order amount in the token
• is_bid - True for buy orders (using quote token to buy token), false for sell orders
• tick - Price tick: (price - 1) * 1000, where price is denominated in the quote token

Returns

The assigned order ID

pub fn place_flip( &mut self, sender: Address, token: Address, amount: u128, is_bid: bool, tick: i16, flip_tick: i16, ) -> Result<u128>

Place a flip order that auto-flips when filled

Flip orders automatically create a new order on the opposite side when completely filled. For bids: flip_tick must be > tick For asks: flip_tick must be < tick

pub fn execute_block(&mut self, sender: Address) -> Result<()>

Process all pending orders into the active orderbook

Only callable by the protocol via system transaction (sender must be Address::ZERO)

fn process_pending_order(&mut self, order_id: u128) -> Result<()>

Process a single pending order into the active orderbook

fn partial_fill_order( &mut self, order: &mut Order, level: &mut TickLevel, fill_amount: u128, taker: Address, ) -> Result<u128>

Partially fill an order with the specified amount. Fill amount is denominated in base token

fn fill_order( &mut self, book_key: B256, order: &mut Order, level: TickLevel, taker: Address, ) -> Result<(u128, Option<(TickLevel, Order)>)>

Fill an order and delete from storage. Returns the next best order and price level.

fn fill_orders_exact_out_post_moderato( &mut self, book_key: B256, bid: bool, amount_out: u128, taker: Address, ) -> Result<u128>

Fill orders for exact output amount, post moderato hardfork

fn fill_orders_exact_out_pre_moderato( &mut self, book_key: B256, bid: bool, amount_out: u128, max_amount_in: u128, taker: Address, ) -> Result<u128>

Fill orders for exact output amount, pre moderato hardfork

fn fill_orders_exact_in_post_moderato( &mut self, book_key: B256, bid: bool, amount_in: u128, taker: Address, ) -> Result<u128>

Fill orders with exact amount in, post Moderato hardfork

fn fill_orders_exact_in_pre_moderato( &mut self, book_key: B256, bid: bool, amount_in: u128, min_amount_out: u128, taker: Address, ) -> Result<u128>

Fill orders with exact amount in, pre Moderato hardfork

fn get_best_price_level( &mut self, book_key: B256, is_bid: bool, ) -> Result<TickLevel>

Helper function to get best tick from orderbook

pub fn cancel(&mut self, sender: Address, order_id: u128) -> Result<()>

Cancel an order and refund tokens to maker Only the order maker can cancel their own order

fn cancel_pending_order(&mut self, order: Order) -> Result<()>

Cancel a pending order (not yet in the active orderbook)

fn cancel_active_order(&mut self, order: Order) -> Result<()>

Cancel an active order (already in the orderbook)

pub fn withdraw( &mut self, user: Address, token: Address, amount: u128, ) -> Result<()>

Withdraw tokens from exchange balance

fn quote_exact_out( &self, book_key: B256, amount_out: u128, is_bid: bool, ) -> Result<u128>

Quote exact output amount without executing trades

fn find_trade_path( &self, token_in: Address, token_out: Address, ) -> Result<Vec<(B256, bool)>>

Find the trade path between two tokens Returns a vector of (book_key, base_for_quote) tuples for each hop Also validates that all pairs exist

fn validate_and_build_route( &self, path: &[Address], ) -> Result<Vec<(B256, bool)>>

Validates that all pairs in the path exist and returns book keys with direction info

fn find_path_to_root(&self, token: Address) -> Result<Vec<Address>>

Find the path from a token to the root (PathUSD) Returns a vector of addresses starting with the token and ending with PathUSD

fn quote_exact_in( &self, book_key: B256, amount_in: u128, is_bid: bool, ) -> Result<u128>

Quote exact input amount without executing trades

Trait Implementations

impl ContractStorage for StablecoinExchange

fn address(&self) -> Address

Contract address.

fn storage(&mut self) -> &mut StorageCtx

Contract storage accessor.

impl Default for StablecoinExchange

fn default() -> Self

Returns the “default value” for a type.

impl Precompile for StablecoinExchange

fn call(&mut self, calldata: &[u8], msg_sender: Address) -> PrecompileResult

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