Rust gRPC SDK

[dependencies]
monaco-grpc-sdk = "0.6"
tonic = { version = "0.14", features = ["transport", "tls-ring", "tls-webpki-roots"] }
tokio = { version = "1", features = ["full"] }

# Request signing for authenticated calls (see "Authenticate requests").
ed25519-dalek = "2"
prost = "0.14"
sha2 = "0.10"
hex = "0.4"
uuid = { version = "1", features = ["v4"] }

use monaco_grpc_sdk::monaco::api::market::{
    market_service_client::MarketServiceClient,
    ListTradingPairsRequest,
};
use tonic::transport::{Channel, ClientTlsConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let channel = Channel::from_static("https://staging.apimonaco.xyz")
        .tls_config(ClientTlsConfig::new().with_webpki_roots())?
        .connect()
        .await?;

    let mut market = MarketServiceClient::new(channel);

    let response = market
        .list_trading_pairs(ListTradingPairsRequest {
            page: Some(1),
            page_size: Some(20),
            market_type: None,
            base_token: None,
            quote_token: None,
            is_active: Some(true),
        })
        .await?
        .into_inner();

    for pair in response.trading_pairs {
        println!("{} {}", pair.symbol, pair.id);
    }

    Ok(())
}

use ed25519_dalek::{Signer, SigningKey};
use monaco_grpc_sdk::monaco::api::orders::{
    orders_service_client::OrdersServiceClient, CreateOrderRequest,
};
use prost::Message;
use sha2::{Digest, Sha256};
use std::time::{SystemTime, UNIX_EPOCH};
use tonic::transport::{Channel, ClientTlsConfig};
use tonic::Request;

/// Wrap a request with the three `x-monaco-*` signing metadata entries.
fn signed_request<T: Message>(msg: T, method_path: &str, key: &SigningKey) -> Request<T> {
    let hash = hex::encode(Sha256::digest(msg.encode_to_vec()));
    // Real current time in milliseconds; a stale or far-future value is rejected.
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system clock before epoch")
        .as_millis()
        .to_string();
    let signing_string = format!("POST\n{method_path}\n{timestamp}\n{hash}");
    let signature = hex::encode(key.sign(signing_string.as_bytes()).to_bytes());
    let public_key = hex::encode(key.verifying_key().to_bytes());

    let mut request = Request::new(msg);
    let md = request.metadata_mut();
    md.insert("x-monaco-publickey", public_key.parse().expect("ascii metadata"));
    md.insert("x-monaco-timestamp", timestamp.parse().expect("ascii metadata"));
    md.insert("x-monaco-signature", signature.parse().expect("ascii metadata"));
    request
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let channel = Channel::from_static("https://staging.apimonaco.xyz")
        .tls_config(ClientTlsConfig::new().with_webpki_roots())?
        .connect()
        .await?;

    // ed25519 session key registered via AuthService.Challenge/Verify (32-byte
    // hex seed). The server verifies against its public key — there is no token.
    let seed: [u8; 32] = hex::decode(std::env::var("MONACO_SESSION_SEED")?)?
        .try_into()
        .expect("MONACO_SESSION_SEED must be 32-byte hex");
    let key = SigningKey::from_bytes(&seed);

    let mut orders = OrdersServiceClient::new(channel);
    const CREATE_ORDER: &str = "/monaco.api.orders.OrdersService/CreateOrder";

    let submission_key = uuid::Uuid::new_v4().to_string();
    let create = CreateOrderRequest {
        idempotency_key: Some(submission_key),
        trading_pair_id: "TRADING_PAIR_UUID".into(), // from MarketService.ListTradingPairs
        order_type: "LIMIT".into(),
        side: "BUY".into(),
        quantity: "0.01".into(),
        price: Some("60000".into()),
        trading_mode: Some("SPOT".into()),
        time_in_force: Some("GTC".into()),
        ..Default::default()
    };
    // Save `create` before sending; retain it for recovery.
    let response = orders
        .create_order(signed_request(create.clone(), CREATE_ORDER, &key))
        .await?
        .into_inner();
    println!("created order: {response:?}");

    Ok(())
}

monaco-grpc-sdk = "=0.6.3-develop.b80cbc4"