binance-api/src/dex/aster/gridConfig.ts

import { DualGridConfig } from './gridDualExecutor';

/**
 * 超详细中文说明（把你当第一次用的朋友来写）：
 *
 * 这个文件做的事：
 * - 从环境变量（.env 或启动命令里的 GRID_XXX）读取参数
 * - 设定“保守、安全”的默认值（就算你一个都不配，也能跑）
 * - 把这些参数转换成网格机器人能理解的配置对象
 *
 * 一句话原则：宁可慢，别炸；先活下来，有单边也要能退。
 *
 * 如何使用：
 * - 不懂就什么都不改，直接跑，默认值很保守。
 * - 想改某个参数：在 .env 里加一行，比如：
 *   GRID_BASE_NOTIONAL=3
 *   这样就把“每笔名义金额”从默认 2 美元改为 3 美元。
 * - 想恢复默认：把这一行删掉或注释掉即可。
 *
 * 参数大类（直白解释）：
 * - 基础参数：交易品种、杠杆、每笔下多少美金、网格步长（间隔）
 * - 节奏控制：多久下一个单、每次下几个、是否激进、是否并发
 * - 成本/点差：点差太小就不做、成本上限（避免越做越亏）
 * - 高频控制：高频模式开不开、每侧最多并发几个、持有多久就平
 * - 做市（限价）参数：优先用限价省手续费，超时就撤掉走市价
 * - 再平衡：两个账户/双向仓位的净敞口太偏时，把它往中间拉
 * - 去杠杆：资金吃紧（可用资金/钱包余额 比例低）就自动减仓
 * - Taker 爆发：在很短时间窗口内快速打几单，但有并发和冷却限制
 * - 保护单：持续维护止盈/止损（可开/可关），避免裸奔
 * - 审计日志：把每次开/平、资金、仓位写日志，方便复盘
 *
 * 提醒：
 * - 你看到的“默认值”都是偏保守，不追求收益最大化，先把风险压住。
 * - 真想冲，就把“每笔名义金额”、“网格步长”、“并发”等逐步往上调，
 *   但务必结合你的资金体量与风险偏好。
 */

export interface GridEnv {
  GRID_SYMBOL?: string;
  GRID_LEVERAGE?: string;
  GRID_BASE_NOTIONAL?: string;
  GRID_STEP_BPS?: string;
  GRID_COUNT?: string;
  GRID_TICK_MS?: string;
  GRID_MAX_OPEN?: string;
  GRID_TP_BPS?: string;
  GRID_SL_BPS?: string;
  GRID_WORKING_TYPE?: 'MARK_PRICE' | 'CONTRACT_PRICE' | string;
  GRID_STATE_FILE?: string;
  GRID_PERSIST_MS?: string;
  GRID_MIN_NOTIONAL_USD?: string;
  GRID_FORCE_OPEN_ON_START?: string;
  GRID_MIN_OPEN_INTERVAL_MS?: string;
  GRID_ORDERS_PER_TICK_PER_SIDE?: string;
  GRID_AGGRESSIVE?: string;
  GRID_PARALLEL_PLACEMENT?: string;
  GRID_MAX_EXPOSURE_USD?: string;
  GRID_REDUCE_WHEN_EXPOSURE_ABOVE_USD?: string;
  GRID_REDUCE_CHUNK_USD?: string;
  GRID_MIN_REDUCE_INTERVAL_MS?: string;
  GRID_USE_MAX_LEVERAGE?: string;
  GRID_CONTINUOUS_PROTECT?: string;
  GRID_PROTECT_REFRESH_MS?: string;
  GRID_HF_MODE?: string;
  GRID_HF_HOLD_MS?: string;
  GRID_HF_MAX_CONCURRENT_PER_SIDE?: string;
  GRID_AUDIT_ENABLED?: string;
  GRID_AUDIT_LOG_FILE?: string;
  GRID_MAKER_MODE?: string;              // 入场使用限价GTX（post-only）
  GRID_MAKER_OFFSET_BPS?: string;        // 入场挂价相对中价偏移bps
  GRID_MAKER_TIMEOUT_MS?: string;        // 入场挂单超时取消
  GRID_REBALANCE_ENABLED?: string;       // 是否启用净敞口再平衡
  GRID_REBALANCE_THRESHOLD_QTY?: string; // 触发再平衡的净持仓阈值（基础币数量）
  GRID_REBALANCE_CHUNK_QTY?: string;     // 每次再平衡数量（基础币数量）
  GRID_REBALANCE_MIN_INTERVAL_MS?: string; // 再平衡最小间隔
  GRID_DELEVERAGE_AFTER_2019?: string;     // -2019 后是否尝试减仓
  GRID_DELEVERAGE_CHUNK_QTY?: string;      // 每次减仓数量（基础币）
  GRID_DELEVERAGE_MIN_INTERVAL_MS?: string;// 减仓最小间隔
  GRID_DELEVERAGE_STEPS_ON_2019?: string;  // -2019 时连击步数
  GRID_DELEVERAGE_MULTIPLIER?: string;     // 连击步进系数
  GRID_DELEVERAGE_MAX_CHUNK_QTY?: string;  // 单次最大减仓数量
  GRID_TAKER_RATIO?: string;               // Taker 触发比例（0~1）
  GRID_TAKER_BURST_MS?: string;            // Taker 爆发时窗（ms）
  GRID_TAKER_MAX_CONCURRENT?: string;      // Taker 每侧最大并发
  GRID_COST_CAP_BPS?: string;              // 成本上限（费率+点差+滑点）bps
  GRID_MIN_SPREAD_BPS?: string;            // 最小点差 bps
  GRID_TAKER_COOLDOWN_MS?: string;         // Taker 连续失败后的冷却（ms）
  GRID_MAX_GROSS_QTY_PER_SIDE?: string;    // 每侧最大总持仓数量（基础币），超过则优先减仓
  GRID_DERISK_ENABLED?: string;            // 启用利用率去杠杆器
  GRID_DERISK_AVAIL_RATIO?: string;        // 可用/钱包 低于该比例时去杠杆（0~1）
  GRID_DERISK_CHUNK_QTY?: string;          // 每次去杠杆数量（基础币）
  GRID_DERISK_INTERVAL_MS?: string;        // 去杠杆最小间隔
  GRID_MAX_NET_QTY?: string;               // 允许的最大净敞口（基础币）
  GRID_ENTRY_ALIGN_ENABLED?: string;       // 启用开仓均价动态回归（成对刷新）
  GRID_ENTRY_ALIGN_BPS?: string;           // 触发阈值：两侧开仓均价差（bps）
  GRID_ENTRY_ALIGN_CHUNK_RATIO?: string;   // 每次回归的成对刷新比例（0~1）
  GRID_ENTRY_ALIGN_MIN_INTERVAL_MS?: string; // 回归的最小间隔
  GRID_ENTRY_ALIGN_MODE?: 'ADD' | 'REPLACE' | 'AUTO' | string; // 回归模式：ADD=同向加仓，REPLACE=先反向平仓再同向重开，AUTO=自适应
  GRID_ENTRY_ALIGN_ADD_BPS?: string;        // AUTO模式：ADD触发阈值（bps）
  GRID_ENTRY_ALIGN_REPLACE_BPS?: string;    // AUTO模式：REPLACE触发阈值（bps）
  GRID_ENTRY_ALIGN_SUSTAIN_TICKS?: string;  // AUTO模式：REPLACE需连续满足阈值的tick数
  // 薄盘口优化
  GRID_SPREAD_AWARE?: string;               // 启用点差感知
  GRID_TAKER_MAX_SPREAD_BPS?: string;       // 允许吃单的最大点差（bps）
  GRID_MAKER_JOIN_BEST?: string;            // maker 价格跟随盘口最优
  GRID_MAKER_INSIDE_TICKS?: string;         // maker 相对最优内移的 tick 数
}

export function loadGridEnv(env: NodeJS.ProcessEnv = process.env): GridEnv {
  return {
    GRID_SYMBOL: env.GRID_SYMBOL,
    GRID_LEVERAGE: env.GRID_LEVERAGE,
    GRID_BASE_NOTIONAL: env.GRID_BASE_NOTIONAL,
    GRID_STEP_BPS: env.GRID_STEP_BPS,
    GRID_COUNT: env.GRID_COUNT,
    GRID_TICK_MS: env.GRID_TICK_MS,
    GRID_MAX_OPEN: env.GRID_MAX_OPEN,
    GRID_TP_BPS: env.GRID_TP_BPS,
    GRID_SL_BPS: env.GRID_SL_BPS,
    GRID_WORKING_TYPE: env.GRID_WORKING_TYPE as any,
    GRID_STATE_FILE: env.GRID_STATE_FILE,
    GRID_PERSIST_MS: env.GRID_PERSIST_MS,
    GRID_MIN_NOTIONAL_USD: env.GRID_MIN_NOTIONAL_USD,
    GRID_FORCE_OPEN_ON_START: env.GRID_FORCE_OPEN_ON_START,
    GRID_MIN_OPEN_INTERVAL_MS: env.GRID_MIN_OPEN_INTERVAL_MS,
    GRID_ORDERS_PER_TICK_PER_SIDE: env.GRID_ORDERS_PER_TICK_PER_SIDE,
    GRID_AGGRESSIVE: env.GRID_AGGRESSIVE,
    GRID_PARALLEL_PLACEMENT: env.GRID_PARALLEL_PLACEMENT,
    GRID_MAX_EXPOSURE_USD: env.GRID_MAX_EXPOSURE_USD,
    GRID_REDUCE_WHEN_EXPOSURE_ABOVE_USD: env.GRID_REDUCE_WHEN_EXPOSURE_ABOVE_USD,
    GRID_REDUCE_CHUNK_USD: env.GRID_REDUCE_CHUNK_USD,
    GRID_MIN_REDUCE_INTERVAL_MS: env.GRID_MIN_REDUCE_INTERVAL_MS,
    GRID_USE_MAX_LEVERAGE: env.GRID_USE_MAX_LEVERAGE,
    GRID_CONTINUOUS_PROTECT: env.GRID_CONTINUOUS_PROTECT,
    GRID_PROTECT_REFRESH_MS: env.GRID_PROTECT_REFRESH_MS,
    GRID_HF_MODE: env.GRID_HF_MODE,
    GRID_HF_HOLD_MS: env.GRID_HF_HOLD_MS,
    GRID_HF_MAX_CONCURRENT_PER_SIDE: env.GRID_HF_MAX_CONCURRENT_PER_SIDE,
    GRID_AUDIT_ENABLED: env.GRID_AUDIT_ENABLED,
    GRID_AUDIT_LOG_FILE: env.GRID_AUDIT_LOG_FILE,
    GRID_TAKER_RATIO: env.GRID_TAKER_RATIO,
    GRID_TAKER_BURST_MS: env.GRID_TAKER_BURST_MS,
    GRID_TAKER_MAX_CONCURRENT: env.GRID_TAKER_MAX_CONCURRENT,
    GRID_COST_CAP_BPS: env.GRID_COST_CAP_BPS,
    GRID_MIN_SPREAD_BPS: env.GRID_MIN_SPREAD_BPS,
    GRID_TAKER_COOLDOWN_MS: env.GRID_TAKER_COOLDOWN_MS
    ,GRID_MAX_GROSS_QTY_PER_SIDE: env.GRID_MAX_GROSS_QTY_PER_SIDE
    ,GRID_DERISK_ENABLED: env.GRID_DERISK_ENABLED
    ,GRID_DERISK_AVAIL_RATIO: env.GRID_DERISK_AVAIL_RATIO
    ,GRID_DERISK_CHUNK_QTY: env.GRID_DERISK_CHUNK_QTY
    ,GRID_DERISK_INTERVAL_MS: env.GRID_DERISK_INTERVAL_MS
    ,GRID_MAX_NET_QTY: env.GRID_MAX_NET_QTY
    ,GRID_ENTRY_ALIGN_ENABLED: env.GRID_ENTRY_ALIGN_ENABLED
    ,GRID_ENTRY_ALIGN_BPS: env.GRID_ENTRY_ALIGN_BPS
    ,GRID_ENTRY_ALIGN_CHUNK_RATIO: env.GRID_ENTRY_ALIGN_CHUNK_RATIO
    ,GRID_ENTRY_ALIGN_MIN_INTERVAL_MS: env.GRID_ENTRY_ALIGN_MIN_INTERVAL_MS
    ,GRID_ENTRY_ALIGN_MODE: env.GRID_ENTRY_ALIGN_MODE as any
    ,GRID_ENTRY_ALIGN_ADD_BPS: env.GRID_ENTRY_ALIGN_ADD_BPS
    ,GRID_ENTRY_ALIGN_REPLACE_BPS: env.GRID_ENTRY_ALIGN_REPLACE_BPS
    ,GRID_ENTRY_ALIGN_SUSTAIN_TICKS: env.GRID_ENTRY_ALIGN_SUSTAIN_TICKS
    ,GRID_SPREAD_AWARE: env.GRID_SPREAD_AWARE
    ,GRID_TAKER_MAX_SPREAD_BPS: env.GRID_TAKER_MAX_SPREAD_BPS
    ,GRID_MAKER_JOIN_BEST: env.GRID_MAKER_JOIN_BEST
    ,GRID_MAKER_INSIDE_TICKS: env.GRID_MAKER_INSIDE_TICKS
  };
}

// 参数默认值（保守）：
// - baseNotionalUsd=2：单笔名义低，减少 -2019
// - gridStepBps=60：较大步长，覆盖成本/点差
// - hfMaxConcurrentPerSide=2、ordersPerTickPerSide=1：降低并发
// - minSpreadBps=25：点差较小时不吃单
// - takerCooldownMs=10000：-2019 后适度冷却
// - maxGrossQtyPerSide=0.02、maxNetQty=0.003：限制总仓与净敞口
// - 去杠杆阈值=25%，步长0.006，间隔6s：保证金吃紧时主动释压
export function toDualGridConfig(env: GridEnv): DualGridConfig {
  const symbol = (env.GRID_SYMBOL || 'BTCUSDT').toUpperCase();
  const leverage = parseInt(env.GRID_LEVERAGE || '100');
  const baseNotionalUsd = parseFloat(env.GRID_BASE_NOTIONAL || '2');
  const gridStepBps = parseInt(env.GRID_STEP_BPS || '60');
  const gridCount = parseInt(env.GRID_COUNT || '1');
  const tickIntervalMs = parseInt(env.GRID_TICK_MS || '700');
  const maxOpenPerSide = parseInt(env.GRID_MAX_OPEN || '1');
  const tpBps = env.GRID_TP_BPS ? parseInt(env.GRID_TP_BPS) : undefined;
  const slBps = env.GRID_SL_BPS ? parseInt(env.GRID_SL_BPS) : undefined;
  const workingType = env.GRID_WORKING_TYPE as 'MARK_PRICE' | 'CONTRACT_PRICE' | undefined;
  const stateFile = env.GRID_STATE_FILE || undefined;
  const persistIntervalMs = env.GRID_PERSIST_MS ? parseInt(env.GRID_PERSIST_MS) : 8000;
  const minNotionalUsd = env.GRID_MIN_NOTIONAL_USD ? parseFloat(env.GRID_MIN_NOTIONAL_USD) : undefined;
  const forceOpenOnStart = env.GRID_FORCE_OPEN_ON_START ? env.GRID_FORCE_OPEN_ON_START === '1' : true;
  const minOpenIntervalMs = env.GRID_MIN_OPEN_INTERVAL_MS ? parseInt(env.GRID_MIN_OPEN_INTERVAL_MS) : 1000;
  const ordersPerTickPerSide = env.GRID_ORDERS_PER_TICK_PER_SIDE ? parseInt(env.GRID_ORDERS_PER_TICK_PER_SIDE) : 1;
  const aggressive = env.GRID_AGGRESSIVE ? env.GRID_AGGRESSIVE === '1' : true;
  const parallelPlacement = env.GRID_PARALLEL_PLACEMENT ? env.GRID_PARALLEL_PLACEMENT === '1' : true;
  const maxExposureUsdPerSide = env.GRID_MAX_EXPOSURE_USD ? parseFloat(env.GRID_MAX_EXPOSURE_USD) : undefined;
  const reduceWhenExposureAboveUsd = env.GRID_REDUCE_WHEN_EXPOSURE_ABOVE_USD ? parseFloat(env.GRID_REDUCE_WHEN_EXPOSURE_ABOVE_USD) : undefined;
  const reduceChunkUsd = env.GRID_REDUCE_CHUNK_USD ? parseFloat(env.GRID_REDUCE_CHUNK_USD) : undefined;
  const minReduceIntervalMs = env.GRID_MIN_REDUCE_INTERVAL_MS ? parseInt(env.GRID_MIN_REDUCE_INTERVAL_MS) : undefined;
  const useMaxLeverage = env.GRID_USE_MAX_LEVERAGE ? env.GRID_USE_MAX_LEVERAGE === '1' : true;
  const continuousProtect = env.GRID_CONTINUOUS_PROTECT ? env.GRID_CONTINUOUS_PROTECT === '1' : false;
  const protectRefreshMs = env.GRID_PROTECT_REFRESH_MS ? parseInt(env.GRID_PROTECT_REFRESH_MS) : 15000;
  const hfMode = env.GRID_HF_MODE ? env.GRID_HF_MODE === '1' : true;
  const hfHoldMs = env.GRID_HF_HOLD_MS ? parseInt(env.GRID_HF_HOLD_MS) : 800;
  const hfMaxConcurrentPerSide = env.GRID_HF_MAX_CONCURRENT_PER_SIDE ? parseInt(env.GRID_HF_MAX_CONCURRENT_PER_SIDE) : 2;
  const hfSymmetric = true;
  // 为进一步减少进场漂移，默认关闭 makerMode，成对下单强制用市价同步成交
  const makerMode = env.GRID_MAKER_MODE ? env.GRID_MAKER_MODE === '1' : false;
  // 为减少价差与滑点：加大挂单偏移、缩短挂单超时
  const makerOffsetBps = env.GRID_MAKER_OFFSET_BPS ? parseInt(env.GRID_MAKER_OFFSET_BPS) : 8;
  const makerTimeoutMs = env.GRID_MAKER_TIMEOUT_MS ? parseInt(env.GRID_MAKER_TIMEOUT_MS) : 800;
  const rebalanceEnabled = env.GRID_REBALANCE_ENABLED ? env.GRID_REBALANCE_ENABLED === '1' : true;
  const rebalanceThresholdQty = env.GRID_REBALANCE_THRESHOLD_QTY ? parseFloat(env.GRID_REBALANCE_THRESHOLD_QTY) : 0.005; // 0.005 BTC
  const rebalanceChunkQty = env.GRID_REBALANCE_CHUNK_QTY ? parseFloat(env.GRID_REBALANCE_CHUNK_QTY) : 0.005;
  const rebalanceMinIntervalMs = env.GRID_REBALANCE_MIN_INTERVAL_MS ? parseInt(env.GRID_REBALANCE_MIN_INTERVAL_MS) : 3000;
  const deleverageAfter2019 = env.GRID_DELEVERAGE_AFTER_2019 ? env.GRID_DELEVERAGE_AFTER_2019 === '1' : true;
  const deleverageChunkQty = env.GRID_DELEVERAGE_CHUNK_QTY ? parseFloat(env.GRID_DELEVERAGE_CHUNK_QTY) : 0.002;
  const deleverageMinIntervalMs = env.GRID_DELEVERAGE_MIN_INTERVAL_MS ? parseInt(env.GRID_DELEVERAGE_MIN_INTERVAL_MS) : 8000;
  const deleverageStepsOn2019 = env.GRID_DELEVERAGE_STEPS_ON_2019 ? parseInt(env.GRID_DELEVERAGE_STEPS_ON_2019) : 3;
  const deleverageMultiplier = env.GRID_DELEVERAGE_MULTIPLIER ? parseFloat(env.GRID_DELEVERAGE_MULTIPLIER) : 2.0;
  const deleverageMaxChunkQty = env.GRID_DELEVERAGE_MAX_CHUNK_QTY ? parseFloat(env.GRID_DELEVERAGE_MAX_CHUNK_QTY) : 0.02;
  const takerRatio = env.GRID_TAKER_RATIO ? parseFloat(env.GRID_TAKER_RATIO) : 0.6;
  const takerBurstMs = env.GRID_TAKER_BURST_MS ? parseInt(env.GRID_TAKER_BURST_MS) : 1000;
  const takerMaxConcurrent = env.GRID_TAKER_MAX_CONCURRENT ? parseInt(env.GRID_TAKER_MAX_CONCURRENT) : 1;
  const costCapBps = env.GRID_COST_CAP_BPS ? parseInt(env.GRID_COST_CAP_BPS) : 30;
  const minSpreadBps = env.GRID_MIN_SPREAD_BPS ? parseInt(env.GRID_MIN_SPREAD_BPS) : 35;
  const takerCooldownMs = env.GRID_TAKER_COOLDOWN_MS ? parseInt(env.GRID_TAKER_COOLDOWN_MS) : 10000;
  const maxGrossQtyPerSide = env.GRID_MAX_GROSS_QTY_PER_SIDE ? parseFloat(env.GRID_MAX_GROSS_QTY_PER_SIDE) : 0.02; // 0.02 BTC
  const deRiskEnabled = env.GRID_DERISK_ENABLED ? env.GRID_DERISK_ENABLED === '1' : true;
  const deRiskAvailRatio = env.GRID_DERISK_AVAIL_RATIO ? parseFloat(env.GRID_DERISK_AVAIL_RATIO) : 0.30; // 可用/钱包 < 30%
  const deRiskChunkQty = env.GRID_DERISK_CHUNK_QTY ? parseFloat(env.GRID_DERISK_CHUNK_QTY) : 0.008;   // 每次去杠杆更多
  const deRiskIntervalMs = env.GRID_DERISK_INTERVAL_MS ? parseInt(env.GRID_DERISK_INTERVAL_MS) : 4000; // 更频繁检查
  const maxNetQty = env.GRID_MAX_NET_QTY ? parseFloat(env.GRID_MAX_NET_QTY) : 0.002;                    // 更紧净敞口
  const entryAlignEnabled = env.GRID_ENTRY_ALIGN_ENABLED ? env.GRID_ENTRY_ALIGN_ENABLED === '1' : true; // 默认开启
  const entryAlignDeltaBps = env.GRID_ENTRY_ALIGN_BPS ? parseInt(env.GRID_ENTRY_ALIGN_BPS) : 15;        // 均价差>15bps回归
  const entryAlignChunkRatio = env.GRID_ENTRY_ALIGN_CHUNK_RATIO ? parseFloat(env.GRID_ENTRY_ALIGN_CHUNK_RATIO) : 0.15; // 每次回滚15%
  const entryAlignMinIntervalMs = env.GRID_ENTRY_ALIGN_MIN_INTERVAL_MS ? parseInt(env.GRID_ENTRY_ALIGN_MIN_INTERVAL_MS) : 8000;
  // 默认 AUTO：小差用 ADD（更少实亏），大差且持续时用 REPLACE（更快回归）
  const entryAlignMode = ((env.GRID_ENTRY_ALIGN_MODE as any) === 'ADD' || (env.GRID_ENTRY_ALIGN_MODE as any) === 'REPLACE' || (env.GRID_ENTRY_ALIGN_MODE as any) === 'AUTO') ? (env.GRID_ENTRY_ALIGN_MODE as any) : 'AUTO';
  const entryAlignAddBps = env.GRID_ENTRY_ALIGN_ADD_BPS ? parseInt(env.GRID_ENTRY_ALIGN_ADD_BPS) : 12;
  const entryAlignReplaceBps = env.GRID_ENTRY_ALIGN_REPLACE_BPS ? parseInt(env.GRID_ENTRY_ALIGN_REPLACE_BPS) : 30;
  const entryAlignSustainTicks = env.GRID_ENTRY_ALIGN_SUSTAIN_TICKS ? parseInt(env.GRID_ENTRY_ALIGN_SUSTAIN_TICKS) : 2;
  // 薄盘口优化默认：开启点差感知，限制大点差时的吃单；maker 贴最优
  const spreadAware = env.GRID_SPREAD_AWARE ? env.GRID_SPREAD_AWARE === '1' : false;
  const takerMaxSpreadBps = env.GRID_TAKER_MAX_SPREAD_BPS ? parseInt(env.GRID_TAKER_MAX_SPREAD_BPS) : 120;
  const makerJoinBest = env.GRID_MAKER_JOIN_BEST ? env.GRID_MAKER_JOIN_BEST === '1' : false;
  const makerInsideTicks = env.GRID_MAKER_INSIDE_TICKS ? parseInt(env.GRID_MAKER_INSIDE_TICKS) : 0;
  const auditEnabled = env.GRID_AUDIT_ENABLED ? env.GRID_AUDIT_ENABLED === '1' : true;
  const auditLogFile = env.GRID_AUDIT_LOG_FILE || undefined;

  return {
    symbol,
    leverage,
    baseNotionalUsd,
    gridStepBps,
    gridCount,
    tickIntervalMs,
    maxOpenPerSide,
    tpBps,
    slBps,
    workingType,
    stateFile,
    persistIntervalMs,
    minNotionalUsd,
    forceOpenOnStart,
    minOpenIntervalMs,
    ordersPerTickPerSide,
    aggressive,
    parallelPlacement,
    maxExposureUsdPerSide,
    reduceWhenExposureAboveUsd,
    reduceChunkUsd,
    minReduceIntervalMs,
    useMaxLeverage,
    continuousProtect,
    protectRefreshMs,
    hfMode,
    hfHoldMs,
    hfMaxConcurrentPerSide,
    hfSymmetric,
    auditEnabled,
    auditLogFile,
    makerMode,
    makerOffsetBps,
    makerTimeoutMs,
    rebalanceEnabled,
    rebalanceThresholdQty,
    rebalanceChunkQty,
    rebalanceMinIntervalMs,
    deleverageAfter2019,
    deleverageChunkQty,
    deleverageMinIntervalMs,
    deleverageStepsOn2019,
    deleverageMultiplier,
    deleverageMaxChunkQty,
    takerRatio,
    takerBurstMs,
    takerMaxConcurrent,
    costCapBps,
    minSpreadBps,
    takerCooldownMs
    ,maxGrossQtyPerSide
    ,deRiskEnabled
    ,deRiskAvailRatio
    ,deRiskChunkQty
    ,deRiskIntervalMs
    ,maxNetQty
    ,entryAlignEnabled
    ,entryAlignDeltaBps
    ,entryAlignChunkRatio
    ,entryAlignMinIntervalMs
    ,entryAlignMode
    ,entryAlignAddBps
    ,entryAlignReplaceBps
    ,entryAlignSustainTicks
    ,spreadAware
    ,takerMaxSpreadBps
    ,makerJoinBest
    ,makerInsideTicks
  };
}