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 and DynamicStreams interface allows for easy & quick setup (see example below and /examples!).
• 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 specific data kinds.
• DynamicStreams for initialising MarketStreams of every supported data kind at once.
• Define what exchange market data you want to stream using the Subscription type.
• Pass Subscriptions to the StreamBuilder::subscribe or DynamicStreams::init methods.
• Each call to the StreamBuilder::subscribe (or each batch passed to the DynamicStreams::init) method opens a new WebSocket connection to the exchange - giving you full control.

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, reconnect::stream::ReconnectingStream},
    subscription::trade::PublicTrades,
};
use barter_integration::model::instrument::kind::InstrumentKind;
use futures::StreamExt;
use tracing::warn;

#[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();

    // Select and merge every exchange Stream using futures_util::stream::select_all
    // Note: use `Streams.select(ExchangeId)` to interact with individual exchange streams!
    let mut joined_stream = streams
        .select_all()
        .with_error_handler(|error| warn!(?error, "MarketStream generated error"));

    while let Some(event) = joined_stream.next().await {
        println!("{event:?}");
    }
}

Modules

• books
  OrderBook related types, and utilities for initialising and maintaining a collection of sorted local Instrument OrderBooks
• error
  All Errors generated in Barter-Data.
• event
  Defines the generic MarketEvent<T> used in every MarketStream.
• exchange
  Connector implementations for each exchange.
• instrument
  InstrumentData trait for instrument describing data.
• 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.

Structs

• NoInitialSnapshots
  Implementation of SnapshotFetcher that does not fetch any initial market data snapshots. Often used for stateless MarketStreams, such as public trades.

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 SubscriptionKind of the passed Subscriptions.
• SnapshotFetcher
  Defines how to fetch market data snapshots for a collection of Subscriptions.

Functions

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

Type Aliases

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