Struct PaperExchange 

pub struct PaperExchange<E: Exchange> { /* private fields */ }

Paper Exchange - wraps a real exchange for quotes, simulates fills locally.

Uses FillSimulator for shared fill matching logic.

Usage

let real_exchange = HyperliquidExchange::new(config);
let paper = PaperExchange::new(real_exchange, initial_balances);
// Use paper as the exchange - strategies see no difference

Implementations

impl<E: Exchange> PaperExchange<E>

pub fn new(quote_source: E, initial_balances: HashMap<AssetId, Decimal>) -> Self

Create a new paper exchange wrapping a real quote source

pub async fn set_balance(&self, asset: AssetId, amount: Decimal)

Set a balance directly (for testing)

pub async fn register_instrument_meta(&self, meta: &InstrumentMeta)

Register instrument metadata for quote-aware paper/backtest accounting.

pub async fn register_instrument_metas(&self, metas: &[InstrumentMeta])

Register several instrument metadata records.

pub async fn balance(&self, asset: &AssetId) -> Decimal

Get current balance

pub async fn pending_orders_count(&self) -> usize

Get pending orders count

pub async fn set_fee_rate(&self, fee_rate: Decimal)

Set fee rate for fill simulation (e.g., 0.0004 = 0.04%) For spot BUY orders, fee is deducted from base asset

pub async fn get_balances(&self) -> HashMap<AssetId, Decimal>

Get current balances (for testing)

pub async fn get_position(&self, instrument: &InstrumentId) -> Decimal

Get position for an instrument (for testing) Returns the net position qty (positive = long, negative = short)

pub async fn set_instrument_leverage( &self, instrument: &InstrumentId, leverage: Decimal, max_leverage: Decimal, )

Set leverage for an instrument in the margin ledger

pub async fn free_usdc(&self) -> Decimal

Get the margin ledger’s free USDC (for testing)

pub async fn enable_simulation_mode(&self)

Enable simulation mode - quotes will come from injected_quotes instead of real exchange. This allows deterministic testing where you control the price feed.

pub async fn disable_simulation_mode(&self)

Disable simulation mode - return to using real exchange quotes.

pub async fn is_simulation_mode(&self) -> bool

Check if simulation mode is enabled.

pub async fn inject_quote( &self, instrument: InstrumentId, bid: Decimal, ask: Decimal, )

Inject a quote for simulation testing. When simulation mode is enabled, poll_quotes will return these instead of real quotes.

pub async fn queue_quotes(&self, quotes: Vec<Quote>)

Queue multiple quotes for batch backtesting (FIFO). When quotes are queued, poll_quotes will pop from this queue first. This enables fast-forward backtesting with realistic price-crossing fills.

pub async fn has_queued_quotes(&self) -> bool

Check if there are still queued quotes remaining. Use this to detect when backtesting is complete.

pub async fn queue_len(&self) -> usize

Get the number of queued quotes remaining.

pub async fn clear_quote_queue(&self)

Clear all queued quotes.

pub async fn set_time(&self, time_ms: i64)

Set simulated time (for deterministic testing).

pub async fn advance_time(&self, delta_ms: i64)

Advance simulated time by delta milliseconds.

pub async fn current_time(&self) -> i64

Get current simulated time.

pub async fn fills(&self) -> Vec<Fill>

Get all simulated fills (for testing).

Trait Implementations

impl<E: Exchange + Send + Sync> Exchange for PaperExchange<E>

fn exchange_id(&self) -> &ExchangeId

Get the exchange ID

fn environment(&self) -> Environment

Get the environment (mainnet/testnet)

fn place_orders<'life0, 'life1, 'async_trait>( &'life0 self, orders: &'life1 [OrderInput], ) -> Pin<Box<dyn Future<Output = Result<Vec<PlaceOrderResult>, ExchangeError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Place multiple limit orders in a single batch API call. Returns a Vec of results, one for each order in the same order as the input.

fn cancel_order<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _instrument: &'life1 InstrumentId, _market_index: &'life2 MarketIndex, client_id: &'life3 ClientOrderId, _exchange_order_id: Option<&'life4 ExchangeOrderId>, ) -> Pin<Box<dyn Future<Output = Result<(), ExchangeError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Cancel an order by client_id or exchange_order_id.

fn cancel_all_orders<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, instrument: &'life1 InstrumentId, _market_index: &'life2 MarketIndex, ) -> Pin<Box<dyn Future<Output = Result<u32, ExchangeError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Cancel all orders for an instrument. Returns number of orders canceled.

fn poll_user_fills<'life0, 'life1, 'async_trait>( &'life0 self, _cursor: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Fill>, ExchangeError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Poll user fills since cursor. This is the primary execution event source. cursor is opaque string (implementation-specific).

fn poll_quotes<'life0, 'life1, 'async_trait>( &'life0 self, instruments: &'life1 [InstrumentId], ) -> Pin<Box<dyn Future<Output = Result<Vec<Quote>, ExchangeError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Poll current quotes/prices.

fn poll_account_state<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AccountState, ExchangeError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Poll account state (absolute). Used for snapshot-based synchronization.

fn instance(&self) -> ExchangeInstance

Get the exchange instance key

fn init<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ExchangeError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Initialize the exchange connection and perform startup validations. Called by the runner before entering the main loop. Implementations can validate: connectivity, vault ownership, account balance, etc.