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 = UnindexedOrderResponseCancel> + Send;
51
52    fn cancel_orders<'a>(
53        &self,
54        requests: impl IntoIterator<Item = OrderRequestCancel<ExchangeId, &'a InstrumentNameExchange>>,
55    ) -> impl Stream<Item = 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 = Order<ExchangeId, InstrumentNameExchange, Result<Open, UnindexedOrderError>>,
68    > + Send;
69
70    fn open_orders<'a>(
71        &self,
72        requests: impl IntoIterator<Item = OrderRequestOpen<ExchangeId, &'a InstrumentNameExchange>>,
73    ) -> impl Stream<Item = Order<ExchangeId, InstrumentNameExchange, Result<Open, UnindexedOrderError>>>
74    {
75        futures::stream::FuturesUnordered::from_iter(
76            requests.into_iter().map(|request| self.open_order(request)),
77        )
78    }
79
80    fn fetch_balances(
81        &self,
82    ) -> impl Future<Output = Result<Vec<AssetBalance<AssetNameExchange>>, UnindexedClientError>>;
83
84    fn fetch_open_orders(
85        &self,
86    ) -> impl Future<
87        Output = Result<Vec<Order<ExchangeId, InstrumentNameExchange, Open>>, UnindexedClientError>,
88    >;
89
90    fn fetch_trades(
91        &self,
92        time_since: DateTime<Utc>,
93    ) -> impl Future<Output = Result<Vec<Trade<QuoteAsset, InstrumentNameExchange>>, UnindexedClientError>>;
94}