Struct binance::market::Market

pub struct Market {
    pub client: Client,
    pub recv_window: u64,
}

Fields

client: Client

recv_window: u64

Implementations

impl Market

pub async fn get_depth<S>(&self, symbol: S) -> Result<OrderBook> where
    S: Into<String>, 

Order book (Default 100; max 5000)

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let orderbook = tokio_test::block_on(market.get_depth("BTCUSDT".to_string()));
assert!(orderbook.is_ok(), "{:?}", orderbook);

pub async fn get_custom_depth<S>(
    &self,
    symbol: S,
    limit: u16
) -> Result<OrderBook> where
    S: Into<String>, 

Order book with a custom depth limit Supported limits are: 5, 10, 20, 50, 100, 500, 1000, 5000

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let orderbook = tokio_test::block_on(market.get_custom_depth("BTCUSDT".to_string(), 50));
assert!(orderbook.is_ok(), "{:?}", orderbook);
let bids_len = orderbook.unwrap().bids.len();
assert_eq!(bids_len, 50);

pub async fn get_all_prices(&self) -> Result<Prices>

Latest price for ALL symbols.

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let prices = tokio_test::block_on(market.get_all_prices());
assert!(prices.is_ok(), "{:?}", prices);

pub async fn get_price<S>(&self, symbol: S) -> Result<SymbolPrice> where
    S: Into<String>, 

Latest price for ONE symbol.

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let price = tokio_test::block_on(market.get_price("BTCUSDT"));
assert!(price.is_ok(), "{:?}", price);

pub async fn get_average_price<S>(&self, symbol: S) -> Result<AveragePrice> where
    S: Into<String>, 

Average price for ONE symbol.

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let avg_price = tokio_test::block_on(market.get_average_price("BTCUSDT"));
assert!(avg_price.is_ok(), "{:?}", avg_price);

pub async fn get_all_book_tickers(&self) -> Result<BookTickers>

Symbols order book ticker -> Best price/qty on the order book for ALL symbols.

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let tickers = tokio_test::block_on(market.get_all_book_tickers());
assert!(tickers.is_ok(), "{:?}", tickers);

pub async fn get_book_ticker<S>(&self, symbol: S) -> Result<Tickers> where
    S: Into<String>, 

-> Best price/qty on the order book for ONE symbol

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let tickers = tokio_test::block_on(market.get_book_ticker("BTCUSDT"));
assert!(tickers.is_ok(), "{:?}", tickers);

pub async fn get_24h_price_stats<S>(&self, symbol: S) -> Result<PriceStats> where
    S: Into<String>, 

24hr ticker price change statistics

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let price_stats = tokio_test::block_on(market.get_24h_price_stats("BTCUSDT"));
assert!(price_stats.is_ok(), "{:?}", price_stats);

pub async fn get_agg_trades<S1, S2, S3, S4, S5>(
    &self,
    symbol: S1,
    from_id: S2,
    start_time: S3,
    end_time: S4,
    limit: S5
) -> Result<Vec<AggTrade>> where
    S1: Into<String>,
    S2: Into<Option<u64>>,
    S3: Into<Option<u64>>,
    S4: Into<Option<u64>>,
    S5: Into<Option<u16>>, 

Get aggregated historical trades. If you provide start_time, you also need to provide end_time. If from_id, start_time and end_time are omitted, the most recent trades are fetched.

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let agg_trades = tokio_test::block_on(market.get_agg_trades("BNBETH", None, None, None, Some(10)));
assert!(agg_trades.is_ok(), "{:?}", agg_trades);

pub async fn get_klines<S1, S2, S3, S4, S5>(
    &self,
    symbol: S1,
    interval: S2,
    limit: S3,
    start_time: S4,
    end_time: S5
) -> Result<KlineSummaries> where
    S1: Into<String>,
    S2: Into<String>,
    S3: Into<Option<u16>>,
    S4: Into<Option<u64>>,
    S5: Into<Option<u64>>, 

Returns up to ‘limit’ klines for given symbol and interval (“1m”, “5m”, …) https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#klinecandlestick-data

Examples

use binance::{api::*, market::*, config::*};
let market: Market = Binance::new_with_env(&Config::default());
let klines = tokio_test::block_on(market.get_klines("BTCUSDT", "1m", None, None, None));
assert!(klines.is_ok(), "{:?}", klines);

Trait Implementations

impl Binance for Market

fn new_with_config(
    api_key: Option<String>,
    secret_key: Option<String>,
    config: &Config
) -> Market

fn new(api_key: Option<String>, secret_key: Option<String>) -> Self

fn new_with_env(config: &Config) -> Self

Create a binance API using environment variables for credentials BINANCE_API_KEY= BINANCE_API_SECRET_KEY=

impl Clone for Market

fn clone(&self) -> Market

Returns a copy of the value.

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

Performs copy-assignment from source.