Struct MockExecution 

pub struct MockExecution<FnTime> {
    pub mocked_exchange: ExchangeId,
    pub clock: FnTime,
    pub request_tx: UnboundedSender<MockExchangeRequest>,
    pub event_rx: Receiver<UnindexedAccountEvent>,
}

Fields

mocked_exchange: ExchangeId

clock: FnTime

request_tx: UnboundedSender<MockExchangeRequest>

event_rx: Receiver<UnindexedAccountEvent>

Implementations

impl<FnTime> MockExecution<FnTime>

pub const fn new( mocked_exchange: ExchangeId, clock: FnTime, request_tx: UnboundedSender<MockExchangeRequest>, event_rx: Receiver<UnindexedAccountEvent>, ) -> MockExecution<FnTime>

impl<FnTime> MockExecution<FnTime>

where FnTime: Fn() -> DateTime<Utc>,

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

Trait Implementations

impl<FnTime> BorrowCapacityClient for MockExecution<FnTime>

where FnTime: Fn() -> DateTime<Utc> + Clone + Send + Sync,

Answered by the simulated venue from its own ledger and the markets it holds: see SimulatedVenue::borrow_capacity for how it values the account, and when it answers None or an error. A venue without a SpotMarginConfig lends against no instrument, so answers ApiError::InstrumentInvalid for every one.

async fn fetch_borrow_capacity( &self, instrument: &InstrumentNameExchange, side: Side, ) -> Result<BorrowCapacity, UnindexedClientError>

How much this account can borrow now for an order on instrument on side.

impl<FnTime> Clone for MockExecution<FnTime>

where FnTime: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<FnTime: Debug> Debug for MockExecution<FnTime>

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

Formats the value using the given formatter.

impl<FnTime> ExecutionClient for MockExecution<FnTime>

where FnTime: Fn() -> DateTime<Utc> + Clone + Send + Sync,

async fn fetch_trades( &self, start: DateTime<Utc>, end: DateTime<Utc>, instruments: &[InstrumentNameExchange], ) -> Result<TradesRead<AssetNameExchange, InstrumentNameExchange>, UnindexedClientError>

The mock venue holds every trade and answers a span whole, so the read is always complete.

const EXCHANGE: ExchangeId = ExchangeId::Mock

const SUPPORTED_KINDS: &'static [InstrumentKindDiscriminant]

The InstrumentKindDiscriminants this client can trade.

type Config = MockExecutionClientConfig<FnTime>

type AccountStream = Pin<Box<dyn Stream<Item = AccountEvent<ExchangeId, AssetNameExchange, InstrumentNameExchange>> + Send>>

fn new(config: Self::Config) -> Self

async fn account_snapshot( &self, _: &[AssetNameExchange], _: &[InstrumentNameExchange], ) -> Result<UnindexedAccountSnapshot, UnindexedClientError>

Reads the account’s balances, and its open orders and positions for instruments, from the venue.

async fn account_stream( &self, _: &[AssetNameExchange], _: &[InstrumentNameExchange], ) -> Result<Self::AccountStream, UnindexedClientError>

Returns a live stream of account events (fills, order updates, balance changes).

async fn cancel_order( &self, request: OrderRequestCancel<ExchangeId, &InstrumentNameExchange>, ) -> UnindexedOrderResponseCancel

Cancel an order at the venue.

async fn open_order( &self, request: OrderRequestOpen<ExchangeId, &InstrumentNameExchange>, ) -> Order<ExchangeId, InstrumentNameExchange, UnindexedOrderState>

Place an order on the exchange.

async fn fetch_balances( &self, assets: &[AssetNameExchange], ) -> Result<Vec<AssetBalance<AssetNameExchange>>, UnindexedClientError>

Fetch current balances for the specified assets.

async fn fetch_open_orders( &self, instruments: &[InstrumentNameExchange], ) -> Result<Vec<Order<ExchangeId, InstrumentNameExchange, Open>>, UnindexedClientError>

Fetch currently open orders, optionally filtered by instrument.

fn validate_config( config: &Self::Config, instruments: &[ClientInstrument<'_>], ) -> Result<(), String>

Checks config against the instruments this client is about to be built to trade, before Self::new is called. Err names what is wrong.

fn cancel_orders<'a>( &self, requests: impl IntoIterator<Item = OrderRequestCancel<ExchangeId, &'a InstrumentNameExchange>>, ) -> impl Stream<Item = UnindexedOrderResponseCancel> + Send

fn open_orders<'a>( &self, requests: impl IntoIterator<Item = OrderRequestOpen<ExchangeId, &'a InstrumentNameExchange>>, ) -> impl Stream<Item = Order<ExchangeId, InstrumentNameExchange, UnindexedOrderState>> + Send

impl<FnTime> OrderStatusClient for MockExecution<FnTime>

where FnTime: Fn() -> DateTime<Utc> + Clone + Send + Sync,

Answered from the venue’s own ledger: an order it filled, cancelled or retired at its deadline is reported, and one still open or never held is omitted. The venue rejects an order only on arrival, in the response to its open request, so it never reports OpenFailed.

async fn fetch_ended_orders( &self, orders: &[UnindexedOrderKey], ) -> Result<Vec<UnindexedInactiveOrder>, UnindexedClientError>

How each of orders ended, for those that have.

fn fetch_order_status( &self, key: &UnindexedOrderKey, ) -> impl Future<Output = Result<VenueOrderStatus, UnindexedClientError>> + Send

where Self: Sync,

What the venue knows of the order under key: live, ended, or nothing.