chainlesschain 0.51.0 → 0.81.0

package/src/lib/bi-engine.js

@@ -297,3 +297,341 @@ export function _resetState() {
   _reports.clear();
   _scheduledReports.clear();
 }
+
+// ─── Phase 95 V2 surface (strictly additive) ───────────────────────
+
+export const CHART_TYPE = Object.freeze({
+  TABLE: "table",
+  BAR: "bar",
+  LINE: "line",
+  PIE: "pie",
+  AREA: "area",
+  SCATTER: "scatter",
+  HEATMAP: "heatmap",
+  FUNNEL: "funnel",
+  GAUGE: "gauge",
+});
+
+export const ANOMALY_METHOD = Object.freeze({
+  Z_SCORE: "z_score",
+  IQR: "iqr",
+});
+
+export const REPORT_FORMAT = Object.freeze({
+  PDF: "pdf",
+  EXCEL: "excel",
+  CSV: "csv",
+  JSON: "json",
+});
+
+export const REPORT_STATUS = Object.freeze({
+  DRAFT: "draft",
+  GENERATED: "generated",
+  SCHEDULED: "scheduled",
+  ARCHIVED: "archived",
+});
+
+export const DASHBOARD_LAYOUT = Object.freeze({
+  GRID: "grid",
+  FLOW: "flow",
+  TABS: "tabs",
+});
+
+const _reportStatusV2 = new Map();
+const _statusHistoryV2 = new Map();
+
+const _allowedReportTransitions = Object.freeze({
+  draft: new Set(["generated", "archived"]),
+  generated: new Set(["scheduled", "archived", "draft"]),
+  scheduled: new Set(["generated", "archived"]),
+  archived: new Set(["draft"]),
+});
+
+function _quantile(sorted, q) {
+  if (sorted.length === 0) return NaN;
+  const pos = (sorted.length - 1) * q;
+  const lo = Math.floor(pos);
+  const hi = Math.ceil(pos);
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + (pos - lo) * (sorted[hi] - sorted[lo]);
+}
+
+export function nlQueryV2({ query, schema } = {}) {
+  if (!query || typeof query !== "string") {
+    throw new Error("query must be a non-empty string");
+  }
+  const normalized = query.replace(/['"]/g, "").trim().toLowerCase();
+  const tokens = normalized.split(/\s+/);
+
+  // Detect table name from schema (first match) or fall back to "data"
+  let table = "data";
+  const knownTables =
+    schema && Array.isArray(schema.tables)
+      ? schema.tables.map((t) => String(t).toLowerCase())
+      : [];
+  for (const t of knownTables) {
+    if (tokens.includes(t)) {
+      table = t;
+      break;
+    }
+  }
+
+  // Detect aggregate intent
+  let aggregate = null;
+  let intent = "list";
+  let visualization = CHART_TYPE.TABLE;
+
+  if (/\b(count|how many)\b/.test(normalized)) {
+    aggregate = "COUNT(*)";
+    intent = "count";
+    visualization = CHART_TYPE.BAR;
+  } else if (/\b(sum|total)\b/.test(normalized)) {
+    aggregate = "SUM(value)";
+    intent = "sum";
+    visualization = CHART_TYPE.GAUGE;
+  } else if (/\b(avg|average|mean)\b/.test(normalized)) {
+    aggregate = "AVG(value)";
+    intent = "avg";
+    visualization = CHART_TYPE.GAUGE;
+  } else if (/\b(trend|over time|timeline|history)\b/.test(normalized)) {
+    intent = "trend";
+    visualization = CHART_TYPE.LINE;
+  } else if (/\b(distribution|breakdown)\b/.test(normalized)) {
+    intent = "distribution";
+    visualization = CHART_TYPE.PIE;
+  }
+
+  // Detect top N
+  let limit = null;
+  const topMatch = normalized.match(/\btop\s+(\d+)\b/);
+  if (topMatch) {
+    limit = parseInt(topMatch[1], 10);
+    if (intent === "list") {
+      intent = "top";
+      visualization = CHART_TYPE.BAR;
+    }
+  }
+
+  // Build SQL
+  let sql;
+  if (aggregate) {
+    sql = `SELECT ${aggregate} FROM ${table}`;
+  } else {
+    sql = `SELECT * FROM ${table}`;
+  }
+  if (limit !== null) {
+    sql += ` ORDER BY value DESC LIMIT ${limit}`;
+  } else if (intent === "trend") {
+    sql += ` ORDER BY created_at ASC`;
+  }
+
+  return {
+    id: crypto.randomUUID(),
+    query,
+    intent,
+    sql,
+    table,
+    aggregate,
+    limit,
+    visualization,
+  };
+}
+
+export function detectAnomalyV2({
+  data,
+  method = ANOMALY_METHOD.Z_SCORE,
+  threshold,
+} = {}) {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new Error("data must be a non-empty array of numbers");
+  }
+  const valid = Object.values(ANOMALY_METHOD);
+  if (!valid.includes(method)) {
+    throw new Error(
+      `Invalid method '${method}'. Expected one of ${valid.join(", ")}`,
+    );
+  }
+
+  if (method === ANOMALY_METHOD.Z_SCORE) {
+    const t = threshold == null ? 2 : threshold;
+    const legacy = detectAnomaly(data, { threshold: t });
+    return { method, threshold: t, ...legacy };
+  }
+
+  // IQR method
+  const sorted = [...data].sort((a, b) => a - b);
+  const q1 = _quantile(sorted, 0.25);
+  const q3 = _quantile(sorted, 0.75);
+  const iqr = q3 - q1;
+  const multiplier = threshold == null ? 1.5 : threshold;
+  const lowerBound = q1 - multiplier * iqr;
+  const upperBound = q3 + multiplier * iqr;
+
+  const anomalies = [];
+  for (let i = 0; i < data.length; i++) {
+    if (data[i] < lowerBound || data[i] > upperBound) {
+      anomalies.push({ index: i, value: data[i] });
+    }
+  }
+
+  return {
+    method,
+    threshold: multiplier,
+    q1,
+    q3,
+    iqr,
+    lowerBound,
+    upperBound,
+    anomalies,
+  };
+}
+
+export function predictTrendV2({ data, periods = 3, method = "linear" } = {}) {
+  if (!Array.isArray(data) || data.length < 2) {
+    throw new Error("data must be an array with at least 2 points");
+  }
+  if (method !== "linear") {
+    throw new Error(`Invalid method '${method}'. Only 'linear' is supported`);
+  }
+
+  const legacy = predictTrend(data, periods);
+
+  // Compute R² (coefficient of determination)
+  const n = data.length;
+  const meanY = data.reduce((s, v) => s + v, 0) / n;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (let i = 0; i < n; i++) {
+    const predicted = legacy.slope * i + (meanY - legacy.slope * ((n - 1) / 2));
+    ssRes += (data[i] - predicted) ** 2;
+    ssTot += (data[i] - meanY) ** 2;
+  }
+  let r2 = ssTot === 0 ? 1 : 1 - ssRes / ssTot;
+  if (r2 < 0) r2 = 0;
+  if (r2 > 1) r2 = 1;
+
+  return {
+    method,
+    ...legacy,
+    r2: Math.round(r2 * 1000) / 1000,
+    confidence: r2 >= 0.7 ? "high" : r2 >= 0.4 ? "medium" : "low",
+  };
+}
+
+export function recommendChart({ intent, dataShape } = {}) {
+  if (intent) {
+    const i = String(intent).toLowerCase();
+    if (i.includes("trend") || i.includes("time")) return CHART_TYPE.LINE;
+    if (i.includes("distribution") || i.includes("share"))
+      return CHART_TYPE.PIE;
+    if (i.includes("compare") || i.includes("top")) return CHART_TYPE.BAR;
+    if (i.includes("correlation")) return CHART_TYPE.SCATTER;
+    if (i.includes("funnel")) return CHART_TYPE.FUNNEL;
+    if (i.includes("heat")) return CHART_TYPE.HEATMAP;
+    if (i.includes("gauge") || i.includes("kpi")) return CHART_TYPE.GAUGE;
+  }
+  if (dataShape) {
+    if (dataShape.dimensions === 1 && dataShape.categorical)
+      return CHART_TYPE.PIE;
+    if (dataShape.timeseries) return CHART_TYPE.LINE;
+    if (dataShape.dimensions === 2) return CHART_TYPE.SCATTER;
+  }
+  return CHART_TYPE.TABLE;
+}
+
+export function createDashboardV2(db, { name, widgets = [], layout } = {}) {
+  if (!name) throw new Error("name is required");
+  let layoutSpec;
+  if (!layout) {
+    layoutSpec = { type: DASHBOARD_LAYOUT.GRID, columns: 2 };
+  } else if (typeof layout === "string") {
+    const valid = Object.values(DASHBOARD_LAYOUT);
+    if (!valid.includes(layout)) {
+      throw new Error(
+        `Invalid layout '${layout}'. Expected one of ${valid.join(", ")}`,
+      );
+    }
+    layoutSpec = { type: layout, columns: 2 };
+  } else {
+    const type = layout.type || DASHBOARD_LAYOUT.GRID;
+    const valid = Object.values(DASHBOARD_LAYOUT);
+    if (!valid.includes(type)) {
+      throw new Error(
+        `Invalid layout type '${type}'. Expected one of ${valid.join(", ")}`,
+      );
+    }
+    layoutSpec = { ...layout, type };
+  }
+  return createDashboard(db, name, widgets, layoutSpec);
+}
+
+export function updateReportStatus(db, { reportId, status } = {}) {
+  const valid = Object.values(REPORT_STATUS);
+  if (!valid.includes(status)) {
+    throw new Error(
+      `Invalid status '${status}'. Expected one of ${valid.join(", ")}`,
+    );
+  }
+  const current = _reportStatusV2.get(reportId) || REPORT_STATUS.DRAFT;
+  const allowed = _allowedReportTransitions[current];
+  if (!allowed.has(status) && current !== status) {
+    throw new Error(`Invalid status transition: ${current} → ${status}`);
+  }
+  _reportStatusV2.set(reportId, status);
+  const hist = _statusHistoryV2.get(reportId) || [];
+  hist.push({
+    from: current,
+    to: status,
+    at: new Date().toISOString(),
+  });
+  _statusHistoryV2.set(reportId, hist);
+  return { reportId, status, previous: current };
+}
+
+export function getReportStatus(reportId) {
+  return _reportStatusV2.get(reportId) || REPORT_STATUS.DRAFT;
+}
+
+export function getReportStatusHistory(reportId) {
+  return (_statusHistoryV2.get(reportId) || []).slice();
+}
+
+export function getBIStatsV2(db) {
+  const dashboards = db.prepare(`SELECT id FROM bi_dashboards`).all();
+  const reports = db.prepare(`SELECT id, format FROM bi_reports`).all();
+  const scheduled = db.prepare(`SELECT id FROM bi_scheduled`).all();
+
+  const byStatus = {
+    draft: 0,
+    generated: 0,
+    scheduled: 0,
+    archived: 0,
+  };
+  for (const r of reports) {
+    const s = _reportStatusV2.get(r.id) || REPORT_STATUS.DRAFT;
+    byStatus[s] = (byStatus[s] || 0) + 1;
+  }
+
+  const byFormat = {};
+  for (const r of reports) {
+    const f = r.format || "pdf";
+    byFormat[f] = (byFormat[f] || 0) + 1;
+  }
+
+  return {
+    dashboards: dashboards.length,
+    reports: {
+      total: reports.length,
+      byStatus,
+      byFormat,
+    },
+    scheduled: scheduled.length,
+    templates: _templates.length,
+    chartTypes: Object.values(CHART_TYPE).length,
+  };
+}
+
+export function _resetV2State() {
+  _reportStatusV2.clear();
+  _statusHistoryV2.clear();
+}

package/src/lib/cross-chain.js

@@ -666,4 +666,349 @@ export function _resetState() {
   _swaps.clear();
   _messages.clear();
   _chainConfigs.clear();
+  _maxActiveBridgesPerAddress = DEFAULT_MAX_ACTIVE_BRIDGES_PER_ADDRESS;
+}
+
+/* ══════════════════════════════════════════════════════════
+ * Phase 89 — Cross-Chain V2 surface (strictly additive)
+ *
+ * Adds canonical enums, per-address bridge concurrency cap,
+ * chain config CRUD, patch-merged state-machine setters,
+ * auto-expire swaps, and all-enum-key stats V2.
+ * ══════════════════════════════════════════════════════════ */
+
+/* ── V2 Frozen Enums ────────────────────────────────────── */
+
+export const BRIDGE_STATUS_V2 = Object.freeze({
+  PENDING: "pending",
+  LOCKED: "locked",
+  MINTED: "minted",
+  COMPLETED: "completed",
+  REFUNDED: "refunded",
+  FAILED: "failed",
+});
+
+export const SWAP_STATUS_V2 = Object.freeze({
+  INITIATED: "initiated",
+  HASH_LOCKED: "hash_locked",
+  CLAIMED: "claimed",
+  REFUNDED: "refunded",
+  EXPIRED: "expired",
+});
+
+export const MESSAGE_STATUS_V2 = Object.freeze({
+  PENDING: "pending",
+  SENT: "sent",
+  DELIVERED: "delivered",
+  FAILED: "failed",
+});
+
+export const CHAIN_ID_V2 = Object.freeze({
+  ETHEREUM: "ethereum",
+  POLYGON: "polygon",
+  BSC: "bsc",
+  ARBITRUM: "arbitrum",
+  SOLANA: "solana",
+});
+
+const DEFAULT_MAX_ACTIVE_BRIDGES_PER_ADDRESS = 3;
+export const CROSSCHAIN_DEFAULT_MAX_ACTIVE_BRIDGES_PER_ADDRESS =
+  DEFAULT_MAX_ACTIVE_BRIDGES_PER_ADDRESS;
+
+let _maxActiveBridgesPerAddress = DEFAULT_MAX_ACTIVE_BRIDGES_PER_ADDRESS;
+
+/* ── State Machine Definitions ──────────────────────────── */
+
+const BRIDGE_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["locked", "failed"])],
+  ["locked", new Set(["minted", "refunded", "failed"])],
+  ["minted", new Set(["completed", "failed"])],
+]);
+const BRIDGE_TERMINALS_V2 = new Set(["completed", "refunded", "failed"]);
+
+const SWAP_TRANSITIONS_V2 = new Map([
+  ["initiated", new Set(["hash_locked", "claimed", "refunded", "expired"])],
+  ["hash_locked", new Set(["claimed", "refunded", "expired"])],
+]);
+const SWAP_TERMINALS_V2 = new Set(["claimed", "refunded", "expired"]);
+
+const MESSAGE_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["sent", "failed"])],
+  ["sent", new Set(["delivered", "failed"])],
+  ["failed", new Set(["pending"])],
+]);
+const MESSAGE_TERMINALS_V2 = new Set(["delivered"]);
+
+/* ── Concurrency Cap ───────────────────────────────────── */
+
+export function setMaxActiveBridgesPerAddress(n) {
+  if (typeof n !== "number" || Number.isNaN(n) || n < 1) {
+    throw new Error("Max active bridges must be a positive integer");
+  }
+  _maxActiveBridgesPerAddress = Math.floor(n);
+}
+
+export function getMaxActiveBridgesPerAddress() {
+  return _maxActiveBridgesPerAddress;
+}
+
+export function getActiveBridgeCount(address) {
+  let count = 0;
+  for (const b of _bridges.values()) {
+    if (BRIDGE_TERMINALS_V2.has(b.status)) continue;
+    if (address == null || b.sender_address === address) count += 1;
+  }
+  return count;
+}
+
+/* ── Chain Config V2 ───────────────────────────────────── */
+
+export function configureChainV2({
+  chainId,
+  rpcUrl,
+  contractAddress,
+  enabled = true,
+}) {
+  if (!_validateChain(chainId)) {
+    throw new Error(`Unsupported chain: ${chainId}`);
+  }
+  const cfg = {
+    chainId,
+    rpcUrl: rpcUrl || null,
+    contractAddress: contractAddress || null,
+    enabled: enabled !== false,
+    updatedAt: _now(),
+  };
+  _chainConfigs.set(chainId, cfg);
+  return { ...cfg };
+}
+
+export function getChainConfigV2(chainId) {
+  const cfg = _chainConfigs.get(chainId);
+  return cfg ? { ...cfg } : null;
+}
+
+export function listChainsV2() {
+  return Object.values(SUPPORTED_CHAINS).map((chain) => {
+    const cfg = _chainConfigs.get(chain.id);
+    return {
+      ...chain,
+      enabled: cfg ? cfg.enabled : false,
+      rpcUrl: cfg ? cfg.rpcUrl : null,
+      contractAddress: cfg ? cfg.contractAddress : null,
+    };
+  });
+}
+
+/* ── Bridge V2 (throws + cap enforcement) ──────────────── */
+
+export function bridgeAssetV2(
+  db,
+  { fromChain, toChain, asset, amount, senderAddress, recipientAddress },
+) {
+  if (!_validateChain(fromChain)) {
+    throw new Error(`Unsupported source chain: ${fromChain}`);
+  }
+  if (!_validateChain(toChain)) {
+    throw new Error(`Unsupported destination chain: ${toChain}`);
+  }
+  if (fromChain === toChain) {
+    throw new Error("Source and destination chains must differ");
+  }
+  if (!amount || amount <= 0) {
+    throw new Error("Amount must be positive");
+  }
+  if (amount > DEFAULT_CONFIG.maxBridgeAmount) {
+    throw new Error(
+      `Amount ${amount} exceeds max ${DEFAULT_CONFIG.maxBridgeAmount}`,
+    );
+  }
+  if (senderAddress) {
+    const active = getActiveBridgeCount(senderAddress);
+    if (active >= _maxActiveBridgesPerAddress) {
+      throw new Error(
+        `Max active bridges per address reached (${active}/${_maxActiveBridgesPerAddress})`,
+      );
+    }
+  }
+
+  const result = bridgeAsset(db, {
+    fromChain,
+    toChain,
+    asset,
+    amount,
+    senderAddress,
+    recipientAddress,
+  });
+  return result;
+}
+
+/* ── Generic patch-merged state setters ────────────────── */
+
+export function setBridgeStatusV2(db, bridgeId, newStatus, patch = {}) {
+  const b = _bridges.get(bridgeId);
+  if (!b) throw new Error(`Bridge not found: ${bridgeId}`);
+
+  const allowed = BRIDGE_TRANSITIONS_V2.get(b.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(`Invalid bridge transition: ${b.status} → ${newStatus}`);
+  }
+  if (!Object.values(BRIDGE_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown bridge status: ${newStatus}`);
+  }
+
+  b.status = newStatus;
+  if (patch.lockTxHash !== undefined) b.lock_tx_hash = patch.lockTxHash;
+  if (patch.mintTxHash !== undefined) b.mint_tx_hash = patch.mintTxHash;
+  if (patch.errorMessage !== undefined) b.error_message = patch.errorMessage;
+  if (BRIDGE_TERMINALS_V2.has(newStatus) && !b.completed_at) {
+    b.completed_at = _now();
+  }
+
+  db.prepare(
+    `UPDATE cc_bridges SET status = ?, lock_tx_hash = ?, mint_tx_hash = ?,
+     completed_at = ?, error_message = ? WHERE id = ?`,
+  ).run(
+    b.status,
+    b.lock_tx_hash,
+    b.mint_tx_hash,
+    b.completed_at,
+    b.error_message,
+    bridgeId,
+  );
+
+  return { ...b };
+}
+
+export function setSwapStatusV2(db, swapId, newStatus, patch = {}) {
+  const s = _swaps.get(swapId);
+  if (!s) throw new Error(`Swap not found: ${swapId}`);
+
+  const allowed = SWAP_TRANSITIONS_V2.get(s.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(`Invalid swap transition: ${s.status} → ${newStatus}`);
+  }
+  if (!Object.values(SWAP_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown swap status: ${newStatus}`);
+  }
+
+  s.status = newStatus;
+  if (patch.claimTxHash !== undefined) s.claim_tx_hash = patch.claimTxHash;
+  if (patch.refundTxHash !== undefined) s.refund_tx_hash = patch.refundTxHash;
+
+  db.prepare(
+    `UPDATE cc_swaps SET status = ?, claim_tx_hash = ?, refund_tx_hash = ?
+     WHERE id = ?`,
+  ).run(s.status, s.claim_tx_hash, s.refund_tx_hash, swapId);
+
+  const out = { ...s };
+  delete out.secret;
+  return out;
+}
+
+export function setMessageStatusV2(db, messageId, newStatus, patch = {}) {
+  const m = _messages.get(messageId);
+  if (!m) throw new Error(`Message not found: ${messageId}`);
+
+  const allowed = MESSAGE_TRANSITIONS_V2.get(m.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(`Invalid message transition: ${m.status} → ${newStatus}`);
+  }
+  if (!Object.values(MESSAGE_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown message status: ${newStatus}`);
+  }
+
+  m.status = newStatus;
+  if (patch.sourceTxHash !== undefined) m.source_tx_hash = patch.sourceTxHash;
+  if (patch.destinationTxHash !== undefined)
+    m.destination_tx_hash = patch.destinationTxHash;
+  if (newStatus === "delivered" && !m.delivered_at) m.delivered_at = _now();
+  if (newStatus === "pending") m.retries += 1;
+
+  db.prepare(
+    `UPDATE cc_messages SET status = ?, source_tx_hash = ?, destination_tx_hash = ?,
+     delivered_at = ?, retries = ? WHERE id = ?`,
+  ).run(
+    m.status,
+    m.source_tx_hash,
+    m.destination_tx_hash,
+    m.delivered_at,
+    m.retries,
+    messageId,
+  );
+
+  return { ...m };
+}
+
+/* ── Auto-expire swaps ─────────────────────────────────── */
+
+export function autoExpireSwapsV2(db) {
+  const now = _now();
+  const expired = [];
+  for (const s of _swaps.values()) {
+    if (s.status !== "initiated" && s.status !== "hash_locked") continue;
+    if (s.expires_at > now) continue;
+
+    s.status = "expired";
+    db.prepare("UPDATE cc_swaps SET status = ? WHERE id = ?").run(
+      "expired",
+      s.id,
+    );
+    const out = { ...s };
+    delete out.secret;
+    expired.push(out);
+  }
+  return expired;
+}
+
+/* ── Stats V2 ──────────────────────────────────────────── */
+
+export function getCrossChainStatsV2() {
+  const bridgesByStatus = {};
+  for (const v of Object.values(BRIDGE_STATUS_V2)) bridgesByStatus[v] = 0;
+  const swapsByStatus = {};
+  for (const v of Object.values(SWAP_STATUS_V2)) swapsByStatus[v] = 0;
+  const messagesByStatus = {};
+  for (const v of Object.values(MESSAGE_STATUS_V2)) messagesByStatus[v] = 0;
+  const chainUsage = {};
+  for (const v of Object.values(CHAIN_ID_V2)) chainUsage[v] = 0;
+
+  let totalBridgeVolume = 0;
+  let totalFees = 0;
+  let activeBridges = 0;
+  for (const b of _bridges.values()) {
+    bridgesByStatus[b.status] = (bridgesByStatus[b.status] || 0) + 1;
+    chainUsage[b.from_chain] = (chainUsage[b.from_chain] || 0) + 1;
+    chainUsage[b.to_chain] = (chainUsage[b.to_chain] || 0) + 1;
+    totalBridgeVolume += b.amount;
+    totalFees += b.fee_amount;
+    if (!BRIDGE_TERMINALS_V2.has(b.status)) activeBridges += 1;
+  }
+
+  for (const s of _swaps.values()) {
+    swapsByStatus[s.status] = (swapsByStatus[s.status] || 0) + 1;
+    chainUsage[s.from_chain] = (chainUsage[s.from_chain] || 0) + 1;
+    chainUsage[s.to_chain] = (chainUsage[s.to_chain] || 0) + 1;
+  }
+
+  for (const m of _messages.values()) {
+    messagesByStatus[m.status] = (messagesByStatus[m.status] || 0) + 1;
+    chainUsage[m.from_chain] = (chainUsage[m.from_chain] || 0) + 1;
+    chainUsage[m.to_chain] = (chainUsage[m.to_chain] || 0) + 1;
+  }
+
+  return {
+    totalBridges: _bridges.size,
+    totalSwaps: _swaps.size,
+    totalMessages: _messages.size,
+    activeBridges,
+    maxActiveBridgesPerAddress: _maxActiveBridgesPerAddress,
+    bridgesByStatus,
+    swapsByStatus,
+    messagesByStatus,
+    chainUsage,
+    totalBridgeVolume,
+    totalFees: Math.round(totalFees * 1000) / 1000,
+    configuredChains: _chainConfigs.size,
+  };
 }