Struct CashFlow 

#[non_exhaustive]
pub struct CashFlow<AssetKey, InstrumentKey> {
    pub kind: CashFlowKind,
    pub asset: AssetKey,
    pub amount: Decimal,
    pub instrument: Option<InstrumentKey>,
    pub time_exchange: DateTime<Utc>,
    pub id: Option<CashFlowId>,
}

One movement of cash into or out of an account that is not a trade, as the venue posted it.

Sent as AccountEventKind::CashFlow. A flow is a delta: apply each one once. The engine adds a flow attributed to an instrument to the carry of that instrument’s open position (see Position::carry in rustrade), and applies none to balances. A venue’s balances already include the flows it has posted, so adding a flow to a balance read after it counts the flow twice. Carry a venue has accrued but not yet posted is no flow: a venue that reports it puts it in Balance::accrued.

Delivery

Each producer says how it avoids sending one flow twice, and what identifies a flow when the venue gives it no id. Known producers, as of writing:

• Hyperliquid perpetuals: funding, as CashFlowKind::Funding. See the client’s rustdoc.
• Alpaca: margin interest, fees and pass-through charges and rebates, read on request by AlpacaClient::fetch_cash_flows rather than streamed, with Alpaca’s activity id. The caller drops what it has already read.
• Binance margin: interest, as CashFlowKind::MarginInterest, read on request by BinanceMargin::fetch_margin_interest rather than streamed, with Binance’s transaction id. The caller drops what it has already read.
• The simulated venue: whatever its configured HoldingCostModels and MarginInterestModel charge, each flow once, with an id from its own sequence.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

kind: CashFlowKind

What the flow is for.

asset: AssetKey

The asset the cash moved in.

amount: Decimal

How much moved, signed: positive when the account received it, negative when it paid.

instrument: Option<InstrumentKey>

The instrument whose position caused the flow, when the venue attributes it to one, as it does funding. None for a flow on the account as a whole.

time_exchange: DateTime<Utc>

When the venue posted the flow.

id: Option<CashFlowId>

The venue’s identifier for the flow, when it gives one. See CashFlowId.

Implementations

impl<AssetKey, InstrumentKey> CashFlow<AssetKey, InstrumentKey>

pub const fn new( kind: CashFlowKind, asset: AssetKey, amount: Decimal, instrument: Option<InstrumentKey>, time_exchange: DateTime<Utc>, id: Option<CashFlowId>, ) -> CashFlow<AssetKey, InstrumentKey>

Trait Implementations

impl<AssetKey: Clone, InstrumentKey: Clone> Clone for CashFlow<AssetKey, InstrumentKey>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<AssetKey: Debug, InstrumentKey: Debug> Debug for CashFlow<AssetKey, InstrumentKey>

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

Formats the value using the given formatter.

impl<'de, AssetKey, InstrumentKey> Deserialize<'de> for CashFlow<AssetKey, InstrumentKey>

where AssetKey: Deserialize<'de>, InstrumentKey: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<AssetKey: Eq, InstrumentKey: Eq> Eq for CashFlow<AssetKey, InstrumentKey>

impl<ExchangeKey, AssetKey, InstrumentKey> From<CashFlow<AssetKey, InstrumentKey>> for AccountEventKind<ExchangeKey, AssetKey, InstrumentKey>

fn from(value: CashFlow<AssetKey, InstrumentKey>) -> Self

Converts to this type from the input type.

impl<AssetKey: Hash, InstrumentKey: Hash> Hash for CashFlow<AssetKey, InstrumentKey>

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<AssetKey: PartialEq, InstrumentKey: PartialEq> PartialEq for CashFlow<AssetKey, InstrumentKey>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<AssetKey, InstrumentKey> Serialize for CashFlow<AssetKey, InstrumentKey>

where AssetKey: Serialize, InstrumentKey: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<AssetKey: PartialEq, InstrumentKey: PartialEq> StructuralPartialEq for CashFlow<AssetKey, InstrumentKey>