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 index_account_event( &self, event: UnindexedAccountEvent, ) -> Result<AccountEvent, AccountIndexError>

Index event, telling a balance for an unregistered asset apart from a lost event.

See AccountIndexError. Self::account_event is the same indexing with one error.

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

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

Index snapshot, failing on any asset the ExecutionInstrumentMap does not register.

Use Self::snapshot_partitioned to skip an unregistered balance instead. This is also the path of an AccountEventKind::Snapshot event on an account stream, which stays strict: it replaces the engine’s whole view of the account, so losing part of it is not tolerated.

Errors

IndexError for an exchange, asset, instrument or order the map does not register.

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

Index snapshot, skipping the top-level balance of an asset the ExecutionInstrumentMap does not register, and returning those assets beside it.

A venue may report more assets than the caller registered (see AccountIndexError::UntrackedBalance), so such a balance is not a fault. Only top-level balances are skipped: an unregistered exchange, instrument, order, or isolated-margin base or quote asset still fails the snapshot, because each registered instrument brings its own assets and the loss would be a mapping defect.

The caller must report PartitionedSnapshot::untracked, or the drop is silent. An empty PartitionedSnapshot::snapshot balance list beside a non-empty untracked usually means the registered asset names do not match the venue’s; it can also be an account that holds only unregistered assets.

Errors

IndexError for an exchange, instrument, order or isolated-margin asset the map does not register.

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 margin_debt( &self, update: MarginDebtUpdate<AssetNameExchange, InstrumentNameExchange>, ) -> Result<MarginDebtUpdate<AssetIndex, InstrumentIndex>, IndexError>

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

Unlike a notice’s, an unknown instrument is an error rather than dropped: an update without one is a debt of the account as a whole, which the engine applies to its asset balances, so an isolated pair’s debt delivered unattributed would overwrite the account’s.

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 instrument_balance_snapshot( &self, snapshot: InstrumentBalanceSnapshot<AssetNameExchange, InstrumentNameExchange>, ) -> Result<InstrumentBalanceSnapshot, IndexError>

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,

Index an order request for this exchange, resolving its instrument to the name this exchange knows it by.

Errors

Returns KeyError when the order’s exchange or instrument is not in the map, and when the instrument is indexed but listed on a different exchange: a request keyed to another exchange’s instrument is not this exchange’s to send.

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, since the indexer holds no prices. The rustrade engine values it when it prices that asset.

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.