Struct Client 

pub struct Client {
    pub transport: Arc<Transport>,
    pub registry: Arc<Mutex<HashMap<String, Sender<ProtoMessage>>>>,
    pub config: Config,
    pub event_handler: Option<Arc<dyn Fn(ProtoMessage) + Send + Sync>>,
}

The main client. Construct with Client::start.

Fields

transport: Arc<Transport>

registry: Arc<Mutex<HashMap<String, Sender<ProtoMessage>>>>

config: Config

event_handler: Option<Arc<dyn Fn(ProtoMessage) + Send + Sync>>

Called for every unsolicited event (spot, execution, …).

Implementations

impl Client

pub async fn account_logout( &self, ctid_trader_account_id: i64, ) -> Result<ProtoOaAccountLogoutRes, Error>

Log out a trader account (does not disconnect the TCP session).

pub async fn get_accounts_by_access_token( &self, access_token: &str, ) -> Result<ProtoOaGetAccountListByAccessTokenRes, Error>

Return all trader accounts linked to the given OAuth access token.

Mirrors ProtoOAGetAccountListByAccessTokenReq.

Examples found in repository

examples/get_accounts.rs (line 30)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("get_accounts=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let token = std::env::var("CTRADER_TOKEN")?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Fetch all accounts linked to the token
    let res = client.get_accounts_by_access_token(&token).await?;

    if res.ctid_trader_account.is_empty() {
        tracing::debug!("No accounts found for this access token.");
    } else {
        tracing::debug!("\nFound {} account(s):\n", res.ctid_trader_account.len());
        tracing::debug!(
            "{:<25} {:<8} {:<15} {}",
            "ctidTradingAccountId",
            "Type",
            "TraderLogin",
            "Broker"
        );
        tracing::debug!("{}", "-".repeat(65));
        for acc in &res.ctid_trader_account {
            tracing::debug!(
                "{:<25} {:<8} {:<15} {}",
                acc.ctid_trader_account_id,
                if acc.is_live.unwrap_or(false) {
                    "live"
                } else {
                    "demo"
                },
                acc.trader_login.unwrap_or(0),
                acc.broker_title_short.as_deref().unwrap_or(""),
            );
        }
    }

    Ok(())
}

pub async fn get_trader( &self, ctid_trader_account_id: i64, ) -> Result<ProtoOaTraderRes, Error>

Get full trader/account info (balance, leverage, currency, etc.).

Examples found in repository

examples/get_trader.rs (line 28)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("new_order=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    let res = client.get_trader(account_id).await?;

    tracing::info!("Trader: {:?}", res);

    Ok(())
}

impl Client

pub async fn asset_list( &self, ctid_trader_account_id: i64, ) -> Result<ProtoOaSymbolsListRes, Error>

List all assets for the given account.

Mirrors ProtoOASymbolsListReq.

pub async fn asset_class_list( &self, ctid_trader_account_id: i64, ) -> Result<ProtoOaAssetClassListRes, Error>

List all symbols for the given account.

Mirrors ProtoOASymbolsListReq.

impl Client

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

Application auth

pub async fn account_auth( &self, ctid_trader_account_id: i64, access_token: &str, ) -> Result<ProtoOaAccountAuthRes, Error>

Authenticate a trader account. Must be called before any account-scoped request (symbols, deals, orders, …).

Mirrors ProtoOAAccountAuthReq in the Go integration test.

Examples found in repository

examples/new_order.rs (line 30)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("new_order=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let token = std::env::var("CTRADER_TOKEN")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Authenticate the account
    let auth_res = client.account_auth(account_id, &token).await?;
    assert_eq!(auth_res.ctid_trader_account_id, account_id);
    tracing::debug!("✓ Account {account_id} authenticated");

    let res = client
        .new_market_order(account_id, 41, ProtoOaTradeSide::Buy, 100000)
        .await?;

    tracing::debug!("{:?}", res);

    // let res = client
    //     .new_limit_order(account_id, 41, ProtoOaTradeSide::Buy, 1000, 4800.00)
    //     .await?;

    // tracing::debug!("{:?}", res);

    // let res = client
    //     .new_stop_loss_take_profit_order(account_id, 41, ProtoOaTradeSide::Buy, 100_000, 500, 1000)
    //     .await?;

    // tracing::debug!("{:?}", res);

    // let res = client
    //     .new_market_range_order(account_id, 41, ProtoOaTradeSide::Buy, 1000)
    //     .await?;

    // tracing::debug!("{:?}", res);

    loop {}
}

examples/symbols_list.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("symbols_list=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let token = std::env::var("CTRADER_TOKEN")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    println!("Connecting …");
    let client = Client::start(config).await?;
    println!("✓ Connected");

    // Authenticate the account
    let auth_res = client.account_auth(account_id, &token).await?;
    assert_eq!(auth_res.ctid_trader_account_id, account_id);
    println!("✓ Account {account_id} authenticated");

    // Fetch symbol list
    let res = client.symbols_list(account_id, false).await?;
    println!("\nTotal symbols: {}", res.symbol.len());

    // Verify XAUUSD is present (same assertion as the Go test)
    let xauusd = res
        .symbol
        .iter()
        .find(|s| s.symbol_name.as_deref() == Some("XAUUSD"));

    match xauusd {
        Some(sym) => println!(
            "✓ XAUUSD found  (id={}, enabled={})",
            sym.symbol_id,
            sym.enabled.unwrap_or(false)
        ),
        None => println!("✗ XAUUSD NOT found in symbol list"),
    }

    // Print first 10 symbols
    println!("\nFirst 10 symbols:");
    println!("{:<10} {:<15} {}", "ID", "Name", "Enabled");
    println!("{}", "-".repeat(35));
    for sym in res.symbol.iter().take(10) {
        println!(
            "{:<10} {:<15} {}",
            sym.symbol_id,
            sym.symbol_name.as_deref().unwrap_or(""),
            sym.enabled.unwrap_or(false),
        );
    }

    Ok(())
}

pub async fn refresh_token( &self, refresh_token: &str, ) -> Result<ProtoOaRefreshTokenRes, Error>

Refresh an expired access token.

impl Client

pub async fn start(config: Config) -> Result<Self, Error>

Connect, authenticate the application, and start the keepalive task.

Examples found in repository

examples/version.rs (line 25)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("version=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Fetch all accounts linked to the token
    let res = client.version().await?;

    tracing::debug!("Version: {}", res.version);

    Ok(())
}

examples/get_trader.rs (line 25)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("new_order=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    let res = client.get_trader(account_id).await?;

    tracing::info!("Trader: {:?}", res);

    Ok(())
}

examples/get_position_unrealized_pnl.rs (line 25)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("new_order=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    let res = client.position_unrealized_pnl(account_id).await?;

    tracing::info!("Position Unrealized PnL: {:?}", res);

    Ok(())
}

examples/subscribe.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("get_accounts=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let account_id = std::env::var("CTRADER_ACCOUNT_ID")?.parse::<i64>()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Fetch all accounts linked to the token
    let res = client.subscribe_symbol(vec![61], account_id).await?;

    println!("{:?}", res);

    Ok(())
}

examples/new_order.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("new_order=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let token = std::env::var("CTRADER_TOKEN")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Authenticate the account
    let auth_res = client.account_auth(account_id, &token).await?;
    assert_eq!(auth_res.ctid_trader_account_id, account_id);
    tracing::debug!("✓ Account {account_id} authenticated");

    let res = client
        .new_market_order(account_id, 41, ProtoOaTradeSide::Buy, 100000)
        .await?;

    tracing::debug!("{:?}", res);

    // let res = client
    //     .new_limit_order(account_id, 41, ProtoOaTradeSide::Buy, 1000, 4800.00)
    //     .await?;

    // tracing::debug!("{:?}", res);

    // let res = client
    //     .new_stop_loss_take_profit_order(account_id, 41, ProtoOaTradeSide::Buy, 100_000, 500, 1000)
    //     .await?;

    // tracing::debug!("{:?}", res);

    // let res = client
    //     .new_market_range_order(account_id, 41, ProtoOaTradeSide::Buy, 1000)
    //     .await?;

    // tracing::debug!("{:?}", res);

    loop {}
}

examples/get_accounts.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("get_accounts=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let token = std::env::var("CTRADER_TOKEN")?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Fetch all accounts linked to the token
    let res = client.get_accounts_by_access_token(&token).await?;

    if res.ctid_trader_account.is_empty() {
        tracing::debug!("No accounts found for this access token.");
    } else {
        tracing::debug!("\nFound {} account(s):\n", res.ctid_trader_account.len());
        tracing::debug!(
            "{:<25} {:<8} {:<15} {}",
            "ctidTradingAccountId",
            "Type",
            "TraderLogin",
            "Broker"
        );
        tracing::debug!("{}", "-".repeat(65));
        for acc in &res.ctid_trader_account {
            tracing::debug!(
                "{:<25} {:<8} {:<15} {}",
                acc.ctid_trader_account_id,
                if acc.is_live.unwrap_or(false) {
                    "live"
                } else {
                    "demo"
                },
                acc.trader_login.unwrap_or(0),
                acc.broker_title_short.as_deref().unwrap_or(""),
            );
        }
    }

    Ok(())
}

Additional examples can be found in:

• examples/symbols_list.rs

pub async fn start_with_handler( config: Config, handler: Option<impl Fn(ProtoMessage) + Send + Sync + 'static>, ) -> Result<Self, Error>

Same as [start] but with an event handler for unsolicited messages.

pub async fn command<Q, R>( &self, req_type: u32, req: Q, res_type: u32, ) -> Result<R, Error>

where Q: Message, R: Message + Default,

Encode req, send it, await the response envelope whose payloadType matches res_type, and decode it as R.

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

Get the API version from the server.

Examples found in repository

examples/version.rs (line 29)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("version=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Fetch all accounts linked to the token
    let res = client.version().await?;

    tracing::debug!("Version: {}", res.version);

    Ok(())
}

impl Client

pub async fn deal_list( &self, ctid_trader_account_id: i64, from_timestamp: i64, to_timestamp: i64, max_rows: Option<i32>, ) -> Result<ProtoOaDealListRes, Error>

List deals (filled order history) filtered by time range.

Timestamps are Unix milliseconds. max_rows caps the result set.

pub async fn deal_list_by_position( &self, ctid_trader_account_id: i64, position_id: i64, from_timestamp: Option<i64>, to_timestamp: Option<i64>, ) -> Result<ProtoOaDealListByPositionIdRes, Error>

List deals associated with a specific position.

pub async fn deal_offset_list( &self, ctid_trader_account_id: i64, deal_id: i64, ) -> Result<ProtoOaDealOffsetListRes, Error>

impl Client

pub async fn get_margin_call_list( &self, ctid_trader_account_id: i64, ) -> Result<ProtoOaMarginCallListRes, Error>

Get active margin calls for the account.

pub async fn get_expected_margin( &self, ctid_trader_account_id: i64, symbol_id: i64, volume: Vec<i64>, ) -> Result<ProtoOaExpectedMarginRes, Error>

Calculate expected margin for a list of volumes on a symbol.

Useful for pre-trade checks before placing an order. Note: moneyDigits in the response specifies the monetary scale factor.

impl Client

pub async fn get_cash_flow_history( &self, ctid_trader_account_id: i64, from_timestamp: i64, to_timestamp: i64, ) -> Result<ProtoOaCashFlowHistoryListRes, Error>

Get cash flow history (deposits, withdrawals) for a time range.

Max range: 1 week (604 800 000 ms). Timestamps in Unix milliseconds.

pub async fn get_dynamic_leverage( &self, ctid_trader_account_id: i64, leverage_id: i64, ) -> Result<ProtoOaGetDynamicLeverageByIdRes, Error>

Get leverage details for a given leverage ID.

impl Client

pub async fn new_market_order( &self, ctid_trader_account_id: i64, symbol_id: i64, trade_side: ProtoOaTradeSide, volume: i64, ) -> Result<ProtoOaExecutionEvent, Error>

Place a market order (immediate fill at best available price).

volume is in units of 0.01 lots: 100 = 0.01 lot, 100_000 = 1 lot.

Examples found in repository

examples/new_order.rs (line 35)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("new_order=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let token = std::env::var("CTRADER_TOKEN")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Authenticate the account
    let auth_res = client.account_auth(account_id, &token).await?;
    assert_eq!(auth_res.ctid_trader_account_id, account_id);
    tracing::debug!("✓ Account {account_id} authenticated");

    let res = client
        .new_market_order(account_id, 41, ProtoOaTradeSide::Buy, 100000)
        .await?;

    tracing::debug!("{:?}", res);

    // let res = client
    //     .new_limit_order(account_id, 41, ProtoOaTradeSide::Buy, 1000, 4800.00)
    //     .await?;

    // tracing::debug!("{:?}", res);

    // let res = client
    //     .new_stop_loss_take_profit_order(account_id, 41, ProtoOaTradeSide::Buy, 100_000, 500, 1000)
    //     .await?;

    // tracing::debug!("{:?}", res);

    // let res = client
    //     .new_market_range_order(account_id, 41, ProtoOaTradeSide::Buy, 1000)
    //     .await?;

    // tracing::debug!("{:?}", res);

    loop {}
}

pub async fn new_market_order_with_sltp( &self, ctid_trader_account_id: i64, symbol_id: i64, trade_side: ProtoOaTradeSide, volume: i64, relative_stop_loss: i64, relative_take_profit: i64, ) -> Result<ProtoOaExecutionEvent, Error>

Place a market order with relative SL/TP (distance from fill price).

relative_stop_loss and relative_take_profit are in 1/100000 of a price unit. 1 pip on a 5-decimal pair = 10 points = 1000 in protocol.

For a BUY: SL = fillPrice − relSL, TP = fillPrice + relTP For a SELL: SL = fillPrice + relSL, TP = fillPrice − relTP

Helper: pips_to_points(n) converts pip count → protocol value.

pub async fn new_market_order_with_trailing_sl( &self, ctid_trader_account_id: i64, symbol_id: i64, trade_side: ProtoOaTradeSide, volume: i64, relative_stop_loss: i64, ) -> Result<ProtoOaExecutionEvent, Error>

Market order with trailing stop loss (relative distance).

pub async fn new_market_range_order( &self, ctid_trader_account_id: i64, symbol_id: i64, trade_side: ProtoOaTradeSide, volume: i64, base_slippage_price: f64, slippage_in_points: i32, ) -> Result<ProtoOaExecutionEvent, Error>

Market range order — fills within a slippage band around base_price.

slippage_in_points is the maximum allowed deviation in points.

pub async fn new_limit_order( &self, ctid_trader_account_id: i64, symbol_id: i64, trade_side: ProtoOaTradeSide, volume: i64, limit_price: f64, stop_loss: Option<f64>, take_profit: Option<f64>, ) -> Result<ProtoOaExecutionEvent, Error>

Place a limit order (fill when price reaches limit_price or better).

stop_loss and take_profit are absolute price levels. Leave as None to omit them.

pub async fn new_stop_order( &self, ctid_trader_account_id: i64, symbol_id: i64, trade_side: ProtoOaTradeSide, volume: i64, stop_price: f64, stop_loss: Option<f64>, take_profit: Option<f64>, ) -> Result<ProtoOaExecutionEvent, Error>

Place a stop order (fill when price breaks through stop_price).

stop_loss and take_profit are absolute price levels.

pub async fn new_stop_limit_order( &self, ctid_trader_account_id: i64, symbol_id: i64, trade_side: ProtoOaTradeSide, volume: i64, stop_price: f64, slippage_in_points: i32, stop_loss: Option<f64>, take_profit: Option<f64>, ) -> Result<ProtoOaExecutionEvent, Error>

Place a stop-limit order (pending stop that becomes a limit on trigger).

stop_price — price level that triggers the order. slippage_in_points — max deviation from stop price for the limit fill.

pub async fn cancel_order( &self, ctid_trader_account_id: i64, order_id: i64, ) -> Result<ProtoOaExecutionEvent, Error>

Cancel an existing pending order.

pub async fn amend_order( &self, ctid_trader_account_id: i64, order_id: i64, volume: Option<i64>, limit_price: Option<f64>, stop_price: Option<f64>, stop_loss: Option<f64>, take_profit: Option<f64>, trailing_stop_loss: Option<bool>, expiration_timestamp: Option<i64>, ) -> Result<ProtoOaExecutionEvent, Error>

Amend an existing pending order.

Only supply the fields you want to change — all are optional except ctid_trader_account_id and order_id.

pub async fn reconcile( &self, ctid_trader_account_id: i64, return_protection_orders: bool, ) -> Result<ProtoOaReconcileRes, Error>

Get open positions and pending orders (current state snapshot).

Set return_protection_orders = true to receive SL/TP as separate orders; otherwise they appear as fields on the position.

pub async fn order_list( &self, ctid_trader_account_id: i64, from_timestamp: Option<i64>, to_timestamp: Option<i64>, ) -> Result<ProtoOaOrderListRes, Error>

List orders filtered by time range.

pub async fn order_details( &self, ctid_trader_account_id: i64, order_id: i64, ) -> Result<ProtoOaOrderDetailsRes, Error>

Get full details for a single order by ID.

pub async fn get_order_list_by_position( &self, ctid_trader_account_id: i64, position_id: i64, from_timestamp: Option<i64>, to_timestamp: Option<i64>, ) -> Result<ProtoOaOrderListByPositionIdRes, Error>

List orders associated with a specific position.

impl Client

pub async fn close_position( &self, ctid_trader_account_id: i64, position_id: i64, volume: i64, ) -> Result<ProtoOaExecutionEvent, Error>

Close an open position, either fully or partially.

To close fully, pass the full position volume.

pub async fn amend_position_sltp( &self, ctid_trader_account_id: i64, position_id: i64, stop_loss: Option<f64>, take_profit: Option<f64>, trailing_stop_loss: Option<bool>, ) -> Result<ProtoOaExecutionEvent, Error>

Amend the Stop Loss and/or Take Profit of an open position.

stop_loss and take_profit are absolute price levels.

pub async fn position_unrealized_pnl( &self, ctid_trader_account_id: i64, ) -> Result<ProtoOaGetPositionUnrealizedPnLRes, Error>

Get unrealized P&L for all open positions.

Note: monetary values in the response are scaled by 10^moneyDigits.

Examples found in repository

examples/get_position_unrealized_pnl.rs (line 28)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("new_order=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    let res = client.position_unrealized_pnl(account_id).await?;

    tracing::info!("Position Unrealized PnL: {:?}", res);

    Ok(())
}

impl Client

pub async fn symbols_list( &self, ctid_trader_account_id: i64, include_archived: bool, ) -> Result<ProtoOaSymbolsListRes, Error>

List all symbols for the given account.

Mirrors ProtoOASymbolsListReq.

Examples found in repository

examples/symbols_list.rs (line 36)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("symbols_list=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let token = std::env::var("CTRADER_TOKEN")?;
    let account_id: i64 = std::env::var("CTRADER_ACCOUNT_ID")?.parse()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    println!("Connecting …");
    let client = Client::start(config).await?;
    println!("✓ Connected");

    // Authenticate the account
    let auth_res = client.account_auth(account_id, &token).await?;
    assert_eq!(auth_res.ctid_trader_account_id, account_id);
    println!("✓ Account {account_id} authenticated");

    // Fetch symbol list
    let res = client.symbols_list(account_id, false).await?;
    println!("\nTotal symbols: {}", res.symbol.len());

    // Verify XAUUSD is present (same assertion as the Go test)
    let xauusd = res
        .symbol
        .iter()
        .find(|s| s.symbol_name.as_deref() == Some("XAUUSD"));

    match xauusd {
        Some(sym) => println!(
            "✓ XAUUSD found  (id={}, enabled={})",
            sym.symbol_id,
            sym.enabled.unwrap_or(false)
        ),
        None => println!("✗ XAUUSD NOT found in symbol list"),
    }

    // Print first 10 symbols
    println!("\nFirst 10 symbols:");
    println!("{:<10} {:<15} {}", "ID", "Name", "Enabled");
    println!("{}", "-".repeat(35));
    for sym in res.symbol.iter().take(10) {
        println!(
            "{:<10} {:<15} {}",
            sym.symbol_id,
            sym.symbol_name.as_deref().unwrap_or(""),
            sym.enabled.unwrap_or(false),
        );
    }

    Ok(())
}

pub async fn subscribe_symbol( &self, symbol_id: Vec<i64>, ctid_trader_account_id: i64, ) -> Result<ProtoOaSubscribeSpotsRes, Error>

Examples found in repository

examples/subscribe.rs (line 30)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()
        .with_env_filter("get_accounts=debug,ctrader_rs=debug")
        .with_line_number(true)
        .init();

    let client_id = std::env::var("CTRADER_CLIENT_ID")?;
    let secret = std::env::var("CTRADER_SECRET")?;
    let account_id = std::env::var("CTRADER_ACCOUNT_ID")?.parse::<i64>()?;

    let config = Config::new(client_id, secret).deadline(Duration::from_secs(5));

    tracing::debug!("Connecting to demo.ctraderapi.com:5035 …");
    let client = Client::start(config).await?;
    tracing::debug!("✓ Connected and application authenticated");

    // Fetch all accounts linked to the token
    let res = client.subscribe_symbol(vec![61], account_id).await?;

    println!("{:?}", res);

    Ok(())
}

pub async fn symbol_by_id( &self, symbol_id: Vec<i64>, ctid_trader_account_id: i64, ) -> Result<ProtoOaSymbolByIdReq, Error>