use wasm_bindgen::prelude::*;
use crate::engine::{Engine, SessionBuffer};
use crate::economy::{create_initial_economy_state, create_initial_central_bank_state, InitialEconomyOptions};
use crate::market::TickCompany;
fn seed_from_js(value: &JsValue, name: &str) -> Result<u64, JsError> {
const RANGE: &str = "an integer from 0 to 2**64 - 1: a Number up to \
Number.MAX_SAFE_INTEGER, or a BigInt for the whole range";
if let Some(n) = value.as_f64() {
if n.fract() == 0.0 && (0.0..=9_007_199_254_740_991.0).contains(&n) {
return Ok(n as u64);
}
return Err(JsError::new(&format!("{name} must be {RANGE}, got {n}")));
}
if value.is_bigint() {
return u64::try_from(value.clone()).map_err(|_| JsError::new(&format!(
"{name} must be {RANGE}, got a BigInt outside it")));
}
let kind = value.js_typeof().as_string().unwrap_or_default();
Err(JsError::new(&format!("{name} must be {RANGE}, got a value of type {kind}")))
}
#[wasm_bindgen]
pub fn version() -> String {
env!("CARGO_PKG_VERSION").to_string()
}
#[wasm_bindgen]
pub fn preset_names() -> Vec<String> {
crate::params::ModelParams::preset_names()
.iter()
.map(|s| (*s).to_string())
.collect()
}
#[wasm_bindgen]
pub struct Sim {
inner: Engine,
buffer: SessionBuffer,
tickers: Vec<String>,
day_count: u32,
}
#[wasm_bindgen]
impl Sim {
#[wasm_bindgen(constructor)]
pub fn new(size: usize,
#[wasm_bindgen(unchecked_param_type = "number | bigint")]
universe_seed: JsValue,
#[wasm_bindgen(unchecked_param_type = "number | bigint")]
seed: JsValue,
preset: &str)
-> Result<Sim, JsError> {
let universe_seed = seed_from_js(&universe_seed, "universe_seed")?;
let seed = seed_from_js(&seed, "seed")?;
Sim::build(size, universe_seed, seed, preset).map_err(|e| JsError::new(&e))
}
#[wasm_bindgen(getter)]
pub fn tickers(&self) -> Vec<String> {
self.tickers.clone()
}
#[wasm_bindgen(getter)]
pub fn prices(&self) -> Vec<f64> {
self.inner.prices()
}
#[wasm_bindgen(getter)]
pub fn day(&self) -> u32 {
self.day_count
}
#[wasm_bindgen(getter, js_name = modelFingerprint)]
pub fn model_fingerprint(&self) -> String {
self.inner.model_fingerprint().to_string()
}
#[wasm_bindgen(getter)]
pub fn vix(&self) -> f64 {
self.inner.published_vix()
}
#[wasm_bindgen(getter, js_name = indexLevel)]
pub fn index_level(&self) -> Option<f64> {
self.inner.index_level().map(|i| i.level)
}
#[wasm_bindgen(getter, js_name = frontFutures)]
pub fn front_futures(&self) -> Vec<FutureQuote> {
front_future_quotes(&self.inner)
}
#[wasm_bindgen(getter, js_name = optionExpiries)]
pub fn option_expiries(&self) -> Vec<OptionExpiry> {
self.inner.option_expiries("IDX").into_iter().map(OptionExpiry::from).collect()
}
#[wasm_bindgen(getter, js_name = nameOptionRoots)]
pub fn name_option_roots(&self) -> Vec<String> {
self.inner.name_option_roots()
}
#[wasm_bindgen(js_name = nameOptionExpiries)]
pub fn name_option_expiries(&self, ticker: &str) -> Vec<OptionExpiry> {
if ticker == "IDX" {
return Vec::new();
}
self.inner.option_expiries(ticker).into_iter().map(OptionExpiry::from).collect()
}
#[wasm_bindgen(js_name = runDay)]
pub fn run_day(&mut self, ticks: usize) -> Result<(), JsError> {
if ticks == 0 {
return Err(JsError::new("ticks must be greater than zero"));
}
self.inner.run_numbered_day(i64::from(self.day_count), ticks, &mut self.buffer);
self.day_count += 1;
Ok(())
}
#[wasm_bindgen(js_name = runDays)]
pub fn run_days(&mut self, days: usize, ticks: usize)
-> Result<(), JsError> {
for _ in 0..days {
self.run_day(ticks)?;
}
Ok(())
}
}
#[wasm_bindgen]
#[derive(Debug, Clone)]
pub struct FutureQuote {
symbol: String,
root: String,
expiry: i64,
price: f64,
fair: f64,
bid: Option<f64>,
ask: Option<f64>,
mark: Option<f64>,
basis_bp: f64,
sessions_to_expiry: f64,
multiplier: f64,
}
#[wasm_bindgen]
impl FutureQuote {
#[wasm_bindgen(getter)]
pub fn symbol(&self) -> String {
self.symbol.clone()
}
#[wasm_bindgen(getter)]
pub fn root(&self) -> String {
self.root.clone()
}
#[wasm_bindgen(getter)]
pub fn expiry(&self) -> f64 {
self.expiry as f64
}
#[wasm_bindgen(getter)]
pub fn price(&self) -> f64 {
self.price
}
#[wasm_bindgen(getter)]
pub fn fair(&self) -> f64 {
self.fair
}
#[wasm_bindgen(getter)]
pub fn bid(&self) -> Option<f64> {
self.bid
}
#[wasm_bindgen(getter)]
pub fn ask(&self) -> Option<f64> {
self.ask
}
#[wasm_bindgen(getter)]
pub fn mark(&self) -> Option<f64> {
self.mark
}
#[wasm_bindgen(getter, js_name = basisBp)]
pub fn basis_bp(&self) -> f64 {
self.basis_bp
}
#[wasm_bindgen(getter, js_name = sessionsToExpiry)]
pub fn sessions_to_expiry(&self) -> f64 {
self.sessions_to_expiry
}
#[wasm_bindgen(getter)]
pub fn multiplier(&self) -> f64 {
self.multiplier
}
}
#[wasm_bindgen]
#[derive(Debug, Clone)]
pub struct OptionExpiry {
expiry: i64,
sessions_to_expiry: f64,
forward: f64,
strike_low: f64,
strike_high: f64,
strike_step: f64,
atm_iv: Option<f64>,
put_25d_iv: Option<f64>,
call_25d_iv: Option<f64>,
skew_25d: Option<f64>,
}
impl From<crate::derivatives::ExpirySummary> for OptionExpiry {
fn from(e: crate::derivatives::ExpirySummary) -> Self {
OptionExpiry {
expiry: e.expiry,
sessions_to_expiry: e.sessions_to_expiry,
forward: e.forward,
strike_low: e.strike_low,
strike_high: e.strike_high,
strike_step: e.strike_step,
atm_iv: e.atm_iv,
put_25d_iv: e.put_25d_iv,
call_25d_iv: e.call_25d_iv,
skew_25d: e.skew_25d,
}
}
}
#[wasm_bindgen]
impl OptionExpiry {
#[wasm_bindgen(getter)]
pub fn expiry(&self) -> f64 {
self.expiry as f64
}
#[wasm_bindgen(getter, js_name = sessionsToExpiry)]
pub fn sessions_to_expiry(&self) -> f64 {
self.sessions_to_expiry
}
#[wasm_bindgen(getter)]
pub fn forward(&self) -> f64 {
self.forward
}
#[wasm_bindgen(getter, js_name = strikeLow)]
pub fn strike_low(&self) -> f64 {
self.strike_low
}
#[wasm_bindgen(getter, js_name = strikeHigh)]
pub fn strike_high(&self) -> f64 {
self.strike_high
}
#[wasm_bindgen(getter, js_name = strikeStep)]
pub fn strike_step(&self) -> f64 {
self.strike_step
}
#[wasm_bindgen(getter, js_name = atmIv)]
pub fn atm_iv(&self) -> Option<f64> {
self.atm_iv
}
#[wasm_bindgen(getter, js_name = put25dIv)]
pub fn put_25d_iv(&self) -> Option<f64> {
self.put_25d_iv
}
#[wasm_bindgen(getter, js_name = call25dIv)]
pub fn call_25d_iv(&self) -> Option<f64> {
self.call_25d_iv
}
#[wasm_bindgen(getter, js_name = skew25d)]
pub fn skew_25d(&self) -> Option<f64> {
self.skew_25d
}
}
fn front_future_quotes(engine: &Engine) -> Vec<FutureQuote> {
engine
.contracts()
.into_iter()
.filter(|c| c.front)
.filter_map(|c| {
let q = engine.quote(&c.symbol)?;
Some(FutureQuote {
symbol: c.symbol,
root: c.root,
expiry: q.expiry,
price: q.price,
fair: q.fair,
bid: q.bid,
ask: q.ask,
mark: q.mark,
basis_bp: q.basis_bp,
sessions_to_expiry: q.sessions_to_expiry,
multiplier: q.multiplier,
})
})
.collect()
}
#[wasm_bindgen(js_name = priceDigest)]
pub fn price_digest(size: usize,
#[wasm_bindgen(unchecked_param_type = "number | bigint")]
universe_seed: JsValue,
#[wasm_bindgen(unchecked_param_type = "number | bigint")]
seed: JsValue,
days: usize, ticks: usize, preset: &str)
-> Result<String, JsError> {
let universe_seed = seed_from_js(&universe_seed, "universe_seed")?;
let seed = seed_from_js(&seed, "seed")?;
crate::engine::fixed_simulation_digest(
size, universe_seed, seed, days, ticks, preset)
.ok_or_else(|| JsError::new(&format!("unknown preset {preset:?}")))
}
impl Sim {
fn build(size: usize, universe_seed: u64, seed: u64, preset: &str) -> Result<Sim, String> {
if size < 2 {
return Err("a universe needs at least two instruments".to_string());
}
let params = crate::params::ModelParams::preset(preset).ok_or_else(|| {
format!(
"unknown preset {preset:?}; this build has {:?}",
crate::params::ModelParams::preset_names()
)
})?;
Ok(Sim::with_params(size, universe_seed, seed, params))
}
fn with_params(size: usize, universe_seed: u64, seed: u64, params: crate::params::ModelParams) -> Sim {
let generated = crate::universe::random_universe(size, universe_seed);
let tickers: Vec<String> =
generated.iter().map(|g| g.ticker.clone()).collect();
let companies: Vec<TickCompany> = generated
.iter()
.enumerate()
.map(|(i, g)| g.to_init().to_tick_company(i))
.collect();
Sim {
inner: Engine::with_params(
seed,
companies,
create_initial_economy_state(&InitialEconomyOptions::default()),
create_initial_central_bank_state(0),
crate::sectors::keys().iter().map(|s| s.to_string()).collect(),
params,
),
buffer: SessionBuffer::new(),
tickers,
day_count: 0,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_sim_numbers_its_days_and_its_calendars_advance() {
let mut sim = Sim::build(24, 7, 11, "pt-v21").unwrap();
let days = 130usize;
let n = sim.tickers().len();
let mut reports = vec![0usize; n];
let mut report_days = std::collections::BTreeSet::new();
let mut ex = vec![0usize; n];
let mut ex_days = std::collections::BTreeSet::new();
for d in 0..days {
sim.run_day(390).unwrap();
assert_eq!(sim.day(), d as u32 + 1);
assert_eq!(sim.inner.elapsed_days(), d as i64);
for (i, m) in sim.inner.earnings_moves().iter().enumerate() {
if *m != 0.0 {
reports[i] += 1;
report_days.insert(d);
}
}
for (i, x) in sim.inner.dividends_today().iter().enumerate() {
if *x != 0.0 {
ex[i] += 1;
ex_days.insert(d);
}
}
}
assert!(reports.iter().all(|&r| (2..=3).contains(&r)), "{reports:?}");
assert!(report_days.len() > 10, "{report_days:?}");
assert!(ex.iter().any(|&k| k > 0), "{ex:?}");
assert!(ex.iter().all(|&k| k <= 3), "{ex:?}");
assert!(ex_days.len() > 5, "{ex_days:?}");
}
#[test]
fn on_a_shipped_preset_there_is_no_index_and_no_future() {
let mut sim = Sim::build(12, 7, 3, "pt-v21").unwrap();
sim.run_days(2, 65).unwrap();
let before = sim.inner.state_hash(2, false);
assert_eq!(sim.index_level(), None);
assert!(sim.front_futures().is_empty());
assert_eq!(sim.inner.state_hash(2, false), before);
}
#[test]
fn with_the_switches_on_the_index_and_each_front_future_read_through() {
let mut p = crate::params::PT_V21;
for (name, value) in [
("index_level_listed", 1.0),
("vix_intraday_live", 1.0),
("forecast_horizon_sessions", 252.0),
("futures_index_listed", 1.0),
("futures_vix_listed", 1.0),
("futures_rates_listed", 1.0),
("futures_oil_listed", 1.0),
] {
p = p.with_override(name, value).unwrap();
}
let mut sim = Sim::with_params(12, 7, 3, p);
sim.run_days(2, 65).unwrap();
let before = sim.inner.state_hash(2, false);
let level = sim.index_level().unwrap();
assert_eq!(level, sim.inner.index_level().unwrap().level);
let fronts = sim.front_futures();
let roots: Vec<String> = fronts.iter().map(|q| q.root()).collect();
assert_eq!(roots, ["IDX", "VIX", "FF", "TR3", "OIL"]);
for q in &fronts {
let quoted = sim.inner.quote(&q.symbol()).unwrap();
assert_eq!(q.price(), quoted.price);
assert_eq!(q.fair(), quoted.fair);
assert_eq!(q.mark(), quoted.mark);
assert_eq!(q.expiry(), quoted.expiry as f64);
}
assert_eq!(sim.inner.state_hash(2, false), before);
}
#[test]
fn on_a_shipped_preset_there_is_no_option_expiry() {
let mut sim = Sim::build(12, 7, 3, "pt-v21").unwrap();
sim.run_days(2, 65).unwrap();
let before = sim.inner.state_hash(2, false);
assert!(sim.option_expiries().is_empty());
assert_eq!(sim.inner.state_hash(2, false), before);
}
#[test]
fn with_the_options_on_each_expiry_reads_through() {
let mut p = crate::params::PT_V21;
for (name, value) in [
("index_level_listed", 1.0),
("vix_intraday_live", 1.0),
("forecast_horizon_sessions", 252.0),
("surface_ssvi", 1.0),
("surface_skew_physical", -0.8),
("surface_skew_premium", -1.0),
("surface_curvature", 1.0),
("surface_curvature_exponent", 0.5),
("options_index_listed", 1.0),
("option_dealer_spread", 0.004),
] {
p = p.with_override(name, value).unwrap();
}
let mut sim = Sim::with_params(12, 7, 3, p);
sim.run_days(2, 65).unwrap();
let before = sim.inner.state_hash(2, false);
let read = sim.option_expiries();
let core = sim.inner.option_expiries("IDX");
assert_eq!(read.len(), 8);
assert_eq!(read.len(), core.len());
for (w, e) in read.iter().zip(&core) {
assert_eq!(w.expiry(), e.expiry as f64);
assert_eq!(w.forward(), e.forward);
assert_eq!(w.atm_iv(), e.atm_iv);
assert_eq!(w.skew_25d(), e.skew_25d);
assert!(w.skew_25d().unwrap() > 0.0, "the put side is dearer");
assert!(w.strike_low() < w.forward() && w.forward() < w.strike_high());
}
assert_eq!(sim.inner.state_hash(2, false), before);
}
#[test]
fn with_the_name_options_on_each_names_expiries_read_through() {
let mut shipped = Sim::build(12, 7, 3, "pt-v21").unwrap();
shipped.run_days(1, 65).unwrap();
assert!(shipped.name_option_roots().is_empty());
let mut p = crate::params::PT_V21;
for (name, value) in [
("index_level_listed", 1.0),
("vix_intraday_live", 1.0),
("forecast_horizon_sessions", 252.0),
("surface_ssvi", 1.0),
("surface_curvature", 1.0),
("surface_curvature_exponent", 0.5),
("options_names_listed", 1.0),
("surface_name_skew", 0.5),
] {
p = p.with_override(name, value).unwrap();
}
let mut sim = Sim::with_params(12, 7, 3, p);
sim.run_days(2, 65).unwrap();
let before = sim.inner.state_hash(2, false);
let roots = sim.name_option_roots();
assert_eq!(roots.len(), 12);
let read = sim.name_option_expiries(&roots[0]);
let core = sim.inner.option_expiries(&roots[0]);
assert_eq!(read.len(), 6);
for (w, e) in read.iter().zip(&core) {
assert_eq!(w.expiry(), e.expiry as f64);
assert_eq!(w.atm_iv(), e.atm_iv);
}
assert!(sim.name_option_expiries("IDX").is_empty());
assert_eq!(sim.inner.state_hash(2, false), before);
}
#[test]
fn a_sim_and_the_digest_run_the_same_days() {
let mut sim = Sim::build(12, 7, 3, "pt-v21").unwrap();
sim.run_days(3, 65).unwrap();
let mut engine = Sim::build(12, 7, 3, "pt-v21").unwrap().inner;
let mut buffer = SessionBuffer::new();
for day in 0..3 {
engine.run_numbered_day(day, 65, &mut buffer);
}
assert_eq!(sim.inner.state_hash(3, false), engine.state_hash(3, false));
}
}