mod grid;
mod persistence;
use std::{collections::HashSet, sync::Arc, time::Duration};
use async_trait::async_trait;
use longtrader_contract::ext::{common_to_decimal, decimal_to_common};
use rust_decimal::Decimal;
use serde::Deserialize;
use tokio::sync::Mutex;
use crate::{
ports::{MarketDataSource, PortError, TradingGateway},
proto::{common, market, trading},
strategies::{Strategy, mid_price},
};
#[derive(Debug, Clone, Deserialize)]
pub struct SimpleGridConfig {
pub exchange_id: common::ExchangeId,
pub symbol: String,
pub lower_price: Decimal,
pub upper_price: Decimal,
pub num_levels: u32,
pub qty_per_level: Decimal,
#[serde(default)]
pub profit_spread_pct: Option<Decimal>,
#[serde(default)]
pub state_file: Option<String>,
}
impl SimpleGridConfig {
pub fn from_config(config: &crate::config::Config) -> color_eyre::Result<Self> {
let params = &config.strategy.params;
let required = |value: Option<Decimal>, name: &str| -> color_eyre::Result<Decimal> {
value.ok_or_else(|| color_eyre::eyre::eyre!("{name} is required"))
};
Ok(Self {
profit_spread_pct: None,
state_file: params
.table()
.get("state_file")
.and_then(toml::Value::as_str)
.map(ToString::to_string),
exchange_id: crate::ports::exchange_id(
params.exchange_id.as_deref().unwrap_or("mock"),
params.label.as_deref().unwrap_or_default(),
),
symbol: params
.symbol
.clone()
.ok_or_else(|| color_eyre::eyre::eyre!("symbol is required"))?,
lower_price: required(params.lower_price, "lower_price")?,
upper_price: required(params.upper_price, "upper_price")?,
num_levels: params
.num_levels
.ok_or_else(|| color_eyre::eyre::eyre!("num_levels is required"))?,
qty_per_level: required(params.qty_per_level, "qty_per_level")?,
})
}
}
#[derive(Debug, Clone)]
pub(crate) struct GridLevel {
price: Decimal,
side: trading::OrderSide,
client_order_id: String,
order_id: String,
}
pub struct SimpleGrid {
config: SimpleGridConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
levels: Mutex<Vec<GridLevel>>,
grid_step: Decimal,
max_consecutive_errors: u32,
}
impl SimpleGrid {
pub fn new(
config: SimpleGridConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
) -> Self {
let grid_step = grid::grid_step(&config);
Self {
config,
gateway,
market,
levels: Mutex::new(Vec::new()),
grid_step,
max_consecutive_errors: 5,
}
}
fn persist_levels(&self, levels: &[GridLevel]) {
persistence::persist_levels(self.config.state_file.as_deref(), levels);
}
fn restore_levels(&self) -> color_eyre::Result<Vec<GridLevel>> {
persistence::restore_levels(&self.config)
}
async fn current_price(&self) -> color_eyre::Result<Decimal> {
let ticker = self
.market
.fetch_ticker(market::FetchTickerRequest {
exchange_id: buffa::MessageField::some(self.config.exchange_id.clone()),
symbol: self.config.symbol.clone(),
..Default::default()
})
.await?;
for candidate in [ticker.last.as_option(), ticker.close.as_option()] {
if let Some(price) = Self::usable_price(candidate) {
return Ok(price);
}
}
let bid = Self::usable_price(ticker.bid.as_option());
let ask = Self::usable_price(ticker.ask.as_option());
if let (Some(bid), Some(ask)) = (bid, ask) {
return Ok(mid_price(bid, ask));
}
color_eyre::eyre::bail!("no usable price in ticker for {}", self.config.symbol);
}
fn usable_price(candidate: Option<&common::Decimal>) -> Option<Decimal> {
let price = common_to_decimal(candidate?).ok()?;
(price > Decimal::ZERO).then_some(price)
}
fn calculate_levels(&self, current_price: Decimal) -> Vec<GridLevel> {
grid::calculate_levels(&self.config, self.grid_step, current_price)
}
async fn place_level_order(&self, level: &mut GridLevel) -> Result<(), PortError> {
let order_req = trading::OrderRequest {
client_order_id: level.client_order_id.clone(),
symbol: self.config.symbol.clone(),
r#type: buffa::EnumValue::Known(trading::OrderType::Limit),
side: buffa::EnumValue::Known(level.side),
amount: buffa::MessageField::some(decimal_to_common(self.config.qty_per_level)),
price: buffa::MessageField::some(decimal_to_common(level.price)),
trigger_price: buffa::MessageField::none(),
time_in_force: buffa::EnumValue::Known(trading::TimeInForce::Gtc),
post_only: false,
reduce_only: false,
params: Default::default(),
..Default::default()
};
let order = self
.gateway
.create_order(trading::CreateOrderRequest {
exchange_id: buffa::MessageField::some(self.config.exchange_id.clone()),
order: buffa::MessageField::some(order_req),
..Default::default()
})
.await?;
level.order_id = order.id;
Ok(())
}
async fn cancel_tracked_orders(&self, levels: &[GridLevel]) {
for level in levels {
if level.order_id.is_empty() {
continue;
}
if let Err(err) = self
.gateway
.cancel_order(trading::CancelOrderRequest {
exchange_id: buffa::MessageField::some(self.config.exchange_id.clone()),
order_id: level.order_id.clone(),
symbol: self.config.symbol.clone(),
..Default::default()
})
.await
{
tracing::warn!(
order_id = %level.order_id,
coid = %level.client_order_id,
error = %err,
"kill-switch cancel failed"
);
}
}
}
#[allow(clippy::cognitive_complexity)]
async fn rebalance(&self) -> color_eyre::Result<()> {
let current = self.current_price().await?;
let snapshot: Vec<GridLevel> = self.levels.lock().await.clone();
let mut errors: u32 = 0;
if snapshot.is_empty() {
let restored = self.restore_levels()?;
if !restored.is_empty() {
tracing::info!(
levels = restored.len(),
"restored grid levels; the next poll reconciles them against the venue"
);
*self.levels.lock().await = restored;
return Ok(());
}
let mut fresh = self.calculate_levels(current);
tracing::info!("initialized {} grid levels on {}", fresh.len(), self.config.symbol);
for level in &mut fresh {
if let Err(err) = self.place_level_order(level).await {
errors += 1;
tracing::error!(price = %level.price, error = %err, "initial placement failed");
}
}
if errors >= self.max_consecutive_errors {
tracing::error!(
errors,
"error threshold reached during init; tripping grid kill-switch"
);
self.cancel_tracked_orders(&fresh).await;
fresh.clear();
}
self.persist_levels(&fresh);
*self.levels.lock().await = fresh;
return Ok(());
}
let open_orders = self
.gateway
.fetch_open_orders(trading::FetchOpenOrdersRequest {
exchange_id: buffa::MessageField::some(self.config.exchange_id.clone()),
symbol: self.config.symbol.clone(),
pagination: buffa::MessageField::none(),
..Default::default()
})
.await?;
let mut live_coids = HashSet::with_capacity(open_orders.len());
let mut live_prices = HashSet::with_capacity(open_orders.len());
for order in &open_orders {
live_coids.insert(order.client_order_id.clone());
if let Some(Ok(price)) = order.price.as_option().map(common_to_decimal) {
live_prices.insert(price);
}
}
let mut updated = snapshot;
for level in &mut updated {
let alive =
live_coids.contains(&level.client_order_id) || live_prices.contains(&level.price);
if alive {
continue;
}
let opposite_side = match level.side {
trading::OrderSide::Sell => trading::OrderSide::Buy,
_ => trading::OrderSide::Sell,
};
let opposite_price = match level.side {
trading::OrderSide::Sell => level.price - self.grid_step,
_ => level.price + self.grid_step,
};
if opposite_price < self.config.lower_price || opposite_price > self.config.upper_price
{
continue;
}
*level = GridLevel {
price: opposite_price,
side: opposite_side,
client_order_id: format!("grid-{}", ulid::Ulid::generate()),
order_id: String::new(),
};
if let Err(err) = self.place_level_order(level).await {
errors += 1;
tracing::error!(price = %level.price, error = %err, "flip placement failed");
}
}
if errors >= self.max_consecutive_errors {
tracing::error!(
errors,
"error threshold reached; tripping grid kill-switch and cancelling tracked orders"
);
self.cancel_tracked_orders(&updated).await;
updated.clear();
self.persist_levels(&updated);
}
*self.levels.lock().await = updated;
Ok(())
}
}
#[async_trait]
impl Strategy for SimpleGrid {
async fn run(&self) -> color_eyre::Result<()> {
tracing::info!(
"starting unified grid on {} ({}-{}, {} levels, qty={}/level)",
self.config.symbol,
self.config.lower_price,
self.config.upper_price,
self.config.num_levels,
self.config.qty_per_level
);
loop {
match self.rebalance().await {
Ok(()) => {}
Err(err) => tracing::error!("grid rebalance error: {err}"),
}
tokio::time::sleep(Duration::from_secs(3)).await;
}
}
}
#[cfg(test)]
mod tests {
use std::sync::Arc as StdArc;
use async_trait::async_trait;
use longtrader_contract::ext::decimal_to_common;
use proptest::prelude::*;
use rust_decimal_macros::dec;
use super::*;
use crate::{
adapters::MockAdapter,
ports::{MarketEventStream, OverflowPolicy, PortError},
};
fn undecodable() -> common::Decimal {
common::Decimal { value: "not-a-number".to_string(), ..Default::default() }
}
fn grid_config() -> SimpleGridConfig {
SimpleGridConfig {
exchange_id: common::ExchangeId {
id: "mock".to_string(),
label: String::new(),
..Default::default()
},
symbol: "BTC/USDT".to_string(),
lower_price: dec!(90),
upper_price: dec!(110),
num_levels: 4,
qty_per_level: dec!(0.1),
profit_spread_pct: None,
state_file: None,
}
}
fn build() -> (StdArc<MockAdapter>, SimpleGrid) {
let adapter = StdArc::new(MockAdapter::new(dec!(100)));
let gateway: StdArc<dyn TradingGateway> = adapter.clone();
let market: StdArc<dyn MarketDataSource> = adapter.clone();
let grid = SimpleGrid::new(grid_config(), gateway, market);
(adapter, grid)
}
async fn open_orders(grid: &SimpleGrid) -> Vec<trading::Order> {
grid.gateway
.fetch_open_orders(trading::FetchOpenOrdersRequest {
exchange_id: buffa::MessageField::some(grid.config.exchange_id.clone()),
symbol: grid.config.symbol.clone(),
pagination: buffa::MessageField::none(),
..Default::default()
})
.await
.expect("test setup")
}
#[tokio::test]
async fn first_rebalance_seeds_the_grid() {
let (_adapter, grid) = build();
grid.rebalance().await.expect("test setup");
let open = open_orders(&grid).await;
assert_eq!(open.len(), 5, "num_levels=4 spans 5 inclusive price points");
let levels = grid.levels.lock().await;
assert_eq!(levels.len(), 5);
let coids: HashSet<_> = levels.iter().map(|l| l.client_order_id.clone()).collect();
assert_eq!(coids.len(), 5);
}
#[tokio::test]
async fn filled_level_flips_to_the_opposite_leg() {
let (adapter, grid) = build();
grid.rebalance().await.expect("test setup");
let lowest = {
let levels = grid.levels.lock().await;
levels.iter().min_by_key(|l| l.price).expect("test setup").clone()
};
let filled_order = open_orders(&grid)
.await
.into_iter()
.find(|o| o.client_order_id == lowest.client_order_id)
.expect("seeded order must exist");
adapter
.cancel_order(trading::CancelOrderRequest {
exchange_id: buffa::MessageField::some(grid.config.exchange_id.clone()),
order_id: filled_order.id.clone(),
symbol: String::new(),
..Default::default()
})
.await
.expect("test setup");
grid.rebalance().await.expect("test setup");
let levels = grid.levels.lock().await;
let flipped = levels.iter().find(|l| l.price == lowest.price + grid.grid_step);
assert!(flipped.is_some(), "opposite leg must be placed one step up");
let flipped = flipped.expect("test setup");
assert_eq!(flipped.side, trading::OrderSide::Sell);
assert_ne!(
flipped.client_order_id, lowest.client_order_id,
"flip must use a fresh client_order_id"
);
let open = open_orders(&grid).await;
assert_eq!(open.len(), 5);
}
#[tokio::test]
async fn repeated_failures_trip_the_kill_switch_and_clear_levels() {
let (adapter, grid) = build();
adapter.fail_next_creates(6).await; let _ = grid.rebalance().await;
let levels = grid.levels.lock().await;
assert!(levels.is_empty(), "kill-switch clears the grid after repeated failures");
}
#[test]
fn a_level_below_the_current_price_buys_and_everything_else_sells() {
assert_eq!(grid::side_for(dec!(99), dec!(100)), trading::OrderSide::Buy);
assert_eq!(grid::side_for(dec!(100), dec!(100)), trading::OrderSide::Sell);
assert_eq!(grid::side_for(dec!(101), dec!(100)), trading::OrderSide::Sell);
}
#[test]
fn the_side_rule_holds_for_degenerate_prices() {
assert_eq!(grid::side_for(Decimal::ZERO, dec!(100)), trading::OrderSide::Buy);
assert_eq!(grid::side_for(dec!(0.00000001), Decimal::ZERO), trading::OrderSide::Sell);
assert_eq!(grid::side_for(Decimal::ZERO, Decimal::ZERO), trading::OrderSide::Sell);
assert_eq!(grid::side_for(dec!(-2), dec!(-1)), trading::OrderSide::Buy);
assert_eq!(grid::side_for(dec!(-1), dec!(-2)), trading::OrderSide::Sell);
assert_eq!(grid::side_for(dec!(-1), dec!(-1)), trading::OrderSide::Sell);
}
fn grid_with(lower: Decimal, upper: Decimal, num_levels: u32) -> SimpleGrid {
let adapter = StdArc::new(MockAdapter::new(dec!(100)));
let gateway: StdArc<dyn TradingGateway> = adapter.clone();
let mut config = grid_config();
config.lower_price = lower;
config.upper_price = upper;
config.num_levels = num_levels;
SimpleGrid::new(config, gateway, adapter as StdArc<dyn MarketDataSource>)
}
#[test]
fn a_zero_level_grid_has_a_zero_step_and_no_levels() {
let grid = grid_with(dec!(90), dec!(110), 0);
assert_eq!(grid.grid_step, Decimal::ZERO);
assert!(grid.calculate_levels(dec!(100)).is_empty());
}
#[test]
fn a_collapsed_span_produces_no_levels() {
let grid = grid_with(dec!(100), dec!(100), 4);
assert_eq!(grid.grid_step, Decimal::ZERO);
assert!(grid.calculate_levels(dec!(100)).is_empty());
}
#[test]
fn an_inverted_span_produces_no_levels() {
let grid = grid_with(dec!(110), dec!(90), 4);
assert!(grid.grid_step < Decimal::ZERO);
assert!(grid.calculate_levels(dec!(100)).is_empty());
}
#[test]
fn the_ladder_is_inclusive_of_both_bounds_and_evenly_spaced() {
let grid = grid_with(dec!(90), dec!(110), 4);
assert_eq!(grid.grid_step, dec!(5));
let levels = grid.calculate_levels(dec!(100));
let prices: Vec<Decimal> = levels.iter().map(|l| l.price).collect();
assert_eq!(prices, vec![dec!(90), dec!(95), dec!(100), dec!(105), dec!(110)]);
assert!(levels.windows(2).all(|w| w[1].price - w[0].price == grid.grid_step));
}
#[test]
fn ladder_sides_follow_the_current_price() {
let grid = grid_with(dec!(90), dec!(110), 4);
let levels = grid.calculate_levels(dec!(100));
let sides: Vec<trading::OrderSide> = levels.iter().map(|l| l.side).collect();
assert_eq!(
sides,
vec![
trading::OrderSide::Buy,
trading::OrderSide::Buy,
trading::OrderSide::Sell,
trading::OrderSide::Sell,
trading::OrderSide::Sell,
]
);
}
#[test]
fn the_ladder_never_exceeds_the_level_count_plus_one() {
for num_levels in 1..=8u32 {
let grid = grid_with(dec!(90), dec!(110), num_levels);
let levels = grid.calculate_levels(dec!(100));
let bound = usize::try_from(num_levels).expect("u32 fits usize") + 1;
assert!(
levels.len() <= bound,
"num_levels={num_levels} produced {} levels",
levels.len()
);
for level in &levels {
assert!(
level.price >= grid.config.lower_price &&
level.price <= grid.config.upper_price,
"{} escaped the configured band",
level.price
);
}
}
}
#[tokio::test]
async fn a_zero_level_grid_never_places_orders() {
let adapter = StdArc::new(MockAdapter::new(dec!(100)));
let gateway: StdArc<dyn TradingGateway> = adapter.clone();
let market: StdArc<dyn MarketDataSource> = adapter.clone();
let mut config = grid_config();
config.num_levels = 0;
let grid = SimpleGrid::new(config, gateway, market);
grid.rebalance().await.expect("an empty ladder is not a failure");
grid.rebalance().await.expect("an empty ladder is not a failure");
assert!(grid.levels.lock().await.is_empty());
assert!(open_orders(&grid).await.is_empty());
}
fn grid_against(ticker: market::Ticker) -> SimpleGrid {
let gateway: StdArc<dyn TradingGateway> = StdArc::new(MockAdapter::new(dec!(100)));
let market: StdArc<dyn MarketDataSource> = StdArc::new(ScriptedTicker::of(ticker));
SimpleGrid::new(grid_config(), gateway, market)
}
#[tokio::test]
async fn a_positive_last_price_is_used_directly() {
let grid = grid_against(ScriptedTicker::build(|t| {
t.last = buffa::MessageField::some(decimal_to_common(dec!(101)));
t.close = buffa::MessageField::some(decimal_to_common(dec!(55)));
}));
assert_eq!(grid.current_price().await.expect("price"), dec!(101));
}
#[tokio::test]
async fn a_zero_last_price_falls_through_to_the_close() {
let grid = grid_against(ScriptedTicker::build(|t| {
t.last = buffa::MessageField::some(decimal_to_common(Decimal::ZERO));
t.close = buffa::MessageField::some(decimal_to_common(dec!(97)));
}));
assert_eq!(grid.current_price().await.expect("price"), dec!(97));
}
#[tokio::test]
async fn an_absent_last_price_falls_through_to_the_close() {
let grid = grid_against(ScriptedTicker::build(|t| {
t.close = buffa::MessageField::some(decimal_to_common(dec!(97)));
}));
assert_eq!(grid.current_price().await.expect("price"), dec!(97));
}
#[tokio::test]
async fn an_absent_last_and_close_falls_back_to_the_bid_ask_midpoint() {
let grid = grid_against(ScriptedTicker::build(|t| {
t.bid = buffa::MessageField::some(decimal_to_common(dec!(99)));
t.ask = buffa::MessageField::some(decimal_to_common(dec!(101)));
}));
assert_eq!(grid.current_price().await.expect("price"), dec!(100));
}
#[tokio::test]
async fn a_non_positive_book_is_not_a_usable_price() {
let cases = [
ScriptedTicker::build(|t| {
t.bid = buffa::MessageField::some(decimal_to_common(Decimal::ZERO));
t.ask = buffa::MessageField::some(decimal_to_common(dec!(101)));
}),
ScriptedTicker::build(|t| {
t.bid = buffa::MessageField::some(decimal_to_common(dec!(99)));
t.ask = buffa::MessageField::some(decimal_to_common(Decimal::ZERO));
}),
ScriptedTicker::build(|t| {
t.bid = buffa::MessageField::some(decimal_to_common(dec!(99)));
}),
ScriptedTicker::build(|t| {
t.ask = buffa::MessageField::some(decimal_to_common(dec!(101)));
}),
ScriptedTicker::build(|_| {}),
];
for ticker in cases {
let grid = grid_against(ticker);
let err = grid.current_price().await.expect_err("no usable price must be an error");
assert!(err.to_string().contains("no usable price"), "{err}");
assert!(err.to_string().contains("BTC/USDT"), "the error must name the symbol: {err}");
}
}
#[tokio::test]
async fn an_undecodable_last_price_falls_through_to_the_close() {
let grid = grid_against(ScriptedTicker::build(|t| {
t.last = buffa::MessageField::some(undecodable());
t.close = buffa::MessageField::some(decimal_to_common(dec!(97)));
t.bid = buffa::MessageField::some(decimal_to_common(dec!(99)));
t.ask = buffa::MessageField::some(decimal_to_common(dec!(101)));
}));
assert_eq!(grid.current_price().await.expect("the close is usable"), dec!(97));
}
#[tokio::test]
async fn an_undecodable_close_falls_through_to_the_book() {
let grid = grid_against(ScriptedTicker::build(|t| {
t.close = buffa::MessageField::some(undecodable());
t.bid = buffa::MessageField::some(decimal_to_common(dec!(99)));
t.ask = buffa::MessageField::some(decimal_to_common(dec!(101)));
}));
assert_eq!(grid.current_price().await.expect("the book is usable"), dec!(100));
}
#[tokio::test]
async fn an_undecodable_last_and_close_still_have_no_usable_price() {
let grid = grid_against(ScriptedTicker::build(|t| {
t.last = buffa::MessageField::some(undecodable());
t.close = buffa::MessageField::some(undecodable());
t.bid = buffa::MessageField::some(undecodable());
t.ask = buffa::MessageField::some(undecodable());
}));
let err = grid.current_price().await.expect_err("no usable rung is an error");
assert!(err.to_string().contains("no usable price"), "{err}");
}
#[tokio::test]
async fn a_ticker_failure_propagates_out_of_the_rebalance() {
let gateway: StdArc<dyn TradingGateway> = StdArc::new(MockAdapter::new(dec!(100)));
let market: StdArc<dyn MarketDataSource> = StdArc::new(FailingTicker);
let grid = SimpleGrid::new(grid_config(), gateway, market);
let err = grid.rebalance().await.expect_err("a broken ticker must not read as a flat tick");
assert!(err.to_string().contains("ticker feed down"), "{err}");
}
struct ScriptedTicker {
ticker: market::Ticker,
}
impl ScriptedTicker {
fn build(build: impl FnOnce(&mut market::Ticker)) -> market::Ticker {
let mut ticker =
market::Ticker { symbol: "BTC/USDT".to_string(), ..Default::default() };
build(&mut ticker);
ticker
}
fn of(ticker: market::Ticker) -> Self {
Self { ticker }
}
}
#[async_trait]
impl MarketDataSource for ScriptedTicker {
async fn fetch_ticker(
&self,
req: market::FetchTickerRequest,
) -> Result<market::Ticker, PortError> {
Ok(market::Ticker { symbol: req.symbol, ..self.ticker.clone() })
}
async fn fetch_order_book(
&self,
_req: market::FetchOrderBookRequest,
) -> Result<market::OrderBook, PortError> {
Err(PortError::Unsupported("no book".into()))
}
async fn get_candles(
&self,
_req: market::GetCandlesRequest,
) -> Result<market::GetCandlesResponse, PortError> {
Err(PortError::Unsupported("no candles".into()))
}
async fn list_symbols(
&self,
_req: market::ListSymbolsRequest,
) -> Result<market::ListSymbolsResponse, PortError> {
Err(PortError::Unsupported("no symbols".into()))
}
async fn search_symbols(
&self,
_req: market::SearchSymbolsRequest,
) -> Result<market::SearchSymbolsResponse, PortError> {
Err(PortError::Unsupported("no symbols".into()))
}
async fn list_tickers(
&self,
_req: market::ListTickersRequest,
) -> Result<market::ListTickersResponse, PortError> {
Err(PortError::Unsupported("no tickers".into()))
}
async fn subscribe_market_data(
&self,
_req: market::StreamMarketDataRequest,
_policy: OverflowPolicy,
) -> Result<MarketEventStream, PortError> {
Err(PortError::Unsupported("no stream".into()))
}
}
struct FailingTicker;
#[async_trait]
impl MarketDataSource for FailingTicker {
async fn fetch_ticker(
&self,
_req: market::FetchTickerRequest,
) -> Result<market::Ticker, PortError> {
Err(PortError::Transport("ticker feed down".into()))
}
async fn fetch_order_book(
&self,
_req: market::FetchOrderBookRequest,
) -> Result<market::OrderBook, PortError> {
Err(PortError::Transport("book feed down".into()))
}
async fn get_candles(
&self,
_req: market::GetCandlesRequest,
) -> Result<market::GetCandlesResponse, PortError> {
Err(PortError::Transport("candle feed down".into()))
}
async fn list_symbols(
&self,
_req: market::ListSymbolsRequest,
) -> Result<market::ListSymbolsResponse, PortError> {
Err(PortError::Transport("symbol feed down".into()))
}
async fn search_symbols(
&self,
_req: market::SearchSymbolsRequest,
) -> Result<market::SearchSymbolsResponse, PortError> {
Err(PortError::Transport("symbol feed down".into()))
}
async fn list_tickers(
&self,
_req: market::ListTickersRequest,
) -> Result<market::ListTickersResponse, PortError> {
Err(PortError::Transport("ticker feed down".into()))
}
async fn subscribe_market_data(
&self,
_req: market::StreamMarketDataRequest,
_policy: OverflowPolicy,
) -> Result<MarketEventStream, PortError> {
Err(PortError::Unsupported("no stream".into()))
}
}
fn grid_with_state_file(path: &std::path::Path) -> SimpleGrid {
let gateway: StdArc<dyn TradingGateway> = StdArc::new(MockAdapter::new(dec!(100)));
let market: StdArc<dyn MarketDataSource> = StdArc::new(MockAdapter::new(dec!(100)));
let mut config = grid_config();
config.state_file = Some(path.to_string_lossy().into_owned());
SimpleGrid::new(config, gateway, market)
}
fn level_identity(level: &GridLevel) -> (String, Decimal, trading::OrderSide) {
(level.client_order_id.clone(), level.price, level.side)
}
#[tokio::test]
async fn persisted_levels_record_price_side_and_client_order_id() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("nested/grid.json");
let grid = grid_with_state_file(&path);
grid.rebalance().await.expect("test setup");
let store = crate::state_store::StateStore::new(&path);
let saved = store.load().expect("load").expect("the grid persisted its state");
let rows = saved.as_array().expect("the document is an array of levels");
assert_eq!(rows.len(), 5);
for (index, row) in rows.iter().enumerate() {
let level = grid.levels.lock().await[index].clone();
assert_eq!(row["price"], serde_json::Value::String(level.price.to_string()));
let side = if matches!(level.side, trading::OrderSide::Buy) { "buy" } else { "sell" };
assert_eq!(row["side"], serde_json::Value::String(side.to_string()));
assert_eq!(row["client_order_id"], serde_json::Value::String(level.client_order_id));
}
}
#[tokio::test]
async fn a_restart_resumes_the_persisted_ladder_instead_of_reseeding_it() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
let first = grid_with_state_file(&path);
first.rebalance().await.expect("seeded");
let seeded: Vec<(String, Decimal, trading::OrderSide)> =
first.levels.lock().await.iter().map(level_identity).collect();
assert_eq!(seeded.len(), 5);
let second = grid_with_state_file(&path);
second.rebalance().await.expect("restored");
let resumed: Vec<(String, Decimal, trading::OrderSide)> =
second.levels.lock().await.iter().map(level_identity).collect();
assert_eq!(resumed, seeded, "the restored ladder is the persisted one");
assert!(
open_orders(&second).await.is_empty(),
"a resumed ladder must not quote again before it has been reconciled"
);
}
#[tokio::test]
async fn a_resumed_ladder_adopts_the_orders_the_venue_still_holds() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
let adapter = StdArc::new(MockAdapter::new(dec!(100)));
let gateway: StdArc<dyn TradingGateway> = adapter.clone();
let market: StdArc<dyn MarketDataSource> = adapter.clone();
let mut config = grid_config();
config.state_file = Some(path.to_string_lossy().into_owned());
let first = SimpleGrid::new(config.clone(), gateway.clone(), market.clone());
first.rebalance().await.expect("seeded");
let seeded_coids: Vec<String> =
first.levels.lock().await.iter().map(|l| l.client_order_id.clone()).collect();
let second = SimpleGrid::new(config, gateway, market);
second.rebalance().await.expect("restored");
second.rebalance().await.expect("reconciled");
let levels = second.levels.lock().await;
let live: Vec<String> = levels.iter().map(|l| l.client_order_id.clone()).collect();
assert_eq!(live, seeded_coids, "every level is still the venue's own order");
let resting = open_orders(&second).await;
assert_eq!(resting.len(), 5, "reconciling a resting ladder places nothing");
}
#[tokio::test]
async fn a_missing_state_file_is_a_normal_first_start() {
let dir = tempfile::tempdir().expect("tmp");
let grid = grid_with_state_file(&dir.path().join("absent/grid.json"));
grid.rebalance().await.expect("a missing file is not an error");
assert_eq!(open_orders(&grid).await.len(), 5, "the ladder seeds from scratch");
assert_eq!(grid.levels.lock().await.len(), 5);
}
#[tokio::test]
async fn a_state_file_that_cannot_be_read_stops_the_grid_instead_of_reseeding() {
let dir = tempfile::tempdir().expect("tmp");
let blocker = dir.path().join("blocker");
std::fs::write(&blocker, "i am a file").expect("write");
let grid = grid_with_state_file(&blocker.join("grid.json"));
let err = grid.rebalance().await.expect_err("an unreadable ladder must not be guessed at");
assert!(err.to_string().contains("read"), "{err}");
assert!(open_orders(&grid).await.is_empty(), "no order may be quoted blind");
assert!(grid.levels.lock().await.is_empty());
}
#[tokio::test]
async fn a_corrupt_state_file_stops_the_grid_instead_of_reseeding() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
std::fs::write(&path, "{not json").expect("write");
let grid = grid_with_state_file(&path);
let err = grid.rebalance().await.expect_err("a corrupt ladder must not be guessed at");
assert!(err.to_string().contains("deserialize state"), "{err}");
assert!(open_orders(&grid).await.is_empty());
}
#[tokio::test]
async fn a_state_file_that_is_not_a_list_of_levels_is_reported() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
crate::state_store::StateStore::new(&path)
.save(&serde_json::json!({"levels": []}))
.expect("write");
let grid = grid_with_state_file(&path);
let err = grid.rebalance().await.expect_err("an unreadable shape must not be guessed at");
assert!(err.to_string().contains("not a list of levels"), "{err}");
}
#[tokio::test]
async fn a_restored_level_outside_the_current_band_is_dropped() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
crate::state_store::StateStore::new(&path)
.save(&serde_json::json!([
{"price": "50", "side": "buy", "client_order_id": "grid-low"},
{"price": "95", "side": "buy", "client_order_id": "grid-in"},
]))
.expect("write");
let grid = grid_with_state_file(&path);
grid.rebalance().await.expect("restored");
let levels = grid.levels.lock().await;
assert_eq!(levels.len(), 1);
assert_eq!(levels[0].client_order_id, "grid-in", "only the in-band level survives");
}
#[tokio::test]
async fn a_restored_level_without_a_client_order_id_gets_a_fresh_one() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
crate::state_store::StateStore::new(&path)
.save(&serde_json::json!([{"price": "95", "side": "buy"}]))
.expect("write");
let grid = grid_with_state_file(&path);
grid.rebalance().await.expect("restored");
let levels = grid.levels.lock().await;
assert_eq!(levels.len(), 1);
assert!(levels[0].client_order_id.starts_with("grid-"));
}
#[tokio::test]
async fn a_restored_level_with_an_unknown_side_is_reported() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
crate::state_store::StateStore::new(&path)
.save(&serde_json::json!([{"price": "95", "side": "long"}]))
.expect("write");
let grid = grid_with_state_file(&path);
let err = grid.rebalance().await.expect_err("an unknown side must not be guessed at");
assert!(err.to_string().contains("buy/sell"), "{err}");
}
#[tokio::test]
async fn the_kill_switch_cancels_by_the_venue_order_id() {
let (_adapter, grid) = build();
grid.rebalance().await.expect("test setup");
assert_eq!(open_orders(&grid).await.len(), 5);
let levels = grid.levels.lock().await.clone();
assert!(
levels.iter().all(|level| !level.order_id.is_empty()),
"every placed level must carry the venue order id"
);
grid.cancel_tracked_orders(&levels).await;
assert_eq!(
open_orders(&grid).await.len(),
0,
"every tracked level must actually be cancelled"
);
}
#[tokio::test]
async fn the_venue_order_id_is_not_the_client_order_id() {
let (adapter, grid) = build();
grid.rebalance().await.expect("test setup");
let levels = grid.levels.lock().await.clone();
let seeded = open_orders(&grid).await;
let first = seeded.first().expect("a seeded order");
assert_ne!(first.id, first.client_order_id, "the venue must assign its own id");
let coid = levels.first().expect("a level").client_order_id.clone();
let err = adapter
.cancel_order(trading::CancelOrderRequest {
exchange_id: buffa::MessageField::some(grid.config.exchange_id.clone()),
order_id: coid.clone(),
symbol: grid.config.symbol.clone(),
..Default::default()
})
.await
.expect_err("the client order id is not the venue order id");
assert!(matches!(err, PortError::InvalidArgument(_)), "{err:?}");
assert_eq!(
open_orders(&grid).await.len(),
5,
"a client-id cancel must not remove anything"
);
}
#[tokio::test]
async fn the_kill_switch_skips_levels_that_were_never_placed() {
let (_adapter, grid) = build();
grid.rebalance().await.expect("test setup");
let mut levels = grid.levels.lock().await.clone();
let total = levels.len();
assert_eq!(total, 5, "the fixture seeds five levels");
levels[0].order_id = String::new();
grid.cancel_tracked_orders(&levels).await;
let remaining = open_orders(&grid).await;
assert_eq!(
remaining.len(),
1,
"only the level that was never placed stays resting, and it must be \
that level rather than an arbitrary one"
);
assert_eq!(
remaining[0].client_order_id, levels[0].client_order_id,
"the survivor must be the level whose venue id was never recorded"
);
}
#[tokio::test]
async fn the_kill_switch_persists_an_empty_ladder() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
let adapter = StdArc::new(MockAdapter::new(dec!(100)));
let gateway: StdArc<dyn TradingGateway> = adapter.clone();
let market: StdArc<dyn MarketDataSource> = adapter.clone();
let mut config = grid_config();
config.state_file = Some(path.to_string_lossy().into_owned());
let grid = SimpleGrid::new(config, gateway, market);
adapter.fail_next_creates(6).await;
let _ = grid.rebalance().await;
assert!(grid.levels.lock().await.is_empty());
let store = crate::state_store::StateStore::new(&path);
let saved = store.load().expect("load").expect("the kill switch persisted a state");
assert_eq!(saved, serde_json::json!([]));
}
#[tokio::test]
async fn a_state_file_that_cannot_be_written_back_does_not_stop_the_grid() {
let dir = tempfile::tempdir().expect("tmp");
let path = dir.path().join("grid.json");
crate::state_store::StateStore::new(&path).save(&serde_json::json!([])).expect("write");
#[cfg(unix)]
make_dir_read_only(dir.path());
let grid = grid_with_state_file(&path);
grid.rebalance().await.expect("an unwritable state file is not fatal");
assert_eq!(open_orders(&grid).await.len(), 5, "the ladder is still quoted");
assert_eq!(grid.levels.lock().await.len(), 5);
#[cfg(unix)]
make_dir_writable(dir.path());
}
#[cfg(unix)]
fn make_dir_read_only(dir: &std::path::Path) {
use std::os::unix::fs::PermissionsExt;
let mut perms = std::fs::metadata(dir).expect("stat").permissions();
perms.set_mode(0o555);
std::fs::set_permissions(dir, perms).expect("chmod");
}
#[cfg(unix)]
fn make_dir_writable(dir: &std::path::Path) {
use std::os::unix::fs::PermissionsExt;
let mut perms = std::fs::metadata(dir).expect("stat").permissions();
perms.set_mode(0o755);
std::fs::set_permissions(dir, perms).expect("chmod");
}
#[tokio::test]
async fn no_state_file_means_no_persistence() {
let (_adapter, grid) = build();
grid.rebalance().await.expect("test setup");
assert_eq!(open_orders(&grid).await.len(), 5);
}
fn config_from(params: &str) -> crate::config::Config {
let doc = format!(
"daemon_endpoint = \"http://localhost:1\"\n\
[strategy]\ntype = \"simple_grid\"\n[strategy.params]\n{params}\n"
);
toml::from_str(&doc).expect("valid toml")
}
#[test]
fn a_config_file_must_supply_every_grid_bound() {
let cfg = SimpleGridConfig::from_config(&config_from(
"symbol = \"BTC/USDT\"\nlower_price = \"90\"\nupper_price = \"110\"\n\
num_levels = 4\nqty_per_level = \"0.1\"\n",
))
.expect("all required fields present");
assert_eq!(cfg.symbol, "BTC/USDT");
assert_eq!(cfg.lower_price, dec!(90));
assert_eq!(cfg.upper_price, dec!(110));
assert_eq!(cfg.num_levels, 4);
assert_eq!(cfg.qty_per_level, dec!(0.1));
assert_eq!(cfg.exchange_id.id, "mock", "the default venue is the mock backend");
assert!(cfg.state_file.is_none(), "state_file is optional");
assert!(cfg.profit_spread_pct.is_none(), "profit_spread_pct is optional");
}
#[test]
fn the_state_file_is_carried_through_from_the_config() {
let cfg = SimpleGridConfig::from_config(&config_from(
"symbol = \"BTC/USDT\"\nlower_price = \"90\"\nupper_price = \"110\"\n\
num_levels = 4\nqty_per_level = \"0.1\"\nstate_file = \"/var/lib/lt/grid.json\"\n",
))
.expect("all required fields present");
assert_eq!(cfg.state_file.as_deref(), Some("/var/lib/lt/grid.json"));
}
#[test]
fn each_missing_required_param_is_named_in_the_error() {
let fields = [
"symbol = \"BTC/USDT\"",
"lower_price = \"90\"",
"upper_price = \"110\"",
"num_levels = 4",
"qty_per_level = \"0.1\"",
];
for omitted in 0..fields.len() {
let body = fields
.iter()
.enumerate()
.filter(|(index, _)| *index != omitted)
.map(|(_, line)| *line)
.collect::<Vec<_>>()
.join("\n");
let err = SimpleGridConfig::from_config(&config_from(&body))
.expect_err("a missing bound must fail startup");
let key = fields[omitted].split('=').next().expect("a key is present").trim();
assert!(err.to_string().contains(key), "the error must name {key}: {err}");
}
}
#[test]
fn the_venue_and_label_are_carried_through_from_the_config() {
let cfg = SimpleGridConfig::from_config(&config_from(
"exchange_id = \"binance\"\nlabel = \"sub-1\"\nsymbol = \"BTC/USDT\"\n\
lower_price = \"90\"\nupper_price = \"110\"\nnum_levels = 4\n\
qty_per_level = \"0.1\"\n",
))
.expect("all required fields present");
assert_eq!(cfg.exchange_id.id, "binance");
assert_eq!(cfg.exchange_id.label, "sub-1");
}
proptest! {
#![proptest_config(ProptestConfig::with_cases(256))]
#[test]
fn the_ladder_is_ordered_in_band_and_correctly_sided(
lower_cent in 100i64..10_000,
width_cent in 1i64..10_000,
num_levels in 1u32..8,
current_cent in 100i64..20_000,
) {
let lower = Decimal::new(lower_cent, 2);
let upper = lower + Decimal::new(width_cent, 2);
let current = Decimal::new(current_cent, 2);
let grid = grid_with(lower, upper, num_levels);
prop_assert!(grid.grid_step > Decimal::ZERO, "a positive span needs a positive step");
let levels = grid.calculate_levels(current);
let bound = usize::try_from(num_levels).expect("u32 fits usize") + 1;
prop_assert!(
levels.len() <= bound,
"num_levels {num_levels} emitted {} levels",
levels.len()
);
for level in &levels {
prop_assert!(level.price >= lower, "{} fell below {lower}", level.price);
prop_assert!(level.price <= upper, "{} rose above {upper}", level.price);
prop_assert_eq!(
level.side,
grid::side_for(level.price, current),
"side must follow side_for at {}",
level.price
);
prop_assert!(level.client_order_id.starts_with("grid-"));
}
let ulp = Decimal::new(1, 18);
prop_assert!(
levels.windows(2).all(|w| {
(w[1].price - w[0].price - grid.grid_step).abs() <= ulp
}),
"levels must be evenly spaced"
);
}
#[test]
fn a_non_positive_span_never_produces_a_ladder(
lower_cent in 100i64..10_000,
width_cent in -10_000i64..0,
num_levels in 1u32..8,
) {
let lower = Decimal::new(lower_cent, 2);
let upper = lower + Decimal::new(width_cent, 2);
let grid = grid_with(lower, upper, num_levels);
prop_assert!(grid.grid_step <= Decimal::ZERO);
prop_assert!(
grid.calculate_levels(lower).is_empty(),
"width {width_cent} must not be laddered"
);
}
#[test]
fn every_seeded_level_gets_its_own_client_order_id(
num_levels in 1u32..6,
) {
let grid = grid_with(dec!(90), dec!(110), num_levels);
let levels = grid.calculate_levels(dec!(100));
let mut ids: Vec<String> = levels.iter().map(|l| l.client_order_id.clone()).collect();
let before = ids.len();
ids.sort();
ids.dedup();
prop_assert_eq!(ids.len(), before, "a client order id was reused");
}
}
}