use std::{collections::HashSet, sync::Arc, time::Duration};
use async_trait::async_trait;
use color_eyre::Result;
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use serde::Deserialize;
use tokio::sync::Mutex;
use crate::{
indicators::Ema,
ports::{MarketDataSource, PortError, TradingGateway},
proto::{common, market, trading},
strategies::{CommonParams, Strategy, limit_order, mid_price, params_from_table},
};
#[derive(Debug, Clone, Deserialize)]
pub struct SkewedGridConfig {
#[serde(flatten)]
pub common: CommonParams,
pub grid_tick: Decimal,
#[serde(default = "default_levels")]
pub num_levels: u32,
pub qty_per_level: Decimal,
#[serde(default = "default_gamma")]
pub gamma: Decimal,
#[serde(default = "default_sigma")]
pub sigma: Decimal,
#[serde(default = "default_horizon")]
pub time_horizon: Decimal,
#[serde(default = "default_vol_window")]
pub vol_window: usize,
}
fn default_levels() -> u32 {
5
}
fn default_gamma() -> Decimal {
dec!(0.1)
}
fn default_sigma() -> Decimal {
dec!(1)
}
fn default_horizon() -> Decimal {
dec!(1)
}
fn default_vol_window() -> usize {
20
}
impl SkewedGridConfig {
pub fn from_params(table: &toml::Table) -> Result<Self> {
params_from_table(table)
}
}
#[derive(Debug, Clone)]
#[allow(dead_code)]
struct GridLevel {
price: Decimal,
side: trading::OrderSide,
client_order_id: String,
order_id: String,
}
#[must_use]
pub fn reservation_price(
mid: Decimal,
inventory: Decimal,
gamma: Decimal,
sigma: Decimal,
time_horizon: Decimal,
) -> Option<Decimal> {
if gamma < Decimal::ZERO || sigma < Decimal::ZERO {
return None;
}
let skew = inventory * gamma * sigma * sigma * time_horizon;
Some(mid - skew)
}
#[must_use]
pub fn plan_skewed_grid(
reservation: Decimal,
mid: Decimal,
grid_tick: Decimal,
num_levels: u32,
is_buy: bool,
) -> Vec<Decimal> {
if grid_tick <= Decimal::ZERO || num_levels == 0 {
return Vec::new();
}
let mut levels = Vec::with_capacity(num_levels as usize);
let direction = if is_buy { -Decimal::ONE } else { Decimal::ONE };
let start = reservation + direction * grid_tick;
for i in 0..num_levels {
let price = start + direction * grid_tick * Decimal::from(i);
if is_buy && price >= mid {
break;
}
if !is_buy && price <= mid {
break;
}
levels.push(price);
}
levels
}
pub struct SkewedGrid {
config: SkewedGridConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
levels: Mutex<Vec<GridLevel>>,
inventory: Mutex<Decimal>,
last_mid: Mutex<Option<Decimal>>,
vol_ema: Mutex<Ema>,
max_consecutive_errors: u32,
}
impl SkewedGrid {
pub fn new(
config: SkewedGridConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
) -> Self {
Self {
config,
gateway,
market,
levels: Mutex::new(Vec::new()),
inventory: Mutex::new(Decimal::ZERO),
last_mid: Mutex::new(None),
vol_ema: Mutex::new(Ema::new(default_vol_window())),
max_consecutive_errors: 10,
}
}
async fn current_mid(&self) -> Result<Decimal> {
let exchange = self.config.common.proto_exchange_id();
let ticker = self
.market
.fetch_ticker(market::FetchTickerRequest {
exchange_id: buffa::MessageField::some(exchange.clone()),
symbol: self.config.common.symbol.clone(),
..Default::default()
})
.await?;
for field in [ticker.last.as_option(), ticker.close.as_option()] {
if let Some(price) = Self::usable_price(field) {
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 for {}", self.config.common.symbol)
}
fn usable_price(candidate: Option<&common::Decimal>) -> Option<Decimal> {
let price = longtrader_contract::ext::common_to_decimal(candidate?).ok()?;
(price > Decimal::ZERO).then_some(price)
}
async fn update_volatility(&self, mid: Decimal) -> Option<Decimal> {
let mut last = self.last_mid.lock().await;
let mut ema = self.vol_ema.lock().await;
if let Some(prev) = *last {
let ret = (mid - prev).abs();
ema.push(ret);
}
*last = Some(mid);
ema.value()
}
async fn place_order(&self, price: Decimal, is_buy: bool) -> Result<String, PortError> {
let coid = format!("skewgrid-{}", ulid::Ulid::generate());
let order = self
.gateway
.create_order(limit_order(
&self.config.common.proto_exchange_id(),
&self.config.common.symbol,
coid.clone(),
is_buy,
price,
self.config.qty_per_level,
))
.await?;
Ok(order.id)
}
async fn cancel_all_tracked(&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.common.proto_exchange_id()),
order_id: level.order_id.clone(),
symbol: self.config.common.symbol.clone(),
..Default::default()
})
.await
{
tracing::warn!(order_id = %level.order_id, error = %err, "skew-grid cancel failed");
}
}
}
#[allow(clippy::cognitive_complexity)]
async fn rebalance(&self) -> Result<()> {
let mid = self.current_mid().await?;
let sigma_estimate = self.update_volatility(mid).await;
let sigma = sigma_estimate.unwrap_or(self.config.sigma);
let inv = *self.inventory.lock().await;
let reservation =
reservation_price(mid, inv, self.config.gamma, sigma, self.config.time_horizon)
.unwrap_or(mid);
let buy_prices =
plan_skewed_grid(reservation, mid, self.config.grid_tick, self.config.num_levels, true);
let sell_prices = plan_skewed_grid(
reservation,
mid,
self.config.grid_tick,
self.config.num_levels,
false,
);
let snapshot: Vec<GridLevel> = self.levels.lock().await.clone();
if snapshot.is_empty() {
let mut fresh = Vec::new();
let mut errors = 0u32;
for price in &buy_prices {
match self.place_order(*price, true).await {
Ok(id) => fresh.push(GridLevel {
price: *price,
side: trading::OrderSide::Buy,
client_order_id: String::new(),
order_id: id,
}),
Err(err) => {
errors += 1;
tracing::error!(price = %price, error = %err, "buy placement failed");
}
}
}
for price in &sell_prices {
match self.place_order(*price, false).await {
Ok(id) => fresh.push(GridLevel {
price: *price,
side: trading::OrderSide::Sell,
client_order_id: String::new(),
order_id: id,
}),
Err(err) => {
errors += 1;
tracing::error!(price = %price, error = %err, "sell placement failed");
}
}
}
if errors >= self.max_consecutive_errors {
tracing::error!(errors, "skew-grid kill-switch tripped on init");
self.cancel_all_tracked(&fresh).await;
fresh.clear();
}
*self.levels.lock().await = fresh;
return Ok(());
}
let live_prices: HashSet<Decimal> = snapshot.iter().map(|l| l.price).collect();
let mut desired = HashSet::new();
for p in &buy_prices {
desired.insert(*p);
}
for p in &sell_prices {
desired.insert(*p);
}
let mut updated = snapshot;
let mut errors = 0u32;
let mut stale = Vec::new();
updated.retain(|level| {
if desired.contains(&level.price) {
return true;
}
if !level.order_id.is_empty() {
stale.push(level.order_id.clone());
}
false
});
if !stale.is_empty() {
let exchange_id = self.config.common.proto_exchange_id();
let symbol = self.config.common.symbol.clone();
let cancels: Vec<_> = stale
.into_iter()
.map(|order_id| {
let gateway = self.gateway.clone();
let exchange_id = exchange_id.clone();
let symbol = symbol.clone();
let reported = order_id.clone();
async move {
(
reported,
gateway
.cancel_order(trading::CancelOrderRequest {
exchange_id: buffa::MessageField::some(exchange_id),
order_id,
symbol,
..Default::default()
})
.await,
)
}
})
.collect();
for (order_id, outcome) in futures_util::future::join_all(cancels).await {
if let Err(err) = outcome {
tracing::error!(
order_id = %order_id,
error = %err,
"skew-grid stale-level cancel failed; the order may still be resting"
);
}
}
}
for price in &desired {
if live_prices.contains(price) {
continue;
}
let is_buy = *price < mid;
match self.place_order(*price, is_buy).await {
Ok(id) => updated.push(GridLevel {
price: *price,
side: if is_buy { trading::OrderSide::Buy } else { trading::OrderSide::Sell },
client_order_id: String::new(),
order_id: id,
}),
Err(err) => {
errors += 1;
tracing::error!(price = %price, error = %err, "skew-grid placement failed");
}
}
}
self.update_inventory(&updated, mid).await;
if errors >= self.max_consecutive_errors {
tracing::error!(errors, "skew-grid kill-switch tripped during rebalance");
self.cancel_all_tracked(&updated).await;
updated.clear();
}
*self.levels.lock().await = updated;
Ok(())
}
async fn update_inventory(&self, current: &[GridLevel], mid: Decimal) {
let mut inv = self.inventory.lock().await;
*inv *= dec!(0.95);
let _ = (current, mid);
}
pub async fn record_fill(&self, qty: Decimal, is_buy: bool) {
let mut inv = self.inventory.lock().await;
if is_buy {
*inv += qty;
} else {
*inv -= qty;
}
}
}
#[async_trait]
impl Strategy for SkewedGrid {
async fn run(&self) -> Result<()> {
tracing::info!(
symbol = %self.config.common.symbol,
gamma = %self.config.gamma,
sigma = %self.config.sigma,
levels = %self.config.num_levels,
"starting Avellaneda–Stoikov skewed grid"
);
let poll = Duration::from_secs(self.config.common.poll_secs.max(1));
loop {
if let Err(err) = self.rebalance().await {
tracing::error!(error = %err, "skew-grid rebalance error");
}
tokio::time::sleep(poll).await;
}
}
}
#[cfg(test)]
mod tests {
use rust_decimal_macros::dec;
use super::*;
#[test]
fn reservation_skews_with_inventory() {
assert_eq!(
reservation_price(dec!(100), dec!(0), dec!(0.1), dec!(1), dec!(1)),
Some(dec!(100))
);
let r = reservation_price(dec!(100), dec!(1), dec!(0.1), dec!(1), dec!(1));
assert_eq!(r, Some(dec!(99.9)));
let r = reservation_price(dec!(100), dec!(-1), dec!(0.1), dec!(1), dec!(1));
assert_eq!(r, Some(dec!(100.1)));
}
#[test]
fn reservation_rejects_negative_params() {
assert!(reservation_price(dec!(100), dec!(1), dec!(-0.1), dec!(1), dec!(1)).is_none());
assert!(reservation_price(dec!(100), dec!(1), dec!(0.1), dec!(-1), dec!(1)).is_none());
}
#[test]
fn grid_places_levels_straddling_reservation() {
let buys = plan_skewed_grid(dec!(99.5), dec!(100), dec!(1), 3, true);
assert_eq!(buys, vec![dec!(98.5), dec!(97.5), dec!(96.5)]);
let sells = plan_skewed_grid(dec!(99.5), dec!(100), dec!(1), 3, false);
assert_eq!(sells, vec![dec!(100.5), dec!(101.5), dec!(102.5)]);
}
#[test]
fn grid_rejects_invalid_tick() {
assert!(plan_skewed_grid(dec!(100), dec!(100), dec!(0), 3, true).is_empty());
assert!(plan_skewed_grid(dec!(100), dec!(100), dec!(-1), 3, true).is_empty());
assert!(plan_skewed_grid(dec!(100), dec!(100), dec!(1), 0, true).is_empty());
}
#[test]
fn buys_stay_below_mid_sells_above() {
let buys = plan_skewed_grid(dec!(50), dec!(100), dec!(1), 100, true);
assert!(buys.iter().all(|p| *p < dec!(100)));
let sells = plan_skewed_grid(dec!(150), dec!(100), dec!(1), 100, false);
assert!(sells.iter().all(|p| *p > dec!(100)));
}
#[test]
fn config_parses_with_defaults() {
let table: toml::Table =
toml::from_str("symbol = \"BTC/USDT\"\ngrid_tick = \"1.0\"\nqty_per_level = \"0.01\"")
.expect("toml");
let cfg = SkewedGridConfig::from_params(&table).expect("parse");
assert_eq!(cfg.grid_tick, dec!(1));
assert_eq!(cfg.num_levels, 5);
assert_eq!(cfg.gamma, dec!(0.1));
assert_eq!(cfg.sigma, dec!(1));
assert_eq!(cfg.time_horizon, dec!(1));
assert_eq!(cfg.vol_window, 20);
}
#[test]
fn config_can_override_every_field() {
let table: toml::Table = toml::from_str(
"symbol = \"BTC/USDT\"\ngrid_tick = \"0.5\"\nnum_levels = 10\n\
qty_per_level = \"0.01\"\ngamma = \"0.2\"\nsigma = \"2.0\"\n\
time_horizon = \"0.5\"\nvol_window = 30",
)
.expect("toml");
let cfg = SkewedGridConfig::from_params(&table).expect("parse");
assert_eq!(cfg.grid_tick, dec!(0.5));
assert_eq!(cfg.num_levels, 10);
assert_eq!(cfg.qty_per_level, dec!(0.01));
assert_eq!(cfg.gamma, dec!(0.2));
assert_eq!(cfg.sigma, dec!(2));
assert_eq!(cfg.time_horizon, dec!(0.5));
assert_eq!(cfg.vol_window, 30);
}
}