clodds 1.1.0

package/dist/db/index.js

@@ -0,0 +1,3382 @@
+"use strict";
+/**
+ * Database - SQLite (sql.js WASM) for local persistence
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDatabase = initDatabase;
+exports.createDatabase = createDatabase;
+const sql_js_1 = __importDefault(require("sql.js"));
+const path_1 = require("path");
+const fs_1 = require("fs");
+const logger_1 = require("../utils/logger");
+const config_1 = require("../utils/config");
+const DB_DIR = (0, config_1.resolveStateDir)();
+const DB_FILE = (0, path_1.join)(DB_DIR, 'clodds.db');
+const BACKUP_DIR = (0, path_1.join)(DB_DIR, 'backups');
+let dbInstance = null;
+let sqlJsDb = null;
+let dbInitPromise = null;
+let backupInterval = null;
+async function initDatabase() {
+    if (dbInstance)
+        return dbInstance;
+    if (dbInitPromise)
+        return dbInitPromise;
+    dbInitPromise = (async () => {
+        // Ensure directory exists
+        if (!(0, fs_1.existsSync)(DB_DIR)) {
+            (0, fs_1.mkdirSync)(DB_DIR, { recursive: true });
+        }
+        logger_1.logger.info(`Opening database: ${DB_FILE}`);
+        // Initialize sql.js
+        const SQL = await (0, sql_js_1.default)();
+        // Load existing database or create new
+        if ((0, fs_1.existsSync)(DB_FILE)) {
+            const buffer = (0, fs_1.readFileSync)(DB_FILE);
+            sqlJsDb = new SQL.Database(buffer);
+        }
+        else {
+            sqlJsDb = new SQL.Database();
+        }
+        const db = sqlJsDb;
+        // Create tables
+        db.run(`
+    CREATE TABLE IF NOT EXISTS _schema_version (
+      version INTEGER NOT NULL,
+      applied_at INTEGER NOT NULL
+    );
+
+    -- Users table
+    CREATE TABLE IF NOT EXISTS users (
+      id TEXT PRIMARY KEY,
+      platform TEXT NOT NULL,
+      platform_user_id TEXT NOT NULL,
+      username TEXT,
+      settings TEXT DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      last_active_at INTEGER NOT NULL,
+      UNIQUE(platform, platform_user_id)
+    );
+
+    -- Alerts table
+    CREATE TABLE IF NOT EXISTS alerts (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      name TEXT,
+      market_id TEXT,
+      platform TEXT,
+      channel TEXT,
+      chat_id TEXT,
+      condition TEXT NOT NULL,
+      enabled INTEGER DEFAULT 1,
+      triggered INTEGER DEFAULT 0,
+      trigger_count INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      last_triggered_at INTEGER,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Positions table
+    CREATE TABLE IF NOT EXISTS positions (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      market_question TEXT,
+      outcome TEXT NOT NULL,
+      outcome_id TEXT NOT NULL,
+      side TEXT NOT NULL,
+      shares REAL NOT NULL,
+      avg_price REAL NOT NULL,
+      current_price REAL,
+      opened_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id),
+      UNIQUE(user_id, platform, market_id, outcome_id)
+    );
+
+    -- Portfolio P&L snapshots
+    CREATE TABLE IF NOT EXISTS portfolio_snapshots (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      total_value REAL NOT NULL,
+      total_pnl REAL NOT NULL,
+      total_pnl_pct REAL NOT NULL,
+      total_cost_basis REAL NOT NULL,
+      positions_count INTEGER NOT NULL,
+      by_platform TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Stop-loss triggers
+    CREATE TABLE IF NOT EXISTS stop_loss_triggers (
+      user_id TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      outcome_id TEXT NOT NULL,
+      market_id TEXT,
+      status TEXT NOT NULL,
+      triggered_at INTEGER NOT NULL,
+      last_price REAL,
+      last_error TEXT,
+      cooldown_until INTEGER,
+      PRIMARY KEY (user_id, platform, outcome_id)
+    );
+
+    -- Market cache table
+    CREATE TABLE IF NOT EXISTS markets (
+      platform TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      data TEXT NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (platform, market_id)
+    );
+
+    -- Market index table (semantic search)
+    CREATE TABLE IF NOT EXISTS market_index (
+      platform TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      slug TEXT,
+      question TEXT NOT NULL,
+      description TEXT,
+      outcomes_json TEXT,
+      tags_json TEXT,
+      status TEXT,
+      url TEXT,
+      end_date INTEGER,
+      resolved INTEGER,
+      volume_24h REAL,
+      liquidity REAL,
+      open_interest REAL,
+      predictions INTEGER,
+      content_hash TEXT,
+      updated_at INTEGER NOT NULL,
+      raw_json TEXT,
+      PRIMARY KEY (platform, market_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_market_index_platform ON market_index(platform);
+    CREATE INDEX IF NOT EXISTS idx_market_index_updated ON market_index(updated_at);
+    CREATE INDEX IF NOT EXISTS idx_market_index_hash ON market_index(content_hash);
+
+    -- Market index embeddings (persistent vectors)
+    CREATE TABLE IF NOT EXISTS market_index_embeddings (
+      platform TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      vector TEXT NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (platform, market_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_market_index_embeddings_hash ON market_index_embeddings(content_hash);
+
+    -- Sessions table
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT,
+      key TEXT PRIMARY KEY,
+      user_id TEXT,
+      channel TEXT NOT NULL,
+      chat_id TEXT NOT NULL,
+      chat_type TEXT NOT NULL,
+      context TEXT DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    -- Cron jobs table
+    CREATE TABLE IF NOT EXISTS cron_jobs (
+      id TEXT PRIMARY KEY,
+      data TEXT NOT NULL,
+      enabled INTEGER DEFAULT 1,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    -- Trading Credentials table (per-user, encrypted)
+    CREATE TABLE IF NOT EXISTS trading_credentials (
+      user_id TEXT NOT NULL,
+      platform TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      encrypted_data TEXT NOT NULL,
+      enabled INTEGER DEFAULT 1,
+      last_used_at INTEGER,
+      failed_attempts INTEGER DEFAULT 0,
+      cooldown_until INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (user_id, platform),
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Watched wallets table (for whale tracking)
+    CREATE TABLE IF NOT EXISTS watched_wallets (
+      user_id TEXT NOT NULL,
+      address TEXT NOT NULL,
+      platform TEXT NOT NULL DEFAULT 'polymarket',
+      nickname TEXT,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (user_id, address),
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Auto-copy settings (for copy trading)
+    CREATE TABLE IF NOT EXISTS auto_copy_settings (
+      user_id TEXT NOT NULL,
+      target_address TEXT NOT NULL,
+      max_size REAL NOT NULL,
+      size_multiplier REAL NOT NULL DEFAULT 0.5,
+      min_confidence REAL NOT NULL DEFAULT 0.55,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (user_id, target_address),
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Paper trading settings
+    CREATE TABLE IF NOT EXISTS paper_trading_settings (
+      user_id TEXT PRIMARY KEY,
+      enabled INTEGER NOT NULL DEFAULT 0,
+      balance REAL NOT NULL DEFAULT 10000,
+      starting_balance REAL NOT NULL DEFAULT 10000,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Paper trading positions
+    CREATE TABLE IF NOT EXISTS paper_positions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      market_name TEXT,
+      side TEXT NOT NULL,
+      size REAL NOT NULL,
+      entry_price REAL NOT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Paper trading trade history
+    CREATE TABLE IF NOT EXISTS paper_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      market_name TEXT,
+      side TEXT NOT NULL,
+      size REAL NOT NULL,
+      price REAL NOT NULL,
+      pnl REAL NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Alert settings (for whale alerts, new market alerts, etc.)
+    CREATE TABLE IF NOT EXISTS alert_settings (
+      user_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      min_size REAL,
+      threshold REAL,
+      markets TEXT,
+      categories TEXT,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (user_id, type),
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    -- Pairing requests (pending DM access)
+    CREATE TABLE IF NOT EXISTS pairing_requests (
+      code TEXT PRIMARY KEY,
+      channel TEXT NOT NULL,
+      userId TEXT NOT NULL,
+      username TEXT,
+      createdAt TEXT NOT NULL,
+      expiresAt TEXT NOT NULL
+    );
+
+    -- Paired users (approved DM access)
+    CREATE TABLE IF NOT EXISTS paired_users (
+      channel TEXT NOT NULL,
+      userId TEXT NOT NULL,
+      username TEXT,
+      pairedAt TEXT NOT NULL,
+      pairedBy TEXT NOT NULL DEFAULT 'allowlist',
+      isOwner INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (channel, userId)
+    );
+
+    -- Hyperliquid trades table
+    CREATE TABLE IF NOT EXISTS hyperliquid_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      trade_id TEXT,
+      order_id TEXT,
+      coin TEXT NOT NULL,
+      side TEXT NOT NULL,
+      direction TEXT,
+      size REAL NOT NULL,
+      price REAL NOT NULL,
+      fee REAL DEFAULT 0,
+      fee_token TEXT DEFAULT 'USDC',
+      closed_pnl REAL,
+      order_type TEXT,
+      is_maker INTEGER DEFAULT 0,
+      leverage INTEGER,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_hl_trades_user ON hyperliquid_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_hl_trades_coin ON hyperliquid_trades(coin);
+    CREATE INDEX IF NOT EXISTS idx_hl_trades_timestamp ON hyperliquid_trades(timestamp);
+
+    -- Hyperliquid positions history
+    CREATE TABLE IF NOT EXISTS hyperliquid_positions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      coin TEXT NOT NULL,
+      side TEXT NOT NULL,
+      size REAL NOT NULL,
+      entry_price REAL NOT NULL,
+      mark_price REAL,
+      liquidation_price REAL,
+      unrealized_pnl REAL,
+      realized_pnl REAL DEFAULT 0,
+      leverage INTEGER,
+      margin_used REAL,
+      opened_at INTEGER NOT NULL,
+      closed_at INTEGER,
+      close_price REAL,
+      close_reason TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_hl_positions_user ON hyperliquid_positions(user_id);
+    CREATE INDEX IF NOT EXISTS idx_hl_positions_coin ON hyperliquid_positions(coin);
+    CREATE INDEX IF NOT EXISTS idx_hl_positions_open ON hyperliquid_positions(closed_at);
+
+    -- Hyperliquid funding payments
+    CREATE TABLE IF NOT EXISTS hyperliquid_funding (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      coin TEXT NOT NULL,
+      funding_rate REAL NOT NULL,
+      payment REAL NOT NULL,
+      position_size REAL NOT NULL,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_hl_funding_user ON hyperliquid_funding(user_id);
+    CREATE INDEX IF NOT EXISTS idx_hl_funding_coin ON hyperliquid_funding(coin);
+    CREATE INDEX IF NOT EXISTS idx_hl_funding_timestamp ON hyperliquid_funding(timestamp);
+
+    -- Binance Futures trades table
+    CREATE TABLE IF NOT EXISTS binance_futures_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      trade_id TEXT,
+      order_id TEXT,
+      symbol TEXT NOT NULL,
+      side TEXT NOT NULL,
+      position_side TEXT,
+      size REAL NOT NULL,
+      price REAL NOT NULL,
+      commission REAL DEFAULT 0,
+      commission_asset TEXT DEFAULT 'USDT',
+      realized_pnl REAL,
+      order_type TEXT,
+      is_maker INTEGER DEFAULT 0,
+      leverage INTEGER,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_binance_trades_user ON binance_futures_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_binance_trades_symbol ON binance_futures_trades(symbol);
+    CREATE INDEX IF NOT EXISTS idx_binance_trades_timestamp ON binance_futures_trades(timestamp);
+
+    -- Binance Futures positions history
+    CREATE TABLE IF NOT EXISTS binance_futures_positions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      symbol TEXT NOT NULL,
+      position_side TEXT NOT NULL,
+      size REAL NOT NULL,
+      entry_price REAL NOT NULL,
+      mark_price REAL,
+      liquidation_price REAL,
+      unrealized_pnl REAL,
+      realized_pnl REAL DEFAULT 0,
+      leverage INTEGER,
+      margin_type TEXT,
+      isolated_margin REAL,
+      opened_at INTEGER NOT NULL,
+      closed_at INTEGER,
+      close_price REAL,
+      close_reason TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_binance_positions_user ON binance_futures_positions(user_id);
+    CREATE INDEX IF NOT EXISTS idx_binance_positions_symbol ON binance_futures_positions(symbol);
+    CREATE INDEX IF NOT EXISTS idx_binance_positions_open ON binance_futures_positions(closed_at);
+
+    -- Binance Futures funding payments
+    CREATE TABLE IF NOT EXISTS binance_futures_funding (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      symbol TEXT NOT NULL,
+      funding_rate REAL NOT NULL,
+      payment REAL NOT NULL,
+      position_size REAL NOT NULL,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_binance_funding_user ON binance_futures_funding(user_id);
+    CREATE INDEX IF NOT EXISTS idx_binance_funding_symbol ON binance_futures_funding(symbol);
+    CREATE INDEX IF NOT EXISTS idx_binance_funding_timestamp ON binance_futures_funding(timestamp);
+
+    -- Bybit Futures trades table
+    CREATE TABLE IF NOT EXISTS bybit_futures_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      trade_id TEXT,
+      order_id TEXT,
+      symbol TEXT NOT NULL,
+      side TEXT NOT NULL,
+      position_side TEXT,
+      size REAL NOT NULL,
+      price REAL NOT NULL,
+      commission REAL DEFAULT 0,
+      commission_asset TEXT DEFAULT 'USDT',
+      closed_pnl REAL,
+      order_type TEXT,
+      is_maker INTEGER DEFAULT 0,
+      leverage INTEGER,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_bybit_trades_user ON bybit_futures_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_bybit_trades_symbol ON bybit_futures_trades(symbol);
+    CREATE INDEX IF NOT EXISTS idx_bybit_trades_timestamp ON bybit_futures_trades(timestamp);
+
+    -- Bybit Futures positions history
+    CREATE TABLE IF NOT EXISTS bybit_futures_positions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      symbol TEXT NOT NULL,
+      side TEXT NOT NULL,
+      size REAL NOT NULL,
+      entry_price REAL NOT NULL,
+      mark_price REAL,
+      liquidation_price REAL,
+      unrealized_pnl REAL,
+      cum_realised_pnl REAL DEFAULT 0,
+      leverage INTEGER,
+      trade_mode TEXT,
+      position_margin REAL,
+      opened_at INTEGER NOT NULL,
+      closed_at INTEGER,
+      close_price REAL,
+      close_reason TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_bybit_positions_user ON bybit_futures_positions(user_id);
+    CREATE INDEX IF NOT EXISTS idx_bybit_positions_symbol ON bybit_futures_positions(symbol);
+    CREATE INDEX IF NOT EXISTS idx_bybit_positions_open ON bybit_futures_positions(closed_at);
+
+    -- Bybit Futures funding payments
+    CREATE TABLE IF NOT EXISTS bybit_futures_funding (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      symbol TEXT NOT NULL,
+      funding_rate REAL NOT NULL,
+      payment REAL NOT NULL,
+      position_size REAL NOT NULL,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_bybit_funding_user ON bybit_futures_funding(user_id);
+    CREATE INDEX IF NOT EXISTS idx_bybit_funding_symbol ON bybit_futures_funding(symbol);
+    CREATE INDEX IF NOT EXISTS idx_bybit_funding_timestamp ON bybit_futures_funding(timestamp);
+
+    -- MEXC Futures trades table
+    CREATE TABLE IF NOT EXISTS mexc_futures_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      trade_id TEXT,
+      order_id TEXT,
+      symbol TEXT NOT NULL,
+      side INTEGER NOT NULL,
+      vol REAL NOT NULL,
+      price REAL NOT NULL,
+      fee REAL DEFAULT 0,
+      fee_asset TEXT DEFAULT 'USDT',
+      realized_pnl REAL,
+      order_type INTEGER,
+      is_maker INTEGER DEFAULT 0,
+      leverage INTEGER,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mexc_trades_user ON mexc_futures_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_mexc_trades_symbol ON mexc_futures_trades(symbol);
+    CREATE INDEX IF NOT EXISTS idx_mexc_trades_timestamp ON mexc_futures_trades(timestamp);
+
+    -- MEXC Futures positions history
+    CREATE TABLE IF NOT EXISTS mexc_futures_positions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      symbol TEXT NOT NULL,
+      position_type INTEGER NOT NULL,
+      hold_vol REAL NOT NULL,
+      open_avg_price REAL NOT NULL,
+      mark_price REAL,
+      liquidation_price REAL,
+      unrealized_pnl REAL,
+      realized_pnl REAL DEFAULT 0,
+      leverage INTEGER,
+      margin_mode INTEGER,
+      position_margin REAL,
+      opened_at INTEGER NOT NULL,
+      closed_at INTEGER,
+      close_price REAL,
+      close_reason TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mexc_positions_user ON mexc_futures_positions(user_id);
+    CREATE INDEX IF NOT EXISTS idx_mexc_positions_symbol ON mexc_futures_positions(symbol);
+    CREATE INDEX IF NOT EXISTS idx_mexc_positions_open ON mexc_futures_positions(closed_at);
+
+    -- MEXC Futures funding payments
+    CREATE TABLE IF NOT EXISTS mexc_futures_funding (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      symbol TEXT NOT NULL,
+      funding_rate REAL NOT NULL,
+      payment REAL NOT NULL,
+      position_size REAL NOT NULL,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mexc_funding_user ON mexc_futures_funding(user_id);
+    CREATE INDEX IF NOT EXISTS idx_mexc_funding_symbol ON mexc_futures_funding(symbol);
+    CREATE INDEX IF NOT EXISTS idx_mexc_funding_timestamp ON mexc_futures_funding(timestamp);
+
+    -- Opinion.trade trades table
+    CREATE TABLE IF NOT EXISTS opinion_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      order_id TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      token_id TEXT NOT NULL,
+      side TEXT NOT NULL,
+      price REAL NOT NULL,
+      size REAL NOT NULL,
+      order_type TEXT NOT NULL,
+      status TEXT DEFAULT 'open',
+      filled_size REAL DEFAULT 0,
+      avg_fill_price REAL,
+      fee REAL DEFAULT 0,
+      tx_hash TEXT,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_opinion_trades_user ON opinion_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_opinion_trades_market ON opinion_trades(market_id);
+    CREATE INDEX IF NOT EXISTS idx_opinion_trades_timestamp ON opinion_trades(timestamp);
+
+    -- Predict.fun trades table
+    CREATE TABLE IF NOT EXISTS predictfun_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      order_hash TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      token_id TEXT NOT NULL,
+      side TEXT NOT NULL,
+      price REAL NOT NULL,
+      quantity REAL NOT NULL,
+      status TEXT DEFAULT 'open',
+      filled_quantity REAL DEFAULT 0,
+      avg_fill_price REAL,
+      fee REAL DEFAULT 0,
+      tx_hash TEXT,
+      is_neg_risk INTEGER DEFAULT 0,
+      is_yield_bearing INTEGER DEFAULT 1,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_predictfun_trades_user ON predictfun_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_predictfun_trades_market ON predictfun_trades(market_id);
+    CREATE INDEX IF NOT EXISTS idx_predictfun_trades_timestamp ON predictfun_trades(timestamp);
+
+    -- Polymarket trades table
+    CREATE TABLE IF NOT EXISTS polymarket_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      order_id TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      token_id TEXT NOT NULL,
+      condition_id TEXT,
+      side TEXT NOT NULL,
+      price REAL NOT NULL,
+      size REAL NOT NULL,
+      order_type TEXT NOT NULL,
+      status TEXT DEFAULT 'open',
+      filled_size REAL DEFAULT 0,
+      avg_fill_price REAL,
+      fee REAL DEFAULT 0,
+      tx_hash TEXT,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_polymarket_trades_user ON polymarket_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_polymarket_trades_market ON polymarket_trades(market_id);
+    CREATE INDEX IF NOT EXISTS idx_polymarket_trades_timestamp ON polymarket_trades(timestamp);
+
+    -- Kalshi trades table
+    CREATE TABLE IF NOT EXISTS kalshi_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      order_id TEXT NOT NULL,
+      market_id TEXT NOT NULL,
+      ticker TEXT NOT NULL,
+      side TEXT NOT NULL,
+      price REAL NOT NULL,
+      count INTEGER NOT NULL,
+      order_type TEXT NOT NULL,
+      status TEXT DEFAULT 'open',
+      filled_count INTEGER DEFAULT 0,
+      avg_fill_price REAL,
+      fee REAL DEFAULT 0,
+      action TEXT,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_kalshi_trades_user ON kalshi_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_kalshi_trades_market ON kalshi_trades(market_id);
+    CREATE INDEX IF NOT EXISTS idx_kalshi_trades_ticker ON kalshi_trades(ticker);
+    CREATE INDEX IF NOT EXISTS idx_kalshi_trades_timestamp ON kalshi_trades(timestamp);
+
+    -- Drift Protocol trades table
+    CREATE TABLE IF NOT EXISTS drift_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      order_id TEXT,
+      market_index INTEGER NOT NULL,
+      market_type TEXT NOT NULL,
+      direction TEXT NOT NULL,
+      base_amount REAL NOT NULL,
+      quote_amount REAL,
+      price REAL,
+      order_type TEXT NOT NULL,
+      status TEXT DEFAULT 'open',
+      filled_amount REAL DEFAULT 0,
+      avg_fill_price REAL,
+      leverage REAL,
+      tx_sig TEXT,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_drift_trades_user ON drift_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_drift_trades_market ON drift_trades(market_index);
+    CREATE INDEX IF NOT EXISTS idx_drift_trades_timestamp ON drift_trades(timestamp);
+
+    -- Manifold Markets trades table
+    CREATE TABLE IF NOT EXISTS manifold_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      bet_id TEXT NOT NULL,
+      contract_id TEXT NOT NULL,
+      outcome TEXT NOT NULL,
+      amount REAL NOT NULL,
+      shares REAL NOT NULL,
+      probability_before REAL,
+      probability_after REAL,
+      status TEXT DEFAULT 'filled',
+      fee REAL DEFAULT 0,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_manifold_trades_user ON manifold_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_manifold_trades_contract ON manifold_trades(contract_id);
+    CREATE INDEX IF NOT EXISTS idx_manifold_trades_timestamp ON manifold_trades(timestamp);
+
+    -- Solana DEX trades table (Jupiter, Raydium, Orca, Meteora)
+    CREATE TABLE IF NOT EXISTS solana_dex_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      tx_sig TEXT NOT NULL,
+      dex TEXT NOT NULL,
+      input_mint TEXT NOT NULL,
+      output_mint TEXT NOT NULL,
+      input_amount REAL NOT NULL,
+      output_amount REAL NOT NULL,
+      input_symbol TEXT,
+      output_symbol TEXT,
+      price_impact REAL,
+      slippage REAL,
+      fee REAL DEFAULT 0,
+      route TEXT,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_solana_dex_trades_user ON solana_dex_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_solana_dex_trades_dex ON solana_dex_trades(dex);
+    CREATE INDEX IF NOT EXISTS idx_solana_dex_trades_timestamp ON solana_dex_trades(timestamp);
+
+    -- Jupiter swaps table (detailed route tracking)
+    CREATE TABLE IF NOT EXISTS jupiter_swaps (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      tx_sig TEXT NOT NULL UNIQUE,
+      input_mint TEXT NOT NULL,
+      output_mint TEXT NOT NULL,
+      input_amount TEXT NOT NULL,
+      output_amount TEXT NOT NULL,
+      input_symbol TEXT,
+      output_symbol TEXT,
+      price_impact_pct REAL,
+      slippage_bps INTEGER,
+      route_plan TEXT,
+      num_hops INTEGER,
+      priority_fee INTEGER,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_jupiter_swaps_user ON jupiter_swaps(user_id);
+    CREATE INDEX IF NOT EXISTS idx_jupiter_swaps_timestamp ON jupiter_swaps(timestamp);
+
+    -- Raydium pools tracking
+    CREATE TABLE IF NOT EXISTS raydium_pools (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      pool_id TEXT NOT NULL UNIQUE,
+      base_mint TEXT NOT NULL,
+      quote_mint TEXT NOT NULL,
+      base_symbol TEXT,
+      quote_symbol TEXT,
+      liquidity REAL,
+      volume_24h REAL,
+      fee_rate REAL,
+      version TEXT,
+      last_updated INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_raydium_pools_mints ON raydium_pools(base_mint, quote_mint);
+
+    -- Orca Whirlpool positions
+    CREATE TABLE IF NOT EXISTS orca_positions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      position_address TEXT NOT NULL,
+      pool_address TEXT NOT NULL,
+      token_a_mint TEXT NOT NULL,
+      token_b_mint TEXT NOT NULL,
+      tick_lower INTEGER,
+      tick_upper INTEGER,
+      liquidity TEXT,
+      fee_owed_a TEXT,
+      fee_owed_b TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_orca_positions_user ON orca_positions(user_id);
+
+    -- Meteora DLMM pools
+    CREATE TABLE IF NOT EXISTS meteora_pools (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      pool_address TEXT NOT NULL UNIQUE,
+      token_x_mint TEXT NOT NULL,
+      token_y_mint TEXT NOT NULL,
+      token_x_symbol TEXT,
+      token_y_symbol TEXT,
+      bin_step INTEGER,
+      active_id INTEGER,
+      liquidity REAL,
+      fee_rate REAL,
+      last_updated INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_meteora_pools_mints ON meteora_pools(token_x_mint, token_y_mint);
+
+    -- Pump.fun tokens
+    CREATE TABLE IF NOT EXISTS pump_tokens (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      mint TEXT NOT NULL UNIQUE,
+      name TEXT,
+      symbol TEXT,
+      creator TEXT,
+      bonding_curve TEXT,
+      market_cap REAL,
+      virtual_sol_reserves REAL,
+      virtual_token_reserves REAL,
+      total_supply TEXT,
+      holder_count INTEGER,
+      is_graduated INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_pump_tokens_symbol ON pump_tokens(symbol);
+    CREATE INDEX IF NOT EXISTS idx_pump_tokens_market_cap ON pump_tokens(market_cap);
+
+    -- Drift trades (perpetuals)
+    CREATE TABLE IF NOT EXISTS drift_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      tx_sig TEXT NOT NULL,
+      market_index INTEGER NOT NULL,
+      market_type TEXT NOT NULL,
+      order_id INTEGER,
+      direction TEXT NOT NULL,
+      base_asset_amount TEXT NOT NULL,
+      quote_asset_amount TEXT,
+      price TEXT,
+      fee TEXT,
+      pnl TEXT,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_drift_trades_user ON drift_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_drift_trades_market ON drift_trades(market_index);
+    CREATE INDEX IF NOT EXISTS idx_drift_trades_timestamp ON drift_trades(timestamp);
+
+    -- Drift positions
+    CREATE TABLE IF NOT EXISTS drift_positions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      market_index INTEGER NOT NULL,
+      market_type TEXT NOT NULL,
+      base_asset_amount TEXT NOT NULL,
+      quote_asset_amount TEXT,
+      entry_price TEXT,
+      unrealized_pnl TEXT,
+      liquidation_price TEXT,
+      leverage REAL,
+      updated_at INTEGER NOT NULL,
+      UNIQUE(user_id, market_index, market_type),
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_drift_positions_user ON drift_positions(user_id);
+
+    -- EVM swap trades table (Uniswap, Sushiswap, 1inch, etc.)
+    CREATE TABLE IF NOT EXISTS evm_swap_trades (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      tx_hash TEXT NOT NULL,
+      chain_id INTEGER NOT NULL,
+      dex TEXT NOT NULL,
+      token_in TEXT NOT NULL,
+      token_out TEXT NOT NULL,
+      amount_in REAL NOT NULL,
+      amount_out REAL NOT NULL,
+      token_in_symbol TEXT,
+      token_out_symbol TEXT,
+      price_impact REAL,
+      slippage REAL,
+      gas_used REAL,
+      gas_price REAL,
+      timestamp INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_evm_swap_trades_user ON evm_swap_trades(user_id);
+    CREATE INDEX IF NOT EXISTS idx_evm_swap_trades_chain ON evm_swap_trades(chain_id);
+    CREATE INDEX IF NOT EXISTS idx_evm_swap_trades_dex ON evm_swap_trades(dex);
+    CREATE INDEX IF NOT EXISTS idx_evm_swap_trades_timestamp ON evm_swap_trades(timestamp);
+
+    -- Create indexes
+    CREATE INDEX IF NOT EXISTS idx_alerts_user ON alerts(user_id);
+    CREATE INDEX IF NOT EXISTS idx_alerts_active ON alerts(enabled, triggered);
+    CREATE INDEX IF NOT EXISTS idx_positions_user ON positions(user_id);
+    CREATE INDEX IF NOT EXISTS idx_portfolio_snapshots_user ON portfolio_snapshots(user_id);
+    CREATE INDEX IF NOT EXISTS idx_portfolio_snapshots_created_at ON portfolio_snapshots(created_at);
+    CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_key ON sessions(key);
+    CREATE INDEX IF NOT EXISTS idx_credentials_user ON trading_credentials(user_id);
+    CREATE INDEX IF NOT EXISTS idx_credentials_user_platform ON trading_credentials(user_id, platform);
+    CREATE INDEX IF NOT EXISTS idx_markets_platform_market ON markets(platform, market_id);
+    CREATE INDEX IF NOT EXISTS idx_users_platform_userid ON users(platform, platform_user_id);
+    CREATE INDEX IF NOT EXISTS idx_watched_wallets_user ON watched_wallets(user_id);
+    CREATE INDEX IF NOT EXISTS idx_paper_positions_user ON paper_positions(user_id);
+    CREATE INDEX IF NOT EXISTS idx_paper_trades_user ON paper_trades(user_id);
+  `);
+        // Backfill new columns on existing databases
+        try {
+            db.run('ALTER TABLE market_index ADD COLUMN content_hash TEXT');
+        }
+        catch {
+            // Column already exists or table missing; ignore.
+        }
+        // Silently add columns if missing - errors mean column already exists
+        try {
+            db.run('ALTER TABLE market_index ADD COLUMN volume_24h REAL');
+        }
+        catch { /* Column exists */ }
+        try {
+            db.run('ALTER TABLE market_index ADD COLUMN liquidity REAL');
+        }
+        catch { /* Column exists */ }
+        try {
+            db.run('ALTER TABLE market_index ADD COLUMN open_interest REAL');
+        }
+        catch { /* Column exists */ }
+        try {
+            db.run('ALTER TABLE market_index ADD COLUMN predictions INTEGER');
+        }
+        catch { /* Column exists */ }
+        try {
+            db.run('ALTER TABLE sessions ADD COLUMN title TEXT');
+        }
+        catch { /* Column exists */ }
+        // Ensure embeddings table exists for older DBs
+        db.run(`
+      CREATE TABLE IF NOT EXISTS market_index_embeddings (
+        platform TEXT NOT NULL,
+        market_id TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        vector TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (platform, market_id)
+      );
+    `);
+        db.run('CREATE INDEX IF NOT EXISTS idx_market_index_embeddings_hash ON market_index_embeddings(content_hash)');
+        // Save after schema creation
+        saveDb();
+        function saveDb() {
+            if (!sqlJsDb)
+                return;
+            const data = sqlJsDb.export();
+            const buffer = Buffer.from(data);
+            (0, fs_1.writeFileSync)(DB_FILE, buffer);
+        }
+        function getBackupConfig() {
+            const intervalMinutes = Number.parseInt(process.env.CLODDS_DB_BACKUP_INTERVAL_MINUTES || '60', 10);
+            const maxFiles = Number.parseInt(process.env.CLODDS_DB_BACKUP_MAX || '10', 10);
+            const intervalMs = Math.max(1, intervalMinutes) * 60 * 1000;
+            return {
+                enabled: intervalMinutes > 0 && maxFiles > 0,
+                intervalMs,
+                maxFiles,
+            };
+        }
+        function ensureBackupDir() {
+            if (!(0, fs_1.existsSync)(BACKUP_DIR)) {
+                (0, fs_1.mkdirSync)(BACKUP_DIR, { recursive: true });
+            }
+        }
+        function listBackupFiles() {
+            if (!(0, fs_1.existsSync)(BACKUP_DIR))
+                return [];
+            return (0, fs_1.readdirSync)(BACKUP_DIR)
+                .filter((name) => name.endsWith('.db'))
+                .map((name) => {
+                const path = (0, path_1.join)(BACKUP_DIR, name);
+                const stats = (0, fs_1.statSync)(path);
+                return { name, path, mtimeMs: stats.mtimeMs };
+            })
+                .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        }
+        function pruneBackups(maxFiles) {
+            const files = listBackupFiles();
+            if (files.length <= maxFiles)
+                return;
+            const toDelete = files.slice(maxFiles);
+            for (const file of toDelete) {
+                try {
+                    (0, fs_1.unlinkSync)(file.path);
+                }
+                catch (error) {
+                    logger_1.logger.warn({ error, file: file.name }, 'Failed to delete old backup');
+                }
+            }
+        }
+        function createBackup() {
+            if (!sqlJsDb)
+                return;
+            ensureBackupDir();
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const filePath = (0, path_1.join)(BACKUP_DIR, `clodds-${timestamp}.db`);
+            const data = sqlJsDb.export();
+            (0, fs_1.writeFileSync)(filePath, Buffer.from(data));
+            const { maxFiles } = getBackupConfig();
+            pruneBackups(maxFiles);
+        }
+        // Helper to get single row
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function getOne(sql, params = []) {
+            const stmt = db.prepare(sql);
+            try {
+                stmt.bind(params);
+                if (stmt.step()) {
+                    const row = stmt.getAsObject();
+                    return row;
+                }
+                return undefined;
+            }
+            finally {
+                stmt.free();
+            }
+        }
+        // Helper to get all rows
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function getAll(sql, params = []) {
+            const stmt = db.prepare(sql);
+            try {
+                stmt.bind(params);
+                const results = [];
+                while (stmt.step()) {
+                    results.push(stmt.getAsObject());
+                }
+                return results;
+            }
+            finally {
+                stmt.free();
+            }
+        }
+        // Helper to run statement
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function run(sql, params = []) {
+            db.run(sql, params);
+            saveDb();
+        }
+        // Helper to query multiple rows
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function query(sql, params = []) {
+            const stmt = db.prepare(sql);
+            try {
+                stmt.bind(params);
+                const results = [];
+                while (stmt.step()) {
+                    results.push(stmt.getAsObject());
+                }
+                return results;
+            }
+            finally {
+                stmt.free();
+            }
+        }
+        // Helper to parse row into typed object
+        function parseUser(row) {
+            if (!row)
+                return undefined;
+            return {
+                id: row.id,
+                platform: row.platform,
+                platformUserId: row.platform_user_id,
+                username: row.username,
+                settings: JSON.parse(row.settings || '{}'),
+                createdAt: new Date(row.created_at),
+                lastActiveAt: new Date(row.last_active_at),
+            };
+        }
+        function extractAccountIdFromSessionKey(key) {
+            const parts = key.split(':');
+            if (parts.length < 4)
+                return undefined;
+            const platform = parts[2];
+            if (platform !== 'whatsapp')
+                return undefined;
+            const candidate = parts[3];
+            if (candidate === 'group' || candidate === 'dm')
+                return undefined;
+            return candidate || undefined;
+        }
+        function parseSession(row) {
+            if (!row)
+                return undefined;
+            let context;
+            try {
+                context = JSON.parse(row.context || '{}');
+            }
+            catch {
+                context = {};
+            }
+            context.messageCount ??= 0;
+            context.lastMarkets ??= [];
+            context.preferences ??= {};
+            context.conversationHistory ??= [];
+            return {
+                id: row.id,
+                key: row.key,
+                userId: row.user_id,
+                channel: row.channel,
+                accountId: extractAccountIdFromSessionKey(row.key),
+                chatId: row.chat_id,
+                chatType: row.chat_type,
+                title: row.title || undefined,
+                context,
+                history: context.conversationHistory || [],
+                lastActivity: row.last_activity ? new Date(row.last_activity) : new Date(row.updated_at),
+                createdAt: new Date(row.created_at),
+                updatedAt: new Date(row.updated_at),
+            };
+        }
+        function parseAlert(row) {
+            return {
+                id: row.id,
+                userId: row.user_id,
+                type: row.type,
+                name: row.name,
+                marketId: row.market_id,
+                platform: row.platform,
+                channel: row.channel,
+                chatId: row.chat_id,
+                condition: JSON.parse(row.condition || '{}'),
+                enabled: Boolean(row.enabled),
+                triggered: Boolean(row.triggered),
+                createdAt: new Date(row.created_at),
+                lastTriggeredAt: row.last_triggered_at ? new Date(row.last_triggered_at) : undefined,
+            };
+        }
+        function parsePosition(row) {
+            const shares = row.shares;
+            const avgPrice = row.avg_price;
+            const currentPrice = row.current_price || avgPrice;
+            const value = shares * currentPrice;
+            const pnl = shares * (currentPrice - avgPrice);
+            const pnlPct = avgPrice > 0 ? ((currentPrice - avgPrice) / avgPrice) * 100 : 0;
+            return {
+                id: row.id,
+                platform: row.platform,
+                marketId: row.market_id,
+                marketQuestion: row.market_question,
+                outcome: row.outcome,
+                outcomeId: row.outcome_id,
+                side: row.side,
+                shares,
+                avgPrice,
+                currentPrice,
+                pnl,
+                pnlPct,
+                value,
+                openedAt: new Date(row.opened_at),
+            };
+        }
+        function parsePortfolioSnapshot(row) {
+            const byPlatformRaw = row.by_platform;
+            let byPlatform = {};
+            if (byPlatformRaw) {
+                try {
+                    byPlatform = JSON.parse(byPlatformRaw);
+                }
+                catch {
+                    byPlatform = {};
+                }
+            }
+            return {
+                userId: row.user_id,
+                totalValue: Number(row.total_value || 0),
+                totalPnl: Number(row.total_pnl || 0),
+                totalPnlPct: Number(row.total_pnl_pct || 0),
+                totalCostBasis: Number(row.total_cost_basis || 0),
+                positionsCount: Number(row.positions_count || 0),
+                byPlatform,
+                createdAt: new Date(row.created_at),
+            };
+        }
+        function parseTradingCredentials(row) {
+            if (!row)
+                return null;
+            return {
+                userId: row.user_id,
+                platform: row.platform,
+                mode: row.mode,
+                encryptedData: row.encrypted_data,
+                enabled: Boolean(row.enabled),
+                lastUsedAt: row.last_used_at ? new Date(row.last_used_at) : undefined,
+                failedAttempts: row.failed_attempts,
+                cooldownUntil: row.cooldown_until ? new Date(row.cooldown_until) : undefined,
+                createdAt: new Date(row.created_at),
+                updatedAt: new Date(row.updated_at),
+            };
+        }
+        const instance = {
+            close() {
+                saveDb();
+                db.close();
+                sqlJsDb = null;
+                dbInstance = null;
+                dbInitPromise = null;
+                if (backupInterval) {
+                    clearInterval(backupInterval);
+                    backupInterval = null;
+                }
+            },
+            save() {
+                saveDb();
+            },
+            backupNow() {
+                createBackup();
+            },
+            getVersion() {
+                try {
+                    const row = getOne('SELECT version FROM _schema_version ORDER BY version DESC LIMIT 1');
+                    return row?.version ?? 0;
+                }
+                catch {
+                    return 0;
+                }
+            },
+            setVersion(version) {
+                run('CREATE TABLE IF NOT EXISTS _schema_version (version INTEGER NOT NULL, applied_at INTEGER NOT NULL)');
+                run('INSERT INTO _schema_version (version, applied_at) VALUES (?, ?)', [version, Date.now()]);
+            },
+            // Users
+            getUserByPlatformId(platform, platformUserId) {
+                return parseUser(getOne('SELECT id, platform, platform_user_id, username, settings, created_at, last_active_at FROM users WHERE platform = ? AND platform_user_id = ?', [platform, platformUserId]));
+            },
+            getUser(userId) {
+                return parseUser(getOne('SELECT id, platform, platform_user_id, username, settings, created_at, last_active_at FROM users WHERE id = ?', [userId]));
+            },
+            listUsers() {
+                return getAll('SELECT id, platform, platform_user_id, username, settings, created_at, last_active_at FROM users')
+                    .map(parseUser)
+                    .filter((user) => Boolean(user));
+            },
+            createUser(user) {
+                run('INSERT INTO users (id, platform, platform_user_id, username, settings, created_at, last_active_at) VALUES (?, ?, ?, ?, ?, ?, ?)', [
+                    user.id,
+                    user.platform,
+                    user.platformUserId,
+                    user.username ?? null,
+                    JSON.stringify(user.settings),
+                    user.createdAt.getTime(),
+                    user.lastActiveAt.getTime(),
+                ]);
+            },
+            updateUserActivity(userId) {
+                run('UPDATE users SET last_active_at = ? WHERE id = ?', [Date.now(), userId]);
+            },
+            updateUserSettings(userId, settings) {
+                const user = instance.getUser(userId);
+                if (!user)
+                    return false;
+                const next = { ...user.settings, ...settings };
+                run('UPDATE users SET settings = ? WHERE id = ?', [JSON.stringify(next), userId]);
+                return true;
+            },
+            updateUserSettingsByPlatform(platform, platformUserId, settings) {
+                const user = instance.getUserByPlatformId(platform, platformUserId);
+                if (!user)
+                    return false;
+                return instance.updateUserSettings(user.id, settings);
+            },
+            // Sessions
+            getSession(key) {
+                return parseSession(getOne('SELECT id, key, user_id, channel, chat_id, chat_type, context, title, created_at, updated_at FROM sessions WHERE key = ?', [key]));
+            },
+            getLatestSessionForUser(userId) {
+                const row = getOne('SELECT channel, chat_id, chat_type, updated_at FROM sessions WHERE user_id = ? ORDER BY updated_at DESC LIMIT 1', [userId]);
+                if (!row)
+                    return undefined;
+                return {
+                    channel: row.channel,
+                    chatId: row.chat_id,
+                    chatType: row.chat_type,
+                    updatedAt: new Date(row.updated_at),
+                };
+            },
+            getLatestSessionForChat(platform, chatId) {
+                return parseSession(getOne('SELECT id, key, user_id, channel, chat_id, chat_type, context, title, created_at, updated_at FROM sessions WHERE channel = ? AND chat_id = ? ORDER BY updated_at DESC LIMIT 1', [platform, chatId]));
+            },
+            createSession(session) {
+                run('INSERT INTO sessions (id, key, user_id, channel, chat_id, chat_type, context, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [
+                    session.id,
+                    session.key,
+                    session.userId,
+                    session.channel,
+                    session.chatId,
+                    session.chatType,
+                    JSON.stringify(session.context),
+                    session.title || null,
+                    session.createdAt.getTime(),
+                    session.updatedAt.getTime(),
+                ]);
+            },
+            updateSession(session) {
+                run('UPDATE sessions SET context = ?, title = ?, updated_at = ? WHERE key = ?', [
+                    JSON.stringify(session.context),
+                    session.title || null,
+                    session.updatedAt.getTime(),
+                    session.key,
+                ]);
+            },
+            deleteSession(key) {
+                run('DELETE FROM sessions WHERE key = ?', [key]);
+            },
+            deleteSessionsBefore(cutoffMs) {
+                const rows = getAll('SELECT key FROM sessions WHERE updated_at < ?', [cutoffMs]);
+                if (rows.length === 0)
+                    return 0;
+                run('DELETE FROM sessions WHERE updated_at < ?', [cutoffMs]);
+                return rows.length;
+            },
+            getSessionById(id) {
+                return parseSession(getOne('SELECT id, key, user_id, channel, chat_id, chat_type, context, title, created_at, updated_at FROM sessions WHERE id = ?', [id]));
+            },
+            listWebchatSessions(userId) {
+                const rows = getAll('SELECT id, title, context, updated_at FROM sessions WHERE channel = ? AND user_id = ? ORDER BY updated_at DESC LIMIT 200', ['webchat', userId]);
+                return rows.map(row => {
+                    let messageCount = 0;
+                    let lastMessage;
+                    try {
+                        const ctx = JSON.parse(row.context || '{}');
+                        const history = ctx.conversationHistory || [];
+                        messageCount = history.length;
+                        if (history.length > 0) {
+                            const last = history[history.length - 1];
+                            lastMessage = typeof last.content === 'string' ? last.content.slice(0, 100) : undefined;
+                        }
+                    }
+                    catch { /* ignore */ }
+                    return {
+                        id: row.id,
+                        title: row.title || undefined,
+                        updatedAt: row.updated_at,
+                        messageCount,
+                        lastMessage,
+                    };
+                });
+            },
+            updateSessionTitle(key, title) {
+                run('UPDATE sessions SET title = ?, updated_at = ? WHERE key = ?', [title, Date.now(), key]);
+            },
+            // Cron jobs
+            listCronJobs() {
+                return getAll('SELECT id, data, enabled, created_at, updated_at FROM cron_jobs ORDER BY created_at ASC').map((row) => ({
+                    id: row.id,
+                    data: row.data,
+                    enabled: Boolean(row.enabled),
+                    createdAtMs: row.created_at,
+                    updatedAtMs: row.updated_at,
+                }));
+            },
+            getCronJob(id) {
+                const row = getOne('SELECT id, data, enabled, created_at, updated_at FROM cron_jobs WHERE id = ?', [id]);
+                if (!row)
+                    return undefined;
+                return {
+                    id: row.id,
+                    data: row.data,
+                    enabled: Boolean(row.enabled),
+                    createdAtMs: row.created_at,
+                    updatedAtMs: row.updated_at,
+                };
+            },
+            upsertCronJob(record) {
+                const existing = record.createdAtMs ? null : this.getCronJob(record.id);
+                const createdAtMs = record.createdAtMs ?? existing?.createdAtMs ?? Date.now();
+                const updatedAtMs = record.updatedAtMs ?? Date.now();
+                run(`INSERT INTO cron_jobs (id, data, enabled, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           data = excluded.data,
+           enabled = excluded.enabled,
+           updated_at = excluded.updated_at`, [record.id, record.data, record.enabled ? 1 : 0, createdAtMs, updatedAtMs]);
+            },
+            deleteCronJob(id) {
+                run('DELETE FROM cron_jobs WHERE id = ?', [id]);
+            },
+            // Alerts
+            getAlerts(userId) {
+                return getAll('SELECT id, user_id, type, name, market_id, platform, channel, chat_id, condition, enabled, triggered, trigger_count, created_at, last_triggered_at FROM alerts WHERE user_id = ?', [userId]).map(parseAlert);
+            },
+            getActiveAlerts() {
+                return getAll('SELECT id, user_id, type, name, market_id, platform, channel, chat_id, condition, enabled, triggered, trigger_count, created_at, last_triggered_at FROM alerts WHERE enabled = 1 AND triggered = 0').map(parseAlert);
+            },
+            createAlert(alert) {
+                run('INSERT INTO alerts (id, user_id, type, name, market_id, platform, channel, chat_id, condition, enabled, triggered, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [
+                    alert.id,
+                    alert.userId,
+                    alert.type,
+                    alert.name || null,
+                    alert.marketId || null,
+                    alert.platform || null,
+                    alert.channel || null,
+                    alert.chatId || null,
+                    JSON.stringify(alert.condition),
+                    alert.enabled ? 1 : 0,
+                    alert.triggered ? 1 : 0,
+                    alert.createdAt.getTime(),
+                ]);
+            },
+            updateAlert(alert) {
+                run('UPDATE alerts SET name = ?, condition = ?, enabled = ?, channel = ?, chat_id = ? WHERE id = ?', [
+                    alert.name || null,
+                    JSON.stringify(alert.condition),
+                    alert.enabled ? 1 : 0,
+                    alert.channel || null,
+                    alert.chatId || null,
+                    alert.id,
+                ]);
+            },
+            deleteAlert(alertId) {
+                run('DELETE FROM alerts WHERE id = ?', [alertId]);
+            },
+            triggerAlert(alertId) {
+                run('UPDATE alerts SET triggered = 1, trigger_count = trigger_count + 1, last_triggered_at = ? WHERE id = ?', [
+                    Date.now(),
+                    alertId,
+                ]);
+            },
+            // Positions
+            getPositions(userId) {
+                return getAll('SELECT id, user_id, platform, market_id, market_question, outcome, outcome_id, side, shares, avg_price, current_price, opened_at, updated_at FROM positions WHERE user_id = ?', [userId]).map(parsePosition);
+            },
+            listPositionsForPricing() {
+                return getAll('SELECT id, user_id, platform, market_id, outcome_id, outcome FROM positions').map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    platform: row.platform,
+                    marketId: row.market_id,
+                    outcomeId: row.outcome_id,
+                    outcome: row.outcome,
+                }));
+            },
+            updatePositionPrice(positionId, currentPrice) {
+                run('UPDATE positions SET current_price = ?, updated_at = ? WHERE id = ?', [currentPrice, Date.now(), positionId]);
+            },
+            upsertPosition(userId, position) {
+                run(`INSERT INTO positions (id, user_id, platform, market_id, market_question, outcome, outcome_id, side, shares, avg_price, current_price, opened_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(user_id, platform, market_id, outcome_id) DO UPDATE SET
+           shares = excluded.shares,
+           avg_price = excluded.avg_price,
+           current_price = excluded.current_price,
+           updated_at = excluded.updated_at`, [
+                    position.id,
+                    userId,
+                    position.platform,
+                    position.marketId,
+                    position.marketQuestion,
+                    position.outcome,
+                    position.outcomeId,
+                    position.side,
+                    position.shares,
+                    position.avgPrice,
+                    position.currentPrice,
+                    position.openedAt.getTime(),
+                    Date.now(),
+                ]);
+            },
+            deletePosition(positionId) {
+                run('DELETE FROM positions WHERE id = ?', [positionId]);
+            },
+            // Portfolio snapshots
+            createPortfolioSnapshot(snapshot) {
+                const createdAt = snapshot.createdAt?.getTime() ?? Date.now();
+                run(`INSERT INTO portfolio_snapshots (user_id, total_value, total_pnl, total_pnl_pct, total_cost_basis, positions_count, by_platform, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    snapshot.userId,
+                    snapshot.totalValue,
+                    snapshot.totalPnl,
+                    snapshot.totalPnlPct,
+                    snapshot.totalCostBasis,
+                    snapshot.positionsCount,
+                    snapshot.byPlatform ? JSON.stringify(snapshot.byPlatform) : null,
+                    createdAt,
+                ]);
+            },
+            getPortfolioSnapshots(userId, options = {}) {
+                const sinceMs = options.sinceMs ?? 0;
+                const limit = options.limit ?? 200;
+                const order = options.order === 'asc' ? 'ASC' : 'DESC';
+                const rows = getAll(`SELECT user_id, total_value, total_pnl, total_pnl_pct, total_cost_basis, positions_count, by_platform, created_at
+         FROM portfolio_snapshots
+         WHERE user_id = ? AND created_at >= ?
+         ORDER BY created_at ${order}
+         LIMIT ?`, [userId, sinceMs, limit]);
+                return rows.map(parsePortfolioSnapshot);
+            },
+            deletePortfolioSnapshotsBefore(cutoffMs) {
+                run('DELETE FROM portfolio_snapshots WHERE created_at < ?', [cutoffMs]);
+            },
+            // Stop-loss triggers
+            getStopLossTrigger(userId, platform, outcomeId) {
+                const row = getOne('SELECT user_id, platform, outcome_id, market_id, status, triggered_at, last_price, last_error, cooldown_until FROM stop_loss_triggers WHERE user_id = ? AND platform = ? AND outcome_id = ?', [userId, platform, outcomeId]);
+                if (!row)
+                    return undefined;
+                return {
+                    userId: row.user_id,
+                    platform: row.platform,
+                    outcomeId: row.outcome_id,
+                    marketId: row.market_id,
+                    status: row.status,
+                    triggeredAt: new Date(row.triggered_at),
+                    lastPrice: row.last_price ?? undefined,
+                    lastError: row.last_error ?? undefined,
+                    cooldownUntil: row.cooldown_until ? new Date(row.cooldown_until) : undefined,
+                };
+            },
+            upsertStopLossTrigger(record) {
+                run(`
+        INSERT INTO stop_loss_triggers (user_id, platform, outcome_id, market_id, status, triggered_at, last_price, last_error, cooldown_until)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(user_id, platform, outcome_id) DO UPDATE SET
+          market_id = excluded.market_id,
+          status = excluded.status,
+          triggered_at = excluded.triggered_at,
+          last_price = excluded.last_price,
+          last_error = excluded.last_error,
+          cooldown_until = excluded.cooldown_until
+        `, [
+                    record.userId,
+                    record.platform,
+                    record.outcomeId,
+                    record.marketId ?? null,
+                    record.status,
+                    record.triggeredAt.getTime(),
+                    record.lastPrice ?? null,
+                    record.lastError ?? null,
+                    record.cooldownUntil ? record.cooldownUntil.getTime() : null,
+                ]);
+            },
+            deleteStopLossTrigger(userId, platform, outcomeId) {
+                run('DELETE FROM stop_loss_triggers WHERE user_id = ? AND platform = ? AND outcome_id = ?', [
+                    userId,
+                    platform,
+                    outcomeId,
+                ]);
+            },
+            // Markets cache
+            cacheMarket(market) {
+                run('INSERT OR REPLACE INTO markets (platform, market_id, data, updated_at) VALUES (?, ?, ?, ?)', [
+                    market.platform,
+                    market.id,
+                    JSON.stringify(market),
+                    Date.now(),
+                ]);
+            },
+            getCachedMarket(platform, marketId, maxAgeMs) {
+                const row = getOne('SELECT data, updated_at FROM markets WHERE platform = ? AND market_id = ?', [platform, marketId]);
+                if (!row)
+                    return undefined;
+                if (maxAgeMs && row.updated_at < Date.now() - maxAgeMs) {
+                    run('DELETE FROM markets WHERE platform = ? AND market_id = ?', [platform, marketId]);
+                    return undefined;
+                }
+                return JSON.parse(row.data);
+            },
+            pruneMarketCache(cutoffMs) {
+                const rows = getAll('SELECT COUNT(*) as count FROM markets WHERE updated_at < ?', [cutoffMs]);
+                const count = rows[0]?.count ?? 0;
+                if (count > 0) {
+                    run('DELETE FROM markets WHERE updated_at < ?', [cutoffMs]);
+                }
+                return count;
+            },
+            // Market index
+            upsertMarketIndex(entry) {
+                run(`INSERT OR REPLACE INTO market_index (
+          platform, market_id, slug, question, description, outcomes_json, tags_json,
+          status, url, end_date, resolved, volume_24h, liquidity, open_interest, predictions,
+          content_hash, updated_at, raw_json
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    entry.platform,
+                    entry.marketId,
+                    entry.slug || null,
+                    entry.question,
+                    entry.description || null,
+                    entry.outcomesJson || null,
+                    entry.tagsJson || null,
+                    entry.status || null,
+                    entry.url || null,
+                    entry.endDate ? entry.endDate.getTime() : null,
+                    entry.resolved ? 1 : 0,
+                    entry.volume24h ?? null,
+                    entry.liquidity ?? null,
+                    entry.openInterest ?? null,
+                    entry.predictions ?? null,
+                    entry.contentHash || null,
+                    entry.updatedAt.getTime(),
+                    entry.rawJson || null,
+                ]);
+            },
+            getMarketIndexHash(platform, marketId) {
+                const row = getOne('SELECT content_hash FROM market_index WHERE platform = ? AND market_id = ?', [platform, marketId]);
+                return row?.content_hash ?? null;
+            },
+            getMarketIndexEmbedding(platform, marketId) {
+                const row = getOne('SELECT content_hash, vector FROM market_index_embeddings WHERE platform = ? AND market_id = ?', [platform, marketId]);
+                if (!row)
+                    return null;
+                try {
+                    const vector = JSON.parse(row.vector);
+                    return { contentHash: row.content_hash, vector };
+                }
+                catch {
+                    return null;
+                }
+            },
+            upsertMarketIndexEmbedding(platform, marketId, contentHash, vector) {
+                run(`INSERT OR REPLACE INTO market_index_embeddings (
+          platform, market_id, content_hash, vector, updated_at
+        ) VALUES (?, ?, ?, ?, ?)`, [
+                    platform,
+                    marketId,
+                    contentHash,
+                    JSON.stringify(vector),
+                    Date.now(),
+                ]);
+            },
+            listMarketIndex(options = {}) {
+                const params = [];
+                const where = [];
+                if (options.platform) {
+                    where.push('platform = ?');
+                    params.push(options.platform);
+                }
+                if (options.textQuery) {
+                    where.push('(question LIKE ? OR description LIKE ? OR tags_json LIKE ?)');
+                    const like = `%${options.textQuery}%`;
+                    params.push(like, like, like);
+                }
+                let sql = 'SELECT * FROM market_index';
+                if (where.length > 0) {
+                    sql += ` WHERE ${where.join(' AND ')}`;
+                }
+                sql += ' ORDER BY updated_at DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    platform: row.platform,
+                    marketId: row.market_id,
+                    slug: row.slug ?? undefined,
+                    question: row.question,
+                    description: row.description ?? undefined,
+                    outcomesJson: row.outcomes_json ?? undefined,
+                    tagsJson: row.tags_json ?? undefined,
+                    status: row.status ?? undefined,
+                    url: row.url ?? undefined,
+                    endDate: row.end_date ? new Date(row.end_date) : undefined,
+                    resolved: Boolean(row.resolved),
+                    volume24h: row.volume_24h ?? undefined,
+                    liquidity: row.liquidity ?? undefined,
+                    openInterest: row.open_interest ?? undefined,
+                    predictions: row.predictions ?? undefined,
+                    contentHash: row.content_hash ?? undefined,
+                    updatedAt: new Date(row.updated_at),
+                    rawJson: row.raw_json ?? undefined,
+                }));
+            },
+            countMarketIndex(platform) {
+                if (platform) {
+                    const rows = getAll('SELECT COUNT(*) as count FROM market_index WHERE platform = ?', [platform]);
+                    return rows[0]?.count ?? 0;
+                }
+                const rows = getAll('SELECT COUNT(*) as count FROM market_index');
+                return rows[0]?.count ?? 0;
+            },
+            pruneMarketIndex(cutoffMs, platform) {
+                if (platform) {
+                    const rows = getAll('SELECT COUNT(*) as count FROM market_index WHERE platform = ? AND updated_at < ?', [platform, cutoffMs]);
+                    const count = rows[0]?.count ?? 0;
+                    if (count > 0) {
+                        run('DELETE FROM market_index WHERE platform = ? AND updated_at < ?', [platform, cutoffMs]);
+                        run('DELETE FROM market_index_embeddings WHERE platform = ? AND updated_at < ?', [platform, cutoffMs]);
+                    }
+                    return count;
+                }
+                const rows = getAll('SELECT COUNT(*) as count FROM market_index WHERE updated_at < ?', [cutoffMs]);
+                const count = rows[0]?.count ?? 0;
+                if (count > 0) {
+                    run('DELETE FROM market_index WHERE updated_at < ?', [cutoffMs]);
+                    run('DELETE FROM market_index_embeddings WHERE updated_at < ?', [cutoffMs]);
+                }
+                return count;
+            },
+            // Trading Credentials
+            getTradingCredentials(userId, platform) {
+                return parseTradingCredentials(getOne('SELECT user_id, platform, mode, encrypted_data, enabled, last_used_at, failed_attempts, cooldown_until, created_at, updated_at FROM trading_credentials WHERE user_id = ? AND platform = ?', [userId, platform]));
+            },
+            createTradingCredentials(creds) {
+                run('INSERT INTO trading_credentials (user_id, platform, mode, encrypted_data, enabled, last_used_at, failed_attempts, cooldown_until, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [
+                    creds.userId,
+                    creds.platform,
+                    creds.mode,
+                    creds.encryptedData,
+                    creds.enabled ? 1 : 0,
+                    creds.lastUsedAt?.getTime() || null,
+                    creds.failedAttempts,
+                    creds.cooldownUntil?.getTime() || null,
+                    creds.createdAt.getTime(),
+                    creds.updatedAt.getTime(),
+                ]);
+            },
+            updateTradingCredentials(creds) {
+                run('UPDATE trading_credentials SET encrypted_data = ?, enabled = ?, last_used_at = ?, failed_attempts = ?, cooldown_until = ?, updated_at = ? WHERE user_id = ? AND platform = ?', [
+                    creds.encryptedData,
+                    creds.enabled ? 1 : 0,
+                    creds.lastUsedAt?.getTime() || null,
+                    creds.failedAttempts,
+                    creds.cooldownUntil?.getTime() || null,
+                    creds.updatedAt.getTime(),
+                    creds.userId,
+                    creds.platform,
+                ]);
+            },
+            deleteTradingCredentials(userId, platform) {
+                run('DELETE FROM trading_credentials WHERE user_id = ? AND platform = ?', [userId, platform]);
+            },
+            listUserTradingPlatforms(userId) {
+                const rows = getAll('SELECT platform FROM trading_credentials WHERE user_id = ? AND enabled = 1', [userId]);
+                return rows.map((r) => r.platform);
+            },
+            // Hyperliquid trades
+            logHyperliquidTrade(trade) {
+                run(`INSERT INTO hyperliquid_trades (
+          user_id, trade_id, order_id, coin, side, direction, size, price,
+          fee, fee_token, closed_pnl, order_type, is_maker, leverage, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.userId,
+                    trade.tradeId || null,
+                    trade.orderId || null,
+                    trade.coin,
+                    trade.side,
+                    trade.direction || null,
+                    trade.size,
+                    trade.price,
+                    trade.fee || 0,
+                    trade.feeToken || 'USDC',
+                    trade.closedPnl || null,
+                    trade.orderType || null,
+                    trade.isMaker ? 1 : 0,
+                    trade.leverage || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getHyperliquidTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM hyperliquid_trades WHERE user_id = ?';
+                if (options.coin) {
+                    sql += ' AND coin = ?';
+                    params.push(options.coin);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    tradeId: row.trade_id,
+                    orderId: row.order_id,
+                    coin: row.coin,
+                    side: row.side,
+                    direction: row.direction,
+                    size: row.size,
+                    price: row.price,
+                    fee: row.fee,
+                    feeToken: row.fee_token,
+                    closedPnl: row.closed_pnl,
+                    orderType: row.order_type,
+                    isMaker: Boolean(row.is_maker),
+                    leverage: row.leverage,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            getHyperliquidStats(userId, options = {}) {
+                const params = [userId];
+                let whereClause = 'WHERE user_id = ?';
+                if (options.coin) {
+                    whereClause += ' AND coin = ?';
+                    params.push(options.coin);
+                }
+                if (options.since) {
+                    whereClause += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                // Get aggregate stats
+                const statsRow = getOne(`SELECT
+          COUNT(*) as total_trades,
+          COALESCE(SUM(size * price), 0) as total_volume,
+          COALESCE(SUM(fee), 0) as total_fees,
+          COALESCE(SUM(closed_pnl), 0) as total_pnl,
+          COALESCE(SUM(CASE WHEN closed_pnl > 0 THEN 1 ELSE 0 END), 0) as win_count,
+          COALESCE(SUM(CASE WHEN closed_pnl < 0 THEN 1 ELSE 0 END), 0) as loss_count,
+          COALESCE(AVG(CASE WHEN closed_pnl > 0 THEN closed_pnl END), 0) as avg_win,
+          COALESCE(AVG(CASE WHEN closed_pnl < 0 THEN closed_pnl END), 0) as avg_loss,
+          COALESCE(MAX(closed_pnl), 0) as largest_win,
+          COALESCE(MIN(closed_pnl), 0) as largest_loss
+        FROM hyperliquid_trades ${whereClause}`, params);
+                // Get stats by coin
+                const coinRows = getAll(`SELECT
+          coin,
+          COUNT(*) as trades,
+          COALESCE(SUM(size * price), 0) as volume,
+          COALESCE(SUM(closed_pnl), 0) as pnl,
+          COALESCE(SUM(fee), 0) as fees
+        FROM hyperliquid_trades ${whereClause}
+        GROUP BY coin`, params);
+                const byCoin = {};
+                for (const row of coinRows) {
+                    byCoin[row.coin] = {
+                        trades: row.trades,
+                        volume: row.volume,
+                        pnl: row.pnl,
+                        fees: row.fees,
+                    };
+                }
+                const totalWins = statsRow?.avg_win ? statsRow.avg_win * (statsRow?.win_count || 0) : 0;
+                const totalLosses = statsRow?.avg_loss ? Math.abs(statsRow.avg_loss) * (statsRow?.loss_count || 0) : 0;
+                const profitFactor = totalLosses > 0 ? totalWins / totalLosses : totalWins > 0 ? Infinity : 0;
+                return {
+                    totalTrades: statsRow?.total_trades || 0,
+                    totalVolume: statsRow?.total_volume || 0,
+                    totalFees: statsRow?.total_fees || 0,
+                    totalPnl: statsRow?.total_pnl || 0,
+                    winCount: statsRow?.win_count || 0,
+                    lossCount: statsRow?.loss_count || 0,
+                    winRate: statsRow?.total_trades ? ((statsRow?.win_count || 0) / statsRow.total_trades) * 100 : 0,
+                    avgWin: statsRow?.avg_win || 0,
+                    avgLoss: statsRow?.avg_loss || 0,
+                    largestWin: statsRow?.largest_win || 0,
+                    largestLoss: statsRow?.largest_loss || 0,
+                    profitFactor,
+                    byCoin,
+                };
+            },
+            // Hyperliquid positions
+            upsertHyperliquidPosition(userId, position) {
+                run(`INSERT INTO hyperliquid_positions (
+          user_id, coin, side, size, entry_price, mark_price, liquidation_price,
+          unrealized_pnl, realized_pnl, leverage, margin_used, opened_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(user_id, coin) WHERE closed_at IS NULL DO UPDATE SET
+          size = excluded.size,
+          entry_price = excluded.entry_price,
+          mark_price = excluded.mark_price,
+          liquidation_price = excluded.liquidation_price,
+          unrealized_pnl = excluded.unrealized_pnl,
+          realized_pnl = excluded.realized_pnl,
+          leverage = excluded.leverage,
+          margin_used = excluded.margin_used,
+          updated_at = excluded.updated_at`, [
+                    userId,
+                    position.coin,
+                    position.side,
+                    position.size,
+                    position.entryPrice,
+                    position.markPrice || null,
+                    position.liquidationPrice || null,
+                    position.unrealizedPnl || null,
+                    position.realizedPnl || 0,
+                    position.leverage || null,
+                    position.marginUsed || null,
+                    position.openedAt.getTime(),
+                    Date.now(),
+                    Date.now(),
+                ]);
+            },
+            getHyperliquidPositions(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM hyperliquid_positions WHERE user_id = ?';
+                if (options.coin) {
+                    sql += ' AND coin = ?';
+                    params.push(options.coin);
+                }
+                if (options.openOnly) {
+                    sql += ' AND closed_at IS NULL';
+                }
+                sql += ' ORDER BY opened_at DESC';
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    coin: row.coin,
+                    side: row.side,
+                    size: row.size,
+                    entryPrice: row.entry_price,
+                    markPrice: row.mark_price,
+                    liquidationPrice: row.liquidation_price,
+                    unrealizedPnl: row.unrealized_pnl,
+                    realizedPnl: row.realized_pnl,
+                    leverage: row.leverage,
+                    marginUsed: row.margin_used,
+                    openedAt: new Date(row.opened_at),
+                    closedAt: row.closed_at ? new Date(row.closed_at) : undefined,
+                    closePrice: row.close_price,
+                    closeReason: row.close_reason,
+                    createdAt: new Date(row.created_at),
+                    updatedAt: new Date(row.updated_at),
+                }));
+            },
+            closeHyperliquidPosition(userId, coin, closePrice, reason) {
+                run(`UPDATE hyperliquid_positions
+         SET closed_at = ?, close_price = ?, close_reason = ?, updated_at = ?
+         WHERE user_id = ? AND coin = ? AND closed_at IS NULL`, [Date.now(), closePrice, reason || 'manual', Date.now(), userId, coin]);
+            },
+            // Hyperliquid funding
+            logHyperliquidFunding(funding) {
+                run(`INSERT INTO hyperliquid_funding (
+          user_id, coin, funding_rate, payment, position_size, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+                    funding.userId,
+                    funding.coin,
+                    funding.fundingRate,
+                    funding.payment,
+                    funding.positionSize,
+                    funding.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getHyperliquidFunding(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM hyperliquid_funding WHERE user_id = ?';
+                if (options.coin) {
+                    sql += ' AND coin = ?';
+                    params.push(options.coin);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    coin: row.coin,
+                    fundingRate: row.funding_rate,
+                    payment: row.payment,
+                    positionSize: row.position_size,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            getHyperliquidFundingTotal(userId, options = {}) {
+                const params = [userId];
+                let whereClause = 'WHERE user_id = ?';
+                if (options.coin) {
+                    whereClause += ' AND coin = ?';
+                    params.push(options.coin);
+                }
+                if (options.since) {
+                    whereClause += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                const row = getOne(`SELECT COALESCE(SUM(payment), 0) as total FROM hyperliquid_funding ${whereClause}`, params);
+                return row?.total || 0;
+            },
+            // =========================================================================
+            // BINANCE FUTURES
+            // =========================================================================
+            logBinanceFuturesTrade(trade) {
+                run(`INSERT INTO binance_futures_trades (
+          user_id, trade_id, order_id, symbol, side, position_side, size, price,
+          commission, commission_asset, realized_pnl, order_type, is_maker, leverage, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.userId,
+                    trade.tradeId || null,
+                    trade.orderId || null,
+                    trade.symbol,
+                    trade.side,
+                    trade.positionSide || null,
+                    trade.size,
+                    trade.price,
+                    trade.commission || 0,
+                    trade.commissionAsset || 'USDT',
+                    trade.realizedPnl || null,
+                    trade.orderType || null,
+                    trade.isMaker ? 1 : 0,
+                    trade.leverage || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getBinanceFuturesTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM binance_futures_trades WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    tradeId: row.trade_id,
+                    orderId: row.order_id,
+                    symbol: row.symbol,
+                    side: row.side,
+                    positionSide: row.position_side,
+                    size: row.size,
+                    price: row.price,
+                    commission: row.commission,
+                    commissionAsset: row.commission_asset,
+                    realizedPnl: row.realized_pnl,
+                    orderType: row.order_type,
+                    isMaker: row.is_maker === 1,
+                    leverage: row.leverage,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                }));
+            },
+            getBinanceFuturesStats(userId, options = {}) {
+                const params = [userId];
+                let whereClause = 'WHERE user_id = ?';
+                if (options.symbol) {
+                    whereClause += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    whereClause += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                const statsRow = getOne(`SELECT
+          COUNT(*) as total_trades,
+          COALESCE(SUM(size * price), 0) as total_volume,
+          COALESCE(SUM(commission), 0) as total_fees,
+          COALESCE(SUM(realized_pnl), 0) as total_pnl,
+          COUNT(CASE WHEN realized_pnl > 0 THEN 1 END) as win_count,
+          COUNT(CASE WHEN realized_pnl < 0 THEN 1 END) as loss_count,
+          COALESCE(AVG(CASE WHEN realized_pnl > 0 THEN realized_pnl END), 0) as avg_win,
+          COALESCE(AVG(CASE WHEN realized_pnl < 0 THEN realized_pnl END), 0) as avg_loss,
+          COALESCE(MAX(realized_pnl), 0) as largest_win,
+          COALESCE(MIN(realized_pnl), 0) as largest_loss
+        FROM binance_futures_trades ${whereClause}`, params);
+                const bySymbolRows = getAll(`SELECT
+          symbol,
+          COUNT(*) as trades,
+          COALESCE(SUM(size * price), 0) as volume,
+          COALESCE(SUM(realized_pnl), 0) as pnl,
+          COALESCE(SUM(commission), 0) as fees
+        FROM binance_futures_trades ${whereClause}
+        GROUP BY symbol`, params);
+                const totalTrades = statsRow?.total_trades || 0;
+                const winCount = statsRow?.win_count || 0;
+                const lossCount = statsRow?.loss_count || 0;
+                const totalWins = statsRow?.avg_win ? statsRow.avg_win * winCount : 0;
+                const totalLosses = statsRow?.avg_loss ? Math.abs(statsRow.avg_loss) * lossCount : 0;
+                return {
+                    totalTrades,
+                    totalVolume: statsRow?.total_volume || 0,
+                    totalFees: statsRow?.total_fees || 0,
+                    totalPnl: statsRow?.total_pnl || 0,
+                    winCount,
+                    lossCount,
+                    winRate: totalTrades > 0 ? (winCount / totalTrades) * 100 : 0,
+                    avgWin: statsRow?.avg_win || 0,
+                    avgLoss: statsRow?.avg_loss || 0,
+                    largestWin: statsRow?.largest_win || 0,
+                    largestLoss: statsRow?.largest_loss || 0,
+                    profitFactor: totalLosses > 0 ? totalWins / totalLosses : totalWins > 0 ? Infinity : 0,
+                    bySymbol: Object.fromEntries(bySymbolRows.map((r) => [r.symbol, { trades: r.trades, volume: r.volume, pnl: r.pnl, fees: r.fees }])),
+                };
+            },
+            upsertBinanceFuturesPosition(userId, position) {
+                run(`INSERT INTO binance_futures_positions (
+          user_id, symbol, position_side, size, entry_price, mark_price, liquidation_price,
+          unrealized_pnl, realized_pnl, leverage, margin_type, isolated_margin, opened_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(user_id, symbol) WHERE closed_at IS NULL DO UPDATE SET
+          size = excluded.size,
+          entry_price = excluded.entry_price,
+          mark_price = excluded.mark_price,
+          liquidation_price = excluded.liquidation_price,
+          unrealized_pnl = excluded.unrealized_pnl,
+          realized_pnl = excluded.realized_pnl,
+          leverage = excluded.leverage,
+          margin_type = excluded.margin_type,
+          isolated_margin = excluded.isolated_margin,
+          updated_at = excluded.updated_at`, [
+                    userId,
+                    position.symbol,
+                    position.positionSide,
+                    position.size,
+                    position.entryPrice,
+                    position.markPrice || null,
+                    position.liquidationPrice || null,
+                    position.unrealizedPnl || null,
+                    position.realizedPnl || 0,
+                    position.leverage || null,
+                    position.marginType || null,
+                    position.isolatedMargin || null,
+                    position.openedAt.getTime(),
+                    Date.now(),
+                    Date.now(),
+                ]);
+            },
+            getBinanceFuturesPositions(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM binance_futures_positions WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.openOnly) {
+                    sql += ' AND closed_at IS NULL';
+                }
+                sql += ' ORDER BY opened_at DESC';
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    symbol: row.symbol,
+                    positionSide: row.position_side,
+                    size: row.size,
+                    entryPrice: row.entry_price,
+                    markPrice: row.mark_price,
+                    liquidationPrice: row.liquidation_price,
+                    unrealizedPnl: row.unrealized_pnl,
+                    realizedPnl: row.realized_pnl,
+                    leverage: row.leverage,
+                    marginType: row.margin_type,
+                    isolatedMargin: row.isolated_margin,
+                    openedAt: new Date(row.opened_at),
+                    closedAt: row.closed_at ? new Date(row.closed_at) : undefined,
+                    closePrice: row.close_price,
+                    closeReason: row.close_reason,
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                    updatedAt: row.updated_at ? new Date(row.updated_at) : undefined,
+                }));
+            },
+            closeBinanceFuturesPosition(userId, symbol, closePrice, reason) {
+                run(`UPDATE binance_futures_positions
+         SET closed_at = ?, close_price = ?, close_reason = ?, updated_at = ?
+         WHERE user_id = ? AND symbol = ? AND closed_at IS NULL`, [Date.now(), closePrice, reason || 'manual', Date.now(), userId, symbol]);
+            },
+            logBinanceFuturesFunding(funding) {
+                run(`INSERT INTO binance_futures_funding (
+          user_id, symbol, funding_rate, payment, position_size, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+                    funding.userId,
+                    funding.symbol,
+                    funding.fundingRate,
+                    funding.payment,
+                    funding.positionSize,
+                    funding.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getBinanceFuturesFunding(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM binance_futures_funding WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    symbol: row.symbol,
+                    fundingRate: row.funding_rate,
+                    payment: row.payment,
+                    positionSize: row.position_size,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                }));
+            },
+            getBinanceFuturesFundingTotal(userId, options = {}) {
+                const params = [userId];
+                let whereClause = 'WHERE user_id = ?';
+                if (options.symbol) {
+                    whereClause += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    whereClause += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                const row = getOne(`SELECT COALESCE(SUM(payment), 0) as total FROM binance_futures_funding ${whereClause}`, params);
+                return row?.total || 0;
+            },
+            // =========================================================================
+            // BYBIT FUTURES
+            // =========================================================================
+            logBybitFuturesTrade(trade) {
+                run(`INSERT INTO bybit_futures_trades (
+          user_id, trade_id, order_id, symbol, side, position_side, size, price,
+          commission, commission_asset, closed_pnl, order_type, is_maker, leverage, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.userId,
+                    trade.tradeId || null,
+                    trade.orderId || null,
+                    trade.symbol,
+                    trade.side,
+                    trade.positionSide || null,
+                    trade.size,
+                    trade.price,
+                    trade.commission || 0,
+                    trade.commissionAsset || 'USDT',
+                    trade.closedPnl || null,
+                    trade.orderType || null,
+                    trade.isMaker ? 1 : 0,
+                    trade.leverage || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getBybitFuturesTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM bybit_futures_trades WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    tradeId: row.trade_id,
+                    orderId: row.order_id,
+                    symbol: row.symbol,
+                    side: row.side,
+                    positionSide: row.position_side,
+                    size: row.size,
+                    price: row.price,
+                    commission: row.commission,
+                    commissionAsset: row.commission_asset,
+                    closedPnl: row.closed_pnl,
+                    orderType: row.order_type,
+                    isMaker: row.is_maker === 1,
+                    leverage: row.leverage,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                }));
+            },
+            getBybitFuturesStats(userId, options = {}) {
+                const params = [userId];
+                let whereClause = 'WHERE user_id = ?';
+                if (options.symbol) {
+                    whereClause += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    whereClause += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                const statsRow = getOne(`SELECT
+          COUNT(*) as total_trades,
+          COALESCE(SUM(size * price), 0) as total_volume,
+          COALESCE(SUM(commission), 0) as total_fees,
+          COALESCE(SUM(closed_pnl), 0) as total_pnl,
+          COUNT(CASE WHEN closed_pnl > 0 THEN 1 END) as win_count,
+          COUNT(CASE WHEN closed_pnl < 0 THEN 1 END) as loss_count,
+          COALESCE(AVG(CASE WHEN closed_pnl > 0 THEN closed_pnl END), 0) as avg_win,
+          COALESCE(AVG(CASE WHEN closed_pnl < 0 THEN closed_pnl END), 0) as avg_loss,
+          COALESCE(MAX(closed_pnl), 0) as largest_win,
+          COALESCE(MIN(closed_pnl), 0) as largest_loss
+        FROM bybit_futures_trades ${whereClause}`, params);
+                const bySymbolRows = getAll(`SELECT
+          symbol,
+          COUNT(*) as trades,
+          COALESCE(SUM(size * price), 0) as volume,
+          COALESCE(SUM(closed_pnl), 0) as pnl,
+          COALESCE(SUM(commission), 0) as fees
+        FROM bybit_futures_trades ${whereClause}
+        GROUP BY symbol`, params);
+                const totalTrades = statsRow?.total_trades || 0;
+                const winCount = statsRow?.win_count || 0;
+                const lossCount = statsRow?.loss_count || 0;
+                const totalWins = statsRow?.avg_win ? statsRow.avg_win * winCount : 0;
+                const totalLosses = statsRow?.avg_loss ? Math.abs(statsRow.avg_loss) * lossCount : 0;
+                return {
+                    totalTrades,
+                    totalVolume: statsRow?.total_volume || 0,
+                    totalFees: statsRow?.total_fees || 0,
+                    totalPnl: statsRow?.total_pnl || 0,
+                    winCount,
+                    lossCount,
+                    winRate: totalTrades > 0 ? (winCount / totalTrades) * 100 : 0,
+                    avgWin: statsRow?.avg_win || 0,
+                    avgLoss: statsRow?.avg_loss || 0,
+                    largestWin: statsRow?.largest_win || 0,
+                    largestLoss: statsRow?.largest_loss || 0,
+                    profitFactor: totalLosses > 0 ? totalWins / totalLosses : totalWins > 0 ? Infinity : 0,
+                    bySymbol: Object.fromEntries(bySymbolRows.map((r) => [r.symbol, { trades: r.trades, volume: r.volume, pnl: r.pnl, fees: r.fees }])),
+                };
+            },
+            upsertBybitFuturesPosition(userId, position) {
+                run(`INSERT INTO bybit_futures_positions (
+          user_id, symbol, side, size, entry_price, mark_price, liquidation_price,
+          unrealized_pnl, cum_realised_pnl, leverage, trade_mode, position_margin, opened_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(user_id, symbol) WHERE closed_at IS NULL DO UPDATE SET
+          size = excluded.size,
+          entry_price = excluded.entry_price,
+          mark_price = excluded.mark_price,
+          liquidation_price = excluded.liquidation_price,
+          unrealized_pnl = excluded.unrealized_pnl,
+          cum_realised_pnl = excluded.cum_realised_pnl,
+          leverage = excluded.leverage,
+          trade_mode = excluded.trade_mode,
+          position_margin = excluded.position_margin,
+          updated_at = excluded.updated_at`, [
+                    userId,
+                    position.symbol,
+                    position.side,
+                    position.size,
+                    position.entryPrice,
+                    position.markPrice || null,
+                    position.liquidationPrice || null,
+                    position.unrealizedPnl || null,
+                    position.cumRealisedPnl || 0,
+                    position.leverage || null,
+                    position.tradeMode || null,
+                    position.positionMargin || null,
+                    position.openedAt.getTime(),
+                    Date.now(),
+                    Date.now(),
+                ]);
+            },
+            getBybitFuturesPositions(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM bybit_futures_positions WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.openOnly) {
+                    sql += ' AND closed_at IS NULL';
+                }
+                sql += ' ORDER BY opened_at DESC';
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    symbol: row.symbol,
+                    side: row.side,
+                    size: row.size,
+                    entryPrice: row.entry_price,
+                    markPrice: row.mark_price,
+                    liquidationPrice: row.liquidation_price,
+                    unrealizedPnl: row.unrealized_pnl,
+                    cumRealisedPnl: row.cum_realised_pnl,
+                    leverage: row.leverage,
+                    tradeMode: row.trade_mode,
+                    positionMargin: row.position_margin,
+                    openedAt: new Date(row.opened_at),
+                    closedAt: row.closed_at ? new Date(row.closed_at) : undefined,
+                    closePrice: row.close_price,
+                    closeReason: row.close_reason,
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                    updatedAt: row.updated_at ? new Date(row.updated_at) : undefined,
+                }));
+            },
+            closeBybitFuturesPosition(userId, symbol, closePrice, reason) {
+                run(`UPDATE bybit_futures_positions
+         SET closed_at = ?, close_price = ?, close_reason = ?, updated_at = ?
+         WHERE user_id = ? AND symbol = ? AND closed_at IS NULL`, [Date.now(), closePrice, reason || 'manual', Date.now(), userId, symbol]);
+            },
+            logBybitFuturesFunding(funding) {
+                run(`INSERT INTO bybit_futures_funding (
+          user_id, symbol, funding_rate, payment, position_size, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+                    funding.userId,
+                    funding.symbol,
+                    funding.fundingRate,
+                    funding.payment,
+                    funding.positionSize,
+                    funding.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getBybitFuturesFunding(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM bybit_futures_funding WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    symbol: row.symbol,
+                    fundingRate: row.funding_rate,
+                    payment: row.payment,
+                    positionSize: row.position_size,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                }));
+            },
+            getBybitFuturesFundingTotal(userId, options = {}) {
+                const params = [userId];
+                let whereClause = 'WHERE user_id = ?';
+                if (options.symbol) {
+                    whereClause += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    whereClause += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                const row = getOne(`SELECT COALESCE(SUM(payment), 0) as total FROM bybit_futures_funding ${whereClause}`, params);
+                return row?.total || 0;
+            },
+            // =========================================================================
+            // MEXC FUTURES
+            // =========================================================================
+            logMexcFuturesTrade(trade) {
+                run(`INSERT INTO mexc_futures_trades (
+          user_id, trade_id, order_id, symbol, side, vol, price,
+          fee, fee_asset, realized_pnl, order_type, is_maker, leverage, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.userId,
+                    trade.tradeId || null,
+                    trade.orderId || null,
+                    trade.symbol,
+                    trade.side,
+                    trade.vol,
+                    trade.price,
+                    trade.fee || 0,
+                    trade.feeAsset || 'USDT',
+                    trade.realizedPnl || null,
+                    trade.orderType || null,
+                    trade.isMaker ? 1 : 0,
+                    trade.leverage || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getMexcFuturesTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM mexc_futures_trades WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    tradeId: row.trade_id,
+                    orderId: row.order_id,
+                    symbol: row.symbol,
+                    side: row.side,
+                    vol: row.vol,
+                    price: row.price,
+                    fee: row.fee,
+                    feeAsset: row.fee_asset,
+                    realizedPnl: row.realized_pnl,
+                    orderType: row.order_type,
+                    isMaker: row.is_maker === 1,
+                    leverage: row.leverage,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                }));
+            },
+            getMexcFuturesStats(userId, options = {}) {
+                const params = [userId];
+                let whereClause = 'WHERE user_id = ?';
+                if (options.symbol) {
+                    whereClause += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    whereClause += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                const statsRow = getOne(`SELECT
+          COUNT(*) as total_trades,
+          COALESCE(SUM(vol * price), 0) as total_volume,
+          COALESCE(SUM(fee), 0) as total_fees,
+          COALESCE(SUM(realized_pnl), 0) as total_pnl,
+          COUNT(CASE WHEN realized_pnl > 0 THEN 1 END) as win_count,
+          COUNT(CASE WHEN realized_pnl < 0 THEN 1 END) as loss_count,
+          COALESCE(AVG(CASE WHEN realized_pnl > 0 THEN realized_pnl END), 0) as avg_win,
+          COALESCE(AVG(CASE WHEN realized_pnl < 0 THEN realized_pnl END), 0) as avg_loss,
+          COALESCE(MAX(realized_pnl), 0) as largest_win,
+          COALESCE(MIN(realized_pnl), 0) as largest_loss
+        FROM mexc_futures_trades ${whereClause}`, params);
+                const bySymbolRows = getAll(`SELECT
+          symbol,
+          COUNT(*) as trades,
+          COALESCE(SUM(vol * price), 0) as volume,
+          COALESCE(SUM(realized_pnl), 0) as pnl,
+          COALESCE(SUM(fee), 0) as fees
+        FROM mexc_futures_trades ${whereClause}
+        GROUP BY symbol`, params);
+                const totalTrades = statsRow?.total_trades || 0;
+                const winCount = statsRow?.win_count || 0;
+                const lossCount = statsRow?.loss_count || 0;
+                const totalWins = statsRow?.avg_win ? statsRow.avg_win * winCount : 0;
+                const totalLosses = statsRow?.avg_loss ? Math.abs(statsRow.avg_loss) * lossCount : 0;
+                return {
+                    totalTrades,
+                    totalVolume: statsRow?.total_volume || 0,
+                    totalFees: statsRow?.total_fees || 0,
+                    totalPnl: statsRow?.total_pnl || 0,
+                    winCount,
+                    lossCount,
+                    winRate: totalTrades > 0 ? (winCount / totalTrades) * 100 : 0,
+                    avgWin: statsRow?.avg_win || 0,
+                    avgLoss: statsRow?.avg_loss || 0,
+                    largestWin: statsRow?.largest_win || 0,
+                    largestLoss: statsRow?.largest_loss || 0,
+                    profitFactor: totalLosses > 0 ? totalWins / totalLosses : totalWins > 0 ? Infinity : 0,
+                    bySymbol: Object.fromEntries(bySymbolRows.map((r) => [r.symbol, { trades: r.trades, volume: r.volume, pnl: r.pnl, fees: r.fees }])),
+                };
+            },
+            upsertMexcFuturesPosition(userId, position) {
+                run(`INSERT INTO mexc_futures_positions (
+          user_id, symbol, position_type, hold_vol, open_avg_price, mark_price, liquidation_price,
+          unrealized_pnl, realized_pnl, leverage, margin_mode, position_margin, opened_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(user_id, symbol) WHERE closed_at IS NULL DO UPDATE SET
+          hold_vol = excluded.hold_vol,
+          open_avg_price = excluded.open_avg_price,
+          mark_price = excluded.mark_price,
+          liquidation_price = excluded.liquidation_price,
+          unrealized_pnl = excluded.unrealized_pnl,
+          realized_pnl = excluded.realized_pnl,
+          leverage = excluded.leverage,
+          margin_mode = excluded.margin_mode,
+          position_margin = excluded.position_margin,
+          updated_at = excluded.updated_at`, [
+                    userId,
+                    position.symbol,
+                    position.positionType,
+                    position.holdVol,
+                    position.openAvgPrice,
+                    position.markPrice || null,
+                    position.liquidationPrice || null,
+                    position.unrealizedPnl || null,
+                    position.realizedPnl || 0,
+                    position.leverage || null,
+                    position.marginMode || null,
+                    position.positionMargin || null,
+                    position.openedAt.getTime(),
+                    Date.now(),
+                    Date.now(),
+                ]);
+            },
+            getMexcFuturesPositions(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM mexc_futures_positions WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.openOnly) {
+                    sql += ' AND closed_at IS NULL';
+                }
+                sql += ' ORDER BY opened_at DESC';
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    symbol: row.symbol,
+                    positionType: row.position_type,
+                    holdVol: row.hold_vol,
+                    openAvgPrice: row.open_avg_price,
+                    markPrice: row.mark_price,
+                    liquidationPrice: row.liquidation_price,
+                    unrealizedPnl: row.unrealized_pnl,
+                    realizedPnl: row.realized_pnl,
+                    leverage: row.leverage,
+                    marginMode: row.margin_mode,
+                    positionMargin: row.position_margin,
+                    openedAt: new Date(row.opened_at),
+                    closedAt: row.closed_at ? new Date(row.closed_at) : undefined,
+                    closePrice: row.close_price,
+                    closeReason: row.close_reason,
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                    updatedAt: row.updated_at ? new Date(row.updated_at) : undefined,
+                }));
+            },
+            closeMexcFuturesPosition(userId, symbol, closePrice, reason) {
+                run(`UPDATE mexc_futures_positions
+         SET closed_at = ?, close_price = ?, close_reason = ?, updated_at = ?
+         WHERE user_id = ? AND symbol = ? AND closed_at IS NULL`, [Date.now(), closePrice, reason || 'manual', Date.now(), userId, symbol]);
+            },
+            logMexcFuturesFunding(funding) {
+                run(`INSERT INTO mexc_futures_funding (
+          user_id, symbol, funding_rate, payment, position_size, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+                    funding.userId,
+                    funding.symbol,
+                    funding.fundingRate,
+                    funding.payment,
+                    funding.positionSize,
+                    funding.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getMexcFuturesFunding(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM mexc_futures_funding WHERE user_id = ?';
+                if (options.symbol) {
+                    sql += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    userId: row.user_id,
+                    symbol: row.symbol,
+                    fundingRate: row.funding_rate,
+                    payment: row.payment,
+                    positionSize: row.position_size,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: row.created_at ? new Date(row.created_at) : undefined,
+                }));
+            },
+            getMexcFuturesFundingTotal(userId, options = {}) {
+                const params = [userId];
+                let whereClause = 'WHERE user_id = ?';
+                if (options.symbol) {
+                    whereClause += ' AND symbol = ?';
+                    params.push(options.symbol);
+                }
+                if (options.since) {
+                    whereClause += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                const row = getOne(`SELECT COALESCE(SUM(payment), 0) as total FROM mexc_futures_funding ${whereClause}`, params);
+                return row?.total || 0;
+            },
+            // Opinion.trade trades
+            logOpinionTrade(trade) {
+                run(`INSERT INTO opinion_trades (
+          user_id, order_id, market_id, token_id, side, price, size, order_type,
+          status, filled_size, avg_fill_price, fee, tx_hash, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.oddsUserId,
+                    trade.orderId,
+                    trade.marketId,
+                    trade.tokenId,
+                    trade.side,
+                    trade.price,
+                    trade.size,
+                    trade.orderType,
+                    trade.status || 'open',
+                    trade.filledSize || 0,
+                    trade.avgFillPrice || trade.price,
+                    trade.fee || 0,
+                    trade.txHash || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getOpinionTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM opinion_trades WHERE user_id = ?';
+                if (options.marketId) {
+                    sql += ' AND market_id = ?';
+                    params.push(options.marketId);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    oddsUserId: row.user_id,
+                    orderId: row.order_id,
+                    marketId: row.market_id,
+                    tokenId: row.token_id,
+                    side: row.side,
+                    price: row.price,
+                    size: row.size,
+                    orderType: row.order_type,
+                    status: row.status,
+                    filledSize: row.filled_size,
+                    avgFillPrice: row.avg_fill_price,
+                    fee: row.fee,
+                    txHash: row.tx_hash,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            // Predict.fun trades
+            logPredictFunTrade(trade) {
+                run(`INSERT INTO predictfun_trades (
+          user_id, order_hash, market_id, token_id, side, price, quantity,
+          status, filled_quantity, avg_fill_price, fee, tx_hash,
+          is_neg_risk, is_yield_bearing, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.oddsUserId,
+                    trade.orderHash,
+                    trade.marketId,
+                    trade.tokenId,
+                    trade.side,
+                    trade.price,
+                    trade.quantity,
+                    trade.status || 'open',
+                    trade.filledQuantity || 0,
+                    trade.avgFillPrice || trade.price,
+                    trade.fee || 0,
+                    trade.txHash || null,
+                    trade.isNegRisk ? 1 : 0,
+                    trade.isYieldBearing !== false ? 1 : 0,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getPredictFunTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM predictfun_trades WHERE user_id = ?';
+                if (options.marketId) {
+                    sql += ' AND market_id = ?';
+                    params.push(options.marketId);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    oddsUserId: row.user_id,
+                    orderHash: row.order_hash,
+                    marketId: row.market_id,
+                    tokenId: row.token_id,
+                    side: row.side,
+                    price: row.price,
+                    quantity: row.quantity,
+                    status: row.status,
+                    filledQuantity: row.filled_quantity,
+                    avgFillPrice: row.avg_fill_price,
+                    fee: row.fee,
+                    txHash: row.tx_hash,
+                    isNegRisk: row.is_neg_risk === 1,
+                    isYieldBearing: row.is_yield_bearing === 1,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            // Polymarket trades
+            logPolymarketTrade(trade) {
+                run(`INSERT INTO polymarket_trades (
+          user_id, order_id, market_id, token_id, condition_id, side, price, size, order_type,
+          status, filled_size, avg_fill_price, fee, tx_hash, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.oddsUserId,
+                    trade.orderId,
+                    trade.marketId,
+                    trade.tokenId,
+                    trade.conditionId || null,
+                    trade.side,
+                    trade.price,
+                    trade.size,
+                    trade.orderType,
+                    trade.status || 'open',
+                    trade.filledSize || 0,
+                    trade.avgFillPrice || trade.price,
+                    trade.fee || 0,
+                    trade.txHash || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getPolymarketTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM polymarket_trades WHERE user_id = ?';
+                if (options.marketId) {
+                    sql += ' AND market_id = ?';
+                    params.push(options.marketId);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    oddsUserId: row.user_id,
+                    orderId: row.order_id,
+                    marketId: row.market_id,
+                    tokenId: row.token_id,
+                    conditionId: row.condition_id,
+                    side: row.side,
+                    price: row.price,
+                    size: row.size,
+                    orderType: row.order_type,
+                    status: row.status,
+                    filledSize: row.filled_size,
+                    avgFillPrice: row.avg_fill_price,
+                    fee: row.fee,
+                    txHash: row.tx_hash,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            // Kalshi trades
+            logKalshiTrade(trade) {
+                run(`INSERT INTO kalshi_trades (
+          user_id, order_id, market_id, ticker, side, price, count, order_type,
+          status, filled_count, avg_fill_price, fee, action, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.oddsUserId,
+                    trade.orderId,
+                    trade.marketId,
+                    trade.ticker,
+                    trade.side,
+                    trade.price,
+                    trade.count,
+                    trade.orderType,
+                    trade.status || 'open',
+                    trade.filledCount || 0,
+                    trade.avgFillPrice || trade.price,
+                    trade.fee || 0,
+                    trade.action || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getKalshiTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM kalshi_trades WHERE user_id = ?';
+                if (options.marketId) {
+                    sql += ' AND market_id = ?';
+                    params.push(options.marketId);
+                }
+                if (options.ticker) {
+                    sql += ' AND ticker = ?';
+                    params.push(options.ticker);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    oddsUserId: row.user_id,
+                    orderId: row.order_id,
+                    marketId: row.market_id,
+                    ticker: row.ticker,
+                    side: row.side,
+                    price: row.price,
+                    count: row.count,
+                    orderType: row.order_type,
+                    status: row.status,
+                    filledCount: row.filled_count,
+                    avgFillPrice: row.avg_fill_price,
+                    fee: row.fee,
+                    action: row.action,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            // Drift trades
+            logDriftTrade(trade) {
+                run(`INSERT INTO drift_trades (
+          user_id, order_id, market_index, market_type, direction, base_amount, quote_amount,
+          price, order_type, status, filled_amount, avg_fill_price, leverage, tx_sig, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.oddsUserId,
+                    trade.orderId || null,
+                    trade.marketIndex,
+                    trade.marketType,
+                    trade.direction,
+                    trade.baseAmount,
+                    trade.quoteAmount || null,
+                    trade.price || null,
+                    trade.orderType,
+                    trade.status || 'open',
+                    trade.filledAmount || 0,
+                    trade.avgFillPrice || trade.price || null,
+                    trade.leverage || null,
+                    trade.txSig || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getDriftTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM drift_trades WHERE user_id = ?';
+                if (options.marketIndex !== undefined) {
+                    sql += ' AND market_index = ?';
+                    params.push(options.marketIndex);
+                }
+                if (options.marketType) {
+                    sql += ' AND market_type = ?';
+                    params.push(options.marketType);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    oddsUserId: row.user_id,
+                    orderId: row.order_id,
+                    marketIndex: row.market_index,
+                    marketType: row.market_type,
+                    direction: row.direction,
+                    baseAmount: row.base_amount,
+                    quoteAmount: row.quote_amount,
+                    price: row.price,
+                    orderType: row.order_type,
+                    status: row.status,
+                    filledAmount: row.filled_amount,
+                    avgFillPrice: row.avg_fill_price,
+                    leverage: row.leverage,
+                    txSig: row.tx_sig,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            // Manifold trades
+            logManifoldTrade(trade) {
+                run(`INSERT INTO manifold_trades (
+          user_id, bet_id, contract_id, outcome, amount, shares,
+          probability_before, probability_after, status, fee, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.oddsUserId,
+                    trade.betId,
+                    trade.contractId,
+                    trade.outcome,
+                    trade.amount,
+                    trade.shares,
+                    trade.probabilityBefore || null,
+                    trade.probabilityAfter || null,
+                    trade.status || 'filled',
+                    trade.fee || 0,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getManifoldTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM manifold_trades WHERE user_id = ?';
+                if (options.contractId) {
+                    sql += ' AND contract_id = ?';
+                    params.push(options.contractId);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    oddsUserId: row.user_id,
+                    betId: row.bet_id,
+                    contractId: row.contract_id,
+                    outcome: row.outcome,
+                    amount: row.amount,
+                    shares: row.shares,
+                    probabilityBefore: row.probability_before,
+                    probabilityAfter: row.probability_after,
+                    status: row.status,
+                    fee: row.fee,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            // Solana DEX trades
+            logSolanaDexTrade(trade) {
+                run(`INSERT INTO solana_dex_trades (
+          user_id, tx_sig, dex, input_mint, output_mint, input_amount, output_amount,
+          input_symbol, output_symbol, price_impact, slippage, fee, route, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.oddsUserId,
+                    trade.txSig,
+                    trade.dex,
+                    trade.inputMint,
+                    trade.outputMint,
+                    trade.inputAmount,
+                    trade.outputAmount,
+                    trade.inputSymbol || null,
+                    trade.outputSymbol || null,
+                    trade.priceImpact || null,
+                    trade.slippage || null,
+                    trade.fee || 0,
+                    trade.route || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getSolanaDexTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM solana_dex_trades WHERE user_id = ?';
+                if (options.dex) {
+                    sql += ' AND dex = ?';
+                    params.push(options.dex);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    oddsUserId: row.user_id,
+                    txSig: row.tx_sig,
+                    dex: row.dex,
+                    inputMint: row.input_mint,
+                    outputMint: row.output_mint,
+                    inputAmount: row.input_amount,
+                    outputAmount: row.output_amount,
+                    inputSymbol: row.input_symbol,
+                    outputSymbol: row.output_symbol,
+                    priceImpact: row.price_impact,
+                    slippage: row.slippage,
+                    fee: row.fee,
+                    route: row.route,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            // EVM swap trades
+            logEvmSwapTrade(trade) {
+                run(`INSERT INTO evm_swap_trades (
+          user_id, tx_hash, chain_id, dex, token_in, token_out, amount_in, amount_out,
+          token_in_symbol, token_out_symbol, price_impact, slippage, gas_used, gas_price, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    trade.oddsUserId,
+                    trade.txHash,
+                    trade.chainId,
+                    trade.dex,
+                    trade.tokenIn,
+                    trade.tokenOut,
+                    trade.amountIn,
+                    trade.amountOut,
+                    trade.tokenInSymbol || null,
+                    trade.tokenOutSymbol || null,
+                    trade.priceImpact || null,
+                    trade.slippage || null,
+                    trade.gasUsed || null,
+                    trade.gasPrice || null,
+                    trade.timestamp.getTime(),
+                    Date.now(),
+                ]);
+            },
+            getEvmSwapTrades(userId, options = {}) {
+                const params = [userId];
+                let sql = 'SELECT * FROM evm_swap_trades WHERE user_id = ?';
+                if (options.chainId !== undefined) {
+                    sql += ' AND chain_id = ?';
+                    params.push(options.chainId);
+                }
+                if (options.dex) {
+                    sql += ' AND dex = ?';
+                    params.push(options.dex);
+                }
+                if (options.since) {
+                    sql += ' AND timestamp >= ?';
+                    params.push(options.since);
+                }
+                sql += ' ORDER BY timestamp DESC';
+                if (options.limit) {
+                    sql += ' LIMIT ?';
+                    params.push(options.limit);
+                }
+                const rows = getAll(sql, params);
+                return rows.map((row) => ({
+                    id: row.id,
+                    oddsUserId: row.user_id,
+                    txHash: row.tx_hash,
+                    chainId: row.chain_id,
+                    dex: row.dex,
+                    tokenIn: row.token_in,
+                    tokenOut: row.token_out,
+                    amountIn: row.amount_in,
+                    amountOut: row.amount_out,
+                    tokenInSymbol: row.token_in_symbol,
+                    tokenOutSymbol: row.token_out_symbol,
+                    priceImpact: row.price_impact,
+                    slippage: row.slippage,
+                    gasUsed: row.gas_used,
+                    gasPrice: row.gas_price,
+                    timestamp: new Date(row.timestamp),
+                    createdAt: new Date(row.created_at),
+                }));
+            },
+            // Jupiter swaps
+            logJupiterSwap(swap) {
+                run(`INSERT OR REPLACE INTO jupiter_swaps (
+          user_id, tx_sig, input_mint, output_mint, input_amount, output_amount,
+          input_symbol, output_symbol, price_impact_pct, slippage_bps, route_plan,
+          num_hops, priority_fee, timestamp, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    swap.oddsUserId, swap.txSig, swap.inputMint, swap.outputMint,
+                    swap.inputAmount, swap.outputAmount, swap.inputSymbol || null,
+                    swap.outputSymbol || null, swap.priceImpactPct || null,
+                    swap.slippageBps || null, swap.routePlan || null, swap.numHops || null,
+                    swap.priorityFee || null, swap.timestamp.getTime(), Date.now(),
+                ]);
+            },
+            getJupiterSwaps(userId, limit = 50) {
+                const rows = getAll('SELECT * FROM jupiter_swaps WHERE user_id = ? ORDER BY timestamp DESC LIMIT ?', [userId, limit]);
+                return rows.map((r) => ({
+                    id: r.id,
+                    oddsUserId: r.user_id,
+                    txSig: r.tx_sig,
+                    inputMint: r.input_mint,
+                    outputMint: r.output_mint,
+                    inputAmount: r.input_amount,
+                    outputAmount: r.output_amount,
+                    inputSymbol: r.input_symbol,
+                    outputSymbol: r.output_symbol,
+                    priceImpactPct: r.price_impact_pct,
+                    slippageBps: r.slippage_bps,
+                    routePlan: r.route_plan,
+                    numHops: r.num_hops,
+                    priorityFee: r.priority_fee,
+                    timestamp: new Date(r.timestamp),
+                    createdAt: new Date(r.created_at),
+                }));
+            },
+            // Drift positions
+            upsertDriftPosition(position) {
+                run(`INSERT OR REPLACE INTO drift_positions (
+          user_id, market_index, market_type, base_asset_amount, quote_asset_amount,
+          entry_price, unrealized_pnl, liquidation_price, leverage, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    position.oddsUserId, position.marketIndex, position.marketType,
+                    position.baseAssetAmount, position.quoteAssetAmount || null,
+                    position.entryPrice || null, position.unrealizedPnl || null,
+                    position.liquidationPrice || null, position.leverage || null, Date.now(),
+                ]);
+            },
+            getDriftPositions(userId) {
+                const rows = getAll('SELECT * FROM drift_positions WHERE user_id = ? ORDER BY market_index', [userId]);
+                return rows.map((r) => ({
+                    id: r.id,
+                    oddsUserId: r.user_id,
+                    marketIndex: r.market_index,
+                    marketType: r.market_type,
+                    baseAssetAmount: r.base_asset_amount,
+                    quoteAssetAmount: r.quote_asset_amount,
+                    entryPrice: r.entry_price,
+                    unrealizedPnl: r.unrealized_pnl,
+                    liquidationPrice: r.liquidation_price,
+                    leverage: r.leverage,
+                    updatedAt: new Date(r.updated_at),
+                }));
+            },
+            // Pump.fun tokens
+            upsertPumpToken(token) {
+                run(`INSERT OR REPLACE INTO pump_tokens (
+          mint, name, symbol, creator, bonding_curve, market_cap,
+          virtual_sol_reserves, virtual_token_reserves, total_supply,
+          holder_count, is_graduated, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    token.mint, token.name || null, token.symbol || null, token.creator || null,
+                    token.bondingCurve || null, token.marketCap || null,
+                    token.virtualSolReserves || null, token.virtualTokenReserves || null,
+                    token.totalSupply || null, token.holderCount || null,
+                    token.isGraduated ? 1 : 0, token.createdAt.getTime(), Date.now(),
+                ]);
+            },
+            getPumpToken(mint) {
+                const row = getOne('SELECT * FROM pump_tokens WHERE mint = ?', [mint]);
+                if (!row)
+                    return null;
+                return {
+                    id: row.id,
+                    mint: row.mint,
+                    name: row.name,
+                    symbol: row.symbol,
+                    creator: row.creator,
+                    bondingCurve: row.bonding_curve,
+                    marketCap: row.market_cap,
+                    virtualSolReserves: row.virtual_sol_reserves,
+                    virtualTokenReserves: row.virtual_token_reserves,
+                    totalSupply: row.total_supply,
+                    holderCount: row.holder_count,
+                    isGraduated: row.is_graduated === 1,
+                    createdAt: new Date(row.created_at),
+                    updatedAt: new Date(row.updated_at),
+                };
+            },
+            // Raw SQL access
+            run,
+            query,
+            async withConnection(fn) {
+                return fn(dbInstance);
+            },
+        };
+        dbInstance = instance;
+        const backupConfig = getBackupConfig();
+        if (backupConfig.enabled && !backupInterval) {
+            ensureBackupDir();
+            backupInterval = setInterval(() => {
+                try {
+                    createBackup();
+                }
+                catch (error) {
+                    logger_1.logger.warn({ error }, 'Database backup failed');
+                }
+            }, backupConfig.intervalMs);
+        }
+        return instance;
+    })();
+    return dbInitPromise;
+}
+// Sync wrapper for backwards compatibility
+function createDatabase() {
+    // Return a proxy that initializes lazily
+    let initialized = false;
+    let db;
+    const lazyInit = async () => {
+        if (!initialized) {
+            db = await initDatabase();
+            initialized = true;
+        }
+        return db;
+    };
+    // Start initialization immediately
+    const initPromise = lazyInit();
+    // Return proxy that waits for initialization
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (prop === 'then')
+                return undefined; // Not a promise
+            return (...args) => {
+                if (initialized && db) {
+                    return db[prop](...args);
+                }
+                // If not initialized yet, wait
+                return initPromise.then((d) => d[prop](...args));
+            };
+        },
+    });
+}
+//# sourceMappingURL=index.js.map