Struct CreatePriceOrder 

pub struct CreatePriceOrder {
    pub trigger: SpotPriceTrigger,
    pub put: SpotPricePutOrder,
    pub market: String,
    pub x_gate_exp_time: Option<u128>,
    pub credentials: Option<Credentials>,
}

Create a price-triggered order

A price-triggered order (also known as conditional order) will not enter the order book until the trigger condition is met. Once triggered, it will attempt to place a limit order at the preset price and amount.

Important Notes:

• The conditional order does not occupy your balance until it is triggered
• Make sure to set aside enough balance for this order
• A price condition order can only be triggered one time
• When using “<=”, the trigger price should be less than the current market price
• When using “>=”, the trigger price should be greater than the current market price
• Only limit orders are supported as the triggered order type

Status Values:

• “open” : Waiting to trigger
• “cancelled” : Manually cancelled
• “finish” : Successfully executed
• “failed” : Failed to execute
• “expired” : Expired

Gate API Documentation

Fields

trigger: SpotPriceTrigger

Trigger conditions for the order

put: SpotPricePutOrder

Order details to execute when triggered

market: String

Currency pair for the order

x_gate_exp_time: Option<u128>

Request expiration time in milliseconds

credentials: Option<Credentials>

API credentials for authentication

Implementations

impl CreatePriceOrder

pub fn new( market: &str, trigger_price: &str, trigger_rule: &str, order_side: &str, order_price: &str, order_amount: &str, ) -> Self

Create a new price-triggered order request

pub fn trigger(self, trigger: SpotPriceTrigger) -> Self

Set the trigger conditions

pub fn put(self, put: SpotPricePutOrder) -> Self

Set the order details to execute when triggered

pub fn trigger_expiration(self, expiration: i64) -> Self

Set the trigger expiration time in seconds

Examples found in repository

examples/sync/create_price_order.rs (line 26)

fn main() -> Result<(), Box<gateio_rs::ureq::Error>> {
    dotenv::dotenv().ok();

    let api_key = std::env::var("GATE_API_KEY").expect("GATE_API_KEY not set");
    let api_secret = std::env::var("GATE_API_SECRET").expect("GATE_API_SECRET not set");
    let credentials = Credentials::new(api_key, api_secret);

    let client = GateHttpClient::default().credentials(credentials.clone());

    // Create a price-triggered order
    // This example creates a buy order that will trigger when BTC price goes above $50,000
    // When triggered, it will place a limit buy order for 0.001 BTC at $49,900
    let req = spot::create_price_order(
        "BTC_USDT", // market (currency pair)
        "120000",   // trigger_price
        ">=",       // trigger_rule (trigger when price >= $50,000)
        "buy",      // order_side
        "49900",    // order_price (limit price when triggered)
        "0.001",    // order_amount
    )
    .account("normal") // use normal spot account
    .time_in_force("gtc") // good till cancelled
    .trigger_expiration(86400); // expire after 24 hours if not triggered

    println!("Sending price-triggered order request...");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let resp_obj: Value = serde_json::from_str(&body).unwrap();

    println!("Response: {:#}", resp_obj);

    Ok(())
}

pub fn account(self, account: &str) -> Self

Set the trading account type for the triggered order

Examples found in repository

examples/sync/create_price_order.rs (line 24)

fn main() -> Result<(), Box<gateio_rs::ureq::Error>> {
    dotenv::dotenv().ok();

    let api_key = std::env::var("GATE_API_KEY").expect("GATE_API_KEY not set");
    let api_secret = std::env::var("GATE_API_SECRET").expect("GATE_API_SECRET not set");
    let credentials = Credentials::new(api_key, api_secret);

    let client = GateHttpClient::default().credentials(credentials.clone());

    // Create a price-triggered order
    // This example creates a buy order that will trigger when BTC price goes above $50,000
    // When triggered, it will place a limit buy order for 0.001 BTC at $49,900
    let req = spot::create_price_order(
        "BTC_USDT", // market (currency pair)
        "120000",   // trigger_price
        ">=",       // trigger_rule (trigger when price >= $50,000)
        "buy",      // order_side
        "49900",    // order_price (limit price when triggered)
        "0.001",    // order_amount
    )
    .account("normal") // use normal spot account
    .time_in_force("gtc") // good till cancelled
    .trigger_expiration(86400); // expire after 24 hours if not triggered

    println!("Sending price-triggered order request...");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let resp_obj: Value = serde_json::from_str(&body).unwrap();

    println!("Response: {:#}", resp_obj);

    Ok(())
}

pub fn time_in_force(self, time_in_force: &str) -> Self

Set the time in force for the triggered order

Examples found in repository

examples/sync/create_price_order.rs (line 25)

fn main() -> Result<(), Box<gateio_rs::ureq::Error>> {
    dotenv::dotenv().ok();

    let api_key = std::env::var("GATE_API_KEY").expect("GATE_API_KEY not set");
    let api_secret = std::env::var("GATE_API_SECRET").expect("GATE_API_SECRET not set");
    let credentials = Credentials::new(api_key, api_secret);

    let client = GateHttpClient::default().credentials(credentials.clone());

    // Create a price-triggered order
    // This example creates a buy order that will trigger when BTC price goes above $50,000
    // When triggered, it will place a limit buy order for 0.001 BTC at $49,900
    let req = spot::create_price_order(
        "BTC_USDT", // market (currency pair)
        "120000",   // trigger_price
        ">=",       // trigger_rule (trigger when price >= $50,000)
        "buy",      // order_side
        "49900",    // order_price (limit price when triggered)
        "0.001",    // order_amount
    )
    .account("normal") // use normal spot account
    .time_in_force("gtc") // good till cancelled
    .trigger_expiration(86400); // expire after 24 hours if not triggered

    println!("Sending price-triggered order request...");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let resp_obj: Value = serde_json::from_str(&body).unwrap();

    println!("Response: {:#}", resp_obj);

    Ok(())
}

pub fn x_gate_exp_time(self, x_gate_exp_time: u128) -> Self

Specify the expiration time (milliseconds); If the GATE receives the request time greater than the expiration time, the request will be rejected

pub fn credentials(self, creds: Credentials) -> Self

Set API credentials for authentication

Trait Implementations

impl From<CreatePriceOrder> for Request

fn from(request: CreatePriceOrder) -> Request

Converts to this type from the input type.