Struct AccountEventIndexer 

pub struct AccountEventIndexer {
    pub map: Arc<ExecutionInstrumentMap>,
}

Fields

map: Arc<ExecutionInstrumentMap>

Implementations

impl AccountEventIndexer

pub const fn new(map: Arc<ExecutionInstrumentMap>) -> AccountEventIndexer

impl AccountEventIndexer

pub fn account_event( &self, event: UnindexedAccountEvent, ) -> Result<AccountEvent, IndexError>

pub fn snapshot( &self, snapshot: UnindexedAccountSnapshot, ) -> Result<AccountSnapshot, IndexError>

pub fn asset_balance( &self, balance: AssetBalance<AssetNameExchange>, ) -> Result<AssetBalance<AssetIndex>, IndexError>

pub fn asset_balance_update( &self, update: AssetBalanceUpdate<AssetNameExchange>, ) -> Result<AssetBalanceUpdate<AssetIndex>, IndexError>

pub fn isolated_instrument_state( &self, state: IsolatedInstrumentState<AssetNameExchange>, ) -> Result<IsolatedInstrumentState<AssetIndex>, IndexError>

Index the per-pair isolated state’s base/quote asset names to indices.

Errors

Returns IndexError if either the base or quote asset is not registered in the map — matching the fail-fast behaviour of top-level Self::asset_balance.

pub fn fill_recovery_gap( &self, gap: FillRecoveryGap<InstrumentNameExchange>, ) -> Result<FillRecoveryGap<InstrumentIndex>, IndexError>

Index a FillRecoveryGap’s instruments.

Errors

Returns IndexError if any instrument is not registered in the map. The whole gap fails rather than dropping that instrument, which would understate what is missing. A venue names only the instruments its stream was opened with, so this fails only for a stream opened with an instrument the map does not hold.

pub fn cash_flow( &self, flow: CashFlow<AssetNameExchange, InstrumentNameExchange>, ) -> Result<CashFlow<AssetIndex, InstrumentIndex>, IndexError>

Index a CashFlow’s asset and, when it names one, instrument.

Errors

Returns IndexError if the asset, or a named instrument, is not registered in the map.

pub fn notice( &self, exchange: ExchangeIndex, notice: AccountNotice<InstrumentNameExchange>, ) -> AccountNotice<InstrumentIndex>

Index an AccountNotice’s instrument, when it names one.

Never fails. A notice naming an instrument that is not in the map is kept, with its instrument set to None and a warn: a notice changes no state, so dropping one about a margin call or liquidation would cost more than losing its attribution.

pub fn instrument_balance_update( &self, update: InstrumentBalanceUpdate<AssetNameExchange, InstrumentNameExchange>, ) -> Result<InstrumentBalanceUpdate, IndexError>

Index an InstrumentBalanceUpdate’s instrument and asset keys.

Errors

Returns IndexError if the instrument or the asset is not registered in the map.

pub fn order_snapshot( &self, order: UnindexedOrderSnapshot, ) -> Result<OrderSnapshot, IndexError>

pub fn order_response_cancel( &self, response: OrderResponseCancel<ExchangeId, AssetNameExchange, InstrumentNameExchange>, ) -> Result<OrderResponseCancel, IndexError>

pub fn order_key(&self, key: UnindexedOrderKey) -> Result<OrderKey, IndexError>

pub fn order_state(&self, state: UnindexedOrderState) -> OrderState

Index an UnindexedOrderState to an OrderState.

Used by ExecutionManager to index open_order responses. Never fails: an order state carries no key, and the error of a failed open is indexed by Self::order_error.

pub fn api_error(&self, error: UnindexedApiError) -> ApiError

Index an UnindexedApiError returned for an order request (open or cancel).

Never fails. An error carries the venue’s answer to a request, and the caller must receive that answer, so a name the ExecutionInstrumentMap does not hold degrades the error instead of discarding it (and the order response or client error carrying it). Each degrade logs a warn! naming what was dropped:

• ApiError::BalanceInsufficient keeps its variant, with the asset None.
• ApiError::AssetInvalid and ApiError::InstrumentInvalid have no index to carry, so they become ApiError::OrderRejected holding their own message, which keeps the name and the venue’s text.

For an error from any other request, use Self::client_error, which degrades to ApiError::RequestRejected instead.

pub fn order_request<Kind>( &self, order: &OrderEvent<Kind, ExchangeIndex, InstrumentIndex>, ) -> Result<OrderEvent<Kind, ExchangeId, &InstrumentNameExchange>, KeyError>

where Kind: Clone,

pub fn order_error(&self, error: UnindexedOrderError) -> OrderError

Index an UnindexedOrderError. Never fails: see Self::api_error.

pub fn client_error(&self, error: UnindexedClientError) -> ClientError

Index an UnindexedClientError. Never fails: like Self::api_error, but an unresolvable ApiError::AssetInvalid or ApiError::InstrumentInvalid becomes ApiError::RequestRejected, since the request need not have been an order.

pub fn account_stream_init_error( &self, error: UnindexedAccountStreamInitError, ) -> AccountStreamInitError

Index an UnindexedAccountStreamInitError. Never fails, as Self::client_error.

pub fn reinit_failure( &self, failure: AccountReinitFailure<AssetNameExchange, InstrumentNameExchange>, ) -> AccountReinitFailure

Index an AccountReinitFailure. Never fails, as Self::client_error.

pub fn trade_amendment( &self, amendment: TradeAmendment<AssetNameExchange, InstrumentNameExchange>, ) -> Result<TradeAmendment<AssetIndex, InstrumentIndex>, IndexError>

Index a TradeAmendment. A replacement trade is indexed as trade indexes one, so an amendment fails where its trade would.

pub fn trade( &self, trade: Trade<AssetNameExchange, InstrumentNameExchange>, ) -> Result<Trade<AssetIndex, InstrumentIndex>, IndexError>

Index a trade, converting fee asset and computing fees_quote.

Computes fees_quote based on fee asset relationship to instrument:

• Fee in quote asset: fees_quote = Some(fees)
• Fee in base asset: fees_quote = Some(fees * price)
• Fee in third-party asset (e.g., BNB): fees_quote = None

A fee asset that is not in the map

The trade is kept, with its fee zeroed: fees is 0 in the instrument’s quote asset and fees_quote is None. A warn names the fee’s asset and amount. Dropping the trade would leave the engine’s position different from the venue’s, which costs far more than one unknown fee. The warn is per trade, so an account that pays every fee in an unregistered asset logs one per fill until the asset is registered. Two cases reach this:

• An asset the account pays fees in but no instrument implies, such as BNB on Binance spot with “pay fees with BNB” turned on. Register it with IndexedInstrumentsBuilder::add_asset to keep its fee.
• The "UNKNOWN" placeholder some integrations use when the venue gave no fee asset: IBKR fetch_trades for an execution IB sent no commission report for, and Binance when a report omits commissionAsset.

Errors

Returns IndexError if the trade’s instrument is not in the map.

Trait Implementations

impl Clone for AccountEventIndexer

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccountEventIndexer

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

Formats the value using the given formatter.

impl Indexer for AccountEventIndexer

type Unindexed = AccountEvent<ExchangeId, AssetNameExchange, InstrumentNameExchange>

type Indexed = AccountEvent

fn index(&self, item: Self::Unindexed) -> Result<Self::Indexed, IndexError>

Index the input.