Struct binance::margin::Margin[−][src]

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

Fields

client: Clientrecv_window: u64

Implementations

[src]

impl Margin

[src]

pub async fn transfer<S, F>(
 &self,
 symbol: S,
 qty: F,
 transfer_type: MarginTransferType
) -> Result<TransactionId> where
 S: Into<String>,
 F: Into<f64>,

Execute transfer between spot account and margin account.

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let transaction_id = tokio_test::block_on(margin.transfer("BTCUSDT", 0.001, MarginTransferType::FromMainToMargin));
assert!(transaction_id.is_ok(), "{:?}", transaction_id);

[src]

pub async fn loan<S, F>(&self, symbol: S, qty: F) -> Result<TransactionId> where
S: Into<String>,
F: Into<f64>,

Apply for a loan.

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let transaction_id = tokio_test::block_on(margin.loan("BTCUSDT", 0.001));
assert!(transaction_id.is_ok(), "{:?}", transaction_id);

[src]

pub async fn repay<S, F>(&self, symbol: S, qty: F) -> Result<TransactionId> where
S: Into<String>,
F: Into<f64>,

Repay loan for margin account.

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let transaction_id = tokio_test::block_on(margin.repay("BTCUSDT", 0.001));
assert!(transaction_id.is_ok(), "{:?}", transaction_id);

[src]

pub async fn trade(&self, margin_order: MarginOrder) -> Result<TransactionId>

Post a new order for margin account.

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let margin_order = MarginOrder {
    symbol: "BTCUSDT".to_string(),
    side: OrderSide::Sell,
    order_type: OrderType::Limit,
    quantity: 0.001,
    price: 10.0,
    stop_price: 10.0,
    new_client_order_id: "my_id".to_string(),
    iceberg_qty: 10.0,
    new_order_resp_type: OrderResponse::Ack,
    time_in_force: TimeInForce::FOK
};
let transaction_id = tokio_test::block_on(margin.trade(margin_order));
assert!(transaction_id.is_ok(), "{:?}", transaction_id);

[src]

pub async fn cancel_trade<S, F>(
 &self,
 symbol: S,
 order_id: F,
 orig_client_order_id: String,
 new_client_order_id: String
) -> Result<TransactionId> where
 S: Into<String>,
 F: Into<u64>,

Cancel an existing order

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let transaction_id = tokio_test::block_on(margin.cancel_trade("BTCUSDT", 1_u64, "my_id".to_string(), "my_next_id".to_string()));
assert!(transaction_id.is_ok(), "{:?}", transaction_id);

[src]

pub async fn loans(
&self,
loan_query: RecordsQuery
) -> Result<RecordsQueryResult<LoanState>>

Get existing loan records

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let loan_query = RecordsQuery {
   asset: "BTC".to_string(),
   tx_id: None,
   start_time: None,
   end_time: None,
   current: None,
   size: None,
   transfer_type: Some(TransferType::RollIn)
};
let records = tokio_test::block_on(margin.loans(loan_query));
assert!(records.is_ok(), "{:?}", records);

[src]

pub async fn repays(
&self,
repays_query: RecordsQuery
) -> Result<RecordsQueryResult<RepayState>>

Get existing repay records history

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let records_query = RecordsQuery {
   asset: "BTC".to_string(),
   tx_id: None,
   start_time: None,
   end_time: None,
   current: None,
   size: None,
   transfer_type: Some(TransferType::RollIn)
};
let records = tokio_test::block_on(margin.repays(records_query));
assert!(records.is_ok(), "{:?}", records);

[src]

pub async fn details(&self) -> Result<MarginAccountDetails>

Get margin account details

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let account_details = tokio_test::block_on(margin.details());
assert!(account_details.is_ok(), "{:?}", account_details);

[src]

pub async fn asset<S>(&self, asset: S) -> Result<AssetDetails> where
S: Into<String>,

Get asset details

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let asset_detail = tokio_test::block_on(margin.asset("BTC"));
assert!(asset_detail.is_ok(), "{:?}", asset_detail);

[src]

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

Get margin pair market data

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let pair_details = tokio_test::block_on(margin.pair("BTCUSDT"));
assert!(pair_details.is_ok(), "{:?}", pair_details);

[src]

pub async fn all_assets(&self) -> Result<AllAssets>

Get all assets details

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let all_assets = tokio_test::block_on(margin.all_assets());
assert!(all_assets.is_ok(), "{:?}", all_assets);

[src]

pub async fn all_pairs(&self) -> Result<AllPairs>

Get all pair details

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let all_pairs = tokio_test::block_on(margin.all_pairs());
assert!(all_pairs.is_ok(), "{:?}", all_pairs);

[src]

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

Get price index

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let price_index = tokio_test::block_on(margin.price_index("BTCUSDT"));
assert!(price_index.is_ok(), "{:?}", price_index);

[src]

pub async fn transfers(
&self,
transfers_query: RecordsQuery
) -> Result<RecordsQueryResult<OrderState>>

Get transfer history

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let records_query = RecordsQuery {
   asset: "BTC".to_string(),
   tx_id: None,
   start_time: None,
   end_time: None,
   current: None,
   size: None,
   transfer_type: Some(TransferType::RollIn)
};
let records = tokio_test::block_on(margin.transfers(records_query));
assert!(records.is_ok(), "{:?}", records);

[src]

pub async fn interests(
&self,
interest_query: RecordsQuery
) -> Result<RecordsQueryResult<InterestState>>

Get interest history

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let records_query = RecordsQuery {
   asset: "BTC".to_string(),
   tx_id: None,
   start_time: None,
   end_time: None,
   current: None,
   size: None,
   transfer_type: Some(TransferType::RollIn)
};
let records = tokio_test::block_on(margin.interests(records_query));
assert!(records.is_ok(), "{:?}", records);

[src]

pub async fn forced_liquidations(
&self,
forced_liquidations_query: RecordsQuery
) -> Result<RecordsQueryResult<ForcedLiquidationState>>

Get forced liquidation history

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let records_query = RecordsQuery {
   asset: "BTC".to_string(),
   tx_id: None,
   start_time: None,
   end_time: None,
   current: None,
   size: None,
   transfer_type: Some(TransferType::RollIn)
};
let records = tokio_test::block_on(margin.forced_liquidations(records_query));
assert!(records.is_ok(), "{:?}", records);

[src]

pub async fn order(
&self,
margin_order: MarginOrderQuery
) -> Result<MarginOrderState>

Get an existing order state

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let records_query = MarginOrderQuery {
    symbol: "BTCUSDT".to_string(),
    order_id: "1".to_string(),
    orig_client_order_id: "my_id".to_string(),
};
let records = tokio_test::block_on(margin.order(records_query));
assert!(records.is_ok(), "{:?}", records);

[src]

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

Get open orders

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let order_state = tokio_test::block_on(margin.open_orders("BTCUSDT"));
assert!(order_state.is_ok(), "{:?}", order_state);

[src]

pub async fn orders(
&self,
all_orders_query: RecordsQuery
) -> Result<RecordsQueryResult<OrderSumaryState>>

Get all orders

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let records_query = RecordsQuery {
   asset: "BTC".to_string(),
   tx_id: None,
   start_time: None,
   end_time: None,
   current: None,
   size: None,
   transfer_type: Some(TransferType::RollIn)
};
let records = tokio_test::block_on(margin.orders(records_query));
assert!(records.is_ok(), "{:?}", records);

[src]

pub async fn trades(
&self,
all_orders_query: RecordsQuery
) -> Result<RecordsQueryResult<OwnTradesState>>

Get all trades

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let records_query = RecordsQuery {
   asset: "BTC".to_string(),
   tx_id: None,
   start_time: None,
   end_time: None,
   current: None,
   size: None,
   transfer_type: Some(TransferType::RollIn)
};
let records = tokio_test::block_on(margin.trades(records_query));
assert!(records.is_ok(), "{:?}", records);

[src]

pub async fn max_borrowable<S>(&self, asset: S) -> Result<MaxAmount> where
S: Into<String>,

Get max borrowable

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let max = tokio_test::block_on(margin.max_borrowable("BTC"));
assert!(max.is_ok(), "{:?}", max);

[src]

pub async fn max_transferable<S>(&self, asset: S) -> Result<MaxAmount> where
S: Into<String>,

Get max transferable

Examples

use binance::{api::*, margin::*, config::*, rest_model::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let max = tokio_test::block_on(margin.max_transferable("BTC"));
assert!(max.is_ok(), "{:?}", max);

[src]

pub async fn start(&self) -> Result<UserDataStream>

Start user data stream

Examples

use binance::{api::*, margin::*, config::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let start = tokio_test::block_on(margin.start());
assert!(start.is_ok(), "{:?}", start);
assert!(start.unwrap().listen_key.len() > 0)

[src]

pub async fn keep_alive(&self, listen_key: &str) -> Result<Success>

Current open orders on a symbol

Examples

use binance::{api::*, margin::*, config::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let start = tokio_test::block_on(margin.start());
assert!(start.is_ok(), "{:?}", start);
let keep_alive = tokio_test::block_on(margin.keep_alive(&start.unwrap().listen_key));
assert!(keep_alive.is_ok())

[src]

pub async fn close(&self, listen_key: &str) -> Result<Success>

Close the user stream

Examples

use binance::{api::*, margin::*, config::*};
let margin: Margin = Binance::new_with_env(&Config::testnet());
let start = tokio_test::block_on(margin.start());
assert!(start.is_ok(), "{:?}", start);
let close = tokio_test::block_on(margin.close(&start.unwrap().listen_key));
assert!(close.is_ok())

Trait Implementations

[src]

impl Binance for Margin

[src]

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

[src]

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

[src]

fn new_with_env(config: &Config) -> Self

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

[src]

impl Clone for Margin

[src]

fn clone(&self) -> Margin

Returns a copy of the value. Read more

1.0.0[src]

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

Performs copy-assignment from source. Read more

Auto Trait Implementations

impl !RefUnwindSafe for Margin

impl Send for Margin

impl Sync for Margin

impl Unpin for Margin

impl !UnwindSafe for Margin

Blanket Implementations

[src]

impl<T> Any for T where
T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

impl<T> Borrow<T> for T where
T: ?Sized,

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

impl<T> BorrowMut<T> for T where
T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

[src]

impl<T> Instrument for T

[src]

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

[src]

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

[src]

impl<T, U> Into for T where
U: From<T>,

[src]

pub fn into(self) -> U

Performs the conversion.

impl<T> Same<T> for T

type Output = T

Should always be Self

[src]

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

[src]

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

[src]

pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

[src]

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

[src]

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

[src]

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct binance::margin::Margin[−][src]

Fields

Implementations

impl Margin

pub async fn transfer<S, F>( &self, symbol: S, qty: F, transfer_type: MarginTransferType) -> Result<TransactionId> where S: Into<String>, F: Into<f64>,

pub async fn loan<S, F>(&self, symbol: S, qty: F) -> Result<TransactionId> where S: Into<String>, F: Into<f64>,

pub async fn repay<S, F>(&self, symbol: S, qty: F) -> Result<TransactionId> where S: Into<String>, F: Into<f64>,

pub async fn trade(&self, margin_order: MarginOrder) -> Result<TransactionId>

pub async fn cancel_trade<S, F>( &self, symbol: S, order_id: F, orig_client_order_id: String, new_client_order_id: String) -> Result<TransactionId> where S: Into<String>, F: Into<u64>,

pub async fn loans( &self, loan_query: RecordsQuery) -> Result<RecordsQueryResult<LoanState>>

pub async fn repays( &self, repays_query: RecordsQuery) -> Result<RecordsQueryResult<RepayState>>

pub async fn details(&self) -> Result<MarginAccountDetails>

pub async fn asset<S>(&self, asset: S) -> Result<AssetDetails> where S: Into<String>,

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

pub async fn all_assets(&self) -> Result<AllAssets>

pub async fn all_pairs(&self) -> Result<AllPairs>

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

pub async fn transfers( &self, transfers_query: RecordsQuery) -> Result<RecordsQueryResult<OrderState>>

pub async fn interests( &self, interest_query: RecordsQuery) -> Result<RecordsQueryResult<InterestState>>

pub async fn forced_liquidations( &self, forced_liquidations_query: RecordsQuery) -> Result<RecordsQueryResult<ForcedLiquidationState>>

pub async fn order( &self, margin_order: MarginOrderQuery) -> Result<MarginOrderState>

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

pub async fn orders( &self, all_orders_query: RecordsQuery) -> Result<RecordsQueryResult<OrderSumaryState>>

pub async fn trades( &self, all_orders_query: RecordsQuery) -> Result<RecordsQueryResult<OwnTradesState>>

pub async fn max_borrowable<S>(&self, asset: S) -> Result<MaxAmount> where S: Into<String>,

pub async fn max_transferable<S>(&self, asset: S) -> Result<MaxAmount> where S: Into<String>,

pub async fn start(&self) -> Result<UserDataStream>

pub async fn keep_alive(&self, listen_key: &str) -> Result<Success>

pub async fn close(&self, listen_key: &str) -> Result<Success>

Trait Implementations

impl Binance for Margin

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

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

fn new_with_env(config: &Config) -> Self

impl Clone for Margin

fn clone(&self) -> Margin

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

Auto Trait Implementations

impl !RefUnwindSafe for Margin

impl Send for Margin

impl Sync for Margin

impl Unpin for Margin

impl !UnwindSafe for Margin

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

impl<T> Same<T> for T

type Output = T

impl<T> ToOwned for T where T: Clone,

type Owned = T

pub fn to_owned(&self) -> T

pub fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip<V> for T where V: MultiLane<T>,

pub fn vzip(self) -> V

pub async fn transfer<S, F>(
&self,
symbol: S,
qty: F,
transfer_type: MarginTransferType
) -> Result<TransactionId> where
S: Into<String>,
F: Into<f64>,

pub async fn loan<S, F>(&self, symbol: S, qty: F) -> Result<TransactionId> where
S: Into<String>,
F: Into<f64>,

pub async fn repay<S, F>(&self, symbol: S, qty: F) -> Result<TransactionId> where
S: Into<String>,
F: Into<f64>,

pub async fn cancel_trade<S, F>(
&self,
symbol: S,
order_id: F,
orig_client_order_id: String,
new_client_order_id: String
) -> Result<TransactionId> where
S: Into<String>,
F: Into<u64>,

pub async fn loans(
&self,
loan_query: RecordsQuery
) -> Result<RecordsQueryResult<LoanState>>

pub async fn repays(
&self,
repays_query: RecordsQuery
) -> Result<RecordsQueryResult<RepayState>>

pub async fn asset<S>(&self, asset: S) -> Result<AssetDetails> where
S: Into<String>,

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

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

pub async fn transfers(
&self,
transfers_query: RecordsQuery
) -> Result<RecordsQueryResult<OrderState>>

pub async fn interests(
&self,
interest_query: RecordsQuery
) -> Result<RecordsQueryResult<InterestState>>

pub async fn forced_liquidations(
&self,
forced_liquidations_query: RecordsQuery
) -> Result<RecordsQueryResult<ForcedLiquidationState>>

pub async fn order(
&self,
margin_order: MarginOrderQuery
) -> Result<MarginOrderState>

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

pub async fn orders(
&self,
all_orders_query: RecordsQuery
) -> Result<RecordsQueryResult<OrderSumaryState>>

pub async fn trades(
&self,
all_orders_query: RecordsQuery
) -> Result<RecordsQueryResult<OwnTradesState>>

pub async fn max_borrowable<S>(&self, asset: S) -> Result<MaxAmount> where
S: Into<String>,

pub async fn max_transferable<S>(&self, asset: S) -> Result<MaxAmount> where
S: Into<String>,

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

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> ToOwned for T where
T: Clone,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

impl<V, T> VZip<V> for T where
V: MultiLane<T>,