Crate barter_data

Barter-Data

A high-performance WebSocket integration library for streaming public market data from leading cryptocurrency exchanges - batteries included. It is:

• Easy: Barter-Data’s simple StreamBuilder interface allows for easy & quick setup (see example below!).
• Normalised: Barter-Data’s unified interface for consuming public WebSocket data means every Exchange returns a normalised data model.
• Real-Time: Barter-Data utilises real-time WebSocket integrations enabling the consumption of normalised tick-by-tick data.
• Extensible: Barter-Data is highly extensible, and therefore easy to contribute to with coding new integrations!

User API

• StreamBuilder for initialising MarketStreams of various kinds.
• Define what exchange market data you want to stream using the Subscription type.
• Pass Subscriptions to the StreamBuilder::subscribe method.
• Each call to the StreamBuilder::subscribe method opens a new WebSocket connection to the exchange - giving you full control.
• Call StreamBuilder::init to start streaming!

Examples

For a comprehensive collection of examples, see the /examples directory.

Multi Exchange Public Trades

use barter_data::exchange::gateio::spot::GateioSpot;
use barter_data::{
    exchange::{
        binance::{futures::BinanceFuturesUsd, spot::BinanceSpot},
        coinbase::Coinbase,
        okx::Okx,
    },
    streams::Streams,
    subscription::trade::PublicTrades,
};
use barter_integration::model::instrument::kind::InstrumentKind;
use futures::StreamExt;

#[tokio::main]
async fn main() {
    // Initialise PublicTrades Streams for various exchanges
    // '--> each call to StreamBuilder::subscribe() initialises a separate WebSocket connection
    let streams = Streams::<PublicTrades>::builder()
        .subscribe([
            (BinanceSpot::default(), "btc", "usdt", InstrumentKind::Spot, PublicTrades),
            (BinanceSpot::default(), "eth", "usdt", InstrumentKind::Spot, PublicTrades),
        ])
        .subscribe([
            (BinanceFuturesUsd::default(), "btc", "usdt", InstrumentKind::Perpetual, PublicTrades),
            (BinanceFuturesUsd::default(), "eth", "usdt", InstrumentKind::Perpetual, PublicTrades),
        ])
        .subscribe([
            (Coinbase, "btc", "usd", InstrumentKind::Spot, PublicTrades),
            (Coinbase, "eth", "usd", InstrumentKind::Spot, PublicTrades),
        ])
        .subscribe([
            (GateioSpot::default(), "btc", "usdt", InstrumentKind::Spot, PublicTrades),
            (GateioSpot::default(), "eth", "usdt", InstrumentKind::Spot, PublicTrades),
        ])
        .subscribe([
            (Okx, "btc", "usdt", InstrumentKind::Spot, PublicTrades),
            (Okx, "eth", "usdt", InstrumentKind::Spot, PublicTrades),
            (Okx, "btc", "usdt", InstrumentKind::Perpetual, PublicTrades),
            (Okx, "eth", "usdt", InstrumentKind::Perpetual, PublicTrades),
       ])
        .init()
        .await
        .unwrap();

    // Join all exchange PublicTrades streams into a single tokio_stream::StreamMap
    // Notes:
    //  - Use `streams.select(ExchangeId)` to interact with the individual exchange streams!
    //  - Use `streams.join()` to join all exchange streams into a single mpsc::UnboundedReceiver!
    let mut joined_stream = streams.join_map().await;

    while let Some((exchange, trade)) = joined_stream.next().await {
        println!("Exchange: {exchange}, Market<PublicTrade>: {trade:?}");
    }
}

Modules

• error
  All Errors generated in Barter-Data.
• event
  Defines the generic MarketEvent<T> used in every MarketStream.
• exchange
  Connector implementations for each exchange.
• streams
  High-level API types used for building MarketStreams from collections of Barter Subscriptions.
• subscriber
  Subscriber, SubscriptionMapper and SubscriptionValidator traits that define how a Connector will subscribe to exchange MarketStreams.
• subscription
  Types that communicate the type of each MarketStream to initialise, and what normalised Barter output type the exchange will be transformed into.
• transformer
  Generic ExchangeTransformer implementations used by MarketStreams to translate exchange specific types to normalised Barter types.

Traits

• Identifier
  Defines a generic identification type for the implementor.
• MarketStream
  [Stream] that yields Market<Kind> events. The type of Market<Kind> depends on the provided SubKind of the passed Subscriptions.

Functions

• distribute_messages_to_exchange
  Transmit WsMessages sent from the ExchangeTransformer to the exchange via the WsSink.
• schedule_pings_to_exchange
  Schedule the sending of custom application-level ping WsMessages to the exchange using the provided PingInterval.

Type Definitions

• ExchangeWsStream
  Convenient type alias for an ExchangeStream utilising a tungstenite WebSocket.