dexbot 1.1.10

package/dist/modules/constants.js

@@ -0,0 +1,1464 @@
+"use strict";
+/**
+ * modules/constants.ts - Configuration and Constants
+ *
+ * Global configuration, constants, and defaults for DEXBot2.
+ * All constants are frozen to prevent accidental runtime modifications.
+ * Local overrides can be loaded from profiles/general.settings.json
+ *
+ * ===============================================================================
+ * EXPORTED CONSTANTS
+ * ===============================================================================
+ *
+ * ENUM DEFINITIONS:
+ *   1. ORDER_TYPES - Grid entry categories
+ *      { SELL: 'sell', BUY: 'buy', SPREAD: 'spread' }
+ *      - SELL: Orders above market price, size in base asset (assetA)
+ *      - BUY: Orders below market price, size in quote asset (assetB)
+ *      - SPREAD: Placeholder orders in spread zone around market price
+ *
+ *   2. ORDER_STATES - Order lifecycle states (affects fund tracking)
+ *      { VIRTUAL: 'virtual', ACTIVE: 'active', PARTIAL: 'partial' }
+ *      - VIRTUAL: Not yet on-chain, size in funds.virtual (reserved)
+ *                 Also used for filled orders converted to SPREAD placeholders
+ *      - ACTIVE: Placed on-chain, size in funds.committed
+ *      - PARTIAL: Partially filled on-chain, mixed state
+ *
+ * DEFAULT CONFIGURATION (applied when not explicitly set):
+ *   3. DEFAULT_CONFIG - Bot configuration defaults
+ *      Price: startPrice, minPrice, maxPrice, incrementPercent, targetSpreadPercent
+ *      Control: active, dryRun
+ *      Trading pair: assetA, assetB
+ *      Allocation: weightDistribution, botFunds, activeOrders
+ *
+ * TIMING PARAMETERS:
+ *   4. TIMING - Operational timing constants
+ *      SYNC_DELAY_MS, ACCOUNT_TOTALS_TIMEOUT_MS, MILLISECONDS_PER_SECOND
+ *      BLOCKCHAIN_FETCH_INTERVAL_MIN, FILL_DEDUPE_WINDOW_MS
+ *      FILL_RECORD_RETENTION_MS
+ *      LOCK_TIMEOUT_MS, SYNC_LOCK_TIMEOUT_MS
+ *      CONNECTION_TIMEOUT_MS, DAEMON_STARTUP_TIMEOUT_MS
+ *      RUN_LOOP_DEFAULT_MS, OPEN_ORDERS_SYNC_LOOP_ENABLED, CHECK_INTERVAL_MS
+ *      CREDENTIAL_BROADCAST_TIMEOUT_MS, CREDENTIAL_DAEMON_INNER_DEADLINE_MS
+ *
+ * GRID & ORDER LIMITS:
+ *   5. GRID_LIMITS - Grid sizing and scaling constraints
+ *      MIN_SPREAD_FACTOR, MIN_SPREAD_ORDERS, MIN_ORDER_COUNT
+ *      FUND_INVARIANT_PERCENT_TOLERANCE
+ *      Includes GRID_COMPARISON sub-object for grid divergence metrics
+ *
+ *   6. INCREMENT_BOUNDS - Price increment percentage validation
+ *      MIN_INCREMENT_PERCENT, MAX_INCREMENT_PERCENT
+ *
+ * FEE CONFIGURATION:
+ *   7. FEE_PARAMETERS - Fee calculation and reservation parameters
+ *      BTS_RESERVATION_MULTIPLIER, MARKET_FEE_PERCENT, TAKER_FEE_PERCENT
+ *      TAKER_PERCENT_OVERRIDE, BTS_TAKER_OVERRIDE
+ *
+ * API & BLOCKCHAIN:
+ *   8. API_LIMITS - Blockchain API call constraints
+ *      MAX_ORDERS_PER_CALL, API_TIMEOUT_MS, API_RETRY_DELAY_MS
+ *      MAX_API_RETRIES, HISTORICAL_SYNC_BATCH_SIZE
+ *
+ * FILL PROCESSING:
+ *   9. FILL_PROCESSING - Fill event handling configuration
+ *      FILL_ACK_WAIT_MS, FILL_TIMEOUT_MS, FILL_RETRY_ATTEMPTS
+ *      Includes BATCH_LIMITS sub-object
+ *
+ * MARKET ADAPTER CONFIGURATION:
+ *   10. MARKET_ADAPTER - Price tracking and grid recalculation trigger settings
+ *       AMA_DELTA_THRESHOLD_PERCENT: % change in AMA center price that triggers grid reset
+ *       DEFAULT_AMA_KEY: Default AMA profile used for `gridPrice: "ama"`
+ *       AMAS: Built-in AMA1..AMA4 presets for market adapter defaults
+ *       Related to bot AMA configuration (profiles/bots.json: ama.enabled, erPeriod, etc.)
+ *       Stored in: profiles/general.settings.json
+ *
+ * MAINTENANCE & MONITORING:
+ *   11. MAINTENANCE - Background maintenance task configuration
+ *       HEALTH_CHECK_INTERVAL_MS, PERSISTENCE_CHECK_INTERVAL_MS
+ *       LOCK_CLEANUP_INTERVAL_MS
+ *
+ *   12. NODE_MANAGEMENT - Multi-node health checking and failover configuration
+ *       DEFAULT_NODES: List of BitShares nodes for redundancy
+ *       HEALTH_CHECK_INTERVAL_MS, HEALTH_CHECK_TIMEOUT_MS, MAX_PING_MS
+ *       BLACKLIST_THRESHOLD: Failures before node is blacklisted
+ *       EXPECTED_CHAIN_ID: BitShares mainnet chain ID validation
+ *       SELECTION_STRATEGY: Node selection algorithm (latency-based)
+ *
+ *   13. UPDATER - Version checking and update notification
+ *       CHECK_INTERVAL_MS, REPO_URL, NOTIFICATION_MIN_LEVEL
+ *
+ * LOGGING CONFIGURATION:
+ *   14. LOGGING_CONFIG - Structured logging configuration
+ *       changeTracking: Smart change detection
+ *       display.colors: TTY color support
+ *       display.fundStatus, display.statusSummary, display.gridDiagnostics
+ *       Categories for enabling/disabling log types
+ *
+ *   15. LOG_LEVEL - Current logging verbosity level
+ *       Affects which messages are displayed: 'debug', 'info', 'warn', 'error'
+ *
+ *   16. PIPELINE_TIMING - Pipeline execution timing thresholds
+ *   17. COW_PERFORMANCE - Copy-on-write grid performance settings
+ *   18. REBALANCE_STATES - Rebalance lifecycle state enum
+ *   19. COW_ACTIONS - Copy-on-write action type enum
+ *   20. CR_ZONES - Credit ratio zone constants
+ *   21. DEFAULT_TARGET_CR - Default target collateral ratio
+ *   22. NATIVE_CLIENT - Native blockchain client configuration
+ *   23. LAUNCHER - Launcher configuration (PM2, Docker)
+ *   24. BUILD_DIR - Build directory path
+ *   25. BTS_PRECISION - BTS asset precision
+ *   26. DAEMON_ERRORS - Credential daemon error codes
+ *   27. DAEMON_CODES - Credential daemon codes
+ *   28. CREDENTIAL_PROMPTS - Credential prompt configuration
+ *
+ * ===============================================================================
+ *
+ * LOCAL SETTINGS OVERRIDE:
+ * Read from profiles/general.settings.json if it exists.
+ * Supports overriding any exported constant with custom values.
+ * Useful for development, testing, and performance tuning.
+ *
+ * FREEZING:
+ * Most exported objects are frozen at module load to prevent accidental runtime modifications.
+ * This ensures constants remain truly constant throughout bot lifetime.
+ *
+ * ===============================================================================
+ */
+// Order categories used by the OrderManager when classifying grid entries.
+const ORDER_TYPES = Object.freeze({
+    SELL: 'sell',
+    BUY: 'buy',
+    SPREAD: 'spread'
+});
+// Life-cycle states assigned to generated or active orders.
+// State transitions affect fund calculations in manager.recalculateFunds()
+const ORDER_STATES = Object.freeze({
+    VIRTUAL: 'virtual', // Not on-chain, size in funds.virtual; also used for fully filled orders converted to SPREAD
+    ACTIVE: 'active', // On-chain, size in funds.committed.grid (and .chain if has orderId)
+    PARTIAL: 'partial' // On-chain, partially filled order, size in funds.committed.grid (and .chain if has orderId)
+});
+// Rebalance lifecycle states used by COW planning/broadcast/commit pipeline.
+const REBALANCE_STATES = Object.freeze({
+    NORMAL: 'NORMAL',
+    REBALANCING: 'REBALANCING',
+    BROADCASTING: 'BROADCASTING'
+});
+// Canonical action labels used by grid reconciliation and batch broadcasting.
+const COW_ACTIONS = Object.freeze({
+    CREATE: 'create',
+    CANCEL: 'cancel',
+    UPDATE: 'update'
+});
+// Defaults applied when instantiating an OrderManager with minimal configuration.
+// These values are used when a parameter is not explicitly provided in the bot config.
+let DEFAULT_CONFIG = {
+    // Price configuration
+    startPrice: "pool", // Market price source: "pool" (liquidity pool), "book" (order book), or numeric value
+    minPrice: "2x", // Lower price bound: "Nx" = N times below startPrice, or numeric value
+    maxPrice: "2x", // Upper price bound: "Nx" = N times above startPrice, or numeric value
+    gridPrice: null, // Optional reference price for x-factor bounds calculation.
+    // "pool"    = use the live pool price for the pair
+    // "book"    = use the live order book price for the pair
+    // "ama"/"ama1".."ama4" = use the effective center snapshot from profiles/orders/<botKey>.dynamicgrid.json
+    // numeric   = fixed numeric value
+    // null      = use startPrice
+    incrementPercent: 0.5, // Price step between grid levels (0.5 = 0.5% geometric spacing)
+    targetSpreadPercent: 2, // Target spread width between best buy and best sell (2 = 2%)
+    // Bot control
+    active: true, // Whether bot should actively place/manage orders
+    dryRun: false, // If true, simulate operations without blockchain transactions
+    // Trading pair
+    assetA: null, // Base asset symbol (e.g., "BTS")
+    assetB: null, // Quote asset symbol (e.g., "USD")
+    // Fund allocation
+    weightDistribution: { sell: 1, buy: 1 }, // Geometric weight for order sizing (1 = ~1:2 center/outer split, 0.5 = linear)
+    botFunds: { sell: "100%", buy: "100%" }, // Percentage of wallet balance to allocate ("100%" or numeric value)
+    activeOrders: { sell: 20, buy: 20 }, // Number of orders to maintain closest to market on each side
+    // BTS fee management for non-BTS pairs
+    min_BTS_value: null, // Minimum BTS balance to maintain (null = auto from activeOrders × fees × multiplier)
+};
+// Timing constants used by OrderManager and helpers
+let TIMING = {
+    SYNC_DELAY_MS: 500,
+    ACCOUNT_TOTALS_TIMEOUT_MS: 10000,
+    // Conversion factor: milliseconds per second
+    MILLISECONDS_PER_SECOND: 1000,
+    // Blockchain fetch interval: how often to refresh blockchain account values (in minutes)
+    // Default: 240 minutes (4 hours). Set to 0 or non-number to disable periodic fetches.
+    BLOCKCHAIN_FETCH_INTERVAL_MIN: 240,
+    // Override interval for shared accounts (multiple bots on same account).
+    // When the fund registry detects multiple bots on the same account, the fetch
+    // interval drops to this value to reduce stale balance window.
+    SHARED_ACCOUNT_FETCH_INTERVAL_MIN: 5,
+    // BTS acquisition for non-BTS pairs: min cooldown between acquisition attempts (minutes)
+    BTS_ACQUIRE_COOLDOWN_MIN: 60,
+    // Fill processing timing
+    FILL_DEDUPE_WINDOW_MS: 5000, // 5 seconds - window for deduplicating same fill events
+    FILL_RECORD_RETENTION_MS: 7 * 24 * 60 * 60 * 1000, // 7 days - how long to keep persisted fill records (was 1h, increased to close double-credit window on restarts >1h apart)
+    PROCESSED_FILL_PERSIST_BATCH_MS: 250, // 250ms - coalesce processed-fill persistence writes under burst load
+    PROCESSED_FILL_PERSIST_BATCH_SIZE: 25, // Flush immediately once this many processed fills are queued
+    AUDIT_LOG_MAX_SIZE: 100 * 1024 * 1024, // 100 MB total disk budget for audit logs (current + rotated)
+    AUDIT_LOG_MAX_FILES: 5, // number of rotated audit log files to retain
+    // Order locking timing
+    // Reduced from 30s to 10s to prevent lock-based starvation under high fill rates.
+    // Locks that exceed this timeout are auto-expired by _cleanExpiredLocks() to ensure
+    // orders are never permanently blocked if a process crashes while holding the lock.
+    // This self-healing mechanism prevents deadlocks while still protecting against races.
+    LOCK_TIMEOUT_MS: 10000, // 10 seconds - balances transaction latency with lock starvation prevention
+    // Sync lock acquisition timeout - prevents indefinite lock hangs
+    // Uses Promise.race() to enforce timeout on lock acquisition attempts
+    SYNC_LOCK_TIMEOUT_MS: 20000, // 20 seconds - prevents deadlocks while allowing slow operations
+    // Connection and initialization timeouts
+    CONNECTION_TIMEOUT_MS: 30000, // 30 seconds - BitShares client connection establishment timeout
+    DAEMON_STARTUP_TIMEOUT_MS: 60000, // 60 seconds - Private key daemon startup timeout
+    RETRY_BACKOFF_CAP_MS: 30000, // 30 seconds - Max exponential backoff delay for connection retries
+    DAEMON_PING_TIMEOUT_MS: 5000, // 5 seconds - Private key daemon ping/healthcheck timeout
+    CREDENTIAL_DAEMON_WATCHDOG_MS: 60000, // 60 seconds - Credential daemon watchdog polling interval
+    // Main loop and polling defaults
+    RUN_LOOP_DEFAULT_MS: 300000, // 5 minutes - default open-orders sync cycle delay (env override: OPEN_ORDERS_SYNC_LOOP_MS)
+    OPEN_ORDERS_SYNC_LOOP_ENABLED: false, // Preferred flag: continuous open-order watchdog sync loop (default false — react to fills only)
+    CHECK_INTERVAL_MS: 100, // 100 milliseconds - polling interval for connection/daemon readiness checks
+    // Blockchain settle delay before follow-up structural work after a scheduled maintenance action.
+    // Gives maintenance-triggered cancels/rebalances time to acquire locks, broadcast, and settle
+    // before a deferred grid resync attempts more on-chain changes.
+    BLOCKCHAIN_SETTLE_DELAY_MS: 6000,
+    // Credit deal proactive renewal timing
+    CREDIT_DEAL_CHECK_INTERVAL_MIN: 60, // How often to check credit deal expiry (minutes)
+    CREDIT_DEAL_EXPIRY_THRESHOLD_HOURS: 12, // Proactively renew deals expiring within this window
+    CREDIT_DEAL_SPLIT_MAX_PIECES: 48, // Max pieces per _splitOversizedCreditDeals cycle (~4.8min at 6s/piece)
+    // LOCK_REFRESH_MIN_MS: Minimum interval for refreshing order lock leases during long operations.
+    // Prevents lock expiration during extended reconciliations or batch operations.
+    // Default: 250ms (4 refreshes per second minimum during long operations).
+    LOCK_REFRESH_MIN_MS: 250,
+    // LOG_THROTTLE_INTERVAL_MS: Default throttle interval for _logThrottled
+    // in accounting.ts et al. Prevents repeated identical log messages from
+    // flooding the log during sustained error conditions.
+    LOG_THROTTLE_INTERVAL_MS: 30000,
+    // CREDENTIAL_BROADCAST_TIMEOUT_MS: Outer timeout for a credential-daemon broadcast
+    // request, enforced by the bot socket client (modules/dexbot_credential_client.ts).
+    // Rationale: Broadcasts can take much longer than read-only daemon calls because the
+    // daemon must sign locally, then push the signed transaction to a BitShares node and
+    //   wait for chain inclusion. 30s gives slow mainnet nodes enough headroom on cold
+    //   start while still bounding bot-side wait time.
+    // If this outer timer fires before the daemon responds, the bot raises a typed
+    // BroadcastUncertainError and enters the recovery path (chain may or may not have
+    // accepted the operations).
+    CREDENTIAL_BROADCAST_TIMEOUT_MS: 30000,
+    // CREDENTIAL_DAEMON_INNER_DEADLINE_MS: Inner deadline enforced inside the credential
+    // daemon's broadcastWithRetry (credential-daemon.ts). Must be strictly less than
+    // CREDENTIAL_BROADCAST_TIMEOUT_MS so the daemon can report a typed
+    // { success:false, code:'BROADCAST_DEADLINE' } failure before the bot-side
+    // socket timer fires. 5s of slack is enough for the bot to receive and
+    // process the typed reply on a slow connection. 25s gives slow mainnet
+    // nodes most of the outer window for a successful broadcast; the recovery
+    // path handles whatever takes longer.
+    CREDENTIAL_DAEMON_INNER_DEADLINE_MS: 25000,
+    // CREDENTIAL_DAEMON_BROADCAST_RETRIES: Number of broadcast attempts inside the
+    // credential daemon's broadcastWithRetry. Each attempt connects, signs, and pushes
+    // the transaction. Total wall time across all attempts is capped by
+    // CREDENTIAL_DAEMON_INNER_DEADLINE_MS above. 2 is a pragmatic balance: try once,
+    // retry once on disconnect, while leaving room for a slow block before the deadline.
+    CREDENTIAL_DAEMON_BROADCAST_RETRIES: 3,
+    // SAFETY_NET_SYNC_TIMEOUT_MS: Cap on the post-reconnect safety-net sync
+    // in dexbot_class.ts. Must stay below the 20s shutdown lock timeout so
+    // it never holds _fillProcessingLock longer than the shutdown deadline.
+    SAFETY_NET_SYNC_TIMEOUT_MS: 25000,
+    // TARGETED_DRIFT_SYNC_COOLDOWN_MS: Minimum interval between targeted drift
+    // reconciliation cycles. Prevents rapid re-triggering when the grid is
+    // oscillating around the drift threshold.
+    TARGETED_DRIFT_SYNC_COOLDOWN_MS: 60000,
+};
+// Grid limits and scaling constants
+let GRID_LIMITS = {
+    // MIN_SPREAD_FACTOR: Ensures spread is at least (incrementPercent × MIN_SPREAD_FACTOR) slots wide.
+    // Rationale: Spread must be sufficiently wide to:
+    //   1. Avoid order collision (orders too close get rejected by blockchain)
+    //   2. Allow bid-ask arbitrage room (market makers profit from the spread)
+    //   3. Scale proportionally to grid spacing (tighter increments need tighter spread buffer)
+    //
+    // Example Calculation (incrementPercent = 0.5%, targetSpread = 2%):
+    //   - MIN_SPREAD_FACTOR = 2.1 → minSpread = 0.5% × 2.1 = 1.05%
+    //   - But target is 2%, so final spread = max(1.05%, 2%) = 2% (target wins)
+    //   - This ensures spread is at least (0.5% × 2.1) but respects user's targetSpread
+    //
+    // Default: 2.1 ensures 3-slot minimum gap even with tight increment (see grid.ts::SPREAD_GAP_FORMULA)
+    MIN_SPREAD_FACTOR: 2.1,
+    // MIN_ORDER_SIZE_FACTOR: Minimum order size = blockchain_minimum × this factor.
+    // Rationale: Orders smaller than blockchain minimum are rejected.
+    //   - Blockchain minimum ≈ 1 satoshi (10^-8 per unit)
+    //   - Float arithmetic and fee deductions can round amounts down
+    //   - Safety factor = 50× ensures orders survive rounding
+    // Example: If blockchainMin = 1 BTS, then minSize = 50 BTS (very conservative for mainnet)
+    // This trades off efficiency (larger minimum) for reliability (never hits rounding floor)
+    MIN_ORDER_SIZE_FACTOR: 50,
+    // PRICE_TOLERANCE_MAX_PERCENT: Maximum price tolerance as fraction of grid price.
+    // Clamps calculatePriceTolerance so tiny dust-sized orders never produce tolerances
+    // larger than this fraction. 0.01 = 1% of price.
+    PRICE_TOLERANCE_MAX_PERCENT: 0.01,
+    // PRICE_TOLERANCE_MIN_ABSOLUTE: Floor for the price tolerance cap in price units.
+    // Ensures the cap is non-zero even for extremely cheap assets.
+    PRICE_TOLERANCE_MIN_ABSOLUTE: 0.0001,
+    // GRID_REGENERATION_PERCENTAGE: Trigger threshold for automatic grid size recalculation.
+    // Formula: IF (availableFunds / allocatedCapital) × 100 ≥ threshold → regenerate
+    // Rationale: After fills, free balance rises relative to allocated grid capital.
+    //   - 3% = regen triggered when available funds represent ≥3% of side allocation
+    //   - This allows gradual accumulation while preventing lag during high-fill periods
+    //   - If threshold too low: constant regeneration (churn, fees)
+    //   - If threshold too high: capital remains underutilized, grid undersized
+    // Example: 20 active orders × 100 BTS each = 2000 BTS grid
+    //   - availableFunds ≥ 60 BTS → (60/2000 = 3%) triggers regeneration
+    //   - Allows ~3 fill-proceeds before resize (reduces churn)
+    // Checked independently per side, allowing asymmetric fill patterns.
+    GRID_REGENERATION_PERCENTAGE: 3,
+    // PARTIAL_DUST_THRESHOLD_PERCENTAGE: Threshold for treating partially-filled orders as "dust".
+    // Formula: IF (actualSize / idealSize) × 100 < threshold → dust
+    // Rationale: Partially-filled orders become progressively smaller.
+    //   - 5% = orders below 5% of ideal size are rotated (to restore grid symmetry)
+    //   - Dust orders waste grid slots (they should be closed or brought back to ideal size)
+    //   - Rotation replaces dust order with a fresh one at proper size
+    //   - Detects both accidental low fills and normal fill-chain truncation
+    // Example: idealSize = 100 BTS, but actual = 3 BTS → (3/100 = 3%) < 5% → dust
+    //   - This order would be rotated to free the slot
+    PARTIAL_DUST_THRESHOLD_PERCENTAGE: 5,
+    // DUST_CANCEL_DELAY_SEC: Legacy — no longer used. Dust is cancelled immediately on detection
+    // (no delay, no timer). Kept for backward-compat so existing configs don't break on load.
+    // Default -1 (disabled) makes freshly-written configs self-documenting.
+    DUST_CANCEL_DELAY_SEC: -1,
+    // FUND_INVARIANT_PERCENT_TOLERANCE: Allowed percentage drift in fund tracking before triggering recovery.
+    // Formula: tolerance = max(precisionSlack, balance × percentTolerance)
+    // Rationale: Fund tracking can drift due to:
+    //   1. Float arithmetic rounding (resolved by precisionSlack, ~10^-precision)
+    //   2. In-flight blockchain transactions (resolved by percentTolerance)
+    //   3. Fee accumulation from multiple operations
+    // Default: 0.1% (0.1%) means for 1000 BTS balance, drift up to 1 BTS is tolerated
+    //   - Accounts for ~5 fill-fee events before recovery triggered
+    //   - Too low: false positives (recoveries on healthy operations)
+    //   - Too high: undetected drift (fund leaks)
+    // Drifts larger than this tolerance trigger immediate recovery (re-sync from blockchain).
+    FUND_INVARIANT_PERCENT_TOLERANCE: 0.1,
+    // MIN_SPREAD_ORDERS: Minimum number of empty slots in spread zone (between best buy and best sell).
+    // Rationale: Spread must be sufficiently wide to:
+    //   1. Prevent order collision (blockchain rejects orders with identical price)
+    //   2. Ensure market makers profit from the bid-ask difference
+    //   3. Allow price movement without orders crossing each other
+    // Default: 2 (at least 2 empty slots between buy and sell sides)
+    // Example: Buy @ 99.9, empty, empty, Sell @ 100.1 → 2-slot spread (acceptable)
+    //         Buy @ 99.9, empty, Sell @ 100.0 → 1-slot spread (too tight, rebalance triggered)
+    MIN_SPREAD_ORDERS: 2,
+    // Grid comparison metrics
+    // Detects significant divergence between calculated (in-memory) and persisted grid state
+    // after order fills and rotations
+    // NOTE: Independent from MARKET_ADAPTER.AMA_DELTA_THRESHOLD_PERCENT
+    //   - RMS_PERCENTAGE: Triggers grid reset when calculated grid diverges from blockchain state
+    //   - AMA_DELTA_THRESHOLD_PERCENT: Triggers grid reset when AMA center price moves significantly
+    //   Both can be configured independently in profiles/general.settings.json
+    GRID_COMPARISON: {
+        // Metric calculation: RMS (Root Mean Square) of relative order size differences
+        // Formula: RMS = √(mean of ((calculated - persisted) / persisted)²)
+        // Represents the quadratic mean of relative size errors
+        SUMMED_RELATIVE_SQUARED_DIFFERENCE: 'summedRelativeSquaredDiff',
+        // Divergence threshold for automatic grid regeneration (RMS as percentage)
+        // When compareGrids() metric exceeds this threshold, updateGridOrderSizes will be triggered
+        // Set to 0 to completely disable RMS divergence checks (Issue #5: RMS Divergence Check Disabling)
+        //
+        // RMS Threshold Reference Table (for 5% distribution: 5% outliers, 95% perfect):
+        // ┌────────────────────────────────────────────────────────┐
+        // │ RMS %       │ Avg Error │ Description                 │
+        // ├────────────────────────────────────────────────────────┤
+        // │ 0           │ N/A       │ Disabled (no checks)        │
+        // │ 4.5%        │ ~1.0%     │ Very strict                 │
+        // │ 9.8%        │ ~2.2%     │ Strict                      │
+        // │ 14.3%       │ ~3.2%     │ Default (balanced)          │
+        // │ 20.1%       │ ~4.5%     │ Lenient                     │
+        // │ 31.7%       │ ~7.1%     │ Very lenient                │
+        // │ 44.7%       │ ~10%      │ Extremely lenient           │
+        // └────────────────────────────────────────────────────────┘
+        RMS_PERCENTAGE: 14.3
+    },
+    // STATE_CHANGE_HISTORY_MAX: Maximum number of state changes to retain in circular buffer.
+    // Used by StateChangeLogger for tracking recent grid/fund mutations.
+    // Default: 100 entries (balances memory usage with debugging utility).
+    STATE_CHANGE_HISTORY_MAX: 100,
+    // RELATIVE_ORDER_UPDATE_THRESHOLD_PERCENT: Relative threshold for in-memory
+    // order equality checks in COW delta planning.
+    // Example: 0.1 means two values are considered equal when diff < 0.1% of magnitude.
+    // Note: Final blockchain update filtering still happens with integer precision checks.
+    RELATIVE_ORDER_UPDATE_THRESHOLD_PERCENT: 0.1,
+    // PRICE_DRIFT_TOLERANCE_MULTIPLIER: Tolerance multiplier for matching
+    // chain-order price drift against planned grid slots in sync_engine.ts.
+    // Drift beyond strict tolerance but within multiplier × tolerance is
+    // tagged as "price-drift-orphan" instead of rejected outright.
+    PRICE_DRIFT_TOLERANCE_MULTIPLIER: 4,
+};
+// Increment percentage bounds for grid configuration
+let INCREMENT_BOUNDS = {
+    // Minimum increment percentage allowed (0.01%)
+    MIN_PERCENT: 0.01,
+    // Maximum increment percentage allowed (10%)
+    MAX_PERCENT: 10,
+    // Minimum increment as decimal factor (0.01% = 0.0001)
+    MIN_FACTOR: 0.0001,
+    // Maximum increment as decimal factor (10% = 0.10)
+    MAX_FACTOR: 0.10
+};
+// Fee-related parameters for order operations
+let FEE_PARAMETERS = {
+    // BTS_RESERVATION_MULTIPLIER: Factor applied to totalTargetOrders to reserve BTS fee budget.
+    // Formula: BTS reserved = totalTargetOrders × BTS_RESERVATION_MULTIPLIER
+    // Rationale: Each order can be updated/cancelled during rebalancing, and each operation incurs a fee.
+    //   - Conservative estimate: each order may be touched ~5 times during its lifetime
+    //   - Orders get: created (1 fee), rotated (2 fees: cancel + place), updated (1 fee), cancelled (1 fee)
+    //   - So ~5 fees per order is safe buffer to prevent fee starvation
+    // Example: 20 active orders → 20 × 5 = 100 BTS reserved for fee operations
+    // Set to 0 to disable fee reservation (not recommended for production).
+    BTS_RESERVATION_MULTIPLIER: 5,
+    // Fallback BTS fee (satoshis) when dynamic fee calculation fails.
+    // Rationale: During startup or when fee API is unavailable, use this conservative estimate.
+    //   - 100 satoshis = 0.00000100 BTS (typical limit order fee is 1-2 BTS on mainnet)
+    //   - Using satoshi precision prevents integer division errors
+    //   - Actual fees are calculated and deducted once fee API responds
+    BTS_FALLBACK_FEE: 100,
+    // MAKER_FEE_PERCENT: Percentage of base fee charged for maker orders (orders that rest in book).
+    // Rationale: BitShares incentivizes providing liquidity (making orders) with lower fees.
+    //   - 0.1 = 10% of the base order creation fee
+    //   - Typical: 2 BTS base fee × 0.1 = 0.2 BTS charged (maker)
+    //   - vs. 2 BTS for taker orders (taker: 100% of base fee)
+    //   - This 10× discount encourages grid bots (primarily makers) to place orders
+    MAKER_FEE_PERCENT: 0.1,
+    // MAKER_REFUND_PERCENT: Percentage of maker fee refunded after order execution/cancellation.
+    // Rationale: BitShares refunds unused maker fees when order is cancelled or fills.
+    //   - 0.9 = 90% refund of the maker fee paid
+    //   - Typical: Paid 0.2 BTS, get 0.18 BTS refund, net cost 0.02 BTS
+    //   - Refund arrives in a separate transaction after cancellation
+    //   - This incentive structure encourages taker participation (market efficiency)
+    MAKER_REFUND_PERCENT: 0.9,
+    // TAKER_FEE_PERCENT: Percentage of base fee charged for taker orders (orders that cross spread).
+    // Rationale: Takers (who immediately fill) pay full fee; they consume liquidity.
+    //   - 1.0 = 100% of the base order creation fee
+    //   - Typical: 2 BTS base fee × 1.0 = 2 BTS charged (no refund)
+    //   - Full fee covers order broadcast and execution costs
+    TAKER_FEE_PERCENT: 1.0,
+    // GRAPHENE_FEE_RATE_DENOM: BitShares credit-offer fee-rate denominator.
+    // The on-chain fee_rate is an integer; fee percent = fee_rate / DENOM.
+    // Example: fee_rate 30000 → 30000 / 1000000 = 3% flat fee at repayment.
+    GRAPHENE_FEE_RATE_DENOM: 1000000,
+    // DEFAULT_MAX_FEE_RATE_PER_DAY: Default maximum daily fee rate for credit offers.
+    // 1/2900 ≈ 0.0003448 = 0.03448% per day = ~1.034% per month.
+    // This provides a reasonable default cap so short-duration high-flat-fee offers
+    // are rejected while long-duration low-flat-fee offers are accepted.
+    DEFAULT_MAX_FEE_RATE_PER_DAY: 1 / 2900,
+    // GRAPHENE_COLLATERAL_RATIO_DENOM: Denominator for target_collateral_ratio in call_order_update operations.
+    // Matches the protocol constant in bitshares-core (libraries/protocol/include/graphene/protocol/config.hpp).
+    // On-chain value = human_CR * DENOM. Example: 2.0 CR → 2000 on chain.
+    GRAPHENE_COLLATERAL_RATIO_DENOM: 1000,
+    // BTS_ACQUIRE_THRESHOLD: Trigger acquisition when BTS free drops below min_BTS_value × this factor.
+    // At 1.0, acquisition fires exactly when BTS hits min_BTS_value.
+    BTS_ACQUIRE_THRESHOLD: 1,
+    // BTS_ACQUIRE_TARGET_MULTIPLIER: Target BTS after acquisition = min_BTS_value × this factor.
+    // At 3.0, fills to 3× min_BTS_value, creating a hysteresis band.
+    // The bot won't re-acquire until it burns through 2× min_BTS_value in fees.
+    BTS_ACQUIRE_TARGET_MULTIPLIER: 3,
+    // POOL_SLIPPAGE_TOLERANCE: Max slippage for pool swaps (decimal fraction).
+    // min_to_receive = expectedAmount × (1 - tolerance).
+    POOL_SLIPPAGE_TOLERANCE: 0.02,
+};
+// Collateral ratio health zones for MPA position management.
+// Only the red boundaries are stored; everything between is green (acceptable).
+let CR_ZONES = Object.freeze({
+    RED_HIGH: 3.0,
+    RED_LOW: 1.7,
+});
+// Default target collateral ratio when returning to green zone.
+// Computed as the midpoint of the green band.
+const DEFAULT_TARGET_CR = (CR_ZONES.RED_LOW + CR_ZONES.RED_HIGH) / 2;
+// Build output directory name (relative to project root).
+// Centralized in modules/utils/build_dir.ts to avoid circular dependency with
+// general_settings.ts (both constants.ts and general_settings.ts import it).
+const { BUILD_DIR } = require('./utils/build_dir');
+const DAEMON_ERRORS = Object.freeze({
+    SESSION_EXPIRED: 'invalid or expired session',
+    SOURCE_AUTH_DENIED: 'invalid source authentication',
+});
+// DAEMON_CODES: Canonical error-code constants shared between the credential
+// daemon, the bot client, and tests. Every code value is identical to its
+// property name so that a receiver comparing against e.g.
+// err.code === DAEMON_CODES.BROADCAST_DEADLINE stays in sync with
+// senders that assign the same symbol.
+const DAEMON_CODES = Object.freeze({
+    BROADCAST_DEADLINE: 'BROADCAST_DEADLINE',
+    CREDENTIAL_DAEMON_UNAVAILABLE: 'CREDENTIAL_DAEMON_UNAVAILABLE',
+});
+// Interactive credential-prompt limits
+// (modules/chain_keys.ts master-password authentication, etc.).
+// Capped to prevent infinite stdin loops on a corrupted vault or a forgotten
+// password without requiring Ctrl+C.
+let CREDENTIAL_PROMPTS = {
+    // MAX_MASTER_PASSWORD_ATTEMPTS: Hard upper bound on master-password
+    // retries. The vault unlock throws MasterPasswordError after this many
+    // failed attempts. The check is enforced both in _promptPassword and at
+    // the top of the authenticate() loop as defense-in-depth.
+    // 3 attempts: scrypt N=2^17 makes each guess expensive (~1s), so 3
+    // attempts absorbs legitimate typos without meaningfully weakening
+    // brute-force resistance.
+    MAX_MASTER_PASSWORD_ATTEMPTS: 3,
+};
+// BTS blockchain precision constant.
+// Number of decimal places for BTS on BitShares (5 decimals → 1 satoshi = 0.00001 BTS).
+// Used for converting raw chain deferred_fee to float BTS in sync/reconcile paths.
+let BTS_PRECISION = 5;
+// API request limits and batch sizes for blockchain operations
+let API_LIMITS = {
+    // Maximum number of liquidity pools per batch request
+    POOL_BATCH_SIZE: 100,
+    // Maximum number of batch iterations for pool scanning (~10k total pools)
+    MAX_POOL_SCAN_BATCHES: 100,
+    // Depth of order book to fetch for market price derivation
+    ORDERBOOK_DEPTH: 5,
+    // Maximum number of limit orders per batch request
+    LIMIT_ORDERS_BATCH: 100,
+    // Maximum page for LP history API queries (market adapter)
+    LP_API_MAX_PAGE: 101,
+};
+// Fill processing configuration
+let FILL_PROCESSING = {
+    // Mode for fill processing: 'history' reads from historical fills
+    MODE: 'history',
+    // Operation type for fill_order blockchain operations
+    OPERATION_TYPE: 4,
+    // Indicator for taker (non-maker) fills
+    TAKER_INDICATOR: 0,
+    // Maximum fills processed per rebalance/broadcast cycle.
+    // Behavior:
+    // - 1..MAX_FILL_BATCH_SIZE fills -> single unified batch
+    // - >MAX_FILL_BATCH_SIZE fills   -> fixed-size chunking at MAX_FILL_BATCH_SIZE
+    // Set to 1 for current sequential behavior.
+    MAX_FILL_BATCH_SIZE: 4,
+    // MAX_CONSECUTIVE_CONSUMER_FAILURES: Threshold for the _consumeFillQueue
+    // watchdog. Below this count, the consumer re-schedules on every failure
+    // via setImmediate. At or above this count, the consumer switches to
+    // exponential backoff (see CONSUMER_BACKOFF_* below) instead of stopping
+    // permanently. The counter is reset on the consumer's success path and on
+    // shutdown, so transient failure bursts (e.g., a credential daemon outage
+    // that self-resolves) recover automatically once a cycle succeeds.
+    MAX_CONSECUTIVE_CONSUMER_FAILURES: 5,
+    // CONSUMER_BACKOFF_INITIAL_MS: First backoff delay after the consumer
+    // has hit MAX_CONSECUTIVE_CONSUMER_FAILURES. Each subsequent failure
+    // doubles the delay up to CONSUMER_BACKOFF_MAX_MS.
+    CONSUMER_BACKOFF_INITIAL_MS: 15000,
+    // CONSUMER_BACKOFF_MAX_MS: Upper bound on the consumer's backoff delay
+    // between retries once the failure budget is exhausted. With defaults
+    // (5 failures, 15s initial, 60s cap) the worst-case retry interval
+    // after a sustained outage is 60 seconds. The consumer NEVER stops
+    // re-scheduling entirely — the original infinite setImmediate loop was
+    // changed to slow-but-persistent retries.
+    // Reduced from 300s to 60s per tuning review: time-sensitive fills (e.g.,
+    // credential daemon recovery) should not wait 5 minutes between retries.
+    CONSUMER_BACKOFF_MAX_MS: 60000,
+};
+// Cleanup and maintenance parameters
+// NOTE: CLEANUP_PROBABILITY is defined here but currently unused.
+// Reserved for future cleanup-scheduling feature.
+let MAINTENANCE = {
+    // Probability of running cleanup operation on any cycle (0.1 = 10%)
+    CLEANUP_PROBABILITY: 0.1
+};
+// Node management and health checking configuration
+let NODE_MANAGEMENT = {
+    // Whether node failover is enabled when no explicit setting is present.
+    DEFAULT_ENABLED: true,
+    // Startup retry/backoff for transient BitShares connection failures.
+    STARTUP_RETRY_INITIAL_DELAY_MS: 500,
+    STARTUP_RETRY_MAX_DELAY_MS: 5000,
+    STARTUP_REFRESH_INTERVAL_MS: 30000,
+    STARTUP_CONNECT_TIMEOUT_MS: 5000,
+    // Cooldown window between successive failover assessments (ms).
+    // Kept above the native transport close-coalesce window so cascading
+    // close events normally collapse into one node-health assessment.
+    FAILOVER_ASSESSMENT_COOLDOWN_MS: 500,
+    // Default node list (used if no config file)
+    DEFAULT_NODES: [
+        'wss://btsws.roelandp.nl/ws',
+        'wss://cloud.xbts.io/ws',
+        'wss://node.xbts.io/ws',
+        'wss://public.xbts.io/ws',
+        'wss://dex.iobanker.com/ws',
+        'wss://api.dex.trading/',
+        'wss://api.bts.mobi/ws',
+        'wss://api.btslebin.com/ws'
+    ],
+    // Health check defaults
+    HEALTH_CHECK_INTERVAL_MS: 4 * 60 * 60 * 1000, // 4 hours
+    CREDENTIAL_DAEMON_NODE_REFRESH_INTERVAL_MS: 60 * 60 * 1000, // 1 hour - lightweight health-cache reread by credential daemon
+    HEALTH_CHECK_TIMEOUT_MS: 5000, // 5 seconds per check
+    MAX_PING_MS: 3000, // Max acceptable latency
+    BLACKLIST_THRESHOLD: 3, // Failures before blacklist
+    BLACKLIST_COOLDOWN_MS: 7 * 24 * 60 * 60 * 1000, // 7 days before retrying blacklisted nodes
+    // Expected chain ID (BitShares mainnet)
+    EXPECTED_CHAIN_ID: '4018d7844c78f6a6c41c6a552b898022310fc5dec06da467ee7905a8dad512c8',
+    // Selection strategy
+    SELECTION_STRATEGY: 'latency' // latency-based selection
+};
+// Pipeline timeout configuration
+let PIPELINE_TIMING = {
+    // TIMEOUT_MS: Maximum duration for pipeline operations before forcing maintenance.
+    // Rationale: If pipeline hangs (stuck in lock, slow blockchain, etc), force a maintenance cycle.
+    //   - 300000 ms = 5 minutes
+    //   - Prevents infinite hangs; ensures bot recovers or logs the problem
+    //   - Typical pipeline cycle completes in <100ms (unless blockchain is slow)
+    //   - 5 minute timeout allows for slow network periods while still being responsive
+    // When timeout is exceeded, pipeline triggers maintenance (logs, cleanup, state check).
+    TIMEOUT_MS: 300000,
+    // RECOVERY_RETRY_INTERVAL_MS: Minimum cooldown time between fund invariant recovery attempts.
+    // Rationale: When a fund tracking invariant violation is detected:
+    //   - First attempt: immediate (no wait) — try to fix quickly
+    //   - Subsequent attempts: wait at least this duration — prevent tight retry loops
+    //   - Prevents blockchain query spam while allowing eventual convergence
+    //
+    // Backoff Timeline Example (defaults):
+    //   - T=0s: Violation detected → immediate recovery attempt #1
+    //   - T=45s: Next violation check → still in cooldown, skip retry
+    //   - T=65s: Next violation check → cooldown expired, attempt #2
+    //   - T=125s: Attempt #3 (another 60s)
+    //   - T=180s: Attempt #4
+    //   - T=240s: Attempt #5 (max reached)
+    //   - T=300s: Fill arrives → counter resets, ready for new recovery episode
+    //
+    // Default: 60000 ms (60 seconds) balances responsiveness with resource efficiency.
+    //   - Too low (e.g., 5s): constant recovery attempts, high blockchain load
+    //   - Too high (e.g., 600s): slow detection of new invariant drift, bad UX
+    RECOVERY_RETRY_INTERVAL_MS: 60000,
+    // MAX_RECOVERY_ATTEMPTS: Maximum recovery retry attempts before giving up.
+    // Rationale: Limit total recovery effort to prevent runaway loop.
+    //   - After N failed attempts, bot stops recovery until next fill/sync
+    //   - This allows bot to stabilize when recovery is impossible
+    //   - Example: if funds are impossible to recover, don't keep trying indefinitely
+    //
+    // Retry Lifecycle (defaults, MAX = 5):
+    //   - Attempts 1-5: Each spaced RECOVERY_RETRY_INTERVAL_MS apart (~60s each)
+    //   - Attempt 5 fails: stop retrying
+    //   - Next fill or blockchain fetch (after ~1 minute): counter resets, new episode starts
+    //   - Total time blocked per episode: ~5 × 60s = 5 minutes before giving up
+    //
+    // Special Cases:
+    //   - Set to 0: unlimited retries (not recommended; can cause infinite recovery loops)
+    //   - Set to 1: one-shot only (minimal recovery effort; original patch15 behavior)
+    //   - Set to 5: balanced (typical value; ~5 min of effort)
+    MAX_RECOVERY_ATTEMPTS: 5,
+    // FEE_EVENT_DEDUP_TTL_MS: How long to remember settled fee events for deduplication.
+    // Prevents the same fill from being fee-settled multiple times when
+    // re-detected across sync cycles or reconnections.
+    // Default: 6 hours (21600000 ms).
+    FEE_EVENT_DEDUP_TTL_MS: 6 * 60 * 60 * 1000,
+    // MAX_FEE_EVENT_CACHE_SIZE: Maximum number of fee events to keep in deduplication cache.
+    // Prevents unbounded memory growth during extended operation with many fills.
+    // When exceeded, oldest entries are evicted to 75% capacity.
+    // Default: 10000 entries (~60MB worst case with long event IDs).
+    MAX_FEE_EVENT_CACHE_SIZE: 10000,
+    // CACHE_EVICTION_RETENTION_RATIO: Target ratio of entries to keep during cache eviction.
+    // When cache exceeds max size, evict down to (maxSize × ratio) entries.
+    // Default: 0.75 (75%) - evicts oldest 25% to get back to 75% capacity.
+    CACHE_EVICTION_RETENTION_RATIO: 0.75,
+    // RECOVERY_DECAY_FALLBACK_MS: Default decay window for recovery attempt counter (milliseconds).
+    // Used when RECOVERY_RETRY_INTERVAL_MS is not configured.
+    // After this idle time, recovery attempt count resets to prevent permanent exhaustion.
+    // Default: 3 minutes (180000 ms).
+    RECOVERY_DECAY_FALLBACK_MS: 3 * 60 * 1000,
+    // RETRY defaults for generic withRetry() utility and similar patterns.
+    RETRY_MAX_ATTEMPTS: 3,
+    RETRY_BASE_DELAY_MS: 1000,
+    RETRY_MAX_DELAY_MS: 10000,
+};
+// Market Adapter Configuration
+// Controls price tracking and grid recalculation triggers.
+// See: market_adapter/market_adapter.ts, modules/account_bots.ts
+let MARKET_ADAPTER = {
+    // Default candle/runtime cadence for the standalone market adapter.
+    // Keep these centralized so the adapter, logs, and tests do not drift from
+    // the production 1h candle workflow.
+    RUNTIME_DEFAULTS: {
+        intervalSeconds: 3600,
+        intervalLabel: '1h',
+        pollSeconds: 3600,
+        bootstrapLookbackHours: 720,
+        nativeBackfillHours: 6,
+        maxStaleHours: 6,
+        sourceRetries: 3,
+        retryDelayMs: 800,
+        maxPages: 80,
+        pageLimit: 100,
+        minRequiredCandles: 80,
+    },
+    // Watchdog defaults for launchers that supervise the standalone adapter.
+    // Reuse existing node-startup and recovery timings so restart polling and
+    // stability windows stay aligned with the rest of the runtime.
+    WATCHDOG_DEFAULTS: {
+        staleLockGraceMs: 30 * 60 * 1000,
+        // Poll every 30s during startup/recovery and allow 13 fast retries:
+        // enough to ride out transient launch failures without retrying forever.
+        intervalMs: NODE_MANAGEMENT.STARTUP_REFRESH_INTERVAL_MS,
+        maxRestarts: 13,
+        minUptimeMs: PIPELINE_TIMING.RECOVERY_RETRY_INTERVAL_MS,
+        restartExhaustionResetMs: PIPELINE_TIMING.RECOVERY_DECAY_FALLBACK_MS,
+    },
+    // KIBANA_REQUEST_TIMEOUT_MS: Shared per-request timeout for Kibana-backed candle fetches.
+    // Used by both the standalone LP history fetcher and the live market adapter's
+    // bootstrap / repair / backfill calls so long-running scans share one ceiling.
+    KIBANA_REQUEST_TIMEOUT_MS: 3 * 60 * 1000,
+    // KIBANA_FETCH_CHUNK_MONTHS: Default historical window size for the standalone
+    // LP fetcher when it splits long requests into sequential sub-requests.
+    KIBANA_FETCH_CHUNK_MONTHS: 3,
+    // CEX_API_DELAY_MS: Minimum delay between paginated CEX API requests to avoid
+    // rate limiting. Applied between candle-fetch pages during synthetic data seeding.
+    CEX_API_DELAY_MS: 500,
+    // AMA_DELTA_THRESHOLD_PERCENT: Percentage change in AMA center price that triggers a grid reset.
+    //   - When AMA price moves ±AMA_DELTA_THRESHOLD_PERCENT from the last recorded center,
+    //     a recalculate.<botKey>.trigger file is written to signal grid regeneration.
+    //   - Configurable per deployment via profiles/general.settings.json under MARKET_ADAPTER.
+    //   - Range: 0.1 to 50.0 (enforced in account_bots.ts)
+    //   - Default: 1.00 (slightly more responsive than the 1.21% sigma calibration baseline)
+    AMA_DELTA_THRESHOLD_PERCENT: 1.00,
+    // AMA_SLOPE_DELTA_THRESHOLD_PERCENT: Percentage of max slope used as the slope trigger
+    // threshold. Used as (AMA_SLOPE_DELTA_THRESHOLD_PERCENT / 100) in the computation:
+    //   threshold = (AMA_SLOPE_DELTA_THRESHOLD_PERCENT / 100) × maxSlopePct
+    //   - Default: 10 (meaning 10% of max slope)
+    AMA_SLOPE_DELTA_THRESHOLD_PERCENT: 10,
+    // DYNAMIC_WEIGHT_ASYMMETRIC_TREND_THRESHOLD: Minimum blended trend strength required
+    // before the bot applies a directional weight shift in the asymmetrical path.
+    // Higher values ignore weaker trend signals and keep weights closer to the static baseline.
+    // Lower values allow smaller trend signals to affect buy/sell weighting.
+    // Default is 0 so the gate stays disabled unless a market/bot override enables it.
+    // nob: th% (Min Output Threshold)
+    DYNAMIC_WEIGHT_ASYMMETRIC_TREND_THRESHOLD: 0,
+    // DYNAMIC_WEIGHT_SYMMETRIC_SHIFT_THRESHOLD: Minimum volatility shift required before the
+    // symmetric ATR dampening actually changes the output weights.
+    // Higher values ignore smaller ATR-driven adjustments.
+    // Lower values let volatility influence the symmetric shift sooner.
+    // (used by the volatility research tool)
+    DYNAMIC_WEIGHT_SYMMETRIC_SHIFT_THRESHOLD: 0.1,
+    // DYNAMIC_WEIGHT_CLIP_PERCENTILE: Outlier filter for unusually large AMA/Kalman moves.
+    // Higher values suppress more extreme spikes before they influence dynamic weights.
+    // 0 disables clipping.
+    // Configurable per market or per bot via market_profiles.json or botOverrides.
+    // nob: clip%
+    DYNAMIC_WEIGHT_CLIP_PERCENTILE: 10,
+    // DYNAMIC_WEIGHT_AMA_LOOKBACK_BARS: Lookback window for measuring AMA trend.
+    // Lower values react faster to recent price changes.
+    // Higher values smooth the signal and require a more sustained move.
+    // nob: lb (Lookback Bars)
+    DYNAMIC_WEIGHT_AMA_LOOKBACK_BARS: 9,
+    // DYNAMIC_WEIGHT_AMA_MAX_SLOPE_PCT: Average per-bar trend size that counts as "full strength" for AMA.
+    // Lower values make the AMA channel reach maximum influence more easily.
+    // Higher values require a stronger price move before AMA reaches full effect.
+    // nob: amaS% (AMA Max Slope %)
+    DYNAMIC_WEIGHT_AMA_MAX_SLOPE_PCT: 0.085,
+    // DYNAMIC_WEIGHT_KALMAN_MAX_SLOPE_PCT: Trend size that counts as "full strength" for
+    // the Kalman composite branch. Kept separate from the AMA slope knob so the two
+    // channels can saturate independently.
+    // Lower values make the Kalman channel reach maximum influence more easily.
+    // Higher values require a stronger move before the Kalman branch reaches full effect.
+    // nob: kalS% (Kalman Max Slope %)
+    DYNAMIC_WEIGHT_KALMAN_MAX_SLOPE_PCT: 0.8,
+    // DYNAMIC_WEIGHT_AMA_NEUTRAL_ZONE_PCT: Ignore small AMA moves around flat price action.
+    // Higher values create a larger neutral zone and reduce small trend reactions.
+    // Lower values make the AMA channel react to smaller moves.
+    // nob: nz% (Neutral Zone %)
+    DYNAMIC_WEIGHT_AMA_NEUTRAL_ZONE_PCT: 0,
+    // DYNAMIC_WEIGHT_ALPHA: Blend between AMA trend and Kalman trend.
+    // 0 = pure Kalman, 1 = pure AMA.
+    // Higher values trust AMA more, lower values trust Kalman more.
+    // nob: alpha
+    DYNAMIC_WEIGHT_ALPHA: 0.5,
+    // DYNAMIC_WEIGHT_DW: Blend inside the Kalman signal between velocity and displacement.
+    // Lower values emphasize momentum/velocity.
+    // Higher values emphasize how far price has moved away from the modal baseline.
+    // Default 0.5 balances velocity and displacement.
+    // nob: dw (Displacement Weight)
+    DYNAMIC_WEIGHT_DW: 0.5,
+    // DYNAMIC_WEIGHT_GAIN: Overall strength of the blended dynamic-weight signal.
+    // Higher values make dynamic weights more aggressive.
+    // Lower values keep weights closer to the static baseline.
+    // nob: gain
+    DYNAMIC_WEIGHT_GAIN: 1.0,
+    // DYNAMIC_WEIGHT_ASYMMETRIC_OFFSET_CLAMP: Maximum directional offset away from neutral.
+    // Overridable per market pair or per bot via market_adapter_settings.json.
+    DYNAMIC_WEIGHT_ASYMMETRIC_OFFSET_CLAMP: 0.5,
+    // DYNAMIC_WEIGHT_SYMMETRIC_SHIFT_CLAMP: Maximum symmetric downward shift from volatility.
+    // Overridable per market pair or per bot via market_adapter_settings.json.
+    DYNAMIC_WEIGHT_SYMMETRIC_SHIFT_CLAMP: 0.5,
+    // DYNAMIC_WEIGHT_ATR_PERIOD_DEFAULT: ATR lookback used by the live volatility penalty
+    // and the volatility research chart. 14 is the standard Wilder ATR window.
+    // Overridable per market pair or per bot via market_adapter_settings.json.
+    DYNAMIC_WEIGHT_ATR_PERIOD_DEFAULT: 14,
+    // DYNAMIC_WEIGHT_MIN_WEIGHT / MAX_WEIGHT: Final weight clamp after all adjustments.
+    DYNAMIC_WEIGHT_MIN_WEIGHT: -1,
+    DYNAMIC_WEIGHT_MAX_WEIGHT: 2,
+    // DYNAMIC_WEIGHT_REGIME_SENSITIVITY: How strongly the regime filter dampens or preserves
+    // the dynamic-weight signal.
+    // 0 ignores regime filtering, 1 uses the table as-is, and higher values make bad regimes
+    // suppress the signal more aggressively.
+    // nob: regime
+    DYNAMIC_WEIGHT_REGIME_SENSITIVITY: 1,
+    // Shared Kalman tuning defaults used by both the research HTML and the live dynamic-weight
+    // market adapter so both paths start from the same smoothing and echo behavior.
+    DYNAMIC_WEIGHT_KALMAN_R_NOISE_DEFAULT: 0.05,
+    DYNAMIC_WEIGHT_KALMAN_Q_TACTICAL_DEFAULT: 0.01,
+    DYNAMIC_WEIGHT_KALMAN_Q_MODAL_DEFAULT: 0.0001,
+    DYNAMIC_WEIGHT_KALMAN_SMOOTH_PCT_DEFAULT: 100,
+    DYNAMIC_WEIGHT_KALMAN_DISP_SCALE_MULT_DEFAULT: 1.8,
+    DYNAMIC_WEIGHT_KALMAN_DISP_THRESHOLD_MULT_DEFAULT: 1.5,
+    DYNAMIC_WEIGHT_KALMAN_SMOOTH_SPAN_PCT_DEFAULT: 100,
+    DYNAMIC_WEIGHT_SIGNAL_CONFIRM_BARS_DEFAULT: 0,
+    // Adaptive Kalman velocity smoothing budget (0-1.0)
+    DYNAMIC_WEIGHT_KALMAN_SMOOTHING_BUDGET: 0.60,
+    DYNAMIC_WEIGHT_KALMAN_SMOOTHING_FLOOR: 0,
+    // DYNAMIC_WEIGHT_ABSOLUTE_THRESHOLD_DEFAULT: Minimum raw regime multiplier deviation before
+    // the dampening branch is allowed to reduce the output.
+    DYNAMIC_WEIGHT_ABSOLUTE_THRESHOLD_DEFAULT: 0.05,
+    // DYNAMIC_WEIGHT_DISP_SCALE_MIN_PCT: Minimum Kalman displacement scale in percent.
+    // This is the active Kalman displacement scale in both the HTML research tool and the
+    // live directional signal path.
+    // The live smoother clamps this to at least 1.0 so 0.5% displacements do not saturate
+    // confidence too early.
+    // Exposed in the research chart as the `dsp` control.
+    DYNAMIC_WEIGHT_DISP_SCALE_MIN_PCT: 1.0,
+    // DYNAMIC_WEIGHT_VOLATILITY_EXPONENT: Controls how quickly the volatility penalty ramps up.
+    // Higher values delay the penalty in calm markets and make it matter more in higher volatility.
+    // Lower values make the penalty start affecting weights earlier.
+    // Overridable per market pair or per bot via market_adapter_settings.json.
+    DYNAMIC_WEIGHT_VOLATILITY_EXPONENT: 1.0,
+    // DYNAMIC_WEIGHT_VOLATILITY_SCALE_X_DEFAULT: Overall strength multiplier of the ATR-based
+    // volatility penalty. Higher = more aggressive shrinking of unused inventory.
+    // 1-100 range; 10.0 is a recommended start that leaves orders on the book during
+    // mild volatility. Increase to 20-30 if you want the bot to pull orders more
+    // aggressively during volatile periods.
+    // Overridable per market pair or per bot via market_adapter_settings.json.
+    DYNAMIC_WEIGHT_VOLATILITY_SCALE_X_DEFAULT: 10.0,
+    // ASYMMETRIC_BOUNDS_MAX_ASYMMETRY_FACTOR: Maximum ratio tilt applied to min/max
+    // grid bounds when the AMA slope indicates a strong trend. At full slope strength:
+    //   Downtrend: minPrice divisor grows by 1+factor, maxPrice multiplier shrinks by 1-factor
+    //   Uptrend:   maxPrice multiplier grows by 1+factor, minPrice divisor shrinks by 1-factor
+    // This widens the bound in the trend direction and tightens the opposite side,
+    // giving the grid more room when the AMA center trails price in a trend.
+    // 0 disables asymmetry. Recommended range: 0.15–0.35.
+    // Overridable per bot via market_adapter_settings.json.
+    ASYMMETRIC_BOUNDS_MAX_ASYMMETRY_FACTOR: 0.35,
+    // STALE_TAIL_THRESHOLD_CANDLES: Number of consecutive candles with an identical close
+    // price that triggers pruning of the trailing tail. Prevents gap-filled synthetic candles
+    // from carrying a frozen price forward indefinitely when the pool has no activity.
+    // At 1h intervals, 24 = 24 hours. Overridable via cfg.staleTailThreshold.
+    STALE_TAIL_THRESHOLD_CANDLES: 24,
+    // HURST_CONFIG: Standard window and scales for Hurst exponent calculation.
+    HURST_CONFIG: {
+        window: 256,
+        scales: [8, 16, 32, 64],
+    },
+    // PE_CONFIG: Standard parameters for Permutation Entropy calculation.
+    PE_CONFIG: {
+        m: 5,
+        delay: 1,
+        window: 54,
+    },
+    // HURST_ZONE_BAND: Width of the neutral Hurst zone between trending and mean-reverting regimes.
+    // Higher values classify more markets as "random/unclear".
+    // Lower values switch more quickly into trending or mean-reverting states.
+    HURST_ZONE_BAND: 0.05,
+    // PE_NODES: Signal-quality bands for permutation entropy.
+    // Lower entropy means cleaner, more structured price action.
+    // Higher entropy means noisier price action, where the bot should trust signals less.
+    PE_NODES: [0.60, 0.725, 0.85],
+    // REGIME_TABLE: Signal-strength table for combinations of market structure and noise.
+    // Rows are Hurst regimes [trending, random, mean-reverting].
+    // Columns are entropy regimes [structured, mixed, noisy].
+    // Higher values preserve more of the dynamic-weight signal.
+    // Lower values dampen the signal in unclear or hostile conditions.
+    REGIME_TABLE: [
+        [1.0, 0.7, 0.3], // Trending (H > 0.5 + HURST_ZONE_BAND)
+        [0.6, 0.4, 0.15], // Random
+        [0.3, 0.2, 0.05], // Mean-reverting (H < 0.5 - HURST_ZONE_BAND)
+    ],
+    // DEFAULT_AMA_KEY: Built-in default profile for `gridPrice: "ama"` when no
+    // pair-specific market_profiles entry exists.
+    DEFAULT_AMA_KEY: 'AMA3',
+    // AMAS: Built-in AMA presets derived from the local LP 1.19.133 fitting results.
+    // Fitted with per-AMA λ weights (0.0031 / 0.0025 / 0.00185 / 0.0013) on 1h candles
+    // (2023-07 → 2026-07, SMA-warmup-aligned optimizer, ER=781 fixed, Fast=5.2 fixed).
+    // These serve as stable defaults for the market adapter and can be overridden by
+    // pair-specific profiles in profiles/market_profiles.json.
+    AMAS: {
+        AMA1: {
+            name: 'AMA1 (cap 25%)',
+            erPeriod: 781,
+            fastPeriod: 5.2,
+            slowPeriod: 62.1,
+        },
+        AMA2: {
+            name: 'AMA2 (cap 30%)',
+            erPeriod: 781,
+            fastPeriod: 5.2,
+            slowPeriod: 71.7,
+        },
+        AMA3: {
+            name: 'AMA3 (cap 35%)',
+            erPeriod: 781,
+            fastPeriod: 5.2,
+            slowPeriod: 82.7,
+        },
+        AMA4: {
+            name: 'AMA4 (cap 40%)',
+            erPeriod: 781,
+            fastPeriod: 5.2,
+            slowPeriod: 95.5,
+        },
+    },
+    // AMA_CONVERGENCE_ER_AVG: Typical market Efficiency Ratio used to estimate
+    // average AMA convergence rate from cold start. Lower = more conservative
+    // (assumes more noise → slower convergence → more candles needed).
+    // Calibrated against pool 133 1h (2023-05-07 -> 2026-05-06) — implied ER corrects for
+    // Jensen's inequality (E[f(ER)] ≠ f(E[ER]) for convex f = x²).
+    AMA_CONVERGENCE_ER_AVG: 0.151,
+    // AMA_CONVERGENCE_EPSILON: Target fraction of initialization bias remaining
+    // after convergence. 0.01 = 99 % of the initial bias has decayed.
+    AMA_CONVERGENCE_EPSILON: 0.01,
+    // AMA_ER_SMOOTH_FAST_PERIOD: Fast-period equivalent for smoothing the raw
+    // Efficiency Ratio via EMA before it enters the SC formula. Raw ER can spike
+    // at regime boundaries (trending ↔ ranging), causing jerky AMA transitions
+    // and false grid re-centering triggers.
+    // 0 = disabled (raw ER used directly, backward compatible).
+    // Enabled alpha = 2 / (AMA_ER_SMOOTH_FAST_PERIOD + 1).
+    // Overridable per bot via bots.json inline `ama.erSmoothPeriod` field.
+    AMA_ER_SMOOTH_FAST_PERIOD: 0,
+};
+// Logging Level Configuration
+// Options:
+// - 'debug': Verbose output including calculation details, API calls, and flow tracing.
+// - 'info':  Standard production output. State changes (Active/Filled), keys confirmations, and errors.
+// - 'warn':  Warnings (non-critical issues) and errors only.
+// - 'error': Critical errors only.
+// - 'critical': Sustained critical failures (fill consumer cascade, permanent faults).
+let LOG_LEVEL = 'info';
+// Fine-grained Logging Configuration
+// Controls what gets logged at each level and which categories are enabled
+// Can be overridden in profiles/general.settings.json via LOGGING_CONFIG
+let LOGGING_CONFIG = {
+    changeTracking: {
+        enabled: true,
+        ignoreMinor: {
+            fundPrecision: 8, // Ignore fund changes smaller than 0.00000001
+            pricePrecision: 4 // Ignore price changes smaller than 0.0001
+        }
+    },
+    categories: {
+        fundChanges: {
+            enabled: true,
+            level: "debug",
+            options: {
+                onlyChanges: true,
+                aggregateSmall: true,
+                hideComponentBreakdown: true
+            }
+        },
+        orderStateChanges: {
+            enabled: true,
+            level: "info",
+            options: {
+                onlyChanges: true,
+                compactFormat: true
+            }
+        },
+        fillEvents: {
+            enabled: true,
+            level: "info",
+            options: {
+                onlyChanges: true,
+                aggregateFees: true
+            }
+        },
+        boundaryEvents: {
+            enabled: true,
+            level: "info",
+            options: {
+                onlyChanges: true
+            }
+        },
+        errorWarnings: {
+            enabled: true,
+            level: "warn",
+            options: {
+                alwaysLog: true
+            }
+        },
+        edgeCases: {
+            enabled: true,
+            level: "warn",
+            options: {
+                alwaysLog: true
+            }
+        }
+    },
+    // Rotation config: maxSize is the total disk budget for all log files (current + rotated).
+    // Per-file limit = maxSize / (maxFiles + 1). Oldest rotated files are pruned beyond maxFiles.
+    rotation: {
+        enabled: true,
+        maxSize: 1181116007, // 1.1 GB total log budget
+        maxFiles: 10
+    },
+    json: {
+        enabled: false
+    },
+    display: {
+        gridDiagnostics: {
+            enabled: false,
+            showOnDemandOnly: true
+        },
+        fundStatus: {
+            enabled: false,
+            showDetailed: false,
+            compactFormat: true
+        },
+        statusSummary: {
+            enabled: false
+        },
+        colors: {
+            enabled: "auto"
+        }
+    }
+};
+// Updater Configuration
+let UPDATER = {
+    // Whether the automated updater is enabled
+    ACTIVE: false,
+    // Hardcoded repository URL
+    REPOSITORY_URL: "https://github.com/froooze/DEXBot2.git",
+    // Default branch policy: 'auto' (track current), 'main', 'dev', 'test'
+    BRANCH: "auto",
+    // Automated update schedule using Cron format:
+    // ┌────────────── minute (0 - 59)
+    // │ ┌──────────── hour (0 - 23)
+    // │ │ ┌────────── day of month (1 - 31)
+    // │ │ │ ┌──────── month (1 - 12)
+    // │ │ │ │ ┌────── day of week (0 - 6) (0 is Sunday)
+    // │ │ │ │ │
+    // 0 0 * * *  (Default: Daily at midnight)
+    SCHEDULE: "0 0 * * *"
+};
+let LAUNCHER = {
+    MONOLITHIC: {
+        maxRestarts: 13,
+        minUptimeMs: 24 * 60 * 60 * 1000,
+        restartDelayMs: 3000,
+        controlStopTimeoutMs: 12000,
+        // SUPERVISOR_POLL_TIMEOUT_MS: Maximum wall-clock duration the
+        // `node unlock <bot>` (or monolithic wrapper) waits for the
+        // supervisor to report that all supervised bots have stopped. If a
+        // bot is stuck in a PM2 restart loop and reports `restarting`
+        // indefinitely, the launcher's setInterval poll would never clear.
+        // After this timeout the launcher rejects the runIsolated promise
+        // with a descriptive error so the user can intervene.
+        SUPERVISOR_POLL_TIMEOUT_MS: 60000,
+        // DAEMON_SIGKILL_DEADLINE_MS: Maximum time the credential-daemon
+        // stop path will wait for a SIGKILL to take effect before giving up
+        // and warning that the process may be in uninterruptible sleep.
+        // Most credential daemons exit within ~100ms of SIGKILL on healthy
+        // systems; 10s is a generous upper bound for slow disks or heavy
+        // process state.
+        DAEMON_SIGKILL_DEADLINE_MS: 10000,
+    },
+    // SUPERVISOR: Centralized defaults for bot_supervisor.ts.
+    // Previously hardcoded locally in the supervisor module.
+    SUPERVISOR: {
+        MAX_RESTARTS: 13,
+        MIN_UPTIME_MS: 24 * 60 * 60 * 1000,
+        RESTART_DELAY_MS: 3000,
+        SHUTDOWN_TIMEOUT_MS: 5000,
+        STAGGER_DELAY_MS: 500,
+        MAX_MEMORY_MB: 250,
+        MEMORY_CHECK_INTERVAL_MS: 60000,
+        STATUS_LOG_INTERVAL_MS: 300000,
+        MAX_CRON_LOOKAHEAD_MINUTES: 366 * 24 * 60,
+    },
+};
+// Copy-on-Write (COW) Grid performance thresholds
+// NOTE: Currently unused — reserved for future COW performance monitoring.
+let COW_PERFORMANCE = {
+    MAX_REBALANCE_PLANNING_MS: 100,
+    MAX_COMMIT_MS: 50,
+    MAX_MEMORY_MB: 50,
+    INDEX_REBUILD_THRESHOLD: 10000,
+    GRID_MEMORY_WARNING: 5000,
+    GRID_MEMORY_CRITICAL: 10000,
+    // WORKING_GRID_BYTES_PER_ORDER: Estimated memory usage per order in working grid (bytes).
+    // Used for memory profiling and warning thresholds.
+    // Default: 500 bytes (includes order object, metadata, and overhead).
+    WORKING_GRID_BYTES_PER_ORDER: 500
+};
+// Native BitShares Client Configuration
+// Constants from the btsdex → native integration (modules/bitshares-native/).
+// Documents chain-level constants, transport tuning, cache sizing, and serialization
+// parameters. The underlying native module is self-contained; these mirror its
+// defaults and serve as the canonical reference for DEXBot2 runtime behavior.
+//
+// Structure:
+//   NATIVE_CLIENT.CHAIN          - Graphene chain parameters
+//   NATIVE_CLIENT.OPERATIONS     - Operation type IDs
+//   NATIVE_CLIENT.OBJECT_TYPES   - Object space/type IDs
+//   NATIVE_CLIENT.TRANSACTION    - Transaction builder limits
+//   NATIVE_CLIENT.TRANSPORT      - WebSocket transport tuning
+//   NATIVE_CLIENT.SUBSCRIPTIONS  - Fill-detection subscription settings
+//   NATIVE_CLIENT.RESOLVERS      - Asset/account cache configuration
+//   NATIVE_CLIENT.ECC            - Cryptographic constants (reference only)
+//
+// Source files:
+//   modules/bitshares-native/serial/chain_constants.ts  (CHAIN, OPERATIONS, OBJECT_TYPES)
+//   modules/bitshares-native/tx/builder.ts               (TRANSACTION)
+//   modules/bitshares-native/transport.ts                (TRANSPORT)
+//   modules/bitshares-native/subscriptions.ts             (SUBSCRIPTIONS)
+//   modules/bitshares-native/resolvers.ts                 (RESOLVERS)
+//   modules/bitshares-native/crypto/ecc.ts                (ECC)
+//   modules/bitshares-native/serial/types.ts              (object_id encoding)
+//   modules/bitshares-native/serial/operations.ts         (operation serializers)
+//   modules/bitshares-native/chain_client.ts              (API registration, core asset)
+//   modules/bitshares_client.ts                           (connection proxy, event wiring)
+//
+let NATIVE_CLIENT = {
+    // -------------------------------------------------------------------------
+    // CHAIN — Graphene blockchain parameters
+    // -------------------------------------------------------------------------
+    CHAIN: {
+        // Precision divisor for blockchain amounts (e.g. 100000 = 5 decimal places).
+        // All on-chain amounts are integers; divide by this for human-readable display.
+        PRECISION: 100000,
+        // Maximum serialized transaction size allowed by the Graphene protocol (bytes).
+        // Transactions exceeding this are rejected by the network. Distinct from the
+        // smaller MAX_TX_SIZE soft limit used by the transaction builder.
+        MAX_TRANSACTION_SIZE: 262144,
+        // Maximum time until transaction expiration (seconds, 24 hours).
+        // Transactions expire after this if not included in a block.
+        MAX_TIME_UNTIL_EXPIRATION: 86400,
+        // Human-readable address prefix for public keys (BTS = BitShares mainnet).
+        ADDRESS_PREFIX: 'BTS',
+        // BitShares mainnet chain ID.
+        // References NODE_MANAGEMENT.EXPECTED_CHAIN_ID (defined above) to avoid
+        // duplicating the same hex literal across two locations.
+        CHAIN_ID: NODE_MANAGEMENT.EXPECTED_CHAIN_ID,
+        // 100% and 1% in Graphene basis points (bps).
+        // Used for fee calculations, credit-offer rates, and collateral ratio checks.
+        PERCENT_100: 10000,
+        PERCENT_1: 100,
+        // Core (fee) asset object ID. Always BTS on mainnet (1.3.0).
+        // Used as default fee payment asset for transaction preparation.
+        CORE_ASSET_ID: '1.3.0',
+    },
+    // -------------------------------------------------------------------------
+    // OPERATIONS — Graphene operation type IDs
+    // -------------------------------------------------------------------------
+    // Corresponds to OP_* constants in serial/chain_constants.ts.
+    // FILL_PROCESSING.OPERATION_TYPE (4) references OP_FILL_ORDER.
+    OPERATIONS: {
+        TRANSFER: 0,
+        LIMIT_ORDER_CREATE: 1,
+        LIMIT_ORDER_CANCEL: 2,
+        CALL_ORDER_UPDATE: 3,
+        FILL_ORDER: 4,
+        ASSET_SETTLE: 17,
+        CREDIT_OFFER_ACCEPT: 72,
+        CREDIT_DEAL_REPAY: 73,
+        CREDIT_DEAL_UPDATE: 76,
+        LIMIT_ORDER_UPDATE: 77,
+        LIQUIDITY_POOL: 63,
+    },
+    // -------------------------------------------------------------------------
+    // OBJECT_TYPES — Graphene object space/type IDs
+    // -------------------------------------------------------------------------
+    // Space 1 (protocol), used for blockchain entity identification.
+    // Object IDs follow the format "space.type.instance" (e.g. "1.2.12345" = account).
+    OBJECT_TYPES: {
+        NULL: 0,
+        BASE: 1,
+        ACCOUNT: 2,
+        ASSET: 3,
+        FORCE_SETTLEMENT: 4,
+        COMMITTEE_MEMBER: 5,
+        WITNESS: 6,
+        LIMIT_ORDER: 7,
+        CALL_ORDER: 8,
+        CUSTOM: 9,
+        PROPOSAL: 10,
+        OPERATION_HISTORY: 11,
+        WITHDRAW_PERMISSION: 12,
+        VESTING_BALANCE: 13,
+        WORKER: 14,
+        BALANCE: 15,
+        HTLC: 16,
+        TICKET: 17,
+        LIQUIDITY_POOL: 18,
+        SAMET_FUND: 19,
+        CREDIT_OFFER: 20,
+        CREDIT_DEAL: 21,
+    },
+    // -------------------------------------------------------------------------
+    // TRANSACTION — Transaction builder limits (tx/builder.js)
+    // -------------------------------------------------------------------------
+    TRANSACTION: {
+        // Soft limit: maximum serialized transaction size (bytes).
+        // Transactions larger than this are rejected by the builder before broadcast.
+        // Must be ≤ CHAIN.MAX_TRANSACTION_SIZE (262144).
+        MAX_SIZE_BYTES: 64000,
+        // Maximum number of operations per single transaction.
+        // Batching above this limit requires multiple transactions.
+        MAX_OPS_PER_TX: 200,
+        // Default transaction expiration time (seconds, 5 minutes).
+        // After signing, the transaction must be broadcast and confirmed within this window.
+        DEFAULT_EXPIRE_SEC: 300,
+        // Hard cap on transaction expiration (seconds, 24 hours).
+        // Enforced by the builder; values above this are clamped down.
+        MAX_EXPIRE_SEC: 86400,
+    },
+    // -------------------------------------------------------------------------
+    // TRANSPORT — WebSocket connection tuning (transport.js)
+    // -------------------------------------------------------------------------
+    TRANSPORT: {
+        // Maximum time for WebSocket handshake to complete (ms).
+        // If the handshake does not complete within this window, the node is skipped.
+        CONNECT_TIMEOUT_MS: 10000,
+        // Outer bound on a full _nativeClient.connect() operation (ms).
+        // The native transport sweeps all configured nodes sequentially, each
+        // bounded by CONNECT_TIMEOUT_MS, before giving up. With 8 default
+        // nodes × 10s handshake = 80s worst case; this gives a 10s buffer
+        // so the outer wrapper rejects cleanly without a hard tail-latency
+        // cliff. The native's connect() cannot be cancelled, so this is a
+        // "stop waiting" signal only — the underlying sweep continues in
+        // the background even after the outer bound fires.
+        CONNECT_TOTAL_TIMEOUT_MS: 90000,
+        // Maximum time waiting for an RPC response before timing out (ms).
+        // Applies to all native JSON-RPC calls (database, history, broadcast).
+        RPC_TIMEOUT_MS: 15000,
+        // Interval between keepalive pings during idle periods (ms).
+        // Uses a lightweight `login` call to detect severed connections early.
+        KEEPALIVE_INTERVAL_MS: 45000,
+        // Coalesce duplicate close events from the same active socket (ms).
+        // Some WebSocket implementations can emit close/error cascades for one
+        // underlying connection failure; this window prevents redundant failover work.
+        CLOSE_COALESCE_MS: 250,
+        // NOTE: These constants are informational but not imported by transport.ts
+        // Reconnection backoff parameters (ms).
+        // Reconnect delay = min(base × 2^attempt + random(0..1000), max).
+        RECONNECT_BASE_MS: 1000,
+        RECONNECT_MAX_MS: 30000,
+    },
+    // -------------------------------------------------------------------------
+    // SUBSCRIPTIONS — Fill-detection subscription settings (subscriptions.js)
+    // -------------------------------------------------------------------------
+    SUBSCRIPTIONS: {
+        // Graphene callback ID used for set_subscribe_callback.
+        // Fixed value; must match the ID registered with the API.
+        CALLBACK_ID: 1,
+        // Object space/type prefix for operation history objects (1.11.x).
+        // Fill_order virtual operations produce 1.11.x operation history objects.
+        // Notice handlers filter incoming object-change notifications by this prefix
+        // to isolate fill events from other blockchain activity.
+        OPERATION_HISTORY_PREFIX: '1.11',
+        // Default operation history object ID used as a fallback starting point
+        // when the account's most_recent_op cannot be resolved.
+        HISTORY_API_OBJECT: '1.11.0',
+        // Maximum number of history entries to fetch per page when scanning for
+        // fills after a subscription notice. The scan pages until it catches up
+        // to the per-subscription cursor (lastDeliveredHistoryId).
+        // This is used as an upper bound; at runtime the actual page limit is
+        // capped at min(HISTORY_LOOKBACK_MAX, node's api_limit_get_account_history)
+        // to avoid FC_ASSERT on nodes with a lower configured limit.
+        HISTORY_LOOKBACK_MAX: 50,
+        // HISTORY_MAX_PAGES: Default cap on pages fetched by
+        // fetchFillHistoryEntries in modules/bitshares-native/subscriptions.ts
+        // when the caller does not pass `options.maxPages`. Bounds the loop in
+        // case the history API keeps returning full pages (which would otherwise
+        // run unbounded). At HISTORY_LOOKBACK_MAX=50 entries per page this caps
+        // the per-call scan at 5k history entries by default.
+        HISTORY_MAX_PAGES: 100,
+        // SUBSCRIBE_TIMEOUT_MS: Outer bound on a single BitShares.subscribe
+        // operation. subscribe() chains several RPCs (get_full_accounts,
+        // primeLastDeliveredHistoryId, refreshSubscriptions), each individually
+        // capped by TRANSPORT.RPC_TIMEOUT_MS (15s). The total can therefore
+        // legitimately take 4× that on a deep-history account. 60s covers
+        // the typical case with headroom; the native per-RPC timeout still
+        // fires earlier on a hard hang.
+        SUBSCRIBE_TIMEOUT_MS: 75000,
+        // Delay before retrying a failed reconnect catch-up for a subscription.
+        RECONNECT_RETRY_DELAY_MS: 5000,
+        // Maximum fill events accepted into the in-memory processing queue.
+        // Subscription callbacks throw before acknowledging history when this
+        // limit would be exceeded, so the cursor remains retryable.
+        MAX_INCOMING_FILL_QUEUE: 1000,
+        // Coalesce window (ms) for the no-fill fallback scan in handleNotice.
+        // Back-to-back non-fill notices that arrive within this window share a
+        // single history scan per subscription instead of triggering one RPC
+        // per notice. Set to 0 to disable coalescing.
+        NOTICE_COALESCE_MS: 250,
+        // Subscription health watchdog — detects silent subscription death
+        // where the websocket stays connected and keep-alive passes but the
+        // node stops delivering notices (server-side timeout, node overload).
+        //
+        // SUBSCRIPTION_HEALTH_CHECK_INTERVAL_MS: How often the watchdog timer
+        // runs to check for stale subscriptions. Default: 60s.
+        SUBSCRIPTION_HEALTH_CHECK_INTERVAL_MS: 60000,
+        // SUBSCRIPTION_SILENT_THRESHOLD_MS: If a subscription has not received
+        // any notice (fill or non-fill) within this window, the watchdog
+        // triggers a resubscribe + history scan. Default: 5 minutes.
+        // Choose a value longer than the expected quiet period between
+        // account operations — low-activity bots should use 10–15 min.
+        SUBSCRIPTION_SILENT_THRESHOLD_MS: 300000,
+    },
+    // -------------------------------------------------------------------------
+    // ORDER_EVENTS — Local order-event correlation settings (chain_orders.js)
+    // -------------------------------------------------------------------------
+    ORDER_EVENTS: {
+        // Time window (ms) for remembering order ids this process just cancelled.
+        // Used only to discard malformed non-economic fill artifacts that are
+        // actually local cancel propagation; real fills with economics are kept.
+        RECENT_OWN_CANCEL_TTL_MS: 5000,
+        // Lazy-GC threshold for the recent-own-cancel map.
+        RECENT_OWN_CANCEL_MAX_ENTRIES: 256,
+    },
+    // -------------------------------------------------------------------------
+    // RESOLVERS — Asset/account resolution cache (resolvers.js)
+    // -------------------------------------------------------------------------
+    RESOLVERS: {
+        // Time-to-live for cached asset and account lookups (ms, 1 hour).
+        // After expiry, the next lookup re-fetches from the blockchain.
+        ASSET_TTL_MS: 3600000,
+        ACCOUNT_TTL_MS: 3600000,
+        // Maximum number of cached assets / accounts.
+        // Least-recently-used entries are evicted when the limit is reached.
+        MAX_ASSETS: 2000,
+        MAX_ACCOUNTS: 1000,
+        // Default LRU cache capacity when no explicit maxSize is provided.
+        LRU_DEFAULT_SIZE: 1000,
+    },
+    // -------------------------------------------------------------------------
+    // ECC — Cryptographic constants (crypto/ecc.js, reference only)
+    // -------------------------------------------------------------------------
+    // These are protocol-level constants that MUST NOT be changed.
+    // Included here for completeness; the native ECC module uses its own copies.
+    ECC: {
+        // Compact signature length (bytes): 1-byte recovery ID + 32-byte r + 32-byte s.
+        SIGNATURE_LENGTH: 65,
+        // Recovery ID offset for BitShares: 27 (Bitcoin standard) + 4 (Graphene offset).
+        // Used when encoding compact [rec|r|s] signatures for broadcast.
+        RECOVERY_OFFSET: 31,
+        // Checksum length for base58check-encoded keys and addresses (bytes).
+        // Uses double-SHA256 for WIF/base58check, ripemd160 for address hashes.
+        CHECKSUM_BYTES: 4,
+        // Wallet Import Format (WIF) magic bytes.
+        // 0x80 = WIF mainnet version prefix (prepended before the private key bytes).
+        // 0x01 = compressed public key indicator (appended after private key bytes).
+        WIF_VERSION_BYTE: 0x80,
+        WIF_COMPRESSED_FLAG: 0x01,
+        // Public key encoding constants.
+        // 0x02/0x03 = compressed (even/odd y), 0x04 = uncompressed prefix.
+        // Valid key lengths: 33 (compressed), 64 (raw xy), 65 (uncompressed).
+        PUBKEY_COMPRESSED_EVEN: 0x02,
+        PUBKEY_COMPRESSED_ODD: 0x03,
+        PUBKEY_UNCOMPRESSED_PREF: 0x04,
+        PUBKEY_LEN_COMPRESSED: 33,
+        PUBKEY_LEN_RAW_XY: 64,
+        PUBKEY_LEN_UNCOMPRESSED: 65,
+        // Deterministic K (RFC 6979) initial HMAC seeds.
+        // K = hmac-sha256(Buffer.alloc(32, 0x00), Buffer.alloc(32, 0x01)).
+        // Only relevant for signature generation internally.
+        DETERMINISTIC_K_SEED: '00-filled + 01-filled 32-byte buffers',
+    },
+};
+// --- LOCAL SETTINGS OVERRIDES ---
+// Load user-defined settings from profiles/general.settings.json if it exists.
+// This allows preserving settings during updates without git stashing.
+// Lazy require breaks the circular dependency: constants → general_settings → constants
+const { readGeneralSettings } = require('./general_settings');
+const settings = readGeneralSettings({
+    fallback: null,
+    onError: (err, filePath) => {
+        console.warn(`[WARN] Failed to load local settings from ${filePath}: ${err.message}`);
+    }
+});
+if (settings) {
+    const { mergeSettings } = require('./settings_merge');
+    const merged = mergeSettings(settings, {
+        LOG_LEVEL,
+        TIMING,
+        GRID_LIMITS,
+        FILL_PROCESSING,
+        PIPELINE_TIMING,
+        DEFAULT_CONFIG,
+        UPDATER,
+        CREDENTIAL_PROMPTS,
+        MAINTENANCE,
+        COW_PERFORMANCE,
+        INCREMENT_BOUNDS,
+        FEE_PARAMETERS,
+        API_LIMITS,
+        LOGGING_CONFIG,
+        NATIVE_CLIENT,
+        LAUNCHER,
+        NODE_MANAGEMENT,
+        MARKET_ADAPTER,
+    });
+    LOG_LEVEL = merged.LOG_LEVEL;
+    TIMING = merged.TIMING;
+    GRID_LIMITS = merged.GRID_LIMITS;
+    FILL_PROCESSING = merged.FILL_PROCESSING;
+    PIPELINE_TIMING = merged.PIPELINE_TIMING;
+    DEFAULT_CONFIG = merged.DEFAULT_CONFIG;
+    UPDATER = merged.UPDATER;
+    CREDENTIAL_PROMPTS = merged.CREDENTIAL_PROMPTS;
+    MAINTENANCE = merged.MAINTENANCE;
+    COW_PERFORMANCE = merged.COW_PERFORMANCE;
+    INCREMENT_BOUNDS = merged.INCREMENT_BOUNDS;
+    FEE_PARAMETERS = merged.FEE_PARAMETERS;
+    API_LIMITS = merged.API_LIMITS;
+    LOGGING_CONFIG = merged.LOGGING_CONFIG;
+    NATIVE_CLIENT = merged.NATIVE_CLIENT;
+    LAUNCHER = merged.LAUNCHER;
+    NODE_MANAGEMENT = merged.NODE_MANAGEMENT;
+    MARKET_ADAPTER = merged.MARKET_ADAPTER;
+}
+// Freeze objects to prevent accidental runtime modifications
+Object.freeze(ORDER_TYPES);
+Object.freeze(ORDER_STATES);
+Object.freeze(REBALANCE_STATES);
+Object.freeze(COW_ACTIONS);
+Object.freeze(TIMING);
+Object.freeze(GRID_LIMITS);
+Object.freeze(GRID_LIMITS.GRID_COMPARISON);
+Object.freeze(INCREMENT_BOUNDS);
+Object.freeze(FEE_PARAMETERS);
+Object.freeze(CR_ZONES);
+Object.freeze(API_LIMITS);
+Object.freeze(FILL_PROCESSING);
+Object.freeze(MAINTENANCE);
+Object.freeze(NODE_MANAGEMENT);
+Object.freeze(PIPELINE_TIMING);
+Object.freeze(UPDATER);
+Object.freeze(LAUNCHER.MONOLITHIC);
+Object.freeze(LAUNCHER.SUPERVISOR);
+Object.freeze(LAUNCHER);
+Object.freeze(COW_PERFORMANCE);
+Object.freeze(LOGGING_CONFIG);
+Object.freeze(NATIVE_CLIENT.CHAIN);
+Object.freeze(NATIVE_CLIENT.OPERATIONS);
+Object.freeze(NATIVE_CLIENT.OBJECT_TYPES);
+Object.freeze(NATIVE_CLIENT.TRANSACTION);
+Object.freeze(NATIVE_CLIENT.TRANSPORT);
+Object.freeze(NATIVE_CLIENT.SUBSCRIPTIONS);
+Object.freeze(NATIVE_CLIENT.RESOLVERS);
+Object.freeze(NATIVE_CLIENT.ECC);
+Object.freeze(NATIVE_CLIENT);
+Object.freeze(MARKET_ADAPTER.RUNTIME_DEFAULTS);
+Object.freeze(MARKET_ADAPTER.WATCHDOG_DEFAULTS);
+Object.freeze(MARKET_ADAPTER.AMAS.AMA1);
+Object.freeze(MARKET_ADAPTER.AMAS.AMA2);
+Object.freeze(MARKET_ADAPTER.AMAS.AMA3);
+Object.freeze(MARKET_ADAPTER.AMAS.AMA4);
+Object.freeze(MARKET_ADAPTER.AMAS);
+Object.freeze(MARKET_ADAPTER);
+Object.freeze(CREDENTIAL_PROMPTS);
+module.exports = { ORDER_TYPES, ORDER_STATES, REBALANCE_STATES, COW_ACTIONS, DEFAULT_CONFIG, TIMING, GRID_LIMITS, LOG_LEVEL, LOGGING_CONFIG, INCREMENT_BOUNDS, FEE_PARAMETERS, CR_ZONES, DEFAULT_TARGET_CR, API_LIMITS, FILL_PROCESSING, MAINTENANCE, NODE_MANAGEMENT, PIPELINE_TIMING, UPDATER, LAUNCHER, COW_PERFORMANCE, NATIVE_CLIENT, MARKET_ADAPTER, BUILD_DIR, BTS_PRECISION, DAEMON_ERRORS, DAEMON_CODES, CREDENTIAL_PROMPTS };
+//# sourceMappingURL=constants.js.map