use crate::mathx;
use crate::mathx::clamp;
pub const MARKET_MAKER_ID: &str = "mm";
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct MakerQuote {
pub bid_price: f64,
pub ask_price: f64,
pub bid_size: f64,
pub ask_size: f64,
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct MakerInventory {
pub position: f64,
pub limit: f64,
}
impl MakerInventory {
pub const fn new(position: f64, limit: f64) -> Self {
MakerInventory { position, limit }
}
}
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub struct QuoteParams {
pub fair_value: f64,
pub half_spread_bps: f64,
pub base_size: f64,
pub inventory: MakerInventory,
pub volatility_multiplier: f64,
pub max_skew: f64,
}
impl Default for QuoteParams {
fn default() -> Self {
Self {
fair_value: 0.0,
half_spread_bps: 0.0,
base_size: 0.0,
inventory: MakerInventory {
position: 0.0,
limit: 0.0,
},
volatility_multiplier: 1.0,
max_skew: 1.0,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct LadderLevel {
pub price: f64,
pub size: f64,
}
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub struct LadderParams {
pub quote: QuoteParams,
pub levels: f64,
pub level_step: f64,
}
impl LadderParams {
pub fn new(quote: QuoteParams, levels: f64, level_step: f64) -> Self {
LadderParams { quote, levels, level_step }
}
}
fn round2(n: f64) -> f64 {
mathx::js_round(n * 100.0) / 100.0
}
pub fn compute_quote(params: &QuoteParams) -> MakerQuote {
let half_spread = params.fair_value
* (params.half_spread_bps / 10_000.0)
* mathx::max(0.1, params.volatility_multiplier);
let load = if params.inventory.limit > 0.0 {
clamp(
params.inventory.position / params.inventory.limit,
-1.0,
1.0,
)
} else {
0.0
};
let skew = -load * half_spread * clamp(params.max_skew, 0.0, 1.0);
let mid = params.fair_value + skew;
let size_tilt = clamp(1.0 - load.abs(), 0.15, 1.0);
let bid_size = if load > 0.0 {
params.base_size * size_tilt
} else {
params.base_size
};
let ask_size = if load < 0.0 {
params.base_size * size_tilt
} else {
params.base_size
};
let bid_price = mathx::max(0.01, mid - half_spread);
let ask_price = mathx::max(bid_price + 0.01, mid + half_spread);
MakerQuote {
bid_price: round2(bid_price),
ask_price: round2(ask_price),
bid_size: mathx::max(1.0, bid_size.floor()),
ask_size: mathx::max(1.0, ask_size.floor()),
}
}
pub fn apply_fill_to_inventory(
inventory: MakerInventory,
taker_side: crate::order_book::Side,
quantity: f64,
) -> MakerInventory {
let delta = match taker_side {
crate::order_book::Side::Buy => -quantity,
crate::order_book::Side::Sell => quantity,
};
MakerInventory {
position: inventory.position + delta,
..inventory
}
}
pub fn quote_ladder(params: &LadderParams) -> (Vec<LadderLevel>, Vec<LadderLevel>) {
let mut bids = Vec::new();
let mut asks = Vec::new();
quote_ladder_into(params, &mut bids, &mut asks);
(bids, asks)
}
pub(crate) fn quote_ladder_into(
params: &LadderParams,
bids: &mut Vec<LadderLevel>,
asks: &mut Vec<LadderLevel>,
) {
bids.clear();
asks.clear();
let top = compute_quote(¶ms.quote);
let half_spread = (top.ask_price - top.bid_price) / 2.0;
let step = mathx::max(0.01, half_spread * 2.0 * params.level_step);
let n = mathx::max(1.0, params.levels);
let mut i = 0i64;
while (i as f64) < n {
let depth_factor = 1.0 / (1.0 + i as f64 * 0.3);
let bid_price = round2(top.bid_price - i as f64 * step);
let ask_price = round2(top.ask_price + i as f64 * step);
if bid_price > 0.0 {
bids.push(LadderLevel {
price: bid_price,
size: mathx::max(1.0, (top.bid_size * depth_factor).floor()),
});
}
asks.push(LadderLevel {
price: ask_price,
size: mathx::max(1.0, (top.ask_size * depth_factor).floor()),
});
i += 1;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::order_book::Side;
fn base() -> QuoteParams {
QuoteParams {
fair_value: 100.0,
half_spread_bps: 10.0,
base_size: 500.0,
inventory: MakerInventory {
position: 0.0,
limit: 1000.0,
},
..Default::default()
}
}
#[test]
fn a_flat_maker_quotes_symmetrically_around_fair_value() {
let q = compute_quote(&base());
assert_eq!(q.bid_price, 99.9);
assert_eq!(q.ask_price, 100.1);
assert_eq!(q.bid_size, 500.0);
assert_eq!(q.ask_size, 500.0);
}
#[test]
fn long_inventory_skews_the_quote_down() {
let mut p = base();
p.inventory.position = 1000.0; let q = compute_quote(&p);
let flat = compute_quote(&base());
assert!(q.bid_price < flat.bid_price, "bid must fall");
assert!(q.ask_price < flat.ask_price, "ask must fall too");
}
#[test]
fn short_inventory_skews_the_quote_up() {
let mut p = base();
p.inventory.position = -1000.0;
let q = compute_quote(&p);
let flat = compute_quote(&base());
assert!(q.bid_price > flat.bid_price);
assert!(q.ask_price > flat.ask_price);
}
#[test]
fn size_tilts_against_growing_the_position() {
let mut p = base();
p.inventory.position = 500.0; let q = compute_quote(&p);
assert!(
q.bid_size < q.ask_size,
"long maker should bid smaller than it offers"
);
}
#[test]
fn over_limit_inventory_saturates_rather_than_inverting() {
let mut at = base();
at.inventory.position = 1000.0;
let mut way_over = base();
way_over.inventory.position = 50_000.0;
assert_eq!(compute_quote(&at), compute_quote(&way_over));
let q = compute_quote(&way_over);
assert!(q.ask_price > q.bid_price, "quotes must never cross");
}
#[test]
fn a_zero_limit_disables_skew_rather_than_dividing_by_zero() {
let mut p = base();
p.inventory = MakerInventory {
position: 900.0,
limit: 0.0,
};
let q = compute_quote(&p);
assert_eq!(q, compute_quote(&base()), "no limit means no skew");
}
#[test]
fn a_collapsing_fair_value_still_yields_a_valid_quote() {
let mut p = base();
p.fair_value = 0.001;
let q = compute_quote(&p);
assert!(q.bid_price >= 0.01);
assert!(q.ask_price >= q.bid_price + 0.01 - 1e-9);
}
#[test]
fn volatility_widens_the_spread() {
let mut p = base();
p.volatility_multiplier = 3.0;
let wide = compute_quote(&p);
let normal = compute_quote(&base());
assert!(wide.ask_price - wide.bid_price > normal.ask_price - normal.bid_price);
}
#[test]
fn the_volatility_multiplier_floors_at_a_tenth() {
let mut tiny = base();
tiny.volatility_multiplier = 0.0001;
let mut floored = base();
floored.volatility_multiplier = 0.1;
assert_eq!(compute_quote(&tiny), compute_quote(&floored));
}
#[test]
fn a_taker_buy_reduces_maker_inventory() {
let inv = MakerInventory {
position: 0.0,
limit: 1000.0,
};
assert_eq!(
apply_fill_to_inventory(inv, Side::Buy, 100.0).position,
-100.0
);
assert_eq!(
apply_fill_to_inventory(inv, Side::Sell, 100.0).position,
100.0
);
}
#[test]
fn the_ladder_thins_and_walks_away_from_the_touch() {
let (bids, asks) = quote_ladder(&LadderParams {
quote: base(),
levels: 5.0,
level_step: 0.5,
});
assert_eq!(bids.len(), 5);
assert_eq!(asks.len(), 5);
for i in 1..5 {
assert!(bids[i].price < bids[i - 1].price, "bids walk down");
assert!(asks[i].price > asks[i - 1].price, "asks walk up");
assert!(bids[i].size <= bids[i - 1].size, "depth thins");
}
}
#[test]
fn every_ladder_price_is_on_the_cent_grid() {
let (bids, asks) = quote_ladder(&LadderParams {
quote: base(),
levels: 10.0,
level_step: 0.5,
});
for l in bids.iter().chain(asks.iter()) {
let cents = l.price * 100.0;
assert!(
(cents - cents.round()).abs() < 1e-9,
"{} is off-grid",
l.price
);
}
}
#[test]
fn zero_levels_still_quotes_one() {
let (bids, asks) = quote_ladder(&LadderParams {
quote: base(),
levels: 0.0,
level_step: 0.5,
});
assert_eq!(bids.len(), 1);
assert_eq!(asks.len(), 1);
}
}
#[cfg(test)]
mod js_round_tests {
use crate::mathx::js_round;
#[test]
fn matches_v8_including_the_two_edge_cases() {
let cases: &[(f64, f64)] = &[
(0.5, 1.0),
(2.5, 3.0),
(-3.5, -3.0), (-0.5, -0.0), (-0.2, -0.0),
(-0.0, -0.0),
(0.0, 0.0),
(0.49999999999999994, 0.0), (1.5, 2.0),
(-1.5, -1.0),
(4503599627370496.5, 4503599627370496.0),
];
for &(input, expected) in cases {
let got = js_round(input);
assert_eq!(
got.to_bits(),
expected.to_bits(),
"js_round({input:?}) = {got:?}, V8 gives {expected:?}"
);
}
}
#[test]
fn propagates_non_finite_like_v8() {
assert!(js_round(f64::NAN).is_nan());
assert_eq!(js_round(f64::INFINITY), f64::INFINITY);
assert_eq!(js_round(f64::NEG_INFINITY), f64::NEG_INFINITY);
}
}