use std::{
collections::BTreeMap,
sync::{Arc, Mutex},
time::Instant,
};
use async_trait::async_trait;
use buffa::{EnumValue, MessageField};
use rust_decimal::Decimal;
use crate::{
ports::{PortError, TradingGateway},
proto::{common, trading, worker},
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OrderIntent {
pub symbol: String,
pub is_buy: bool,
pub qty: Decimal,
pub price: Option<Decimal>,
}
impl OrderIntent {
#[must_use]
pub fn signed_qty(&self) -> Decimal {
if self.is_buy { self.qty } else { -self.qty }
}
#[must_use]
pub fn notional(&self) -> Option<Decimal> {
self.price.map(|price| price * self.qty)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RestingOrder {
pub symbol: String,
pub is_buy: bool,
pub qty: Decimal,
}
impl RestingOrder {
#[must_use]
pub fn signed_qty(&self) -> Decimal {
if self.is_buy { self.qty } else { -self.qty }
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct RiskLimits {
pub max_order_qty: Option<Decimal>,
pub max_order_notional: Option<Decimal>,
pub max_orders_per_minute: Option<u32>,
pub max_open_orders: Option<u32>,
pub max_net_qty_per_symbol: Option<Decimal>,
}
impl RiskLimits {
#[must_use]
pub const fn is_enabled(&self) -> bool {
self.max_order_qty.is_some() ||
self.max_order_notional.is_some() ||
self.max_orders_per_minute.is_some() ||
self.max_open_orders.is_some() ||
self.max_net_qty_per_symbol.is_some()
}
#[must_use]
pub const fn needs_book(&self) -> bool {
self.max_open_orders.is_some() || self.max_net_qty_per_symbol.is_some()
}
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum RiskViolation {
#[error("risk limits need the venue's resting orders, which were not read")]
BookUnavailable,
#[error("order quantity {actual} on {symbol} exceeds the limit {limit}")]
OrderQty { symbol: String, actual: Decimal, limit: Decimal },
#[error("order notional {actual} on {symbol} exceeds the limit {limit}")]
OrderNotional { symbol: String, actual: Decimal, limit: Decimal },
#[error("submission rate exceeds {limit} orders/minute")]
Rate { limit: u32 },
#[error("open orders {actual} exceed the limit {limit}")]
OpenOrders { actual: usize, limit: u32 },
#[error("net quantity {actual} on {symbol} exceeds the limit {limit}")]
NetQty { symbol: String, actual: Decimal, limit: Decimal },
}
const TOKENS_PER_ORDER: u128 = 60_000;
#[derive(Debug)]
struct Bucket {
tokens: u128,
last: Instant,
}
#[derive(Debug)]
pub struct RiskGate {
limits: RiskLimits,
bucket: Mutex<Bucket>,
}
impl RiskGate {
#[must_use]
pub fn new(limits: RiskLimits, now: Instant) -> Self {
let capacity = u128::from(limits.max_orders_per_minute.unwrap_or(0)) * TOKENS_PER_ORDER;
Self { limits, bucket: Mutex::new(Bucket { tokens: capacity, last: now }) }
}
#[must_use]
pub const fn limits(&self) -> RiskLimits {
self.limits
}
pub fn admit(
&self,
intents: &[OrderIntent],
resting: Option<&[RestingOrder]>,
now: Instant,
) -> Result<(), RiskViolation> {
for intent in intents {
if let Some(limit) = self.limits.max_order_qty &&
intent.qty > limit
{
return Err(RiskViolation::OrderQty {
symbol: intent.symbol.clone(),
actual: intent.qty,
limit,
});
}
if let (Some(limit), Some(actual)) = (self.limits.max_order_notional, intent.notional()) &&
actual > limit
{
return Err(RiskViolation::OrderNotional {
symbol: intent.symbol.clone(),
actual,
limit,
});
}
}
if self.limits.needs_book() {
let resting = resting.ok_or(RiskViolation::BookUnavailable)?;
let open = resting.len() + intents.len();
if let Some(limit) = self.limits.max_open_orders &&
open > usize::try_from(limit).unwrap_or(usize::MAX)
{
return Err(RiskViolation::OpenOrders { actual: open, limit });
}
if let Some(limit) = self.limits.max_net_qty_per_symbol {
let mut net: BTreeMap<&str, Decimal> = BTreeMap::new();
for resting in resting {
*net.entry(resting.symbol.as_str()).or_insert(Decimal::ZERO) +=
resting.signed_qty();
}
for intent in intents {
*net.entry(intent.symbol.as_str()).or_insert(Decimal::ZERO) +=
intent.signed_qty();
}
for (symbol, net) in net {
if net.abs() > limit {
return Err(RiskViolation::NetQty {
symbol: symbol.to_string(),
actual: net,
limit,
});
}
}
}
}
self.consume(intents.len(), now)
}
fn consume(&self, orders: usize, now: Instant) -> Result<(), RiskViolation> {
let Some(limit) = self.limits.max_orders_per_minute else {
return Ok(());
};
let capacity = u128::from(limit) * TOKENS_PER_ORDER;
let mut bucket = self.bucket.lock().expect("the gate bucket lock is not poisoned");
if let Some(elapsed) = now.checked_duration_since(bucket.last) {
let refill = elapsed.as_millis() * u128::from(limit);
bucket.tokens = bucket.tokens.saturating_add(refill).min(capacity);
bucket.last = now;
}
let cost = u128::try_from(orders).unwrap_or(u128::MAX).saturating_mul(TOKENS_PER_ORDER);
if bucket.tokens < cost {
return Err(RiskViolation::Rate { limit });
}
bucket.tokens -= cost;
Ok(())
}
}
pub struct RiskGateway {
inner: Arc<dyn TradingGateway>,
gate: RiskGate,
}
impl RiskGateway {
#[must_use]
pub fn new(inner: Arc<dyn TradingGateway>, limits: RiskLimits) -> Self {
Self { inner, gate: RiskGate::new(limits, Instant::now()) }
}
async fn admit(
&self,
intents: &[OrderIntent],
exchange_id: &common::ExchangeId,
) -> Result<(), PortError> {
let resting = if self.gate.limits().needs_book() {
let req = trading::FetchOpenOrdersRequest {
exchange_id: MessageField::some(exchange_id.clone()),
..Default::default()
};
let orders = self.inner.fetch_open_orders(req).await?;
let mut resting = Vec::with_capacity(orders.len());
for order in &orders {
resting.push(resting_of(order)?);
}
Some(resting)
} else {
None
};
self.gate
.admit(intents, resting.as_deref(), Instant::now())
.map_err(|violation| PortError::InvalidArgument(violation.to_string()))
}
}
fn intent_of(order: &trading::OrderRequest) -> Result<OrderIntent, PortError> {
let amount = order
.amount
.as_option()
.ok_or_else(|| PortError::MissingField("order.amount".to_string()))?;
Ok(OrderIntent {
symbol: order.symbol.clone(),
is_buy: matches!(order.side, EnumValue::Known(trading::OrderSide::Buy)),
qty: longtrader_contract::ext::common_to_decimal(amount)?,
price: order
.price
.as_option()
.map(longtrader_contract::ext::common_to_decimal)
.transpose()?,
})
}
fn resting_of(order: &trading::Order) -> Result<RestingOrder, PortError> {
let qty = order
.remaining
.as_option()
.or(order.amount.as_option())
.ok_or_else(|| PortError::MissingField("order.remaining".to_string()))?;
Ok(RestingOrder {
symbol: order.symbol.clone(),
is_buy: matches!(order.side, EnumValue::Known(trading::OrderSide::Buy)),
qty: longtrader_contract::ext::common_to_decimal(qty)?,
})
}
#[async_trait]
impl TradingGateway for RiskGateway {
async fn create_order(
&self,
req: trading::CreateOrderRequest,
) -> Result<trading::Order, PortError> {
let exchange_id =
req.exchange_id.as_option().cloned().unwrap_or_else(common::ExchangeId::default);
let order =
req.order.as_option().ok_or_else(|| PortError::MissingField("order".to_string()))?;
self.admit(&[intent_of(order)?], &exchange_id).await?;
self.inner.create_order(req).await
}
async fn batch_create_orders(
&self,
req: trading::CreateOrdersRequest,
) -> Result<Vec<trading::Order>, PortError> {
let exchange_id =
req.exchange_id.as_option().cloned().unwrap_or_else(common::ExchangeId::default);
let mut intents = Vec::with_capacity(req.orders.len());
for order in &req.orders {
intents.push(intent_of(order)?);
}
self.admit(&intents, &exchange_id).await?;
self.inner.batch_create_orders(req).await
}
async fn cancel_order(
&self,
req: trading::CancelOrderRequest,
) -> Result<trading::Order, PortError> {
self.inner.cancel_order(req).await
}
async fn cancel_all_orders(
&self,
req: trading::CancelAllOrdersRequest,
) -> Result<Vec<trading::Order>, PortError> {
self.inner.cancel_all_orders(req).await
}
async fn fetch_open_orders(
&self,
req: trading::FetchOpenOrdersRequest,
) -> Result<Vec<trading::Order>, PortError> {
self.inner.fetch_open_orders(req).await
}
async fn get_account(
&self,
req: trading::GetAccountRequest,
) -> Result<trading::GetAccountResponse, PortError> {
self.inner.get_account(req).await
}
async fn get_positions(
&self,
req: trading::GetPositionsRequest,
) -> Result<trading::GetPositionsResponse, PortError> {
self.inner.get_positions(req).await
}
async fn get_order_history(
&self,
req: trading::GetOrderHistoryRequest,
) -> Result<trading::GetOrderHistoryResponse, PortError> {
self.inner.get_order_history(req).await
}
async fn get_closed_positions(
&self,
req: trading::GetClosedPositionsRequest,
) -> Result<trading::GetClosedPositionsResponse, PortError> {
self.inner.get_closed_positions(req).await
}
async fn close_position(
&self,
req: trading::ClosePositionRequest,
) -> Result<trading::ClosePositionResponse, PortError> {
self.inner.close_position(req).await
}
async fn close_all_positions(
&self,
req: trading::CloseAllPositionsRequest,
) -> Result<trading::CloseAllPositionsResponse, PortError> {
self.inner.close_all_positions(req).await
}
async fn modify_position(
&self,
req: trading::ModifyPositionRequest,
) -> Result<trading::ModifyPositionResponse, PortError> {
self.inner.modify_position(req).await
}
async fn sync_state(
&self,
exchange_id: &common::ExchangeId,
) -> Result<worker::ReconcileStateResponse, PortError> {
self.inner.sync_state(exchange_id).await
}
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use rust_decimal_macros::dec;
use super::*;
use crate::adapters::MockAdapter;
fn clock() -> Instant {
static ORIGIN: std::sync::OnceLock<Instant> = std::sync::OnceLock::new();
*ORIGIN.get_or_init(Instant::now)
}
fn buy(symbol: &str, qty: Decimal, price: Option<Decimal>) -> OrderIntent {
OrderIntent { symbol: symbol.to_string(), is_buy: true, qty, price }
}
fn sell(symbol: &str, qty: Decimal, price: Option<Decimal>) -> OrderIntent {
OrderIntent { symbol: symbol.to_string(), is_buy: false, qty, price }
}
fn resting(symbol: &str, is_buy: bool, qty: Decimal) -> RestingOrder {
RestingOrder { symbol: symbol.to_string(), is_buy, qty }
}
fn gate(limits: RiskLimits) -> RiskGate {
RiskGate::new(limits, clock())
}
#[test]
fn an_unconfigured_gate_admits_everything() {
let gate = gate(RiskLimits::default());
assert!(!gate.limits().is_enabled());
assert!(!gate.limits().needs_book());
assert!(gate.admit(&[buy("BTC/USDT", dec!(1_000_000), None)], None, clock()).is_ok());
}
#[test]
fn every_limit_enables_the_gate() {
let any = RiskLimits {
max_order_qty: Some(dec!(1)),
max_order_notional: Some(dec!(1)),
max_orders_per_minute: Some(1),
max_open_orders: Some(1),
max_net_qty_per_symbol: Some(dec!(1)),
};
assert!(any.is_enabled());
assert!(any.needs_book());
let local_only = RiskLimits { max_order_qty: Some(dec!(1)), ..RiskLimits::default() };
assert!(local_only.is_enabled());
assert!(!local_only.needs_book(), "a local-only gate must not pay for a book read");
let book_only = RiskLimits { max_open_orders: Some(1), ..RiskLimits::default() };
assert!(book_only.needs_book());
for single in [
RiskLimits { max_order_qty: Some(dec!(1)), ..RiskLimits::default() },
RiskLimits { max_order_notional: Some(dec!(1)), ..RiskLimits::default() },
RiskLimits { max_orders_per_minute: Some(1), ..RiskLimits::default() },
RiskLimits { max_open_orders: Some(1), ..RiskLimits::default() },
RiskLimits { max_net_qty_per_symbol: Some(dec!(1)), ..RiskLimits::default() },
] {
assert!(single.is_enabled(), "{single:?} must arm the gate on its own");
}
}
#[test]
fn a_quantity_above_the_limit_is_refused() {
let gate = gate(RiskLimits { max_order_qty: Some(dec!(1)), ..RiskLimits::default() });
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, clock()).is_ok());
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(1.0001), None)], None, clock()),
Err(RiskViolation::OrderQty {
symbol: "BTC/USDT".to_string(),
actual: dec!(1.0001),
limit: dec!(1),
})
);
}
#[test]
fn the_quantity_limit_is_inclusive() {
let gate = gate(RiskLimits { max_order_qty: Some(dec!(2)), ..RiskLimits::default() });
assert!(gate.admit(&[buy("BTC/USDT", dec!(2), None)], None, clock()).is_ok());
}
#[test]
fn a_notional_above_the_limit_is_refused() {
let gate =
gate(RiskLimits { max_order_notional: Some(dec!(100)), ..RiskLimits::default() });
let at = buy("BTC/USDT", dec!(2), Some(dec!(50)));
let over = buy("BTC/USDT", dec!(2), Some(dec!(50.01)));
assert!(gate.admit(&[at], None, clock()).is_ok());
assert_eq!(
gate.admit(&[over], None, clock()),
Err(RiskViolation::OrderNotional {
symbol: "BTC/USDT".to_string(),
actual: dec!(100.02),
limit: dec!(100),
})
);
}
#[test]
fn an_order_without_a_price_is_not_measured_by_notional() {
let gate =
gate(RiskLimits { max_order_notional: Some(dec!(0.0001)), ..RiskLimits::default() });
let market = buy("BTC/USDT", dec!(1000), None);
assert!(market.notional().is_none());
assert!(gate.admit(&[market], None, clock()).is_ok());
}
#[test]
fn a_book_backed_limit_without_the_book_fails_closed() {
let gate = gate(RiskLimits { max_open_orders: Some(10), ..RiskLimits::default() });
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, clock()),
Err(RiskViolation::BookUnavailable)
);
}
#[test]
fn an_open_order_count_above_the_limit_is_refused() {
let gate = gate(RiskLimits { max_open_orders: Some(2), ..RiskLimits::default() });
let resting = vec![resting("BTC/USDT", true, dec!(1))];
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], Some(&resting), clock()).is_ok());
let batch = [buy("BTC/USDT", dec!(1), None), sell("BTC/USDT", dec!(1), None)];
assert_eq!(
gate.admit(&batch, Some(&resting), clock()),
Err(RiskViolation::OpenOrders { actual: 3, limit: 2 })
);
}
#[test]
fn net_quantity_is_measured_signed_so_two_sided_quotes_cancel() {
let gate =
gate(RiskLimits { max_net_qty_per_symbol: Some(dec!(1)), ..RiskLimits::default() });
let flat = vec![resting("BTC/USDT", true, dec!(5)), resting("BTC/USDT", false, dec!(5))];
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], Some(&flat), clock()).is_ok());
assert!(gate.admit(&[sell("BTC/USDT", dec!(1), None)], Some(&flat), clock()).is_ok());
}
#[test]
fn a_net_quantity_above_the_limit_is_refused_in_either_direction() {
let gate =
gate(RiskLimits { max_net_qty_per_symbol: Some(dec!(2)), ..RiskLimits::default() });
assert!(gate.admit(&[buy("BTC/USDT", dec!(2), None)], Some(&[]), clock()).is_ok());
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(2.5), None)], Some(&[]), clock()),
Err(RiskViolation::NetQty {
symbol: "BTC/USDT".to_string(),
actual: dec!(2.5),
limit: dec!(2),
})
);
assert_eq!(
gate.admit(&[sell("BTC/USDT", dec!(2.5), None)], Some(&[]), clock()),
Err(RiskViolation::NetQty {
symbol: "BTC/USDT".to_string(),
actual: dec!(-2.5),
limit: dec!(2),
})
);
}
#[test]
fn the_net_quantity_limit_is_per_symbol() {
let gate =
gate(RiskLimits { max_net_qty_per_symbol: Some(dec!(1)), ..RiskLimits::default() });
let one_at_cap = vec![resting("BTC/USDT", true, dec!(1))];
assert!(gate.admit(&[buy("ETH/USDT", dec!(1), None)], Some(&one_at_cap), clock()).is_ok());
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(0.5), None)], Some(&one_at_cap), clock()),
Err(RiskViolation::NetQty {
symbol: "BTC/USDT".to_string(),
actual: dec!(1.5),
limit: dec!(1),
})
);
}
#[test]
fn the_rate_limit_refuses_the_order_that_exceeds_it() {
let now = clock();
let gate = gate(RiskLimits { max_orders_per_minute: Some(2), ..RiskLimits::default() });
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now).is_ok());
assert!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now + Duration::from_secs(1))
.is_ok()
);
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now + Duration::from_secs(2)),
Err(RiskViolation::Rate { limit: 2 })
);
}
#[test]
fn a_minute_of_idleness_refills_the_bucket_to_the_limit_and_no_further() {
let now = clock();
let gate = gate(RiskLimits { max_orders_per_minute: Some(1), ..RiskLimits::default() });
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now).is_ok());
assert!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now + Duration::from_secs(61))
.is_ok()
);
assert_eq!(
gate.admit(
&[buy("BTC/USDT", dec!(1), None)],
None,
now + Duration::from_secs(61) + Duration::from_secs(61)
),
Ok(()),
"one order per minute must refill exactly, not drift"
);
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now + Duration::from_secs(123)),
Err(RiskViolation::Rate { limit: 1 }),
"two refilled orders back to back still exceed one per minute"
);
}
#[test]
fn the_slowest_rate_still_refills() {
let now = clock();
let gate = gate(RiskLimits { max_orders_per_minute: Some(1), ..RiskLimits::default() });
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now).is_ok());
assert!(
gate.admit(
&[buy("BTC/USDT", dec!(1), None)],
None,
now + Duration::from_millis(60_000)
)
.is_ok()
);
}
#[test]
fn the_refill_scales_with_the_limit() {
let now = clock();
let gate = gate(RiskLimits { max_orders_per_minute: Some(2), ..RiskLimits::default() });
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now).is_ok());
let half_minute = now + Duration::from_millis(30_000);
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, half_minute).is_ok());
assert!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, half_minute).is_ok(),
"thirty seconds at two per minute must restore exactly one more order"
);
}
#[test]
fn a_refusal_does_not_consume_rate_budget() {
let now = clock();
let gate = gate(RiskLimits {
max_order_qty: Some(dec!(1)),
max_orders_per_minute: Some(1),
..RiskLimits::default()
});
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(5), None)], None, now),
Err(RiskViolation::OrderQty {
symbol: "BTC/USDT".to_string(),
actual: dec!(5),
limit: dec!(1),
})
);
assert!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now).is_ok(),
"the refused order must not have spent the single available slot"
);
}
#[test]
fn a_batch_consumes_one_rate_slot_per_leg() {
let now = clock();
let gate = gate(RiskLimits { max_orders_per_minute: Some(3), ..RiskLimits::default() });
let three = vec![
buy("BTC/USDT", dec!(1), None),
sell("BTC/USDT", dec!(1), None),
buy("BTC/USDT", dec!(1), None),
];
assert!(gate.admit(&three, None, now).is_ok());
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now),
Err(RiskViolation::Rate { limit: 3 })
);
}
#[test]
fn a_batch_larger_than_the_rate_budget_is_refused_whole() {
let now = clock();
let gate = gate(RiskLimits { max_orders_per_minute: Some(2), ..RiskLimits::default() });
let three = vec![
buy("BTC/USDT", dec!(1), None),
sell("BTC/USDT", dec!(1), None),
buy("BTC/USDT", dec!(1), None),
];
assert_eq!(gate.admit(&three, None, now), Err(RiskViolation::Rate { limit: 2 }));
}
#[test]
fn a_non_monotonic_clock_does_not_refill() {
let now = clock();
let gate = gate(RiskLimits { max_orders_per_minute: Some(1), ..RiskLimits::default() });
assert!(gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now).is_ok());
assert_eq!(
gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, now - Duration::from_millis(1)),
Err(RiskViolation::Rate { limit: 1 })
);
}
fn common_dec(value: Decimal) -> common::Decimal {
longtrader_contract::ext::decimal_to_common(value)
}
fn request(
symbol: &str,
side: trading::OrderSide,
qty: Decimal,
price: Option<Decimal>,
) -> trading::OrderRequest {
trading::OrderRequest {
symbol: symbol.to_string(),
side: EnumValue::Known(side),
amount: MessageField::some(common_dec(qty)),
price: price.map(|p| MessageField::some(common_dec(p))).unwrap_or_default(),
..Default::default()
}
}
#[test]
fn an_order_request_maps_to_its_intent() {
let intent =
intent_of(&request("BTC/USDT", trading::OrderSide::Buy, dec!(2), Some(dec!(50))))
.expect("a populated request must map");
assert_eq!(intent, buy("BTC/USDT", dec!(2), Some(dec!(50))));
assert_eq!(intent.signed_qty(), dec!(2));
assert_eq!(intent.notional(), Some(dec!(100)));
let short =
intent_of(&request("BTC/USDT", trading::OrderSide::Sell, dec!(2), Some(dec!(50))))
.expect("a populated request must map");
assert_eq!(short.signed_qty(), dec!(-2));
}
#[test]
fn an_unpriced_request_has_no_price() {
let intent = intent_of(&request("BTC/USDT", trading::OrderSide::Buy, dec!(2), None))
.expect("a populated request must map");
assert_eq!(intent.price, None);
assert_eq!(intent.notional(), None);
}
#[test]
fn a_request_without_an_amount_is_refused() {
let err = intent_of(&trading::OrderRequest {
symbol: "BTC/USDT".to_string(),
..Default::default()
})
.expect_err("a quantityless request cannot be measured");
assert!(matches!(err, PortError::MissingField(_)), "{err}");
}
#[test]
fn a_resting_order_is_measured_by_its_remaining_quantity() {
let order = trading::Order {
symbol: "BTC/USDT".to_string(),
side: EnumValue::Known(trading::OrderSide::Sell),
amount: MessageField::some(common_dec(dec!(5))),
remaining: MessageField::some(common_dec(dec!(1))),
..Default::default()
};
assert_eq!(resting_of(&order).expect("maps"), resting("BTC/USDT", false, dec!(1)));
}
#[test]
fn a_resting_order_without_remaining_falls_back_to_its_amount() {
let order = trading::Order {
symbol: "BTC/USDT".to_string(),
side: EnumValue::Known(trading::OrderSide::Buy),
amount: MessageField::some(common_dec(dec!(5))),
..Default::default()
};
assert_eq!(resting_of(&order).expect("maps"), resting("BTC/USDT", true, dec!(5)));
}
fn create_req(symbol: &str, qty: Decimal, price: Decimal) -> trading::CreateOrderRequest {
trading::CreateOrderRequest {
exchange_id: MessageField::some(common::ExchangeId {
id: "mock".to_string(),
..Default::default()
}),
order: MessageField::some(request(symbol, trading::OrderSide::Buy, qty, Some(price))),
..Default::default()
}
}
async fn open_count(gateway: &dyn TradingGateway) -> usize {
gateway
.fetch_open_orders(trading::FetchOpenOrdersRequest::default())
.await
.expect("the offline venue answers")
.len()
}
#[tokio::test]
async fn the_decorator_refuses_an_order_before_the_venue_sees_it() {
let mock = Arc::new(MockAdapter::new(dec!(95_000)));
let gated = RiskGateway::new(
mock.clone(),
RiskLimits { max_order_qty: Some(dec!(1)), ..RiskLimits::default() },
);
let err = gated
.create_order(create_req("BTC/USDT", dec!(5), dec!(95_000)))
.await
.expect_err("an oversized order must be refused");
assert!(matches!(err, PortError::InvalidArgument(_)), "{err}");
assert_eq!(open_count(&*mock).await, 0, "the refused order must never reach the venue");
}
#[tokio::test]
async fn the_decorator_admits_an_order_inside_the_limits() {
let mock = Arc::new(MockAdapter::new(dec!(95_000)));
let gated = RiskGateway::new(
mock.clone(),
RiskLimits { max_order_qty: Some(dec!(1)), ..RiskLimits::default() },
);
gated.create_order(create_req("BTC/USDT", dec!(1), dec!(95_000))).await.expect("fits");
assert_eq!(open_count(&*mock).await, 1);
}
#[tokio::test]
async fn a_book_backed_limit_is_measured_against_the_venue() {
let mock = Arc::new(MockAdapter::new(dec!(95_000)));
let gated = RiskGateway::new(
mock.clone(),
RiskLimits { max_open_orders: Some(1), ..RiskLimits::default() },
);
gated
.create_order(create_req("BTC/USDT", dec!(1), dec!(95_000)))
.await
.expect("first fits");
let err = gated
.create_order(create_req("BTC/USDT", dec!(1), dec!(95_000)))
.await
.expect_err("the second exceeds one resting order");
assert!(matches!(err, PortError::InvalidArgument(_)), "{err}");
assert_eq!(open_count(&*mock).await, 1, "only the admitted order is resting");
}
#[tokio::test]
async fn a_batch_is_refused_whole_when_one_leg_exceeds_a_limit() {
let mock = Arc::new(MockAdapter::new(dec!(95_000)));
let gated = RiskGateway::new(
mock.clone(),
RiskLimits { max_order_qty: Some(dec!(1)), ..RiskLimits::default() },
);
let err = gated
.batch_create_orders(trading::CreateOrdersRequest {
exchange_id: MessageField::some(common::ExchangeId {
id: "mock".to_string(),
..Default::default()
}),
orders: vec![
request("BTC/USDT", trading::OrderSide::Buy, dec!(1), Some(dec!(95_000))),
request("BTC/USDT", trading::OrderSide::Buy, dec!(5), Some(dec!(95_000))),
],
..Default::default()
})
.await
.expect_err("the oversized leg must refuse the batch");
assert!(matches!(err, PortError::InvalidArgument(_)), "{err}");
assert_eq!(open_count(&*mock).await, 0, "no leg of a refused batch may be placed");
}
#[tokio::test]
async fn the_decorator_never_blocks_a_cancel_all() {
let mock = Arc::new(MockAdapter::new(dec!(95_000)));
mock.create_order(create_req("BTC/USDT", dec!(1), dec!(95_000)))
.await
.expect("place through the ungated venue");
let gated = RiskGateway::new(
mock.clone(),
RiskLimits { max_open_orders: Some(0), ..RiskLimits::default() },
);
let canceled = gated
.cancel_all_orders(trading::CancelAllOrdersRequest::default())
.await
.expect("a cancel-all must never be gated");
assert_eq!(canceled.len(), 1);
}
struct RecordingGateway {
inner: Arc<MockAdapter>,
calls: std::sync::Mutex<Vec<(String, String)>>,
}
impl RecordingGateway {
fn new(inner: Arc<MockAdapter>) -> Self {
Self { inner, calls: std::sync::Mutex::new(Vec::new()) }
}
fn note(&self, method: &str, venue: Option<&common::ExchangeId>) {
let id = venue.map_or_else(String::new, |e| e.id.clone());
self.calls.lock().expect("the call log is not poisoned").push((method.to_string(), id));
}
fn calls(&self) -> Vec<(String, String)> {
self.calls.lock().expect("the call log is not poisoned").clone()
}
}
#[async_trait]
impl TradingGateway for RecordingGateway {
async fn create_order(
&self,
req: trading::CreateOrderRequest,
) -> Result<trading::Order, PortError> {
self.note("create_order", req.exchange_id.as_option());
self.inner.create_order(req).await
}
async fn batch_create_orders(
&self,
req: trading::CreateOrdersRequest,
) -> Result<Vec<trading::Order>, PortError> {
self.note("batch_create_orders", req.exchange_id.as_option());
self.inner.batch_create_orders(req).await
}
async fn cancel_order(
&self,
req: trading::CancelOrderRequest,
) -> Result<trading::Order, PortError> {
self.note("cancel_order", req.exchange_id.as_option());
self.inner.cancel_order(req).await
}
async fn cancel_all_orders(
&self,
req: trading::CancelAllOrdersRequest,
) -> Result<Vec<trading::Order>, PortError> {
self.note("cancel_all_orders", req.exchange_id.as_option());
self.inner.cancel_all_orders(req).await
}
async fn fetch_open_orders(
&self,
req: trading::FetchOpenOrdersRequest,
) -> Result<Vec<trading::Order>, PortError> {
self.note("fetch_open_orders", req.exchange_id.as_option());
self.inner.fetch_open_orders(req).await
}
async fn get_account(
&self,
req: trading::GetAccountRequest,
) -> Result<trading::GetAccountResponse, PortError> {
self.note("get_account", req.exchange_id.as_option());
self.inner.get_account(req).await
}
async fn get_positions(
&self,
req: trading::GetPositionsRequest,
) -> Result<trading::GetPositionsResponse, PortError> {
self.note("get_positions", req.exchange_id.as_option());
self.inner.get_positions(req).await
}
async fn get_order_history(
&self,
req: trading::GetOrderHistoryRequest,
) -> Result<trading::GetOrderHistoryResponse, PortError> {
self.note("get_order_history", req.exchange_id.as_option());
self.inner.get_order_history(req).await
}
async fn get_closed_positions(
&self,
req: trading::GetClosedPositionsRequest,
) -> Result<trading::GetClosedPositionsResponse, PortError> {
self.note("get_closed_positions", req.exchange_id.as_option());
self.inner.get_closed_positions(req).await
}
async fn close_position(
&self,
req: trading::ClosePositionRequest,
) -> Result<trading::ClosePositionResponse, PortError> {
self.note("close_position", req.exchange_id.as_option());
self.inner.close_position(req).await
}
async fn close_all_positions(
&self,
req: trading::CloseAllPositionsRequest,
) -> Result<trading::CloseAllPositionsResponse, PortError> {
self.note("close_all_orders", req.exchange_id.as_option());
self.inner.close_all_positions(req).await
}
async fn modify_position(
&self,
req: trading::ModifyPositionRequest,
) -> Result<trading::ModifyPositionResponse, PortError> {
self.note("modify_position", req.exchange_id.as_option());
self.inner.modify_position(req).await
}
async fn sync_state(
&self,
exchange_id: &common::ExchangeId,
) -> Result<worker::ReconcileStateResponse, PortError> {
self.note("sync_state", Some(exchange_id));
self.inner.sync_state(exchange_id).await
}
}
#[tokio::test]
async fn every_forwarded_call_reaches_the_venue_on_the_same_identity() {
let recorder = Arc::new(RecordingGateway::new(Arc::new(MockAdapter::new(dec!(95_000)))));
let inner = Arc::clone(&recorder) as Arc<dyn TradingGateway>;
let gated = RiskGateway::new(
Arc::clone(&inner),
RiskLimits { max_open_orders: Some(100), ..RiskLimits::default() },
);
let venue = common::ExchangeId { id: "mock".to_string(), ..common::ExchangeId::default() };
let _ = gated
.cancel_order(trading::CancelOrderRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.cancel_all_orders(trading::CancelAllOrdersRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.fetch_open_orders(trading::FetchOpenOrdersRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.get_account(trading::GetAccountRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.get_positions(trading::GetPositionsRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.get_order_history(trading::GetOrderHistoryRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.get_closed_positions(trading::GetClosedPositionsRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.close_position(trading::ClosePositionRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.close_all_positions(trading::CloseAllPositionsRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated
.modify_position(trading::ModifyPositionRequest {
exchange_id: MessageField::some(venue.clone()),
..Default::default()
})
.await;
let _ = gated.sync_state(&venue).await;
let _ = gated.create_order(create_req("BTC/USDT", dec!(1), dec!(95_000))).await;
let calls = recorder.calls();
for method in [
"cancel_order",
"cancel_all_orders",
"fetch_open_orders",
"get_account",
"get_positions",
"get_order_history",
"get_closed_positions",
"close_position",
"close_all_orders",
"modify_position",
"sync_state",
"create_order",
] {
assert!(
calls.iter().any(|(seen, _)| seen == method),
"{method} must reach the venue, saw {calls:?}"
);
}
for (method, seen) in &calls {
assert_eq!(seen, "mock", "{method} must name the venue it was addressed to");
}
}
proptest::proptest! {
#[test]
fn the_quantity_limit_is_inclusive_everywhere(qty in 1u32..1_000) {
let limit = Decimal::from(qty);
let gate = gate(RiskLimits { max_order_qty: Some(limit), ..RiskLimits::default() });
let at = buy("BTC/USDT", limit, None);
let over = buy("BTC/USDT", limit + dec!(0.00000000000000000001), None);
proptest::prop_assert!(gate.admit(&[at], None, clock()).is_ok());
proptest::prop_assert!(gate.admit(&[over], None, clock()).is_err());
}
#[test]
fn signed_netting_never_exceeds_the_largest_leg(
buys in 0u32..50, sells in 0u32..50,
) {
let qty = dec!(0.5);
let mut intents: Vec<OrderIntent> = Vec::new();
for _ in 0..buys {
intents.push(buy("BTC/USDT", qty, None));
}
for _ in 0..sells {
intents.push(sell("BTC/USDT", qty, None));
}
let mut net = Decimal::ZERO;
for intent in &intents {
net += intent.signed_qty();
}
proptest::prop_assert!(net.abs() <= qty * Decimal::from(buys.max(sells)));
}
#[test]
fn the_bucket_never_exceeds_capacity(limit in 1u32..600, idle_ms in 0u64..7_200_000) {
let now = clock();
let gate = gate(RiskLimits {
max_orders_per_minute: Some(limit),
..RiskLimits::default()
});
let later = now + Duration::from_millis(idle_ms);
let mut admitted = 0u32;
for _ in 0..limit + 1 {
if gate.admit(&[buy("BTC/USDT", dec!(1), None)], None, later).is_ok() {
admitted += 1;
}
}
proptest::prop_assert_eq!(admitted, limit);
}
}
}