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,
    ) -> Result<()>;
    fn start(&mut self) -> Result<()>;
    fn stop(&mut self) -> Result<()>;

    // Provided methods
    fn handles_order_venue(&self, venue: Venue) -> 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,
    ) -> 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, ) -> Result<()>

Generates and publishes the account state event.

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 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 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.

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, ) -> Option<Money>

Calculates the commission for a reconciliation fill.

Override this method to provide venue-specific commission logic for inferred fills generated during reconciliation.

Returns None by default, signaling callers to use their own generic commission formula.

Dyn Compatibility

This trait is dyn compatible.

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

Implementors