Struct barter_data::exchange::coinbase::Coinbase

pub struct Coinbase {
    pub ids: SubscriptionIds,
}

Coinbase Subscriber & ExchangeTransformer implementor for the collection of Spot & Futures data.

Fields

ids: SubscriptionIds

Implementations

impl Coinbase

pub const CHANNEL_TRADES: &'static str = "matches"

Coinbase trades channel name.

See docs: https://docs.cloud.coinbase.com/exchange/docs/websocket-channels#match

pub fn build_channel_meta(
    sub: &Subscription
) -> Result<(&str, String), SocketError>

Determine the Coinbase channel metadata associated with an input Barter Subscription. This includes the Coinbase &str channel, and a String market identifier. Both are used to build an Coinbase subscription payload.

Example Ok return: Ok(“matches”, “BTC-USD”) where channel == “matches” & market == “BTC-USD”.

Examples found in repository

src/exchange/coinbase/mod.rs (line 42)

    fn build_subscription_meta(
        subscriptions: &[Subscription],
    ) -> Result<SubscriptionMeta, SocketError> {
        // Allocate SubscriptionIds HashMap to track identifiers for each actioned Subscription
        let mut ids = SubscriptionIds(HashMap::with_capacity(subscriptions.len()));

        // Map Barter Subscriptions to Coinbase channels
        let subscriptions = subscriptions
            .iter()
            .map(|subscription| {
                // Determine the Coinbase specific channel & market for this Barter Subscription
                let (channel, market) = Self::build_channel_meta(subscription)?;

                // Use "channel|market" as the SubscriptionId key in the SubscriptionIds HashMap
                // eg/ SubscriptionId("matches|ETH-USD")
                ids.insert(
                    Coinbase::subscription_id(channel, &market),
                    subscription.clone(),
                );

                // Construct Coinbase specific subscription message
                Ok(Self::subscription(channel, &market))
            })
            .collect::<Result<Vec<_>, SocketError>>()?;

        Ok(SubscriptionMeta {
            ids,
            expected_responses: subscriptions.len(),
            subscriptions,
        })
    }

pub fn subscription(channel: &str, market: &str) -> WsMessage

Build a Coinbase compatible subscription message using the channel & market provided.

Examples found in repository

src/exchange/coinbase/mod.rs (line 52)

    fn build_subscription_meta(
        subscriptions: &[Subscription],
    ) -> Result<SubscriptionMeta, SocketError> {
        // Allocate SubscriptionIds HashMap to track identifiers for each actioned Subscription
        let mut ids = SubscriptionIds(HashMap::with_capacity(subscriptions.len()));

        // Map Barter Subscriptions to Coinbase channels
        let subscriptions = subscriptions
            .iter()
            .map(|subscription| {
                // Determine the Coinbase specific channel & market for this Barter Subscription
                let (channel, market) = Self::build_channel_meta(subscription)?;

                // Use "channel|market" as the SubscriptionId key in the SubscriptionIds HashMap
                // eg/ SubscriptionId("matches|ETH-USD")
                ids.insert(
                    Coinbase::subscription_id(channel, &market),
                    subscription.clone(),
                );

                // Construct Coinbase specific subscription message
                Ok(Self::subscription(channel, &market))
            })
            .collect::<Result<Vec<_>, SocketError>>()?;

        Ok(SubscriptionMeta {
            ids,
            expected_responses: subscriptions.len(),
            subscriptions,
        })
    }

pub fn subscription_id(channel: &str, market: &str) -> SubscriptionId

Build a Coinbase compatible SubscriptionId using the channel & market provided. This is used to associate Coinbase data structures received over the WebSocket with it’s original Barter Subscription.

eg/ SubscriptionId(“matches|ETH-USD”)

Examples found in repository

src/exchange/coinbase/model.rs (line 109)

pub fn de_trade_subscription_id<'de, D>(deserializer: D) -> Result<SubscriptionId, D::Error>
where
    D: serde::de::Deserializer<'de>,
{
    serde::de::Deserialize::deserialize(deserializer)
        .map(|product_id| Coinbase::subscription_id(Coinbase::CHANNEL_TRADES, product_id))
}

src/exchange/coinbase/mod.rs (line 47)

    fn build_subscription_meta(
        subscriptions: &[Subscription],
    ) -> Result<SubscriptionMeta, SocketError> {
        // Allocate SubscriptionIds HashMap to track identifiers for each actioned Subscription
        let mut ids = SubscriptionIds(HashMap::with_capacity(subscriptions.len()));

        // Map Barter Subscriptions to Coinbase channels
        let subscriptions = subscriptions
            .iter()
            .map(|subscription| {
                // Determine the Coinbase specific channel & market for this Barter Subscription
                let (channel, market) = Self::build_channel_meta(subscription)?;

                // Use "channel|market" as the SubscriptionId key in the SubscriptionIds HashMap
                // eg/ SubscriptionId("matches|ETH-USD")
                ids.insert(
                    Coinbase::subscription_id(channel, &market),
                    subscription.clone(),
                );

                // Construct Coinbase specific subscription message
                Ok(Self::subscription(channel, &market))
            })
            .collect::<Result<Vec<_>, SocketError>>()?;

        Ok(SubscriptionMeta {
            ids,
            expected_responses: subscriptions.len(),
            subscriptions,
        })
    }

Trait Implementations

impl Clone for Coinbase

fn clone(&self) -> Coinbase

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Coinbase

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Coinbase

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ExchangeTransformer for Coinbase

const EXCHANGE: ExchangeId = ExchangeId::Coinbase

Unique identifier for an ExchangeTransformer.

fn new(_: UnboundedSender<WsMessage>, ids: SubscriptionIds) -> Self

Constructs a new ExchangeTransformer using a transmitter to the WsSink and the SubscriptionIds HashMap.

impl PartialEq<Coinbase> for Coinbase

fn eq(&self, other: &Coinbase) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Coinbase

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Subscriber for Coinbase

type SubResponse = CoinbaseSubResponse

Deserialisable type that this Subscriber expects to receive from the exchange in response to Subscription requests. Implements Validator in order to determine if the SubResponse communicates a successful outcome.

fn base_url() -> &'static str

Returns the Base URL of the exchange to establish a connection with.

fn build_subscription_meta(
    subscriptions: &[Subscription]
) -> Result<SubscriptionMeta, SocketError>

Uses the provided Barter Subscriptions to build exchange specific subscription payloads. Generates a SubscriptionIds Hashmap that is used by an ExchangeTransformer to identify the Barter Subscriptions associated with received messages.

fn subscribe<'life0, 'async_trait>(
    subscriptions: &'life0 [Subscription]
) -> Pin<Box<dyn Future<Output = Result<(WebSocket, SubscriptionIds), SocketError>> + Send + 'async_trait>>where
    Self: Send + 'async_trait,
    'life0: 'async_trait,

Initialises a WebSocket connection, actions the provided collection of Barter Subscriptions, and validates that the Subscription were accepted by the exchange.

fn validate<'life0, 'async_trait>(
    ids: SubscriptionIds,
    websocket: &'life0 mut WebSocket,
    expected_responses: usize
) -> Pin<Box<dyn Future<Output = Result<SubscriptionIds, SocketError>> + Send + 'async_trait>>where
    Self: Send + 'async_trait,
    'life0: 'async_trait,

Uses the provided WebSocket connection to consume Subscription responses and validate their outcomes.

fn subscription_timeout() -> Duration

Return the expected Duration in which the exchange will respond to all actioned WebSocket Subscription requests.

impl Transformer<MarketEvent> for Coinbase

type Input = CoinbaseMessage

type OutputIter = Vec<Result<MarketEvent, SocketError>, Global>

fn transform(&mut self, input: Self::Input) -> Self::OutputIter

impl Eq for Coinbase

impl StructuralEq for Coinbase

impl StructuralPartialEq for Coinbase