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::new(WS_SANDBOX_URL,
        &["BTC-USD"], &[ChannelType::Heartbeat]);

    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 Definitions

Result