use std::{collections::HashMap, sync::Arc};
use async_trait::async_trait;
use color_eyre::Result;
use rust_decimal::Decimal;
use serde::Deserialize;
use tokio::sync::Mutex;
use crate::{
ports::{MarketDataSource, TradingGateway},
strategies::{CrossVenueParams, Strategy, limit_order, market_order},
};
#[derive(Debug, Clone, Deserialize)]
pub struct HedgeGridConfig {
#[serde(flatten)]
pub venues: CrossVenueParams,
pub lower_price: Decimal,
pub upper_price: Decimal,
pub num_levels: u32,
pub qty_per_level: Decimal,
}
pub struct HedgeGrid {
config: HedgeGridConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
believed: Mutex<HashMap<Decimal, bool>>,
}
impl HedgeGrid {
pub fn new(
config: HedgeGridConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
) -> Self {
Self { config, gateway, market, believed: Mutex::new(HashMap::new()) }
}
pub async fn tick(&self) -> Result<()> {
let primary = self.config.venues.primary.proto();
let hedge = self.config.venues.hedge.proto();
let symbol = self.config.venues.symbol.clone();
let ticker = self
.market
.fetch_ticker(crate::proto::market::FetchTickerRequest {
exchange_id: buffa::MessageField::some(primary.clone()),
symbol: symbol.clone(),
..Default::default()
})
.await?;
let mid = ticker
.last
.as_option()
.map(longtrader_contract::ext::common_to_decimal)
.transpose()?
.unwrap_or_default();
if mid.is_sign_negative() || mid.is_zero() {
return Ok(());
}
if self.config.num_levels == 0 {
return Ok(());
}
let step = (self.config.upper_price - self.config.lower_price) /
Decimal::from(self.config.num_levels);
if step <= Decimal::ZERO {
return Ok(());
}
let open = self
.gateway
.fetch_open_orders(crate::proto::trading::FetchOpenOrdersRequest {
exchange_id: buffa::MessageField::some(primary.clone()),
symbol: symbol.clone(),
pagination: buffa::MessageField::none(),
..Default::default()
})
.await?;
let mut live: HashMap<Decimal, bool> = HashMap::with_capacity(open.len());
for order in &open {
if let Some(Ok(price)) =
order.price.as_option().map(longtrader_contract::ext::common_to_decimal)
{
let is_buy =
order.side == buffa::EnumValue::Known(crate::proto::trading::OrderSide::Buy);
live.insert(price, is_buy);
}
}
let previous = {
let mut believed = self.believed.lock().await;
std::mem::take(&mut *believed)
};
for (price, was_buy) in previous.iter().filter(|(price, _)| !live.contains_key(*price)) {
let coid = format!("hg-hedge-{}", ulid::Ulid::generate());
self.gateway
.create_order(market_order(
&hedge,
&symbol,
coid,
!*was_buy,
self.config.qty_per_level,
))
.await?;
tracing::info!(%price, hedge_is_buy = !*was_buy, "grid level left the book; hedged");
}
let mut believed = HashMap::new();
let mut price = self.config.lower_price;
while price <= self.config.upper_price {
if let Some(resting_is_buy) = live.get(&price) {
believed.insert(price, *resting_is_buy);
} else {
let is_buy = price < mid;
let coid = format!("hg-{}", ulid::Ulid::generate());
let request =
limit_order(&primary, &symbol, coid, is_buy, price, self.config.qty_per_level);
self.gateway.create_order(request).await?;
believed.insert(price, is_buy);
}
price += step;
}
*self.believed.lock().await = believed;
Ok(())
}
}
#[async_trait]
impl Strategy for HedgeGrid {
async fn run(&self) -> Result<()> {
let poll = std::time::Duration::from_secs(self.config.venues.poll_secs.max(1));
loop {
if let Err(err) = self.tick().await {
tracing::error!(error = %err, "hedge-grid tick failed");
}
tokio::time::sleep(poll).await;
}
}
}
#[cfg(test)]
mod tests {
use std::sync::{
Mutex,
atomic::{AtomicUsize, Ordering},
};
use longtrader_contract::ext::{DecimalConvertError, decimal_to_common};
use proptest::prelude::*;
use rust_decimal_macros::dec;
use super::*;
use crate::{
adapters::MockAdapter,
ports::PortError,
proto::{common, market, trading, worker},
strategies::VenueRef,
};
const SYMBOL: &str = "BTC/USDT";
fn config() -> HedgeGridConfig {
HedgeGridConfig {
venues: CrossVenueParams {
primary: VenueRef { exchange_id: "primary".into(), label: String::new() },
hedge: VenueRef { exchange_id: "hedge".into(), label: String::new() },
symbol: SYMBOL.into(),
poll_secs: 30,
},
lower_price: dec!(90),
upper_price: dec!(110),
num_levels: 4,
qty_per_level: dec!(0.1),
}
}
fn config_in_band(lower: Decimal, upper: Decimal, levels: u32) -> HedgeGridConfig {
let mut config = config();
config.lower_price = lower;
config.upper_price = upper;
config.num_levels = levels;
config
}
fn ladder(lower: i64, step: i64, levels: u32) -> HedgeGridConfig {
let base = Decimal::from(lower);
config_in_band(base, base + Decimal::from(i64::from(levels) * step), levels)
}
fn mock_market(mid: Decimal) -> Arc<dyn MarketDataSource> {
Arc::new(MockAdapter::new(mid))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Scripted {
Transport,
Rpc,
Unsupported,
MissingField,
InvalidArgument,
NotFound,
Decimal,
}
fn scripted_error(kind: Scripted) -> PortError {
match kind {
Scripted::Transport => PortError::Transport("venue read failed".into()),
Scripted::Rpc => PortError::Rpc { code: 8, message: "rate limited".into() },
Scripted::Unsupported => PortError::Unsupported("open orders".into()),
Scripted::MissingField => PortError::MissingField("symbol".into()),
Scripted::InvalidArgument => PortError::InvalidArgument("bad symbol".into()),
Scripted::NotFound => PortError::NotFound("open orders".into()),
Scripted::Decimal => PortError::Decimal(DecimalConvertError::NotBase10 {
value: "1e3".into(),
reason: "exponents are not accepted",
}),
}
}
#[derive(Default)]
struct ScriptedGateway {
open_orders: Mutex<Vec<trading::Order>>,
open_failure: Mutex<Option<Scripted>>,
create_failure: Mutex<Option<(usize, Scripted)>>,
submitted: Mutex<Vec<trading::CreateOrderRequest>>,
open_calls: AtomicUsize,
}
impl ScriptedGateway {
fn resting(&self, orders: Vec<trading::Order>) -> &Self {
*self.open_orders.lock().expect("gateway mutex") = orders;
self
}
fn filled(&self, price: Decimal) -> &Self {
self.open_orders.lock().expect("gateway mutex").retain(|order| {
order
.price
.as_option()
.and_then(|d| longtrader_contract::ext::common_to_decimal(d).ok()) !=
Some(price)
});
self
}
fn fail_open(&self, kind: Scripted) -> &Self {
*self.open_failure.lock().expect("gateway mutex") = Some(kind);
self
}
fn fail_create(&self, kind: Scripted) -> &Self {
self.fail_create_from(0, kind)
}
fn fail_create_from(&self, index: usize, kind: Scripted) -> &Self {
*self.create_failure.lock().expect("gateway mutex") = Some((index, kind));
self
}
fn heal_creates(&self) -> &Self {
*self.create_failure.lock().expect("gateway mutex") = None;
self
}
fn resting_orders(&self) -> Vec<trading::Order> {
self.open_orders.lock().expect("gateway mutex").clone()
}
fn submitted(&self) -> Vec<trading::CreateOrderRequest> {
self.submitted.lock().expect("gateway mutex").clone()
}
fn clear_submitted(&self) {
self.submitted.lock().expect("gateway mutex").clear();
}
fn open_reads(&self) -> usize {
self.open_calls.load(Ordering::Relaxed)
}
}
#[async_trait]
impl TradingGateway for ScriptedGateway {
async fn create_order(
&self,
req: trading::CreateOrderRequest,
) -> std::result::Result<trading::Order, PortError> {
let index = {
let mut submitted = self.submitted.lock().expect("gateway mutex");
submitted.push(req.clone());
submitted.len() - 1
};
if let Some((from, kind)) = *self.create_failure.lock().expect("gateway mutex") &&
index >= from
{
return Err(scripted_error(kind));
}
let inner = req.order.as_option().cloned().unwrap_or_default();
let accepted = trading::Order {
id: format!("placed-{}", inner.client_order_id),
client_order_id: inner.client_order_id,
symbol: inner.symbol,
r#type: inner.r#type,
side: inner.side,
price: inner.price,
..Default::default()
};
self.open_orders.lock().expect("gateway mutex").push(accepted.clone());
Ok(accepted)
}
async fn batch_create_orders(
&self,
_req: trading::CreateOrdersRequest,
) -> std::result::Result<Vec<trading::Order>, PortError> {
Err(PortError::Unsupported("batch_create_orders".into()))
}
async fn cancel_order(
&self,
_req: trading::CancelOrderRequest,
) -> std::result::Result<trading::Order, PortError> {
Err(PortError::Unsupported("cancel_order".into()))
}
async fn cancel_all_orders(
&self,
_req: trading::CancelAllOrdersRequest,
) -> std::result::Result<Vec<trading::Order>, PortError> {
Err(PortError::Unsupported("cancel_all_orders".into()))
}
async fn fetch_open_orders(
&self,
_req: trading::FetchOpenOrdersRequest,
) -> std::result::Result<Vec<trading::Order>, PortError> {
self.open_calls.fetch_add(1, Ordering::Relaxed);
if let Some(kind) = *self.open_failure.lock().expect("gateway mutex") {
return Err(scripted_error(kind));
}
Ok(self.open_orders.lock().expect("gateway mutex").clone())
}
async fn get_account(
&self,
_req: trading::GetAccountRequest,
) -> std::result::Result<trading::GetAccountResponse, PortError> {
Err(PortError::Unsupported("get_account".into()))
}
async fn get_positions(
&self,
_req: trading::GetPositionsRequest,
) -> std::result::Result<trading::GetPositionsResponse, PortError> {
Err(PortError::Unsupported("get_positions".into()))
}
async fn get_order_history(
&self,
_req: trading::GetOrderHistoryRequest,
) -> std::result::Result<trading::GetOrderHistoryResponse, PortError> {
Err(PortError::Unsupported("get_order_history".into()))
}
async fn get_closed_positions(
&self,
_req: trading::GetClosedPositionsRequest,
) -> std::result::Result<trading::GetClosedPositionsResponse, PortError> {
Err(PortError::Unsupported("get_closed_positions".into()))
}
async fn close_position(
&self,
_req: trading::ClosePositionRequest,
) -> std::result::Result<trading::ClosePositionResponse, PortError> {
Err(PortError::Unsupported("close_position".into()))
}
async fn close_all_positions(
&self,
_req: trading::CloseAllPositionsRequest,
) -> std::result::Result<trading::CloseAllPositionsResponse, PortError> {
Err(PortError::Unsupported("close_all_positions".into()))
}
async fn modify_position(
&self,
_req: trading::ModifyPositionRequest,
) -> std::result::Result<trading::ModifyPositionResponse, PortError> {
Err(PortError::Unsupported("modify_position".into()))
}
async fn sync_state(
&self,
_exchange_id: &common::ExchangeId,
) -> std::result::Result<worker::ReconcileStateResponse, PortError> {
Ok(worker::ReconcileStateResponse::default())
}
}
struct TickerStub(Option<market::Ticker>);
impl TickerStub {
fn of(ticker: market::Ticker) -> Self {
Self(Some(ticker))
}
fn down() -> Self {
Self(None)
}
}
#[async_trait]
impl MarketDataSource for TickerStub {
async fn fetch_ticker(
&self,
req: market::FetchTickerRequest,
) -> std::result::Result<market::Ticker, PortError> {
self.0
.clone()
.ok_or_else(|| PortError::Transport("ticker feed down".into()))
.map(|ticker| market::Ticker { symbol: req.symbol, ..ticker })
}
async fn fetch_order_book(
&self,
_req: market::FetchOrderBookRequest,
) -> std::result::Result<market::OrderBook, PortError> {
Err(PortError::Unsupported("fetch_order_book".into()))
}
async fn get_candles(
&self,
_req: market::GetCandlesRequest,
) -> std::result::Result<market::GetCandlesResponse, PortError> {
Err(PortError::Unsupported("get_candles".into()))
}
async fn list_symbols(
&self,
_req: market::ListSymbolsRequest,
) -> std::result::Result<market::ListSymbolsResponse, PortError> {
Err(PortError::Unsupported("list_symbols".into()))
}
async fn search_symbols(
&self,
_req: market::SearchSymbolsRequest,
) -> std::result::Result<market::SearchSymbolsResponse, PortError> {
Err(PortError::Unsupported("search_symbols".into()))
}
async fn list_tickers(
&self,
_req: market::ListTickersRequest,
) -> std::result::Result<market::ListTickersResponse, PortError> {
Err(PortError::Unsupported("list_tickers".into()))
}
async fn subscribe_market_data(
&self,
_req: market::StreamMarketDataRequest,
_policy: crate::ports::OverflowPolicy,
) -> std::result::Result<crate::ports::MarketEventStream, PortError> {
Err(PortError::Unsupported("subscribe_market_data".into()))
}
}
fn grid_with(
config: HedgeGridConfig,
source: Arc<dyn MarketDataSource>,
) -> (Arc<ScriptedGateway>, HedgeGrid) {
let gateway = Arc::new(ScriptedGateway::default());
let grid = HedgeGrid::new(config, gateway.clone(), source);
(gateway, grid)
}
fn tick_once(
config: HedgeGridConfig,
source: Arc<dyn MarketDataSource>,
) -> (Arc<ScriptedGateway>, Result<()>) {
let (gateway, grid) = grid_with(config, source);
let runtime = tokio::runtime::Builder::new_current_thread()
.build()
.expect("a current-thread runtime");
let outcome = runtime.block_on(grid.tick());
(gateway, outcome)
}
fn resting(side: trading::OrderSide, price: Decimal) -> trading::Order {
trading::Order {
id: format!("resting-{side:?}-{price}"),
symbol: SYMBOL.into(),
r#type: buffa::EnumValue::Known(trading::OrderType::Limit),
side: buffa::EnumValue::Known(side),
status: buffa::EnumValue::Known(trading::OrderStatus::Open),
price: buffa::MessageField::some(decimal_to_common(price)),
..Default::default()
}
}
fn legs(requests: &[trading::CreateOrderRequest]) -> Vec<(Decimal, bool)> {
requests
.iter()
.filter_map(|req: &trading::CreateOrderRequest| -> Option<(Decimal, bool)> {
let inner = req.order.as_option()?;
if inner.r#type != buffa::EnumValue::Known(trading::OrderType::Limit) {
return None;
}
let price =
longtrader_contract::ext::common_to_decimal(inner.price.as_option()?).ok()?;
Some((price, inner.side == buffa::EnumValue::Known(trading::OrderSide::Buy)))
})
.collect()
}
fn venues(requests: &[trading::CreateOrderRequest]) -> Vec<String> {
requests
.iter()
.map(|req| req.exchange_id.as_option().map_or_else(String::new, |id| id.id.clone()))
.collect()
}
fn is_hedge_leg(req: &trading::CreateOrderRequest) -> bool {
req.order
.as_option()
.is_some_and(|o| o.r#type == buffa::EnumValue::Known(trading::OrderType::Market))
}
fn hedge_leg(requests: &[trading::CreateOrderRequest]) -> Option<&trading::CreateOrderRequest> {
requests.iter().find(|req| is_hedge_leg(req))
}
fn amount_of(amount: Option<&common::Decimal>) -> Decimal {
let raw = amount.expect("every request carries an amount");
longtrader_contract::ext::common_to_decimal(raw).expect("a representable amount")
}
#[tokio::test]
async fn a_zero_level_count_is_a_no_op_instead_of_a_divide_by_zero() {
let mut config = config();
config.num_levels = 0;
let (gateway, grid) = grid_with(config, mock_market(dec!(100)));
grid.tick().await.expect("a zero level count is not an error");
assert!(gateway.submitted().is_empty(), "the guard must place no order");
assert_eq!(gateway.open_reads(), 0, "the guard must run before any venue read");
}
#[tokio::test]
async fn an_inverted_span_is_a_no_op() {
let mut config = config();
config.lower_price = dec!(110);
config.upper_price = dec!(90);
let (gateway, grid) = grid_with(config, mock_market(dec!(100)));
grid.tick().await.expect("an inverted span is not an error");
assert!(gateway.submitted().is_empty(), "an inverted band must place no order");
assert_eq!(gateway.open_reads(), 0);
}
#[tokio::test]
async fn a_collapsed_span_is_a_no_op() {
let mut config = config();
config.lower_price = dec!(100);
config.upper_price = dec!(100);
let (gateway, grid) = grid_with(config, mock_market(dec!(100)));
grid.tick().await.expect("a collapsed span is not an error");
assert!(gateway.submitted().is_empty(), "a zero-width band must place no order");
assert_eq!(gateway.open_reads(), 0);
}
#[tokio::test]
async fn the_level_count_is_checked_before_the_step_is_computed() {
let mut config = config();
config.num_levels = 0;
config.lower_price = dec!(110);
config.upper_price = dec!(90);
let (gateway, grid) = grid_with(config, mock_market(dec!(100)));
grid.tick().await.expect("degenerate configs are not errors");
assert!(gateway.submitted().is_empty());
assert_eq!(gateway.open_reads(), 0);
}
#[tokio::test]
async fn the_first_tick_seeds_one_leg_per_level_below_or_above_the_mid() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
grid.tick().await.expect("seeded");
let submitted = gateway.submitted();
assert_eq!(
legs(&submitted),
vec![
(dec!(90), true),
(dec!(95), true),
(dec!(100), false),
(dec!(105), false),
(dec!(110), false),
],
"a level below the mid buys and every other level sells"
);
assert_eq!(venues(&submitted), vec!["primary".to_string(); 5], "the grid rests on primary");
assert_eq!(hedge_leg(&submitted), None, "nothing has left the book yet");
}
#[tokio::test]
async fn a_level_that_already_has_a_resting_order_is_not_seeded_again() {
let mut config = config();
config.upper_price = dec!(100);
config.num_levels = 5;
let (gateway, grid) = grid_with(config, mock_market(dec!(95)));
grid.tick().await.expect("first poll");
let first = legs(&gateway.submitted());
assert_eq!(first.len(), 6, "the first poll seeds the whole ladder");
assert_eq!(gateway.open_reads(), 1);
gateway.clear_submitted();
grid.tick().await.expect("second poll");
assert_eq!(legs(&gateway.submitted()), Vec::new(), "every level already rests an order");
assert_eq!(hedge_leg(&gateway.submitted()), None, "a resting ladder has no fill to hedge");
assert_eq!(gateway.open_reads(), 2);
}
#[tokio::test]
async fn a_resting_order_at_an_off_ladder_price_suppresses_nothing() {
let gateway = Arc::new(ScriptedGateway::default());
gateway.resting(vec![
resting(trading::OrderSide::Buy, dec!(1)),
resting(trading::OrderSide::Sell, dec!(2)),
]);
let grid = HedgeGrid::new(config(), gateway.clone(), mock_market(dec!(100)));
grid.tick().await.expect("seeded");
assert_eq!(legs(&gateway.submitted()).len(), 5, "no ladder level is covered");
}
#[tokio::test]
async fn a_bid_that_left_the_book_sells_the_hedge_on_the_hedge_venue() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
grid.tick().await.expect("seeded");
gateway.clear_submitted();
gateway.filled(dec!(95));
grid.tick().await.expect("hedged");
let submitted = gateway.submitted();
let hedge = hedge_leg(&submitted).expect("a filled level must be hedged");
assert_eq!(hedge.exchange_id.as_option().map(|id| id.id.as_str()), Some("hedge"));
let order = hedge.order.as_option().expect("a request always carries an order");
assert_eq!(order.side, buffa::EnumValue::Known(trading::OrderSide::Sell));
assert!(order.price.as_option().is_none(), "a hedge is a market order");
assert_eq!(order.symbol, SYMBOL, "both venues trade the same symbol");
assert_eq!(amount_of(order.amount.as_option()), dec!(0.1), "covers exactly one level");
}
#[tokio::test]
async fn an_ask_that_left_the_book_buys_the_hedge_on_the_hedge_venue() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
grid.tick().await.expect("seeded");
gateway.clear_submitted();
gateway.filled(dec!(105));
grid.tick().await.expect("hedged");
let submitted = gateway.submitted();
let hedge = hedge_leg(&submitted).expect("a filled level must be hedged");
let order = hedge.order.as_option().expect("a request always carries an order");
assert_eq!(order.side, buffa::EnumValue::Known(trading::OrderSide::Buy));
}
#[tokio::test]
async fn a_ladder_that_is_still_fully_resting_places_no_hedge_order() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
grid.tick().await.expect("seeded");
gateway.clear_submitted();
grid.tick().await.expect("second poll");
assert_eq!(hedge_leg(&gateway.submitted()), None, "nothing left the book");
assert_eq!(legs(&gateway.submitted()), Vec::new(), "and nothing was re-seeded");
}
#[tokio::test]
async fn every_level_that_left_the_book_is_hedged_separately() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
grid.tick().await.expect("seeded");
gateway.clear_submitted();
gateway.filled(dec!(90));
gateway.filled(dec!(95));
grid.tick().await.expect("hedged");
let submitted = gateway.submitted();
let hedges: Vec<&trading::CreateOrderRequest> =
submitted.iter().filter(|req| is_hedge_leg(req)).collect();
assert_eq!(hedges.len(), 2, "two fills are two hedges");
for hedge in &hedges {
assert_eq!(hedge.exchange_id.as_option().map(|id| id.id.as_str()), Some("hedge"));
}
}
#[tokio::test]
async fn the_grid_does_not_hedge_the_imbalance_it_seeded_itself() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
grid.tick().await.expect("first poll");
gateway.clear_submitted();
grid.tick().await.expect("second poll");
assert_eq!(
hedge_leg(&gateway.submitted()),
None,
"2 resting bids vs 3 resting asks is the ladder's own shape, not a fill"
);
}
#[tokio::test]
async fn a_zero_mid_returns_before_any_venue_work() {
let (gateway, grid) = grid_with(config(), mock_market(Decimal::ZERO));
grid.tick().await.expect("a flat ticker is not an error");
assert!(gateway.submitted().is_empty(), "there is no side to take without a mid");
assert_eq!(gateway.open_reads(), 0);
}
#[tokio::test]
async fn a_ticker_without_a_last_price_is_read_as_a_zero_mid() {
let blank = market::Ticker::default();
let (gateway, grid) = grid_with(config(), Arc::new(TickerStub::of(blank)));
grid.tick().await.expect("no last price is not an error");
assert!(gateway.submitted().is_empty());
assert_eq!(gateway.open_reads(), 0);
}
#[tokio::test]
async fn a_negative_mid_is_rejected_before_any_venue_work() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(-5)));
grid.tick().await.expect("a negative ticker is not an error");
assert!(gateway.submitted().is_empty(), "no level may be priced off a negative mid");
assert_eq!(gateway.open_reads(), 0, "the guard runs before any venue read");
}
#[tokio::test]
async fn an_undecodable_last_price_propagates_before_any_order_work() {
let ticker = market::Ticker {
last: buffa::MessageField::some(common::Decimal {
value: "not-a-number".to_string(),
..Default::default()
}),
..Default::default()
};
let (gateway, grid) = grid_with(config(), Arc::new(TickerStub::of(ticker)));
let err = grid.tick().await.expect_err("an undecodable price must not read as flat");
assert!(err.to_string().contains("not-a-number"), "{err}");
assert!(gateway.submitted().is_empty());
assert_eq!(gateway.open_reads(), 0);
}
#[tokio::test]
async fn a_ticker_failure_propagates_and_places_no_order() {
let (gateway, grid) = grid_with(config(), Arc::new(TickerStub::down()));
let err = grid.tick().await.expect_err("a dead ticker feed must not read as a flat tick");
assert!(err.to_string().contains("ticker feed down"), "{err}");
assert!(gateway.submitted().is_empty());
assert_eq!(gateway.open_reads(), 0);
}
#[tokio::test]
async fn every_fetch_open_orders_failure_propagates_and_places_no_order() {
for kind in [
Scripted::Transport,
Scripted::Rpc,
Scripted::Unsupported,
Scripted::MissingField,
Scripted::InvalidArgument,
Scripted::NotFound,
Scripted::Decimal,
] {
let gateway = Arc::new(ScriptedGateway::default());
gateway.fail_open(kind);
let grid = HedgeGrid::new(config(), gateway.clone(), mock_market(dec!(100)));
let err = grid.tick().await.expect_err("an unreadable open-order set must surface");
let expected = scripted_error(kind).to_string();
assert!(err.to_string().contains(&expected), "{kind:?} surfaced as {err}");
assert!(gateway.submitted().is_empty(), "{kind:?} must place no order");
}
}
#[tokio::test]
async fn a_failed_hedge_placement_propagates() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
grid.tick().await.expect("seeded");
gateway.clear_submitted();
gateway.filled(dec!(95));
gateway.fail_create_from(0, Scripted::Rpc);
let err = grid.tick().await.expect_err("a rejected hedge must surface");
let expected = scripted_error(Scripted::Rpc).to_string();
assert!(err.to_string().contains(&expected), "{err}");
assert_eq!(gateway.submitted().len(), 1, "the cycle stops at the refused hedge");
}
#[tokio::test]
async fn a_rejected_grid_leg_propagates_and_stops_the_cycle() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
gateway.fail_create(Scripted::Transport);
let err = grid.tick().await.expect_err("a rejected leg must not read as a full grid");
let expected = scripted_error(Scripted::Transport).to_string();
assert!(err.to_string().contains(&expected), "{err}");
assert_eq!(gateway.submitted().len(), 1, "the cycle stops at the first refusal");
}
#[tokio::test]
async fn a_refused_leg_is_re_seeded_by_the_next_poll() {
let (gateway, grid) = grid_with(config(), mock_market(dec!(100)));
gateway.fail_create_from(1, Scripted::Transport);
let err = grid.tick().await.expect_err("the first refused leg ends the cycle");
assert!(err.to_string().contains("venue"), "the refusal must reach the caller, got {err}");
assert_eq!(
legs(&gateway.submitted()).len(),
2,
"two legs were attempted before the first refusal"
);
assert_eq!(gateway.resting_orders().len(), 1, "only the accepted leg is live on the venue");
gateway.clear_submitted();
gateway.heal_creates();
grid.tick().await.expect("the venue is healthy again");
assert_eq!(
legs(&gateway.submitted()).len(),
4,
"the four levels that never landed are re-seeded"
);
assert_eq!(hedge_leg(&gateway.submitted()), None, "repairing is not hedging");
}
proptest! {
#![proptest_config(ProptestConfig::with_cases(128))]
#[test]
fn a_positive_ladder_seeds_every_rung_once_inside_the_band(
lower in 1i64..1_000_000,
step in 1i64..1_000,
levels in 1u32..=8,
) {
let mid = Decimal::from(lower);
let (gateway, outcome) = tick_once(ladder(lower, step, levels), mock_market(mid));
outcome.expect("a positive step must seed");
let lower = Decimal::from(lower);
let upper = lower + Decimal::from(i64::from(levels) * step);
let prices: Vec<Decimal> =
legs(&gateway.submitted()).into_iter().map(|(price, _)| price).collect();
prop_assert_eq!(prices.len(), usize::try_from(levels).expect("small") + 1);
prop_assert_eq!(prices.first().copied(), Some(lower));
prop_assert_eq!(prices.last().copied(), Some(upper));
for price in &prices {
prop_assert!(*price >= lower, "{} sits below the band {}", price, lower);
prop_assert!(*price <= upper, "{} sits above the band {}", price, upper);
}
prop_assert!(
prices.windows(2).all(|w| (w[1] - w[0]) == Decimal::from(step)),
"every rung must be exactly one step above the previous: {:?}",
prices
);
}
#[test]
fn a_non_positive_span_is_always_a_no_op(
lower in 1i64..1_000_000,
delta in -1_000i64..1,
levels in 1u32..=8,
) {
let lower = Decimal::from(lower);
let band = config_in_band(lower, lower + Decimal::from(delta), levels);
let (gateway, outcome) = tick_once(band, mock_market(lower));
outcome.expect("a degenerate span is not an error");
prop_assert!(gateway.submitted().is_empty(), "a degenerate span places no order");
prop_assert_eq!(gateway.open_reads(), 0);
}
#[test]
fn the_side_of_every_leg_follows_the_mid_alone(
lower in 1i64..1_000_000,
step in 1i64..1_000,
levels in 1u32..=8,
offset in 1i64..1_000,
) {
let lower = Decimal::from(lower);
let upper = lower + Decimal::from(i64::from(levels) * step);
let offset = Decimal::from(offset);
prop_assume!(lower > offset, "a non-positive mid returns before the ladder");
let band = || config_in_band(lower, upper, levels);
let (buying, outcome) = tick_once(band(), mock_market(upper + offset));
outcome.expect("seeded");
let bought = legs(&buying.submitted());
prop_assert!(!bought.is_empty(), "a positive span always has a first rung");
prop_assert!(
bought.iter().all(|(_, is_buy)| *is_buy),
"a mid above the band must buy every rung"
);
let (selling, outcome) = tick_once(band(), mock_market(lower - offset));
outcome.expect("seeded");
let sold = legs(&selling.submitted());
prop_assert!(!sold.is_empty(), "a positive span always has a first rung");
prop_assert!(
sold.iter().all(|(_, is_buy)| !*is_buy),
"a mid below the band must sell every rung"
);
}
}
}