Trait ExecutionClient 

pub trait ExecutionClient {
    // Required methods
    fn is_connected(&self) -> bool;
    fn client_id(&self) -> ClientId;
    fn account_id(&self) -> AccountId;
    fn venue(&self) -> Venue;
    fn oms_type(&self) -> OmsType;
    fn get_account(&self) -> Option<AccountAny>;
    fn generate_account_state(
        &self,
        balances: Vec<AccountBalance>,
        margins: Vec<MarginBalance>,
        reported: bool,
        ts_event: UnixNanos,
        info: Option<Params>,
    ) -> Result<()>;
    fn start(&mut self) -> Result<()>;
    fn stop(&mut self) -> Result<()>;

    // Provided methods
    fn position_reconciliation_tolerance(&self) -> Decimal { ... }
    fn handles_order_venue(&self, venue: Venue) -> bool { ... }
    fn provides_bulk_position_coverage(
        &self,
        _instrument_id: InstrumentId,
    ) -> bool { ... }
    fn reset(&mut self) -> Result<()> { ... }
    fn dispose(&mut self) -> Result<()> { ... }
    fn connect<'life0, 'async_trait>(
        &'life0 mut self,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn disconnect<'life0, 'async_trait>(
        &'life0 mut self,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn submit_order(&self, cmd: SubmitOrder) -> Result<()> { ... }
    fn submit_order_list(&self, cmd: SubmitOrderList) -> Result<()> { ... }
    fn modify_order(&self, cmd: ModifyOrder) -> Result<()> { ... }
    fn batch_modify_orders(&self, cmd: BatchModifyOrders) -> Result<()> { ... }
    fn cancel_order(&self, cmd: CancelOrder) -> Result<()> { ... }
    fn cancel_all_orders(&self, cmd: CancelAllOrders) -> Result<()> { ... }
    fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> Result<()> { ... }
    fn query_account(&self, cmd: QueryAccount) -> Result<()> { ... }
    fn query_order(&self, cmd: QueryOrder) -> Result<()> { ... }
    fn generate_order_status_report<'life0, 'life1, 'async_trait>(
        &'life0 self,
        cmd: &'life1 GenerateOrderStatusReport,
    ) -> Pin<Box<dyn Future<Output = Result<Option<OrderStatusReport>>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn generate_order_status_reports<'life0, 'life1, 'async_trait>(
        &'life0 self,
        cmd: &'life1 GenerateOrderStatusReports,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<OrderStatusReport>>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn generate_fill_reports<'life0, 'async_trait>(
        &'life0 self,
        cmd: GenerateFillReports,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<FillReport>>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn generate_position_status_reports<'life0, 'life1, 'async_trait>(
        &'life0 self,
        cmd: &'life1 GeneratePositionStatusReports,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<PositionStatusReport>>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn generate_mass_status<'life0, 'async_trait>(
        &'life0 self,
        lookback_mins: Option<u64>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<ExecutionMassStatus>>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn register_external_order(
        &self,
        _client_order_id: ClientOrderId,
        _venue_order_id: VenueOrderId,
        _instrument_id: InstrumentId,
        _strategy_id: StrategyId,
        _ts_init: UnixNanos,
    ) { ... }
    fn on_instrument(&mut self, _instrument: InstrumentAny) { ... }
    fn calculate_commission(
        &self,
        instrument: &InstrumentAny,
        last_qty: Quantity,
        last_px: Price,
        liquidity_side: LiquiditySide,
    ) -> Result<Option<Money>> { ... }
}

Defines the interface for an execution client managing order operations.

Thread Safety

Client instances are not intended to be sent across threads. The ?Send bound allows implementations to hold non-Send state for any Python interop.

Required Methods

fn is_connected(&self) -> bool

fn client_id(&self) -> ClientId

fn account_id(&self) -> AccountId

fn venue(&self) -> Venue

fn oms_type(&self) -> OmsType

fn get_account(&self) -> Option<AccountAny>

fn generate_account_state( &self, balances: Vec<AccountBalance>, margins: Vec<MarginBalance>, reported: bool, ts_event: UnixNanos, info: Option<Params>, ) -> Result<()>

Generates and publishes the account state event.

Implementations may publish synchronously. Callers must release shared state borrows, including clock and cache borrows, before calling this method because subscribers may access the same state.

Errors

Returns an error if generating the account state fails.

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

Starts the execution client.

Errors

Returns an error if the client fails to start.

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

Stops the execution client.

Implementations must be idempotent: the engine and node teardown paths (e.g. backtest end -> reset -> dispose) may call stop() more than once per run. Guard with an internal is_stopped check or equivalent so repeated calls are safe.

Errors

Returns an error if the client fails to stop.

Provided Methods

fn position_reconciliation_tolerance(&self) -> Decimal

Returns the maximum absolute position difference tolerated during reconciliation.

fn handles_order_venue(&self, venue: Venue) -> bool

Returns whether this client can execute orders for the given instrument venue.

Single-venue clients should use the default behavior. Routing brokers can override this when their client venue identifies the broker rather than the instrument’s exchange venue.

fn provides_bulk_position_coverage(&self, _instrument_id: InstrumentId) -> bool

Returns whether a bulk position status report request provides complete coverage for the given instrument, so that an absent report is evidence the position is flat.

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

Resets the execution client to its initial state.

The default implementation is a no-op. Adapters with reconnectable state (caches, sequence counters, in-flight orders) should override this.

Errors

Returns an error if the client fails to reset.

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

Disposes of client resources and cleans up.

The default implementation is a no-op. Adapters that hold async tasks, background threads, or external handles should override this.

Errors

Returns an error if the client fails to dispose.

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

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

Connects the client to the execution venue.

Errors

Returns an error if connection fails.

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

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

Disconnects the client from the execution venue.

Errors

Returns an error if disconnection fails.

fn submit_order(&self, cmd: SubmitOrder) -> Result<()>

Submits a single order command to the execution venue.

Errors

Returns an error if submission fails.

fn submit_order_list(&self, cmd: SubmitOrderList) -> Result<()>

Submits a list of orders to the execution venue.

Errors

Returns an error if submission fails.

fn modify_order(&self, cmd: ModifyOrder) -> Result<()>

Modifies an existing order.

Errors

Returns an error if modification fails.

fn batch_modify_orders(&self, cmd: BatchModifyOrders) -> Result<()>

Modifies a batch of orders.

The default implementation fans out to Self::modify_order so existing execution clients remain compatible until they add native batch support.

Errors

Returns an error if any child modification fails.

fn cancel_order(&self, cmd: CancelOrder) -> Result<()>

Cancels a specific order.

Errors

Returns an error if cancellation fails.

fn cancel_all_orders(&self, cmd: CancelAllOrders) -> Result<()>

Cancels all orders.

Errors

Returns an error if cancellation fails.

fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> Result<()>

Cancels a batch of orders.

Errors

Returns an error if batch cancellation fails.

fn query_account(&self, cmd: QueryAccount) -> Result<()>

Queries the status of an account.

Errors

Returns an error if the query fails.

fn query_order(&self, cmd: QueryOrder) -> Result<()>

Queries the status of an order.

Errors

Returns an error if the query fails.

fn generate_order_status_report<'life0, 'life1, 'async_trait>( &'life0 self, cmd: &'life1 GenerateOrderStatusReport, ) -> Pin<Box<dyn Future<Output = Result<Option<OrderStatusReport>>> + 'async_trait>>

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

Generates a single order status report.

Errors

Returns an error if report generation fails.

fn generate_order_status_reports<'life0, 'life1, 'async_trait>( &'life0 self, cmd: &'life1 GenerateOrderStatusReports, ) -> Pin<Box<dyn Future<Output = Result<Vec<OrderStatusReport>>> + 'async_trait>>

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

Generates multiple order status reports.

Errors

Returns an error if report generation fails.

fn generate_fill_reports<'life0, 'async_trait>( &'life0 self, cmd: GenerateFillReports, ) -> Pin<Box<dyn Future<Output = Result<Vec<FillReport>>> + 'async_trait>>

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

Generates fill reports based on execution results.

Errors

Returns an error if fill report generation fails.

fn generate_position_status_reports<'life0, 'life1, 'async_trait>( &'life0 self, cmd: &'life1 GeneratePositionStatusReports, ) -> Pin<Box<dyn Future<Output = Result<Vec<PositionStatusReport>>> + 'async_trait>>

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

Generates position status reports.

Errors

Returns an error if generation fails.

fn generate_mass_status<'life0, 'async_trait>( &'life0 self, lookback_mins: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<Option<ExecutionMassStatus>>> + 'async_trait>>

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

Generates mass status for executions.

The default composes the granular report generators using the realtime atomic clock. This is clock-correct only for live/realtime clients; clients using a mocked or backtest clock must override this method to compose reports with their own clock.

Errors

Returns an error if status generation fails.

fn register_external_order( &self, _client_order_id: ClientOrderId, _venue_order_id: VenueOrderId, _instrument_id: InstrumentId, _strategy_id: StrategyId, _ts_init: UnixNanos, )

Registers an external order for tracking by the execution client.

This is called after reconciliation creates an external order, allowing the execution client to track it for subsequent events (e.g., cancellations).

fn on_instrument(&mut self, _instrument: InstrumentAny)

Handles an instrument update received via the message bus.

Exec clients that need live instrument updates (e.g. for internal maps) can override this to process instruments for their venue.

fn calculate_commission( &self, instrument: &InstrumentAny, last_qty: Quantity, last_px: Price, liquidity_side: LiquiditySide, ) -> Result<Option<Money>>

Calculates the commission for a reconciliation fill.

Override this method to provide venue-specific commission logic for inferred fills generated during reconciliation. The quantity, price, and liquidity side match the inferred fill event, including any price derived for only the unbooked incremental quantity.

Returns Ok(None) by default, signaling callers to use their own generic commission formula. An error means the venue formula applies but its result could not be represented, so callers must not substitute a zero or generic commission for it.

Errors

Returns an error if the venue commission cannot be calculated or represented.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors