mod crawlers;
mod msg;
mod utils;
use std::sync::{Arc, Mutex};
pub use crawlers::fetch_symbols_retry;
pub use crypto_market_type::MarketType;
pub use msg::*;
pub use utils::get_hot_spot_symbols;
pub fn crawl_trade(
exchange: &str,
market_type: MarketType,
symbols: Option<&[String]>,
on_msg: Arc<Mutex<dyn FnMut(Message) + 'static + Send>>,
duration: Option<u64>,
) {
let func = match exchange {
"binance" => crawlers::binance::crawl_trade,
"bitfinex" => crawlers::bitfinex::crawl_trade,
"bitget" => crawlers::bitget::crawl_trade,
"bithumb" => crawlers::bithumb::crawl_trade,
"bitmex" => crawlers::bitmex::crawl_trade,
"bitstamp" => crawlers::bitstamp::crawl_trade,
"bitz" => crawlers::bitz::crawl_trade,
"bybit" => crawlers::bybit::crawl_trade,
"coinbase_pro" => crawlers::coinbase_pro::crawl_trade,
"deribit" => crawlers::deribit::crawl_trade,
"ftx" => crawlers::ftx::crawl_trade,
"gate" => crawlers::gate::crawl_trade,
"huobi" => crawlers::huobi::crawl_trade,
"kraken" => crawlers::kraken::crawl_trade,
"kucoin" => crawlers::kucoin::crawl_trade,
"mxc" => crawlers::mxc::crawl_trade,
"okex" => crawlers::okex::crawl_trade,
"zbg" => crawlers::zbg::crawl_trade,
_ => panic!("Unknown exchange {}", exchange),
};
let handle = func(market_type, symbols, on_msg, duration);
if let Some(h) = handle {
h.join().expect("The thread panicked");
}
}
pub fn crawl_l2_event(
exchange: &str,
market_type: MarketType,
symbols: Option<&[String]>,
on_msg: Arc<Mutex<dyn FnMut(Message) + 'static + Send>>,
duration: Option<u64>,
) {
let func = match exchange {
"binance" => crawlers::binance::crawl_l2_event,
"bitfinex" => crawlers::bitfinex::crawl_l2_event,
"bitget" => crawlers::bitget::crawl_l2_event,
"bithumb" => crawlers::bithumb::crawl_l2_event,
"bitmex" => crawlers::bitmex::crawl_l2_event,
"bitstamp" => crawlers::bitstamp::crawl_l2_event,
"bitz" => crawlers::bitz::crawl_l2_event,
"bybit" => crawlers::bybit::crawl_l2_event,
"coinbase_pro" => crawlers::coinbase_pro::crawl_l2_event,
"deribit" => crawlers::deribit::crawl_l2_event,
"ftx" => crawlers::ftx::crawl_l2_event,
"gate" => crawlers::gate::crawl_l2_event,
"huobi" => crawlers::huobi::crawl_l2_event,
"kraken" => crawlers::kraken::crawl_l2_event,
"kucoin" => crawlers::kucoin::crawl_l2_event,
"mxc" => crawlers::mxc::crawl_l2_event,
"okex" => crawlers::okex::crawl_l2_event,
"zbg" => crawlers::zbg::crawl_l2_event,
_ => panic!("Unknown exchange {}", exchange),
};
let handle = func(market_type, symbols, on_msg, duration);
if let Some(h) = handle {
h.join().expect("The thread panicked");
}
}
pub fn crawl_l3_event(
exchange: &str,
market_type: MarketType,
symbols: Option<&[String]>,
on_msg: Arc<Mutex<dyn FnMut(Message) + 'static + Send>>,
duration: Option<u64>,
) {
let func = match exchange {
"binance" => panic!("Binance does NOT provide level3 orderbook data"),
"bitfinex" => crawlers::bitfinex::crawl_l3_event,
"bitstamp" => crawlers::bitstamp::crawl_l3_event,
"coinbase_pro" => crawlers::coinbase_pro::crawl_l3_event,
"kucoin" => crawlers::kucoin::crawl_l3_event,
_ => panic!("Unknown exchange {}", exchange),
};
let handle = func(market_type, symbols, on_msg, duration);
if let Some(h) = handle {
h.join().expect("The thread panicked");
}
}
pub fn crawl_l2_snapshot(
exchange: &str,
market_type: MarketType,
symbols: Option<&[String]>,
on_msg: Arc<Mutex<dyn FnMut(Message) + 'static + Send>>,
duration: Option<u64>,
) {
crawlers::crawl_snapshot(
exchange,
market_type,
MessageType::L2Snapshot,
symbols,
on_msg,
duration,
)
}
pub fn crawl_l3_snapshot(
exchange: &str,
market_type: MarketType,
symbols: Option<&[String]>,
on_msg: Arc<Mutex<dyn FnMut(Message) + 'static + Send>>,
duration: Option<u64>,
) {
crawlers::crawl_snapshot(
exchange,
market_type,
MessageType::L3Snapshot,
symbols,
on_msg,
duration,
)
}
pub fn crawl_ticker(
exchange: &str,
market_type: MarketType,
symbols: Option<&[String]>,
on_msg: Arc<Mutex<dyn FnMut(Message) + 'static + Send>>,
duration: Option<u64>,
) {
let func = match exchange {
"binance" => crawlers::binance::crawl_ticker,
"bitfinex" => crawlers::bitfinex::crawl_ticker,
"bitget" => crawlers::bitget::crawl_ticker,
"bithumb" => crawlers::bithumb::crawl_ticker,
"bitz" => crawlers::bitz::crawl_ticker,
"bybit" => crawlers::bybit::crawl_ticker,
"coinbase_pro" => crawlers::coinbase_pro::crawl_ticker,
"deribit" => crawlers::deribit::crawl_ticker,
"gate" => crawlers::gate::crawl_ticker,
"huobi" => crawlers::huobi::crawl_ticker,
"kraken" => crawlers::kraken::crawl_ticker,
"kucoin" => crawlers::kucoin::crawl_ticker,
"mxc" => crawlers::mxc::crawl_ticker,
"okex" => crawlers::okex::crawl_ticker,
"zbg" => crawlers::zbg::crawl_ticker,
_ => panic!("Unknown exchange {}", exchange),
};
let handle = func(market_type, symbols, on_msg, duration);
if let Some(h) = handle {
h.join().expect("The thread panicked");
}
}
pub fn crawl_funding_rate(
exchange: &str,
market_type: MarketType,
symbols: Option<&[String]>,
on_msg: Arc<Mutex<dyn FnMut(Message) + 'static + Send>>,
duration: Option<u64>,
) {
let func = match exchange {
"binance" => crawlers::binance::crawl_funding_rate,
"bitget" => crawlers::bitget::crawl_funding_rate,
"bitmex" => crawlers::bitmex::crawl_funding_rate,
"huobi" => crawlers::huobi::crawl_funding_rate,
"okex" => crawlers::okex::crawl_funding_rate,
_ => panic!("{} does NOT have perpetual swap market", exchange),
};
func(market_type, symbols, on_msg, duration);
}