Struct BettingAccount 

pub struct BettingAccount {
    pub base: BaseAccount,
    pub balances_locked: AHashMap<(InstrumentId, Currency), Money>,
}

Fields

base: BaseAccount

balances_locked: AHashMap<(InstrumentId, Currency), Money>

Per-(instrument, currency) locked balances (transient, not persisted).

Implementations

impl BettingAccount

pub fn new(event: AccountState, calculate_account_state: bool) -> Self

Creates a new BettingAccount instance.

pub fn update_balance_locked( &mut self, instrument_id: InstrumentId, locked: Money, )

Updates the locked balance for the given instrument and currency.

Panics

Panics if locked is negative.

pub fn clear_balance_locked(&mut self, instrument_id: InstrumentId)

Clears all locked balances for the given instrument ID.

pub fn update_balances(&mut self, balances: &[AccountBalance]) -> Result<()>

Updates the account balances, rejecting negative totals.

Errors

Returns an error if any balance has a negative total.

pub const fn is_unleveraged(&self) -> bool

pub fn balance_impact( &self, instrument: &InstrumentAny, quantity: Quantity, price: Price, order_side: OrderSide, ) -> Money

Returns the balance impact for a betting order.

For Sell (back) the impact is the negative stake (quantity). For Buy (lay) the impact is the negative liability (quantity * (price - 1)).

Panics

Panics if order_side is NoOrderSide.

pub fn recalculate_balance(&mut self, currency: Currency)

Recalculates the account balance for the specified currency based on per-instrument locks.

impl BettingAccount

pub fn py_new(event: AccountState, calculate_account_state: bool) -> Self

Creates a new BettingAccount instance.

Methods from Deref<Target = BaseAccount>

pub fn base_balance( &self, currency: Option<Currency>, ) -> Option<&AccountBalance>

Returns a reference to the AccountBalance for the specified currency, or None if absent.

Panics

Panics if currency is None and self.base_currency is None.

pub fn base_balance_total(&self, currency: Option<Currency>) -> Option<Money>

Returns the total Money balance for the specified currency, or None if absent.

Panics

Panics if currency is None and self.base_currency is None.

pub fn base_balances_total(&self) -> IndexMap<Currency, Money>

pub fn base_balance_free(&self, currency: Option<Currency>) -> Option<Money>

Returns the free Money balance for the specified currency, or None if absent.

Panics

Panics if currency is None and self.base_currency is None.

pub fn base_balances_free(&self) -> IndexMap<Currency, Money>

pub fn base_balance_locked(&self, currency: Option<Currency>) -> Option<Money>

Returns the locked Money balance for the specified currency, or None if absent.

Panics

Panics if currency is None and self.base_currency is None.

pub fn base_balances_locked(&self) -> IndexMap<Currency, Money>

pub fn base_last_event(&self) -> Option<AccountState>

pub fn update_balances(&mut self, balances: &[AccountBalance])

Updates the account balances with the provided list of AccountBalance instances.

Note: This method does NOT validate negative balances. Derived account types (CashAccount, MarginAccount) should perform their own validation in apply():

• MarginAccount: allows negative balances (normal for margin trading)
• CashAccount: rejects negative unless allow_borrowing is true

pub fn update_commissions(&mut self, commission: Money)

pub fn commission(&self, currency: &Currency) -> Option<Money>

Returns the total commission for the specified currency.

pub fn commissions(&self) -> AHashMap<Currency, Money>

Returns a map of all commissions by currency.

pub fn base_apply(&mut self, event: AccountState)

Applies an AccountState event, updating balances.

Panics

Panics if event.account_id does not match this account’s ID.

pub fn base_purge_account_events( &mut self, ts_now: UnixNanos, lookback_secs: u64, )

Purges all account state events which are outside the lookback window.

Guaranteed to retain at least the latest event.

Panics

Panics if the purging implementation is changed and all events are purged.

pub fn base_calculate_balance_locked( &mut self, instrument: &InstrumentAny, side: OrderSide, quantity: Quantity, price: Price, use_quote_for_inverse: Option<bool>, ) -> Result<Money>

Calculates the amount of balance to lock for a new order based on the given side, quantity, and price.

Errors

This function never returns an error (TBD).

pub fn base_calculate_pnls( &self, instrument: &InstrumentAny, fill: &OrderFilled, _position: Option<Position>, ) -> Result<Vec<Money>>

Calculates profit and loss amounts for a filled order.

For cash accounts, this calculates the balance impact of a fill:

• BUY: gain base currency quantity, lose quote currency notional.
• SELL: lose base currency quantity, gain quote currency notional.

Note: Unlike betting accounts, cash accounts do NOT cap to position quantity. The full fill quantity is used for PnL calculation.

Errors

This function never returns an error (TBD).

pub fn base_calculate_commission( &self, instrument: &InstrumentAny, last_qty: Quantity, last_px: Price, liquidity_side: LiquiditySide, use_quote_for_inverse: Option<bool>, ) -> Result<Money>

Calculates commission fees for a filled order.

Panics

Panics if instrument fees cannot be converted to f64, or if base currency is unavailable for inverse instruments.

Trait Implementations

impl Account for BettingAccount

fn id(&self) -> AccountId

fn account_type(&self) -> AccountType

fn base_currency(&self) -> Option<Currency>

fn is_cash_account(&self) -> bool

fn is_margin_account(&self) -> bool

fn calculated_account_state(&self) -> bool

fn balance_total(&self, currency: Option<Currency>) -> Option<Money>

fn balances_total(&self) -> IndexMap<Currency, Money>

fn balance_free(&self, currency: Option<Currency>) -> Option<Money>

fn balances_free(&self) -> IndexMap<Currency, Money>

fn balance_locked(&self, currency: Option<Currency>) -> Option<Money>

fn balances_locked(&self) -> IndexMap<Currency, Money>

fn balance(&self, currency: Option<Currency>) -> Option<&AccountBalance>

fn last_event(&self) -> Option<AccountState>

fn events(&self) -> Vec<AccountState>

fn event_count(&self) -> usize

fn currencies(&self) -> Vec<Currency>

fn starting_balances(&self) -> IndexMap<Currency, Money>

fn balances(&self) -> IndexMap<Currency, AccountBalance>

fn apply(&mut self, event: AccountState) -> Result<()>

Applies an account state event to update the account.

fn purge_account_events(&mut self, ts_now: UnixNanos, lookback_secs: u64)

fn calculate_balance_locked( &mut self, instrument: &InstrumentAny, side: OrderSide, quantity: Quantity, price: Price, use_quote_for_inverse: Option<bool>, ) -> Result<Money>

Calculates locked balance for the order parameters.

fn calculate_pnls( &self, instrument: &InstrumentAny, fill: &OrderFilled, position: Option<Position>, ) -> Result<Vec<Money>>

Calculates PnLs for the fill and position.

fn calculate_commission( &self, instrument: &InstrumentAny, last_qty: Quantity, last_px: Price, liquidity_side: LiquiditySide, use_quote_for_inverse: Option<bool>, ) -> Result<Money>

Calculates commission for the order fill parameters.

impl Clone for BettingAccount

fn clone(&self) -> BettingAccount

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BettingAccount

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

Formats the value using the given formatter.

impl Deref for BettingAccount

type Target = BaseAccount

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for BettingAccount

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for BettingAccount

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for BettingAccount

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

Formats the value using the given formatter.

impl From<BettingAccount> for AccountAny

fn from(v: BettingAccount) -> AccountAny

Converts to this type from the input type.

impl<'a, 'py> FromPyObject<'a, 'py> for BettingAccount

where Self: Clone,

type Error = PyClassGuardError<'a, 'py>

The type returned in the event of a conversion error.

fn extract( obj: Borrowed<'a, 'py, PyAny>, ) -> Result<Self, <Self as FromPyObject<'a, 'py>>::Error>

Extracts Self from the bound smart pointer obj.

impl<'py> IntoPyObject<'py> for BettingAccount

type Target = BettingAccount

The Python output type

type Output = Bound<'py, <BettingAccount as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for BettingAccount

fn eq(&self, other: &Self) -> 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 PyClass for BettingAccount

const NAME: &str = "BettingAccount"

Name of the class.

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for BettingAccount

const MODULE: Option<&str>

Module which the class will be associated with.

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = c"\x00"

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type Layout = <<BettingAccount as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<BettingAccount>

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = NoopThreadChecker

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForBettingAccount

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

impl PyClassNewTextSignature for BettingAccount

const TEXT_SIGNATURE: &'static str = "(event, calculate_account_state)"

impl PyStubType for BettingAccount

fn type_output() -> TypeInfo

The type to be used in the output signature, i.e. return type of the Python function or methods.

fn type_input() -> TypeInfo

The type to be used in the input signature, i.e. the arguments of the Python function or methods.

impl PyTypeInfo for BettingAccount

const NAME: &str = <Self as ::pyo3::PyClass>::NAME

👎Deprecated since 0.28.0:

prefer using ::type_object(py).name() to get the correct runtime value

Class name.

const MODULE: Option<&str> = <Self as ::pyo3::impl_::pyclass::PyClassImpl>::MODULE

👎Deprecated since 0.28.0:

prefer using ::type_object(py).module() to get the correct runtime value

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl Serialize for BettingAccount

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryInto<BettingAccount> for AccountAny

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<BettingAccount, <Self as TryInto<BettingAccount>>::Error>

Performs the conversion.

impl DerefToPyAny for BettingAccount

impl Eq for BettingAccount