Rust

[dependencies]
tokio = { version = "1", features = ["full"] }
tonic = { version = "0.14", features = ["tls-webpki-roots"] }
prost = "0.14"

git clone https://github.com/anthid-labs/proto.git

fn main() {
    tonic_prost_build::compile_protos(
        "proto/trading.proto",
    )
    .unwrap();
}

[build-dependencies]
tonic-prost-build = "0.14"

use tonic::metadata::MetadataValue;

request.metadata_mut().insert(
    "x-api-key",
    MetadataValue::try_from("YOUR_API_KEY")?,
);

use tonic::{
    metadata::MetadataValue,
    transport::Channel,
    Request,
};

pub mod trading {
    tonic::include_proto!("trading");
}

use trading::{
    trading_service_client::TradingServiceClient,
    EventType,
    Subscribe,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>>
{
    let mut client =
        TradingServiceClient::connect(
            "https://stream.anthid.com",
        )
        .await?;

    let mut request = Request::new(
        Subscribe {
            trading_account_id:
                "YOUR_TRADING_ACCOUNT_ID"
                    .to_string(),
            subscriptions: vec![
                EventType::BrokerOrder as i32,
                EventType::BrokerPosition
                    as i32,
            ],
        },
    );

    request.metadata_mut().insert(
        "x-api-key",
        MetadataValue::try_from(
            "YOUR_API_KEY",
        )?,
    );

    let mut stream = client
        .subscribe_events(request)
        .await?
        .into_inner();

    while let Some(event) =
        stream.message().await?
    {
        println!("{event:?}");
    }

    Ok(())
}

while let Some(event) =
    stream.message().await?
{
    match event.event {
        Some(
            trading::trading_event::Event::Heartbeat(_),
        ) => {
            println!("heartbeat");
        }

        Some(
            trading::trading_event::Event::Status(
                status,
            ),
        ) => {
            println!(
                "status: {}",
                status.message
            );
        }

        Some(
            trading::trading_event::Event::Error(
                error,
            ),
        ) => {
            println!(
                "error: {}",
                error.message
            );
        }

        Some(
            trading::trading_event::Event::BrokerOrder(
                order,
            ),
        ) => {
            println!(
                "order: {:?}",
                order
            );
        }

        Some(
            trading::trading_event::Event::BrokerPosition(
                position,
            ),
        ) => {
            println!(
                "position: {:?}",
                position
            );
        }

        None => {}
    }
}

use tokio_stream::iter;
use tonic::Request;

use trading::{
    EventType,
    StreamEventsRequest,
    Subscribe,
};

let request_stream = iter(vec![
    StreamEventsRequest {
        msg: Some(
            trading::stream_events_request::Msg::Subscribe(
                Subscribe {
                    trading_account_id:
                        "YOUR_TRADING_ACCOUNT_ID"
                            .to_string(),
                    subscriptions: vec![
                        EventType::BrokerOrder
                            as i32,
                        EventType::BrokerPosition
                            as i32,
                    ],
                },
            ),
        ),
    },
]);

let mut request =
    Request::new(request_stream);

request.metadata_mut().insert(
    "x-api-key",
    MetadataValue::try_from(
        "YOUR_API_KEY",
    )?,
);

let response = client
    .stream_events(request)
    .await?;

let mut stream =
    response.into_inner();