Rust API Overview

use hftbacktest::{
    backtest::{
        Asset,
        Backtest,
        DataSource,
        ExchangeKind,
        assettype::LinearAsset,
        models::{
            CommonFees,
            ConstantLatency,
            PowerProbQueueFunc3,
            ProbQueueModel,
            TradingValueFeeModel,
        },
    },
    depth::HashMapMarketDepth,
};

let mut hbt = Backtest::builder()
    .add_asset(
        Asset::l2_builder()
            .data(vec![DataSource::File("data.npz".to_string())])
            .latency_model(ConstantLatency::new(50_000, 50_000))
            .asset_type(LinearAsset::new(1.0))
            .fee_model(TradingValueFeeModel::new(
                CommonFees::new(-0.00005, 0.0007)
            ))
            .queue_model(ProbQueueModel::new(PowerProbQueueFunc3::new(3.0)))
            .exchange(ExchangeKind::NoPartialFillExchange)
            .depth(|| HashMapMarketDepth::new(0.01, 1.0))
            .build()?
    )
    .build()?;

pub trait Bot<MD>
where
    MD: MarketDepth,
{
    type Error;

    fn current_timestamp(&self) -> i64;
    fn num_assets(&self) -> usize;
    fn position(&self, asset_no: usize) -> f64;
    fn state_values(&self, asset_no: usize) -> &StateValues;
    fn depth(&self, asset_no: usize) -> &MD;
    fn last_trades(&self, asset_no: usize) -> &[Event];
    fn orders(&self, asset_no: usize) -> &HashMap<OrderId, Order>;
    
    fn submit_buy_order(
        &mut self,
        asset_no: usize,
        order_id: OrderId,
        price: f64,
        qty: f64,
        time_in_force: TimeInForce,
        order_type: OrdType,
        wait: bool,
    ) -> Result<ElapseResult, Self::Error>;
    
    fn submit_sell_order(
        &mut self,
        asset_no: usize,
        order_id: OrderId,
        price: f64,
        qty: f64,
        time_in_force: TimeInForce,
        order_type: OrdType,
        wait: bool,
    ) -> Result<ElapseResult, Self::Error>;
    
    fn cancel(
        &mut self,
        asset_no: usize,
        order_id: OrderId,
        wait: bool,
    ) -> Result<ElapseResult, Self::Error>;
    
    fn elapse(&mut self, duration: i64) -> Result<ElapseResult, Self::Error>;
    // ... additional methods
}

[dependencies]
hftbacktest = "*"

use hftbacktest::prelude::*;