Struct Engine 

pub struct Engine<Clock, State, ExecutionTxs, Strategy, Risk> {
    pub clock: Clock,
    pub meta: EngineMeta,
    pub state: State,
    pub execution_txs: ExecutionTxs,
    pub strategy: Strategy,
    pub risk: Risk,
}

Algorithmic trading Engine.

The Engine:

• Processes input EngineEvent (or custom events if implemented).
• Maintains the internal EngineState (instrument data state, open orders, positions, etc.).
• Generates algo orders (if TradingState::Enabled).

Type Parameters

• Clock - EngineClock implementation.
• State - Engine State implementation (eg/ EngineState).
• ExecutionTxs - ExecutionTxMap implementation for sending execution requests.
• Strategy - Trading Strategy implementation (see super::strategy).
• Risk - RiskManager implementation.

Fields

clock: Clock

meta: EngineMeta

state: State

execution_txs: ExecutionTxs

strategy: Strategy

risk: Risk

Implementations

impl<Clock, GlobalData, InstrumentData, ExecutionTxs, Strategy, Risk> Engine<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Strategy, Risk>

pub fn action(&mut self, command: &Command) -> ActionOutput

where InstrumentData: InFlightRequestRecorder, ExecutionTxs: ExecutionTxMap, Strategy: ClosePositionsStrategy<State = EngineState<GlobalData, InstrumentData>>, Risk: RiskManager,

Action an Engine Command, producing an ActionOutput of work done.

pub fn update_from_trading_state_update( &mut self, update: TradingState, ) -> Option<Strategy::OnTradingDisabled>

where Strategy: OnTradingDisabled<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Risk>,

Update the Engine TradingState.

If the TradingState transitions to TradingState::Disabled, the Engine will call the configured OnTradingDisabled strategy logic.

pub fn update_from_account_stream( &mut self, event: &AccountStreamEvent, ) -> UpdateFromAccountOutput<Strategy::OnDisconnect>

where InstrumentData: for<'a> Processor<&'a AccountEvent>, GlobalData: for<'a> Processor<&'a AccountEvent>, Strategy: OnDisconnectStrategy<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Risk>,

Update the Engine from an AccountStreamEvent.

If the input AccountStreamEvent indicates the exchange execution link has disconnected, the Engine will call the configured OnDisconnectStrategy strategy logic.

pub fn update_from_market_stream( &mut self, event: &MarketStreamEvent<InstrumentIndex, InstrumentData::MarketEventKind>, ) -> UpdateFromMarketOutput<Strategy::OnDisconnect>

where InstrumentData: InstrumentDataState, GlobalData: for<'a> Processor<&'a MarketEvent<InstrumentIndex, InstrumentData::MarketEventKind>>, Strategy: OnDisconnectStrategy<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Risk>,

Update the Engine from a MarketStreamEvent.

If the input MarketStreamEvent indicates the exchange market data link has disconnected, the Engine will call the configured OnDisconnectStrategy strategy logic.

pub fn trading_summary_generator( &self, risk_free_return: Decimal, ) -> TradingSummaryGenerator

where Clock: EngineClock,

Returns a TradingSummaryGenerator for the current trading session.

pub fn process_contract_expiry( &mut self, key: &InstrumentIndex, ) -> Vec<PositionExited<AssetIndex, InstrumentIndex>>

where Clock: EngineClock, InstrumentData: InstrumentDataState + InFlightRequestRecorder, ExecutionTxs: ExecutionTxMap,

Processes a ContractExpiry event for the given InstrumentIndex.

Algorithm

1. Guards on expiration_processed (idempotent).
2. Cancels all open orders for the instrument by sending ExecutionRequest::Cancel for each.
3. Derives settlement price from instrument data and contract specification:
   • OTM: settlement price = 0
   • ITM call: settlement = spot - strike (per-contract intrinsic value)
   • ITM put: settlement = strike - spot (per-contract intrinsic value)
4. Synthesises a closing Trade at the settlement price and routes it through instrument_state.update_from_trade.
5. Sets instrument_state.expiration_processed = true.

If no position is open for the instrument, steps 3–4 are skipped. If no market price is available, settlement cannot be computed and the method logs a warning and returns without synthesising a fill. The expiration_processed flag is not set in this case, making the event retryable — re-inject ContractExpiry once the underlying spot instrument has received market data.

Not modelled (deferred)

• Assignment for short writers: short positions at expiry are closed at intrinsic value identical to long positions (OTM at 0, ITM at |spot − strike|). True assignment — where the short writer is obligated to deliver the underlying — is not modelled. A future enhancement would detect net-short positions and open a synthetic underlying position instead of (or in addition to) closing the option position.

• Physical settlement: all settlements are cash-equivalent (a synthetic fill at the settlement price adjusts PnL). No separate “deliver/receive underlying” position is opened. Physically-settled contracts (e.g. some futures-style options) are out of scope until this is revisited.

impl<Clock, State, ExecutionTxs, Strategy, Risk> Engine<Clock, State, ExecutionTxs, Strategy, Risk>

where Clock: EngineClock,

pub fn new( clock: Clock, state: State, execution_txs: ExecutionTxs, strategy: Strategy, risk: Risk, ) -> Self

Construct a new Engine.

An initial EngineMeta is constructed form the provided clock and Sequence(0).

pub fn time(&self) -> DateTime<Utc>

Return Engine clock time.

pub fn reset_metadata(&mut self)

Reset the internal EngineMeta to the clock time and Sequence(0).

Trait Implementations

impl<Audit, Clock, State, ExecutionTxs, Strategy, Risk> Auditor<Audit> for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

where Clock: EngineClock, State: Clone, Strategy: OnTradingDisabled<Clock, State, ExecutionTxs, Risk> + OnDisconnectStrategy<Clock, State, ExecutionTxs, Risk>,

type Snapshot = State

Full state snapshot.

type Context = EngineContext

AuditTick context.

fn audit_snapshot(&mut self) -> AuditTick<Self::Snapshot, Self::Context>

Build an AuditTick containing a full state snapshot.

fn audit<Kind>(&mut self, kind: Kind) -> AuditTick<Audit, Self::Context>

where Audit: From<Kind>,

Build an AuditTick from the provided Kind.

impl<Clock, GlobalData, InstrumentData, ExecutionTxs, Strategy, Risk> CancelOrders for Engine<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Strategy, Risk>

where InstrumentData: InFlightRequestRecorder, ExecutionTxs: ExecutionTxMap,

fn cancel_orders( &mut self, filter: &InstrumentFilter<ExchangeIndex, AssetIndex, InstrumentIndex>, ) -> SendRequestsOutput<RequestCancel, ExchangeIndex, InstrumentIndex>

Generates cancel order requests.

impl<Clock: Clone, State: Clone, ExecutionTxs: Clone, Strategy: Clone, Risk: Clone> Clone for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

fn clone(&self) -> Engine<Clock, State, ExecutionTxs, Strategy, Risk>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Clock, State, ExecutionTxs, Strategy, Risk, ExchangeKey, AssetKey, InstrumentKey> ClosePositions<ExchangeKey, AssetKey, InstrumentKey> for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

where State: InFlightRequestRecorder<ExchangeKey, InstrumentKey>, ExecutionTxs: ExecutionTxMap<ExchangeKey, InstrumentKey>, Strategy: ClosePositionsStrategy<ExchangeKey, AssetKey, InstrumentKey, State = State>, ExchangeKey: Debug + Clone, InstrumentKey: Debug + Clone,

fn close_positions( &mut self, filter: &InstrumentFilter<ExchangeKey, AssetKey, InstrumentKey>, ) -> SendCancelsAndOpensOutput<ExchangeKey, InstrumentKey>

Generates and sends order requests to close open positions.

impl<Clock: Copy, State: Copy, ExecutionTxs: Copy, Strategy: Copy, Risk: Copy> Copy for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

impl<Clock: Debug, State: Debug, ExecutionTxs: Debug, Strategy: Debug, Risk: Debug> Debug for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Clock: Eq, State: Eq, ExecutionTxs: Eq, Strategy: Eq, Risk: Eq> Eq for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

impl<Clock, State, ExecutionTxs, Strategy, Risk, ExchangeKey, InstrumentKey> GenerateAlgoOrders<ExchangeKey, InstrumentKey> for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

where State: InFlightRequestRecorder<ExchangeKey, InstrumentKey>, ExecutionTxs: ExecutionTxMap<ExchangeKey, InstrumentKey>, Strategy: AlgoStrategy<ExchangeKey, InstrumentKey, State = State>, Risk: RiskManager<ExchangeKey, InstrumentKey, State = State>, ExchangeKey: Debug + Clone, InstrumentKey: Debug + Clone,

fn generate_algo_orders( &mut self, ) -> GenerateAlgoOrdersOutput<ExchangeKey, InstrumentKey>

Generates and sends algorithmic order requests.

impl<Clock: Hash, State: Hash, ExecutionTxs: Hash, Strategy: Hash, Risk: Hash> Hash for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Clock: Ord, State: Ord, ExecutionTxs: Ord, Strategy: Ord, Risk: Ord> Ord for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

fn cmp( &self, other: &Engine<Clock, State, ExecutionTxs, Strategy, Risk>, ) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Clock: PartialEq, State: PartialEq, ExecutionTxs: PartialEq, Strategy: PartialEq, Risk: PartialEq> PartialEq for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

fn eq(&self, other: &Engine<Clock, State, ExecutionTxs, Strategy, Risk>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Clock: PartialOrd, State: PartialOrd, ExecutionTxs: PartialOrd, Strategy: PartialOrd, Risk: PartialOrd> PartialOrd for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

fn partial_cmp( &self, other: &Engine<Clock, State, ExecutionTxs, Strategy, Risk>, ) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Clock, GlobalData, InstrumentData, ExecutionTxs, Strategy, Risk> Processor<EngineEvent<<InstrumentData as InstrumentDataState>::MarketEventKind>> for Engine<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Strategy, Risk>

where Clock: EngineClock + for<'a> Processor<&'a EngineEvent<InstrumentData::MarketEventKind>>, InstrumentData: InstrumentDataState, GlobalData: for<'a> Processor<&'a AccountEvent> + for<'a> Processor<&'a MarketEvent<InstrumentIndex, InstrumentData::MarketEventKind>>, ExecutionTxs: ExecutionTxMap<ExchangeIndex, InstrumentIndex>, Strategy: OnTradingDisabled<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Risk> + OnDisconnectStrategy<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Risk> + AlgoStrategy<State = EngineState<GlobalData, InstrumentData>> + ClosePositionsStrategy<State = EngineState<GlobalData, InstrumentData>>, Risk: RiskManager<State = EngineState<GlobalData, InstrumentData>>,

type Audit = EngineAudit<EngineEvent<<InstrumentData as InstrumentDataState>::MarketEventKind>, EngineOutput<<Strategy as OnTradingDisabled<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Risk>>::OnTradingDisabled, <Strategy as OnDisconnectStrategy<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Risk>>::OnDisconnect>>

fn process( &mut self, event: EngineEvent<InstrumentData::MarketEventKind>, ) -> Self::Audit

impl<Clock, State, ExecutionTxs, Strategy, Risk, ExchangeKey, InstrumentKey> SendRequests<ExchangeKey, InstrumentKey> for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

where ExecutionTxs: ExecutionTxMap<ExchangeKey, InstrumentKey>, ExchangeKey: Debug + Clone, InstrumentKey: Debug + Clone,

fn send_requests<Kind>( &self, requests: impl IntoIterator<Item = OrderEvent<Kind, ExchangeKey, InstrumentKey>>, ) -> SendRequestsOutput<Kind, ExchangeKey, InstrumentKey>

where Kind: Debug + Clone, ExecutionRequest<ExchangeKey, InstrumentKey>: From<OrderEvent<Kind, ExchangeKey, InstrumentKey>>,

fn send_request<Kind>( &self, request: &OrderEvent<Kind, ExchangeKey, InstrumentKey>, ) -> Result<(), EngineError>

where Kind: Debug + Clone, ExecutionRequest<ExchangeKey, InstrumentKey>: From<OrderEvent<Kind, ExchangeKey, InstrumentKey>>,

impl<Clock: PartialEq, State: PartialEq, ExecutionTxs: PartialEq, Strategy: PartialEq, Risk: PartialEq> StructuralPartialEq for Engine<Clock, State, ExecutionTxs, Strategy, Risk>

impl<Clock, GlobalData, InstrumentData, ExecutionTxs, Strategy, Risk> SyncShutdown for Engine<Clock, EngineState<GlobalData, InstrumentData>, ExecutionTxs, Strategy, Risk>

where ExecutionTxs: ExecutionTxMap,

type Result = ()

fn shutdown(&mut self) -> Self::Result