#[macro_use]
extern crate tracing;
use env_logger::Builder;
#[tokio::main]
async fn main() {
Builder::new().parse_default_env().init();
info!("running margin endpoints");
#[cfg(feature = "margin_api")]
margin_query().await;
}
#[cfg(feature = "margin_api")]
async fn margin_query() {
use binance::api::*;
use binance::bool_to_string_some;
use binance::config::Config;
use binance::margin::Margin;
use binance::rest_model::*;
use chrono::{Duration, Utc};
use std::ops::Sub;
eprintln!("----------- Margin GET queries ----------");
let margin: Margin = Binance::new_with_env(&Config::default());
let yesterday = Utc::now().sub(Duration::days(1));
let yesterday_millis = yesterday.timestamp_millis() as u64;
let interest_rate_history = margin
.interest_rate_history(InterestRateHistoryQuery {
asset: "BTC".to_string(),
vip_level: Some(1),
..InterestRateHistoryQuery::default()
})
.await
.unwrap();
eprintln!("interest_rate_history = {interest_rate_history:?}");
let interest_rate_history = margin
.interest_rate_history(InterestRateHistoryQuery {
asset: "LTC".to_string(),
..InterestRateHistoryQuery::default()
})
.await
.unwrap();
eprintln!("interest_rate_history = {interest_rate_history:?}");
let records_query = RecordsQuery {
asset: "BTC".to_string(),
transfer_type: Some(TransferType::RollIn),
start_time: Some(yesterday_millis),
..RecordsQuery::default()
};
let loans = margin.loans(records_query).await;
eprintln!("loans = {loans:?}");
let records_query = RecordsQuery {
asset: "BTC".to_string(),
transfer_type: Some(TransferType::RollIn),
start_time: Some(yesterday_millis),
..RecordsQuery::default()
};
let repays = margin.repays(records_query).await;
eprintln!("repays = {repays:?}");
let details = margin.details().await;
eprintln!("details = {details:?}");
let isolated_details = margin.isolated_details(None).await;
eprintln!("isolated_details = {isolated_details:?}");
let isolated_pair = margin.isolated_pair("BTCUSDT").await;
eprintln!("isolated_pair = {isolated_pair:?}");
let isolated_account_limit = margin.isolated_account_limit().await;
eprintln!("isolated_pair = {isolated_account_limit:?}");
let all_pairs = margin.all_pairs().await;
eprintln!("all_pairs = {all_pairs:?}");
let bnb_burn_status = margin.bnb_burn_status().await;
eprintln!("bnb_burn_status = {bnb_burn_status:?}");
let asset = margin.asset("BTC").await;
eprintln!("asset = {asset:?}");
let pair = margin.pair("BTCUSDT").await;
eprintln!("pair = {pair:?}");
let all_assets = margin.all_assets().await;
eprintln!("all_assets = {all_assets:?}");
let all_isolated_pairs = margin.all_isolated_pairs().await;
eprintln!("all_isolated_pairs = {all_isolated_pairs:?}");
let price_index = margin.price_index("BTCUSDT").await;
eprintln!("price_index = {price_index:?}");
let records_query = RecordsQuery {
asset: "BTC".to_string(),
transfer_type: Some(TransferType::RollIn),
..RecordsQuery::default()
};
let transfers = margin.transfers(records_query).await;
eprintln!("transfers = {transfers:?}");
let records_query = IsolatedTransfersQuery {
symbol: "BTC".to_string(),
..IsolatedTransfersQuery::default()
};
let isolated_transfers = margin.isolated_transfers(records_query).await;
eprintln!("isolated_transfers = {isolated_transfers:?}");
let records_query = RecordsQuery {
asset: "BTC".to_string(),
transfer_type: Some(TransferType::RollIn),
..RecordsQuery::default()
};
let interests = margin.interests(records_query).await;
eprintln!("interests = {interests:?}");
let records_query = RecordsQuery {
asset: "BTC".to_string(),
transfer_type: Some(TransferType::RollIn),
..RecordsQuery::default()
};
let forced_liquidations = margin.forced_liquidations(records_query).await;
eprintln!("forced_liquidations = {forced_liquidations:?}");
let records_query = MarginOrderQuery {
symbol: "BTCUSDT".to_string(),
order_id: Some("1".to_string()),
orig_client_order_id: Some("my_id".to_string()),
is_isolated: None,
};
let order = margin.order(records_query).await;
eprintln!("order = {order:?}");
let open_orders = margin.open_orders("BTCUSDT", None).await;
eprintln!("open_orders = {open_orders:?}");
let records_query = MarginOrdersQuery {
symbol: "BTCUSDT".to_string(),
..MarginOrdersQuery::default()
};
let orders = margin.orders(records_query).await;
eprintln!("orders = {orders:?}");
let records_query = MarginOwnTradesQuery {
symbol: "BTCUSDT".to_string(),
..MarginOwnTradesQuery::default()
};
let trades = margin.trades(records_query).await;
eprintln!("trades = {trades:?}");
let records_query = MarginOCOOrderQuery {
symbol: Some("BTCUSDT".to_string()),
is_isolated: bool_to_string_some(true),
orig_client_order_id: Some("id".to_string()),
..MarginOCOOrderQuery::default()
};
let oco_order = margin.oco_order(records_query).await;
eprintln!("oco_order = {oco_order:?}");
let records_query = OCORecordsQuery {
symbol: Some("BTCUSDT".to_string()),
is_isolated: bool_to_string_some(true),
..OCORecordsQuery::default()
};
let all_oco_orders = margin.all_oco_orders(records_query).await;
eprintln!("all_oco_orders = {all_oco_orders:?}");
let max_borrowable = margin.max_borrowable("BTC", None).await;
eprintln!("max_borrowable = {max_borrowable:?}");
let max_transferable = margin.max_transferable("BTC", None).await;
eprintln!("max_transferable = {max_transferable:?}");
}
#[allow(dead_code)]
#[cfg(feature = "margin_api")]
async fn margin_post() {
use binance::api::*;
use binance::config::Config;
use binance::margin::Margin;
use binance::rest_model::*;
eprintln!("----------- Margin POST queries ----------");
let margin: Margin = Binance::new_with_env(&Config::testnet());
let transfer = margin
.transfer("BTC", 0.001, MarginTransferType::FromMainToMargin)
.await;
eprintln!("transfer = {transfer:?}");
let isolated_transfer = margin
.isolated_transfer(
"BTC",
"ETH",
0.001,
IsolatedMarginTransferType::Spot,
IsolatedMarginTransferType::IsolatedMargin,
)
.await;
eprintln!("isolated_transfer = {isolated_transfer:?}");
let loan = margin.loan("BTC", 0.001).await;
eprintln!("loan = {loan:?}");
let loan_with_isolation = margin
.loan_with_isolation("BTC", 0.001, Some(true), Some("BNB".to_string()))
.await;
eprintln!("loan_with_isolation = {loan_with_isolation:?}");
let repay = margin.repay("BTC", 0.001).await;
eprintln!("repay = {repay:?}");
let repay_with_isolation = margin
.repay_with_isolation("BTCUSDT", 0.001, Some(true), Some("BNB".to_string()))
.await;
eprintln!("repay_with_isolation = {repay_with_isolation:?}");
let margin_order = MarginOrder {
symbol: "BTCUSDT".to_string(),
side: OrderSide::Sell,
order_type: OrderType::Limit,
quantity: Some(0.001),
quote_order_qty: None,
price: Some(10.0),
stop_price: Some(10.0),
new_client_order_id: Some("my_id".to_string()),
iceberg_qty: Some(10.0),
new_order_resp_type: OrderResponse::Ack,
time_in_force: Some(TimeInForce::FOK),
side_effect_type: SideEffectType::NoSideEffect,
is_isolated: None,
};
let new_order = margin.new_order(margin_order).await;
eprintln!("new_order = {new_order:?}");
let cancel_trade = margin
.cancel_trade("BTCUSDT", 1_u64, "my_id".to_string(), "my_next_id".to_string(), None)
.await;
eprintln!("cancel_trade = {cancel_trade:?}");
let cancel_oco_order = margin
.cancel_oco_order("BTCUSDT", 1_u64, "my_id".to_string(), "my_next_id".to_string(), None)
.await;
eprintln!("cancel_oco_order = {cancel_oco_order:?}");
let cancel_all_orders = margin.cancel_all_orders("BTCUSDT", None).await;
eprintln!("cancel_all_orders = {cancel_all_orders:?}");
let disable_isolated = margin.disable_isolated("BTCUSDT".to_string()).await;
eprintln!("disable_isolated = {disable_isolated:?}");
let enable_isolated = margin.enable_isolated("BTCUSDT".to_string()).await;
eprintln!("enable_isolated = {enable_isolated:?}");
let toggle_bnb_burn = margin.toggle_bnb_burn(BnbBurnQuery::default()).await;
eprintln!("toggle_bnb_burn = {toggle_bnb_burn:?}");
}