Struct TradeClient 

pub struct TradeClient { /* private fields */ }

Places, amends and cancels orders over the order entry stream (/v5/trade), matching replies to requests by reqId.

Built on Stream: it authenticates on every (re)connect with the credentials and ServerClock of the Config; requests are accepted once Event::Authenticated arrived. Requests in flight when the connection drops fail with Error::ConnectionLost and are not resent: check the order (e.g. by orderLinkId) before retrying.

The order entry stream is not available on demo trading; use testnet.

use bybit::{
    Category, Environment, OrderType, Side,
    http::PlaceOrderRequest,
    ws::{self, TradeClient},
};
use rust_decimal::dec;

let config = ws::Config::trade(Environment::Testnet)?.credentials("API_KEY", "API_SECRET");
let (trade, mut events) = TradeClient::new(config)?;
trade.connect().await?;
while let Some(event) = events.recv().await {
    if matches!(event, ws::Event::Authenticated) {
        break;
    }
}

let mut order = PlaceOrderRequest::new(
    Category::Linear,
    "BTCUSDT",
    Side::Buy,
    OrderType::Limit,
    dec!(0.001),
);
order.price = Some(dec!(10000));
let reply = trade.place_order(&order).await?;
println!("order id: {}", reply.data.order_id);

Implementations

impl TradeClient

pub fn new(config: Config) -> Result<(Self, Receiver<Event>), Error>

Spawn the stream driver (see Stream::new) and the reply router. Returns the client and the events that are not replies to its requests. Fails without credentials: the order entry stream requires authentication.

pub fn handle(&self) -> &Handle

The command handle of the underlying stream.

pub async fn connect(&self) -> Result<(), Error>

Open the connection; requests are accepted after Event::Authenticated.

pub async fn disconnect(&self) -> Result<(), Error>

Close the connection.

pub fn is_ready(&self) -> bool

true while connected and authenticated.

pub async fn place_order( &self, request: &PlaceOrderRequest, ) -> Result<TradeResponse<PlaceOrderResponse>, Error>

Create an order (order.create).

pub async fn amend_order( &self, request: &AmendOrderRequest, ) -> Result<TradeResponse<AmendOrderResponse>, Error>

Amend an order (order.amend).

pub async fn cancel_order( &self, request: &CancelOrderRequest, ) -> Result<TradeResponse<CancelOrderResponse>, Error>

Cancel an order (order.cancel).

pub async fn place_order_batch( &self, request: &PlaceOrderBatchRequest, ) -> Result<TradeResponse<List<PlaceOrderBatchResult>>, Error>

Create orders in a batch (order.create-batch); per-order results are in TradeResponse::ret_ext_info.

pub async fn amend_order_batch( &self, request: &AmendOrderBatchRequest, ) -> Result<TradeResponse<List<AmendOrderBatchResult>>, Error>

Amend orders in a batch (order.amend-batch).

pub async fn cancel_order_batch( &self, request: &CancelOrderBatchRequest, ) -> Result<TradeResponse<List<CancelOrderBatchResult>>, Error>

Cancel orders in a batch (order.cancel-batch).

Trait Implementations

impl Clone for TradeClient

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TradeClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.