barter_execution/client/
mod.rs

1use crate::{
2    UnindexedAccountEvent, UnindexedAccountSnapshot,
3    balance::AssetBalance,
4    error::{UnindexedClientError, UnindexedOrderError},
5    order::{
6        Order,
7        request::{OrderRequestCancel, OrderRequestOpen, UnindexedOrderResponseCancel},
8        state::Open,
9    },
10    trade::Trade,
11};
12use barter_instrument::{
13    asset::{QuoteAsset, name::AssetNameExchange},
14    exchange::ExchangeId,
15    instrument::name::InstrumentNameExchange,
16};
17use chrono::{DateTime, Utc};
18use futures::Stream;
19use std::future::Future;
20
21mod binance;
22pub mod mock;
23
24pub trait ExecutionClient
25where
26    Self: Clone,
27{
28    const EXCHANGE: ExchangeId;
29
30    type Config: Clone;
31    type AccountStream: Stream<Item = UnindexedAccountEvent>;
32
33    fn new(config: Self::Config) -> Self;
34
35    fn account_snapshot(
36        &self,
37        assets: &[AssetNameExchange],
38        instruments: &[InstrumentNameExchange],
39    ) -> impl Future<Output = Result<UnindexedAccountSnapshot, UnindexedClientError>> + Send;
40
41    fn account_stream(
42        &self,
43        assets: &[AssetNameExchange],
44        instruments: &[InstrumentNameExchange],
45    ) -> impl Future<Output = Result<Self::AccountStream, UnindexedClientError>> + Send;
46
47    fn cancel_order(
48        &self,
49        request: OrderRequestCancel<ExchangeId, &InstrumentNameExchange>,
50    ) -> impl Future<Output = Option<UnindexedOrderResponseCancel>> + Send;
51
52    fn cancel_orders<'a>(
53        &self,
54        requests: impl IntoIterator<Item = OrderRequestCancel<ExchangeId, &'a InstrumentNameExchange>>,
55    ) -> impl Stream<Item = Option<UnindexedOrderResponseCancel>> {
56        futures::stream::FuturesUnordered::from_iter(
57            requests
58                .into_iter()
59                .map(|request| self.cancel_order(request)),
60        )
61    }
62
63    fn open_order(
64        &self,
65        request: OrderRequestOpen<ExchangeId, &InstrumentNameExchange>,
66    ) -> impl Future<
67        Output = Option<
68            Order<ExchangeId, InstrumentNameExchange, Result<Open, UnindexedOrderError>>,
69        >,
70    > + Send;
71
72    fn open_orders<'a>(
73        &self,
74        requests: impl IntoIterator<Item = OrderRequestOpen<ExchangeId, &'a InstrumentNameExchange>>,
75    ) -> impl Stream<
76        Item = Option<Order<ExchangeId, InstrumentNameExchange, Result<Open, UnindexedOrderError>>>,
77    > {
78        futures::stream::FuturesUnordered::from_iter(
79            requests.into_iter().map(|request| self.open_order(request)),
80        )
81    }
82
83    fn fetch_balances(
84        &self,
85    ) -> impl Future<Output = Result<Vec<AssetBalance<AssetNameExchange>>, UnindexedClientError>>;
86
87    fn fetch_open_orders(
88        &self,
89    ) -> impl Future<
90        Output = Result<Vec<Order<ExchangeId, InstrumentNameExchange, Open>>, UnindexedClientError>,
91    >;
92
93    fn fetch_trades(
94        &self,
95        time_since: DateTime<Utc>,
96    ) -> impl Future<Output = Result<Vec<Trade<QuoteAsset, InstrumentNameExchange>>, UnindexedClientError>>;
97}