schema.hpp

Go to the documentation of this file.

#pragma once
// Declarative config schema (8.7): every known key with its section, type and whether it
// is required. config.cpp validates the parsed TOML against this table and reports
// errors with line numbers; an unknown key is an error too, so a misspelled or renamed key never
// leaves the real one at its default.
// Sections "sim", "backtest" and "storage" are free-form (owned by the sim, backtest and store
// libraries), and a [venues.<name>] key this table does not list belongs to the connector its
// `kind` names: the venue declares, validates and documents it
// (include/fastmm/venues/registry.hpp).
//
// The doc strings are the key tables of docs/reference/configuration.md
// (python3 tools/docs_config_ref.py regenerates them): say what the key does, its unit and its
// default.
#include <cstddef>
#include <span>
#include <string_view>
 
namespace fastmm {
 
enum class KeyType : unsigned char { String, Int, Float, Bool, IntArray, StringArray, Table, Any };
 
struct KeySpec {
  std::string_view section;  // "engine", "venues.*", "instruments[]", "strategy", ...
  std::string_view key;
  KeyType type;
  bool required;
  std::string_view doc;
};
 
inline constexpr KeySpec kConfigSchema[] = {
    // [engine]
    {"engine",
     "name",
     KeyType::String,
     false,
     "session name, used in logs, journal file names and the status file (default \"fastmm\")"},
    {"engine",
     "cpu",
     KeyType::Int,
     false,
     "CPU core of the engine thread; -1 = not pinned (default -1)"},
    {"engine",
     "net_cpus",
     KeyType::IntArray,
     false,
     "CPU cores of the network threads, one per venue in order; with spin_mode = \"adaptive\" a "
     "thread whose core it shares with the engine or another network thread blocks when idle "
     "instead of spinning (default [])"},
    {"engine",
     "spin_mode",
     KeyType::String,
     false,
     "busy (spin forever) | adaptive (spin briefly, then block until work arrives; use on WSL2 "
     "and laptops) (default adaptive)"},
    {"engine",
     "net_backend",
     KeyType::String,
     false,
     "event loop of fastmm-live and fastmm-sim-exchange: epoll | io_uring (Linux 5.13 or newer; "
     "falls back to epoll with a warning) (default epoll)"},
    {"engine",
     "threading",
     KeyType::String,
     false,
     "fastmm-live: split (engine and network threads, rings between them) | single (one venue; "
     "its network loop, the engine and order sending run on the engine thread, cpu; net_cpus is "
     "ignored) (default split)"},
    {"engine",
     "journal",
     KeyType::Bool,
     false,
     "record every consumed event to a .fmj journal (default true)"},
    {"engine", "journal_dir", KeyType::String, false, "directory for journals (default \"runs\")"},
    {"engine",
     "journal_sync",
     KeyType::String,
     false,
     "how far a journal write is pushed: async (msync every 100 ms; survives the process dying) | "
     "fdatasync (msync + fdatasync on the same tick; survives power loss) (default async)"},
    {"engine",
     "journal_max_bytes",
     KeyType::Int,
     false,
     "roll the journal over to the next part at this size, bytes; each part is a complete journal "
     "(\"x.fmj\", \"x.1.fmj\", ...); 0 = one file per session (default 0)"},
    {"engine",
     "journal_retention_days",
     KeyType::Int,
     false,
     "delete .fmj files in journal_dir last written more than this many days ago, at start; "
     "0 = keep everything (default 0)"},
    {"engine",
     "epoch_file",
     KeyType::String,
     false,
     "session epoch file, keeps client order ids unique across restarts (default "
     "\"runs/session_epoch\")"},
    {"engine",
     "kill_file",
     KeyType::String,
     false,
     "latched kill switch and cumulative PnL, so [risk] max_loss is a budget across restarts "
     "(default \"<journal_dir>/<name>.kill\")"},
    {"engine",
     "instance_lock",
     KeyType::Bool,
     false,
     "fastmm-live: take an exclusive lock on lock_file before touching the account and refuse to "
     "start (exit code 8) while another process holds it; --standby and --takeover take it "
     "whatever this says (default false)"},
    {"engine",
     "lock_file",
     KeyType::String,
     false,
     "the instance lock's file (default \"<journal_dir>/<name>.lock\")"},
    {"engine",
     "handoff_timeout_ms",
     KeyType::Int,
     false,
     "fastmm-live --takeover: how long to wait for the running session to release the instance "
     "lock once it accepted the handoff, ms (default 75000)"},
    {"engine",
     "ack_timeout_ms",
     KeyType::Int,
     false,
     "force-cancel an order whose ack has not arrived within this long, ms; 0 = off (default 0)"},
    {"engine",
     "queue_conservatism",
     KeyType::Float,
     false,
     "the queue position estimate ctx.queue_ahead, from 0 to 1: at 0 a level's shrink is shared "
     "between cancels ahead of and behind our order, at 1 cancels never move it up (default 1.0; "
     "a backtest uses [backtest] queue_conservatism when set)"},
    {"engine",
     "flatten_interval_ms",
     KeyType::Int,
     false,
     "how often an operator flatten looks at the position left and sends the next reduce-only "
     "slice, ms (default 500)"},
    {"engine",
     "flatten_timeout_ms",
     KeyType::Int,
     false,
     "how long an operator flatten keeps trying before it gives up and leaves the position, ms; "
     "0 = until it is flat or an operator stops it (default 60000)"},
    {"engine",
     "flatten_slippage_bps",
     KeyType::Int,
     false,
     "how far through the touch a flatten prices its orders when the command gives no "
     "--max-slippage-bps, basis points (default 25)"},
    {"engine",
     "rng_seed",
     KeyType::Int,
     false,
     "seed of the strategy random generator ctx.rng() (default 1)"},
    {"engine",
     "md_ring_bytes",
     KeyType::Int,
     false,
     "market-data ring per venue, bytes, a power of two (default 4194304)"},
    {"engine",
     "order_ring_bytes",
     KeyType::Int,
     false,
     "order-event ring per venue, bytes, a power of two (default 1048576)"},
    {"engine",
     "journal_ring_bytes",
     KeyType::Int,
     false,
     "engine-to-journal ring, bytes, a power of two (default 16777216)"},
    {"engine",
     "max_events_per_step",
     KeyType::Int,
     false,
     "events taken from each ring per engine iteration (default 64)"},
    {"engine",
     "feed_budget_per_ring",
     KeyType::Int,
     false,
     "fastmm-live: events the engine takes from one input ring before the next ring's turn; 1 "
     "interleaves the rings, so a burst of one account's order events does not hold up the "
     "market data behind it (default 64)"},
    {"engine",
     "net_spin_dedicated",
     KeyType::Bool,
     false,
     "with spin_mode = \"adaptive\": a network thread pinned to a core of its own (net_cpus, "
     "shared with neither the engine nor another network thread) polls without ever blocking, as "
     "with \"busy\"; threads on shared or unpinned cores still block when idle (default false)"},
    {"engine",
     "crossed_grace_ms",
     KeyType::Int,
     false,
     "tolerate a crossed book this long before pulling its quotes, ms (default 100)"},
    {"engine",
     "latency_publish_ms",
     KeyType::Int,
     false,
     "latency histogram publish interval, ms (default 1000)"},
    {"engine",
     "tsc_recalibrate_s",
     KeyType::Int,
     false,
     "fastmm-live: TSC recalibration period, s; 0 = off (default 10)"},
    {"engine",
     "timer_slack_ns",
     KeyType::Int,
     false,
     "fastmm-live: timer slack of its threads, ns; how late a timed wait may end (adaptive "
     "spin_mode: the engine's idle wait, at most 1 ms, and with threading = \"single\" a 50 us "
     "sleep); 0 = the kernel's, 50000 (default 0)"},
    {"engine",
     "restore_position",
     KeyType::Bool,
     false,
     "carry the previous session's positions over from the store and replay the venue's executions "
     "since its last recorded fill (venues that can replay executions); default true"},
    {"engine",
     "lock_memory",
     KeyType::Bool,
     false,
     "fastmm-live: mlockall() the process, so no page is swapped out or faulted in on the hot "
     "path; needs ulimit -l above the process size, a warning otherwise (default false)"},
    {"engine",
     "cpu_dma_latency_us",
     KeyType::Int,
     false,
     "fastmm-live: holds /dev/cpu_dma_latency at this many us for the session, so no CPU enters "
     "an idle state that takes longer to wake; 0 keeps every CPU polling in C0; needs write "
     "access to the device, a warning otherwise; -1 = no request (default -1)"},
    {"engine",
     "rt_priority",
     KeyType::Int,
     false,
     "fastmm-live: SCHED_FIFO priority 1..99 of the engine thread (with threading = \"single\" it "
     "also runs the network loop); needs CAP_SYS_NICE or ulimit -r at least as high, a warning "
     "otherwise; a busy-spinning FIFO thread starves the kernel's threads on its core unless the "
     "core is isolated; 0 = the default scheduler (default 0)"},
    {"engine",
     "net_rt_priority",
     KeyType::Int,
     false,
     "fastmm-live: SCHED_FIFO priority 1..99 of the network threads, as rt_priority; ignored with "
     "threading = \"single\"; 0 = the default scheduler (default 0)"},
    {"engine",
     "log_irq_affinity",
     KeyType::Bool,
     false,
     "fastmm-live: at start, log each network interface's queue interrupts with the CPUs they may "
     "run on and which of them are cpu or net_cpus, and warn about any that may run on the "
     "engine's CPU; read only (default false)"},
    {"engine",
     "min_requote_ticks",
     KeyType::Int,
     false,
     "keep a resting quote whose price is within this many ticks of the desired price (default 1)"},
    {"engine",
     "min_requote_interval_ms",
     KeyType::Int,
     false,
     "change the same quote slot at most this often, ms (default 50)"},
    {"engine",
     "min_qty_bps",
     KeyType::Int,
     false,
     "keep a resting quote whose remaining quantity covers this share of the desired quantity, "
     "bps (default 8000 = 80 %)"},
    {"engine", "post_only", KeyType::Bool, false, "send quotes as post-only orders (default true)"},
    {"engine",
     "supports_replace",
     KeyType::Bool,
     false,
     "let the quote manager amend orders in place where the venue supports it (default true)"},
    {"engine",
     "reject_backoff_ms",
     KeyType::Int,
     false,
     "after a venue reject other than a post-only cross, no new orders on that side for this "
     "long, doubling with each further reject, ms; 0 = off (default 1000)"},
    {"engine",
     "reject_backoff_max_ms",
     KeyType::Int,
     false,
     "cap of the doubling reject backoff, ms (default 60000)"},
    {"engine",
     "quote_token_reserve",
     KeyType::Int,
     false,
     "order tokens of [risk] orders_per_sec a quote that does not reduce the position leaves for "
     "the strategy's own orders and for quotes that do; quotes short of a token wait and are "
     "placed in turn as tokens return, not refused (default 0)"},
    {"engine",
     "on_kill",
     KeyType::String,
     false,
     "fastmm-live after a kill switch the engine trips itself ([risk] max_loss, a full ring, every "
     "venue killed): exit (normal shutdown, exit code 6) | stay (keep running with quoting off) "
     "(default exit)"},
    // [venues.<name>]
    {"venues.*",
     "kind",
     KeyType::String,
     true,
     "name of a registered connector; the keys it adds to this section are its own "
     "(see Connectors below)"},
    {"venues.*", "ws_url", KeyType::String, false, "market-data WebSocket URL"},
    {"venues.*",
     "ws_api_url",
     KeyType::String,
     false,
     "order-entry WebSocket API URL, where the venue has one"},
    {"venues.*", "rest_url", KeyType::String, false, "REST base URL"},
    {"venues.*", "api_key", KeyType::String, false, "API key, written as \"${VARIABLE}\""},
    {"venues.*", "api_secret", KeyType::String, false, "API secret, written as \"${VARIABLE}\""},
    {"venues.*",
     "api_passphrase",
     KeyType::String,
     false,
     "API key passphrase where the venue has one (OKX, Coinbase Exchange), written as "
     "\"${VARIABLE}\""},
    {"venues.*",
     "testnet",
     KeyType::Bool,
     false,
     "the endpoints are a testnet or demo environment (default true)"},
    {"venues.*",
     "supports_replace",
     KeyType::Bool,
     false,
     "the venue can amend an order in place (default false)"},
    {"venues.*",
     "insecure_tls",
     KeyType::Bool,
     false,
     "skip TLS certificate verification; local simulator only (default false)"},
    {"venues.*",
     "ca_file",
     KeyType::String,
     false,
     "extra CA certificate, for example tests/fixtures/tls/cert.pem for the local simulator"},
    {"venues.*",
     "public_only",
     KeyType::Bool,
     false,
     "market data only: no keys, no private sessions, no orders on this venue (default false)"},
    {"venues.*",
     "pool_of",
     KeyType::String,
     false,
     "name of another [venues.<name>] of the same kind whose instruments this account takes orders "
     "for, with its own keys, balances and order-count windows; no instruments or market data of "
     "its own (default none)"},
    {"venues.*",
     "recv_window_ms",
     KeyType::Int,
     false,
     "validity window of signed requests, ms (default 3000)"},
    {"venues.*",
     "source_ip",
     KeyType::String,
     false,
     "the venue's connections leave this host from this address, IPv4 or IPv6; it must be one of "
     "the host's (default: the kernel chooses)"},
    {"venues.*",
     "source_interface",
     KeyType::String,
     false,
     "the venue's connections leave this host from this network interface's address; exclusive "
     "with source_ip (default: the kernel chooses)"},
    {"venues.*",
     "fill_audit_interval_s",
     KeyType::Int,
     false,
     "fastmm-live compares the venue's trade history with the stored fills this often, s; 0 = off "
     "(default 0, at least 10)"},
    {"venues.*",
     "fill_audit_lag_s",
     KeyType::Int,
     false,
     "a fill audit reads up to this long ago, s, so the execution replay has booked what it will "
     "(default 180)"},
    {"venues.*",
     "fill_audit_mode",
     KeyType::String,
     false,
     "\"report\" logs and counts what differs; \"book\" also books the executions the engine "
     "missed "
     "(default \"report\")"},
    {"venues.*",
     "fees",
     KeyType::Table,
     false,
     "[venues.<name>.fees] table: maker_bps and taker_bps, used for PnL"},
    {"venues.*.fees",
     "maker_bps",
     KeyType::Float,
     false,
     "maker fee, bps; negative = rebate (default 0)"},
    {"venues.*.fees", "taker_bps", KeyType::Float, false, "taker fee, bps (default 0)"},
    {"venues.*",
     "treasury",
     KeyType::Table,
     false,
     "[venues.<primary>.treasury] table: transfers that keep one asset spread over the accounts "
     "of the pool this venue is the primary of (fastmm-live)"},
    {"venues.*.treasury",
     "enabled",
     KeyType::Bool,
     false,
     "move the asset between the pool's accounts (default false)"},
    {"venues.*.treasury",
     "dry_run",
     KeyType::Bool,
     false,
     "log and journal the planned transfers without sending them; needs no transfer key (default "
     "false)"},
    {"venues.*.treasury",
     "asset",
     KeyType::String,
     false,
     "the asset kept spread, for example USDT; required when enabled"},
    {"venues.*.treasury",
     "weights",
     KeyType::Table,
     false,
     "{ <account> = <weight>, ... }: each account's share of the pool's free balance (default 1 "
     "each)"},
    {"venues.*.treasury",
     "min_free",
     KeyType::Table,
     false,
     "{ <account> = \"<decimal>\", ... }: free balance an account is topped up to and never gives "
     "below (default 0)"},
    {"venues.*.treasury",
     "threshold",
     KeyType::Float,
     false,
     "an account is short below its target times (1 - threshold), 0 to 1 (default 0.2)"},
    {"venues.*.treasury",
     "min_amount",
     KeyType::Any,
     false,
     "smallest transfer, decimal (default 0)"},
    {"venues.*.treasury",
     "max_amount",
     KeyType::Any,
     false,
     "largest transfer, decimal; 0 = no cap (default 0)"},
    {"venues.*.treasury",
     "step",
     KeyType::Any,
     false,
     "transfer amounts round down to a multiple of it, decimal (default 0.01)"},
    {"venues.*.treasury",
     "interval_s",
     KeyType::Int,
     false,
     "how often the balances are looked at and a transfer in flight is asked for, s (default 10)"},
    {"venues.*.treasury",
     "min_interval_s",
     KeyType::Int,
     false,
     "least time between two transfers sent, s (default 60)"},
    {"venues.*.treasury",
     "max_per_hour",
     KeyType::Int,
     false,
     "transfers sent in any hour; 0 = no limit (default 12)"},
    {"venues.*.treasury",
     "cooldown_s",
     KeyType::Int,
     false,
     "no transfer for this long after one failed or timed out, s (default 300)"},
    {"venues.*.treasury",
     "timeout_s",
     KeyType::Int,
     false,
     "a transfer unresolved this long times out (cooldown_s; still asked for), and one the venue "
     "has no record of fails, s (default 60)"},
    {"venues.*.treasury",
     "settle_s",
     KeyType::Int,
     false,
     "longest wait after a transfer for both accounts' balances to report it, s (default 30)"},
    {"venues.*.treasury",
     "state_file",
     KeyType::String,
     false,
     "the transfers in flight, the id counter and the limiter across restarts (default "
     "<journal_dir>/<engine name>.<primary>.treasury)"},
    // [[instruments]]
    {"instruments[]", "venue", KeyType::String, true, "name of a [venues.<name>] table"},
    {"instruments[]", "symbol", KeyType::String, true, "venue symbol, for example BTCUSDT"},
    {"instruments[]", "base", KeyType::String, false, "base asset, for example BTC"},
    {"instruments[]", "quote", KeyType::String, false, "quote asset, for example USDT"},
    {"instruments[]",
     "asset_class",
     KeyType::String,
     false,
     "spot | perpetual (perp) | future (futures) | option | fx | equity (default spot)"},
    {"instruments[]", "tick", KeyType::Any, true, "price increment, decimal"},
    {"instruments[]", "lot", KeyType::Any, true, "quantity increment, decimal"},
    {"instruments[]", "min_qty", KeyType::Any, false, "smallest order quantity, decimal"},
    {"instruments[]", "max_qty", KeyType::Any, false, "largest order quantity, decimal"},
    {"instruments[]",
     "min_notional",
     KeyType::Any,
     false,
     "smallest order value, settlement currency (base coin for an inverse contract), "
     "decimal"},
    {"instruments[]",
     "contract_multiplier",
     KeyType::Any,
     false,
     "units of the underlying per contract, decimal; PnL and notional use it (default 1)"},
    {"instruments[]",
     "enabled",
     KeyType::Bool,
     false,
     "trade this instrument; false loads it without trading (default true)"},
    {"instruments[]", "price_decimals", KeyType::Int, false, "price display precision (default 8)"},
    {"instruments[]", "expiry", KeyType::String, false, "expiry of a derivative, ISO-8601"},
    {"instruments[]", "strike", KeyType::Any, false, "option strike, decimal"},
    {"instruments[]", "option_type", KeyType::String, false, "call | put"},
    {"instruments[]",
     "maker_bps",
     KeyType::Float,
     false,
     "maker fee of this instrument, bps; negative = rebate. Overrides the venue's fees table"},
    {"instruments[]",
     "taker_bps",
     KeyType::Float,
     false,
     "taker fee of this instrument, bps. Overrides the venue's fees table"},
    {"instruments[]",
     "initial_margin",
     KeyType::Any,
     false,
     "initial margin of a derivative, fraction of the notional (0.1 at 10x leverage), decimal; the "
     "balance check and estimate use it (default: none, an order passes while the venue reports "
     "margin available)"},
    // [strategy]
    {"strategy", "name", KeyType::String, true, "registered strategy name (see --list-strategies)"},
    {"strategy",
     "max_param_age_ms",
     KeyType::Int,
     false,
     "disable quoting before the first parameter update and while none was applied for this long, "
     "ms of engine time (default 0: off)"},
    {"strategy",
     "state_file",
     KeyType::String,
     false,
     "file the strategy's state() is written to every state_interval_s and at the end, and "
     "restore() reads at the start (a strategy that keeps state; default: none)"},
    {"strategy",
     "state_interval_s",
     KeyType::Int,
     false,
     "how often the state is written, seconds of engine time (default 300)"},
    {"strategy",
     "state_snapshot_interval_s",
     KeyType::Int,
     false,
     "with a journal, how often the strategy's state() and the positions are written to it, "
     "seconds of engine time, for a backtest to start from (default 0: never)"},
    {"strategy",
     "params",
     KeyType::Table,
     false,
     "[strategy.params] table: the strategy's parameters"},
    {"strategy.params", "*", KeyType::Any, false, "strategy parameters (validated by the schema)"},
    // [risk]
    {"risk", "max_order_qty", KeyType::Any, false, "largest order quantity, decimal"},
    {"risk",
     "max_order_notional",
     KeyType::Any,
     false,
     "largest order value, settlement currency (base coin for an inverse contract), decimal"},
    {"risk",
     "max_position",
     KeyType::Any,
     false,
     "largest absolute position per instrument, counting same-side open orders, decimal"},
    {"risk", "max_open_orders", KeyType::Int, false, "open orders per instrument"},
    {"risk",
     "price_collar_bps",
     KeyType::Int,
     false,
     "refuse limit prices further than this from the mid, bps"},
    {"risk",
     "fat_finger_bps",
     KeyType::Int,
     false,
     "refuse limit prices further than this from the last trade, bps"},
    {"risk",
     "stale_md_ms",
     KeyType::Int,
     false,
     "refuse orders when the instrument's book is older than this, ms"},
    {"risk",
     "max_loss",
     KeyType::Any,
     false,
     "trip the kill switch when net PnL falls to -max_loss, settlement currency (the "
     "[accounting] reporting_currency when set), decimal; latched across restarts in kill_file"},
    {"risk",
     "max_gross_notional",
     KeyType::Any,
     false,
     "refuse an order that would take the portfolio's summed |position| at the last marks past "
     "this, settlement currency (or reporting_currency), decimal"},
    {"risk",
     "max_net_notional",
     KeyType::Any,
     false,
     "refuse an order that would take the portfolio's signed position sum further past this, "
     "settlement currency (or reporting_currency), decimal"},
    {"risk", "orders_per_sec", KeyType::Int, false, "token-bucket order rate, orders/s"},
    {"risk",
     "burst",
     KeyType::Int,
     false,
     "token-bucket capacity, orders (default orders_per_sec)"},
    {"risk",
     "stp",
     KeyType::Bool,
     false,
     "self-trade prevention against our own resting orders (default true)"},
    {"risk",
     "max_feed_lag_ms",
     KeyType::Int,
     false,
     "pull a venue's quotes and refuse orders that could rest there without reducing the "
     "position while its market data arrives this much later than its baseline, ms; resumes "
     "100 ms after the last message over it (default 0: off)"},
    {"risk",
     "check_balance",
     KeyType::Bool,
     false,
     "refuse an order the venue's reported balance, less this session's orders and fills since, "
     "cannot cover; off for a venue until it reports balances (default true)"},
    {"risk",
     "underlying",
     KeyType::Table,
     false,
     "one [risk.underlying.BTC] table per base asset: a net position limit over every instrument "
     "and venue that trades it"},
    {"risk.underlying.*",
     "max_net",
     KeyType::Any,
     true,
     "refuse an order that would take the net position in this base asset, open orders on the "
     "order's side included, further past this; base units (contracts times contract_multiplier, "
     "inverse contracts at the mark), decimal; 0: tracked, no limit"},
    // [gateway]
    {"gateway",
     "orders_per_sec",
     KeyType::Int,
     false,
     "fastmm-gateway: new orders and replaces per second per venue, over every attached strategy "
     "(default 0: off)"},
    {"gateway",
     "burst",
     KeyType::Int,
     false,
     "fastmm-gateway: token-bucket capacity of orders_per_sec, orders (default orders_per_sec)"},
    {"gateway",
     "max_open_notional",
     KeyType::Any,
     false,
     "fastmm-gateway: refuse an order that would take the notional working at its venue, over "
     "every attached strategy and both sides, past this; settlement currency, decimal"},
    {"gateway",
     "max_loss",
     KeyType::Any,
     false,
     "fastmm-gateway: trip the account's kill switch when the net PnL of every strategy together, "
     "carried across restarts in the gateway's kill file, reaches -max_loss; decimal, in "
     "[accounting] reporting_currency when set"},
    {"gateway",
     "max_gross_notional",
     KeyType::Any,
     false,
     "fastmm-gateway: refuse an order that would take the sum of the account's |position| at the "
     "marks past this, unless it reduces its instrument's position; decimal"},
    {"gateway",
     "max_net_notional",
     KeyType::Any,
     false,
     "fastmm-gateway: refuse an order that would take the account's net position at the marks "
     "further past this, unless it reduces its instrument's position; decimal"},
    {"gateway",
     "underlying",
     KeyType::Table,
     false,
     "fastmm-gateway: one [gateway.underlying.BTC] table per base asset: the account's net limit, "
     "over every strategy and venue"},
    {"gateway",
     "check_balance",
     KeyType::Bool,
     false,
     "fastmm-gateway: refuse an order the venue's reported balance, less the orders and fills of "
     "every attached strategy since, cannot cover (default true)"},
    {"gateway.underlying.*",
     "max_net",
     KeyType::Any,
     true,
     "fastmm-gateway: refuse an order that would take the account's net position in this base "
     "asset, working orders on the order's side included, further past this; base units, decimal"},
    {"gateway",
     "shared",
     KeyType::Table,
     false,
     "fastmm-gateway: one [gateway.shared.\"venue:symbol\"] table per instrument that several "
     "strategies may trade at once (default: one strategy per instrument)"},
    {"gateway.shared.*",
     "primary",
     KeyType::String,
     false,
     "fastmm-gateway: [engine] name of the strategy that books this instrument's events naming no "
     "order (funding, liquidation fills, executions of orders placed elsewhere); default none: "
     "the account alone books them"},
    // [accounting]
    {"accounting",
     "reporting_currency",
     KeyType::String,
     false,
     "currency the PnL totals, [risk] max_loss and the exposure caps (and fastmm-gateway's) are in "
     "when instruments settle in more than one; every other settlement currency needs a source in "
     "[accounting.fx] (default unset: no conversion)"},
    {"accounting",
     "fx",
     KeyType::Table,
     false,
     "[accounting.fx] table: one entry per other settlement currency, the instrument whose mid "
     "prices it in reporting_currency (BTC = \"binance:BTCUSDT\"; a pair quoted the other way "
     "round, USDTBTC, is inverted)"},
    {"accounting.fx", "*", KeyType::String, false, "FX source of one settlement currency"},
    {"accounting",
     "mark",
     KeyType::String,
     false,
     "what a derivative's position is valued at for the unrealized PnL, max_loss and the "
     "exposure caps (fastmm-gateway's too): venue (its venue's mark price while it is fresh, else "
     "the book's mid) | mid (default venue)"},
    {"accounting",
     "stale_mark_ms",
     KeyType::Int,
     false,
     "a venue's mark or index price older than this is stale: ctx.mark and ctx.index flag it and "
     "the position is valued at the mid, ms (default 15000)"},
    {"accounting",
     "stale_funding_ms",
     KeyType::Int,
     false,
     "a venue's funding rate older than this is stale (ctx.funding flags it), ms (default "
     "180000)"},
    {"accounting",
     "stale_fx_ms",
     KeyType::Int,
     false,
     "an [accounting.fx] rate whose source's book has not updated for this long is not current: "
     "an order that adds exposure in that currency is refused; ms (default 60000; 0: a valid "
     "book is enough). Not [risk] stale_md_ms: a quiet FX book can go seconds without a change"},
    // [logging]
    {"logging",
     "level",
     KeyType::String,
     false,
     "trace | debug | info | warn (or warning) | error | off (default info)"},
    {"logging", "file", KeyType::String, false, "log file; empty = stderr only"},
    {"logging",
     "mirror_level",
     KeyType::String,
     false,
     "records at or above this level are also written to stderr (default warn)"},
    {"logging",
     "status_interval_s",
     KeyType::Int,
     false,
     "seconds between the per-venue status lines, 0 = none (default 1 with a log file, 10 on "
     "stderr)"},
    // free-form
    {"sim", "*", KeyType::Any, false, "simulator settings"},
    {"sim.*", "*", KeyType::Any, false, "simulator sub-tables"},
    {"backtest", "*", KeyType::Any, false, "backtester settings"},
    {"backtest.*", "*", KeyType::Any, false, "backtester sub-tables"},
};
 
[[nodiscard]] inline std::span<const KeySpec> config_schema() noexcept {
  return kConfigSchema;
}
 
}  // namespace fastmm