Trait ExecutionAlgorithm

Source

pub trait ExecutionAlgorithm: DataActor {
Show 43 methods    // Required methods
    fn core_mut(&mut self) -> &mut ExecutionAlgorithmCore;
    fn on_order(&mut self, order: OrderAny) -> Result<()>;

    // Provided methods
    fn id(&mut self) -> ExecAlgorithmId { ... }
    fn execute(&mut self, command: TradingCommand) -> Result<()> { ... }
    fn on_order_list(&mut self, order_list: OrderList) -> Result<()> { ... }
    fn handle_cancel_order(&mut self, command: CancelOrder) -> Result<()> { ... }
    fn generate_order_canceled(&mut self, order: &OrderAny) -> OrderCanceled { ... }
    fn spawn_market(
        &mut self,
        primary: &mut OrderAny,
        quantity: Quantity,
        time_in_force: TimeInForce,
        reduce_only: bool,
        tags: Option<Vec<Ustr>>,
        reduce_primary: bool,
    ) -> MarketOrder { ... }
    fn spawn_limit(
        &mut self,
        primary: &mut OrderAny,
        quantity: Quantity,
        price: Price,
        time_in_force: TimeInForce,
        expire_time: Option<UnixNanos>,
        post_only: bool,
        reduce_only: bool,
        display_qty: Option<Quantity>,
        emulation_trigger: Option<TriggerType>,
        tags: Option<Vec<Ustr>>,
        reduce_primary: bool,
    ) -> LimitOrder { ... }
    fn spawn_market_to_limit(
        &mut self,
        primary: &mut OrderAny,
        quantity: Quantity,
        time_in_force: TimeInForce,
        expire_time: Option<UnixNanos>,
        post_only: bool,
        reduce_only: bool,
        display_qty: Option<Quantity>,
        tags: Option<Vec<Ustr>>,
        reduce_primary: bool,
    ) -> MarketToLimitOrder { ... }
    fn reduce_primary_order(
        &mut self,
        primary: &mut OrderAny,
        spawn_qty: Quantity,
    ) { ... }
    fn submit_order(
        &mut self,
        order: OrderAny,
        position_id: Option<PositionId>,
        client_id: Option<ClientId>,
    ) -> Result<()> { ... }
    fn modify_order(
        &mut self,
        order: &OrderAny,
        quantity: Option<Quantity>,
        price: Option<Price>,
        trigger_price: Option<Price>,
        client_id: Option<ClientId>,
    ) -> Result<()> { ... }
    fn modify_order_in_place(
        &mut self,
        order: &mut OrderAny,
        quantity: Option<Quantity>,
        price: Option<Price>,
        trigger_price: Option<Price>,
    ) -> Result<()> { ... }
    fn cancel_order(
        &mut self,
        order: &OrderAny,
        client_id: Option<ClientId>,
    ) -> Result<()> { ... }
    fn subscribe_to_strategy_events(&mut self, strategy_id: StrategyId) { ... }
    fn handle_order_event(&mut self, event: OrderEventAny) { ... }
    fn handle_position_event(&mut self, event: PositionEvent) { ... }
    fn on_start(&mut self) -> Result<()> { ... }
    fn on_stop(&mut self) -> Result<()> { ... }
    fn on_reset(&mut self) -> Result<()> { ... }
    fn on_time_event(&mut self, _event: &TimeEvent) -> Result<()> { ... }
    fn on_order_initialized(&mut self, event: OrderInitialized) { ... }
    fn on_order_denied(&mut self, event: OrderDenied) { ... }
    fn on_order_emulated(&mut self, event: OrderEmulated) { ... }
    fn on_order_released(&mut self, event: OrderReleased) { ... }
    fn on_order_submitted(&mut self, event: OrderSubmitted) { ... }
    fn on_order_rejected(&mut self, event: OrderRejected) { ... }
    fn on_order_accepted(&mut self, event: OrderAccepted) { ... }
    fn on_algo_order_canceled(&mut self, event: OrderCanceled) { ... }
    fn on_order_expired(&mut self, event: OrderExpired) { ... }
    fn on_order_triggered(&mut self, event: OrderTriggered) { ... }
    fn on_order_pending_update(&mut self, event: OrderPendingUpdate) { ... }
    fn on_order_pending_cancel(&mut self, event: OrderPendingCancel) { ... }
    fn on_order_modify_rejected(&mut self, event: OrderModifyRejected) { ... }
    fn on_order_cancel_rejected(&mut self, event: OrderCancelRejected) { ... }
    fn on_order_updated(&mut self, event: OrderUpdated) { ... }
    fn on_algo_order_filled(&mut self, event: OrderFilled) { ... }
    fn on_order_event(&mut self, event: OrderEventAny) { ... }
    fn on_position_opened(&mut self, event: PositionOpened) { ... }
    fn on_position_changed(&mut self, event: PositionChanged) { ... }
    fn on_position_closed(&mut self, event: PositionClosed) { ... }
    fn on_position_event(&mut self, event: PositionEvent) { ... }
}

Expand description

Core trait for implementing execution algorithms in NautilusTrader.

Execution algorithms are specialized [DataActor]s that receive orders from strategies and execute them by spawning child orders. They are used for order slicing algorithms like TWAP and VWAP.

§Key Capabilities

All [DataActor] capabilities (data subscriptions, event handling, timers)
Order spawning (market, limit, market-to-limit)
Order lifecycle management (submit, modify, cancel)
Event filtering for algorithm-owned orders

§Implementation

User algorithms should implement the required methods and hold an ExecutionAlgorithmCore member. The struct should Deref and DerefMut to ExecutionAlgorithmCore (which itself derefs to DataActorCore).

Required Methods§

Source

fn core_mut(&mut self) -> &mut ExecutionAlgorithmCore

Provides mutable access to the internal ExecutionAlgorithmCore.

Source

fn on_order(&mut self, order: OrderAny) -> Result<()>

Called when a primary order is received for execution.

Override this method to implement the algorithm’s order slicing logic.

§Errors

Returns an error if order handling fails.

Provided Methods§

Source

fn id(&mut self) -> ExecAlgorithmId

Returns the execution algorithm ID.

Source

fn execute(&mut self, command: TradingCommand) -> Result<()>

Executes a trading command.

This is the main entry point for commands routed to the algorithm. Dispatches to the appropriate handler based on command type.

Commands are only processed when the algorithm is in Running state.

§Errors

Returns an error if command handling fails.

Source

fn on_order_list(&mut self, order_list: OrderList) -> Result<()>

Called when an order list is received for execution.

Override this method to handle order lists. The default implementation processes each order individually.

§Errors

Returns an error if order list handling fails.

Source

fn handle_cancel_order(&mut self, command: CancelOrder) -> Result<()>

Handles a cancel order command for algorithm-managed orders.

This generates an internal cancel event and publishes it. The order is canceled locally without sending a command to the execution engine.

§Errors

Returns an error if cancellation fails.

Source

fn generate_order_canceled(&mut self, order: &OrderAny) -> OrderCanceled

Generates an OrderCanceled event for an order.

Source

fn spawn_market( &mut self, primary: &mut OrderAny, quantity: Quantity, time_in_force: TimeInForce, reduce_only: bool, tags: Option<Vec<Ustr>>, reduce_primary: bool, ) -> MarketOrder

Spawns a market order from a primary order.

Creates a new market order with:

A unique client order ID: {primary_id}-E{sequence}.
The primary order’s trader ID, strategy ID, and instrument ID.
The algorithm’s exec_algorithm_id.
exec_spawn_id set to the primary order’s client order ID.

If reduce_primary is true, the primary order’s quantity will be reduced by the spawned quantity.

Source

fn spawn_limit( &mut self, primary: &mut OrderAny, quantity: Quantity, price: Price, time_in_force: TimeInForce, expire_time: Option<UnixNanos>, post_only: bool, reduce_only: bool, display_qty: Option<Quantity>, emulation_trigger: Option<TriggerType>, tags: Option<Vec<Ustr>>, reduce_primary: bool, ) -> LimitOrder

Spawns a limit order from a primary order.

Creates a new limit order with:

A unique client order ID: {primary_id}-E{sequence}
The primary order’s trader ID, strategy ID, and instrument ID
The algorithm’s exec_algorithm_id
exec_spawn_id set to the primary order’s client order ID

If reduce_primary is true, the primary order’s quantity will be reduced by the spawned quantity.

Source

fn spawn_market_to_limit( &mut self, primary: &mut OrderAny, quantity: Quantity, time_in_force: TimeInForce, expire_time: Option<UnixNanos>, post_only: bool, reduce_only: bool, display_qty: Option<Quantity>, tags: Option<Vec<Ustr>>, reduce_primary: bool, ) -> MarketToLimitOrder

Spawns a market-to-limit order from a primary order.

Creates a new market-to-limit order with:

A unique client order ID: {primary_id}-E{sequence}
The primary order’s trader ID, strategy ID, and instrument ID
The algorithm’s exec_algorithm_id
exec_spawn_id set to the primary order’s client order ID

If reduce_primary is true, the primary order’s quantity will be reduced by the spawned quantity.

Source

fn reduce_primary_order(&mut self, primary: &mut OrderAny, spawn_qty: Quantity)

Reduces the primary order’s quantity by the spawn quantity.

Generates an OrderUpdated event and applies it to the primary order, then updates the order in the cache.

Source

fn submit_order( &mut self, order: OrderAny, position_id: Option<PositionId>, client_id: Option<ClientId>, ) -> Result<()>

Submits an order to the execution engine via the risk engine.

§Errors

Returns an error if order submission fails.

Source

fn modify_order( &mut self, order: &OrderAny, quantity: Option<Quantity>, price: Option<Price>, trigger_price: Option<Price>, client_id: Option<ClientId>, ) -> Result<()>

Modifies an order.

§Errors

Returns an error if order modification fails.

Source

fn modify_order_in_place( &mut self, order: &mut OrderAny, quantity: Option<Quantity>, price: Option<Price>, trigger_price: Option<Price>, ) -> Result<()>

Modifies an INITIALIZED or RELEASED order in place without sending a command.

This is useful for adjusting order parameters before submission. The order is updated locally by applying an OrderUpdated event and updating the cache.

At least one parameter must differ from the current order values.