Crate coinbase_pro_rs

Coinbase pro client with sync/async + websocket-feed support

Structure

There are two main structures to work with: Private and Public, which provide interfaces to work with https://docs.pro.coinbase.com . The structures should be parametrised with: Sync or ASync adapter-type, which blocks future and returns result of its execution for Sync adapter or returns Future for ASync adapter.

WSFeed provides futures::Stream of websocket message for different channels.

Examples

Async

use std::future::Future;
use coinbase_pro_rs::{Public, ASync, SANDBOX_URL};
use futures::{TryFutureExt};

#[tokio::main]
async fn main() {
    let client: Public<ASync> = Public::new_with_keep_alive(SANDBOX_URL, false);
    // if keep_alive is not disables - tokio::run will hold the connection without exiting the example
    client.get_time().await
        .map_err(|_| ())
        .and_then(|time| {
            println!("Coinbase.time: {}", time.iso);
            Ok(())
        });

}

Sync

use coinbase_pro_rs::{Public, Sync, SANDBOX_URL};

fn main() {
   let client: Public<Sync> = Public::new(SANDBOX_URL);
   let time = client.get_time().unwrap();
   println!("Coinbase.time: {}", time.iso);
}

Websocket

use futures::{Future, Stream, StreamExt, TryStreamExt};
use coinbase_pro_rs::{WSFeed, CBError, WS_SANDBOX_URL};
use coinbase_pro_rs::structs::wsfeed::*;

#[tokio::main]
async fn main() {
    let stream = WSFeed::connect(WS_SANDBOX_URL,
        &["BTC-USD"], &[ChannelType::Heartbeat]).await.unwrap();

    stream
        .take(10)
        .for_each(|msg: Result<Message, CBError>| async {
        match msg.unwrap() {
            Message::Heartbeat {sequence, last_trade_id, time, ..} => println!("{}: seq:{} id{}",
                                                                               time, sequence, last_trade_id),
            Message::Error {message} => println!("Error: {}", message),
            Message::InternalError(_) => panic!("internal_error"),
            other => println!("{:?}", other)
        }
    }).await;
}

Re-exports

pub use crate::adapters::ASync;

pub use crate::adapters::Sync;

pub use crate::private::Private;

pub use crate::public::Public;

pub use crate::wsfeed::WSFeed;

Modules

adapters

private

Contains structure which provides access to Private section of Coinbase api

public

Contains structure which provides access to Public section of Coinbase api

structs

wsfeed

Contains structure which provides futures::Stream to websocket-feed of Coinbase api

Enums

CBError

Coinbase-pro-rs error

WSError

Websocket specific errors

Constants

MAIN_URL

https://api.pro.coinbase.com

SANDBOX_URL

https://api-public.sandbox.pro.coinbase.com

WS_SANDBOX_URL

wss://ws-feed-public.sandbox.pro.coinbase.com

WS_URL

wss://ws-feed.pro.coinbase.com

Type Aliases

Result