Struct barter_data::exchange::ftx::Ftx

pub struct Ftx {
    pub ids: SubscriptionIds,
}

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

Fields

ids: SubscriptionIds

Implementations

impl Ftx

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

Ftx trades channel name.

See docs: https://docs.ftx.com/#trades

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

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

Example Ok Return: Ok(“trades”, “BTC/USDT”) where channel == “trades” & market == “BTC/USDT”

Examples found in repository

src/exchange/ftx/mod.rs (line 48)

    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 Ftx subscriptions
        let subscriptions = subscriptions
            .iter()
            .map(|subscription| {
                // Determine the Ftx 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
                // eg/ SubscriptionId("trades|BTC/USDT")
                ids.insert(Ftx::subscription_id(channel, &market), subscription.clone());

                // Construct Ftx 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 Ftx compatible subscription message using the channel & market provided.

Examples found in repository

src/exchange/ftx/mod.rs (line 55)

    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 Ftx subscriptions
        let subscriptions = subscriptions
            .iter()
            .map(|subscription| {
                // Determine the Ftx 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
                // eg/ SubscriptionId("trades|BTC/USDT")
                ids.insert(Ftx::subscription_id(channel, &market), subscription.clone());

                // Construct Ftx 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 Ftx compatible SubscriptionId using the channel & market provided. This is used to associate Ftx data structures received over the WebSocket with it’s original Barter Subscription.

eg/ SubscriptionId(“trades|BTC/USDT”)

Examples found in repository

src/exchange/ftx/model.rs (line 102)

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(|market| Ftx::subscription_id(Ftx::CHANNEL_TRADES, market))
}

src/exchange/ftx/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 Ftx subscriptions
        let subscriptions = subscriptions
            .iter()
            .map(|subscription| {
                // Determine the Ftx 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
                // eg/ SubscriptionId("trades|BTC/USDT")
                ids.insert(Ftx::subscription_id(channel, &market), subscription.clone());

                // Construct Ftx 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 Ftx

fn clone(&self) -> Ftx

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ftx

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ftx

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

Deserialize this value from the given Serde deserializer.

impl ExchangeTransformer for Ftx

const EXCHANGE: ExchangeId = ExchangeId::Ftx

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<Ftx> for Ftx

fn eq(&self, other: &Ftx) -> 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 Ftx

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 Ftx

type SubResponse = FtxSubResponse

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 Ftx

type Input = FtxMessage

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

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

impl Eq for Ftx

impl StructuralEq for Ftx

impl StructuralPartialEq for Ftx