@oracle-agent/oracle 0.13.0 → 0.14.0

package/src/data/providers/bob-rootstock.mjs

@@ -0,0 +1,198 @@
+// BOB and Rootstock — the two Bitcoin L2s that speak EVM — via Blockscout v2.
+//
+// Grouped in one module because they are the same integration: both run a
+// Blockscout v2 instance with an identical REST schema, so one code path serves
+// both and the only difference is the base URL.
+//
+//   BOB       chainId 60808  https://explorer.gobob.xyz
+//   Rootstock chainId 30     https://rootstock.blockscout.com
+//
+// Verified live:
+//   GET /api/v2/stats                    200  on both
+//   GET /api/v2/addresses/{address}      200  on both (coin balance + flags)
+//   GET /api/v2/addresses/{a}/token-balances  token holdings
+//
+// Distinct from the generic `blockscout` provider, which is registered for L1
+// and EVM L2 rollups only — these two chains are absent from that map, and
+// their Bitcoin-L2 framing is the reason to surface them separately.
+//
+// Read-only.
+
+import { httpJson } from "../http.mjs";
+
+export const BTC_L2_CHAINS = Object.freeze({
+  60808: { name: "bob", label: "BOB (Build on Bitcoin)", url: "https://explorer.gobob.xyz", nativeSymbol: "ETH" },
+  30: { name: "rootstock", label: "Rootstock (RSK)", url: "https://rootstock.blockscout.com", nativeSymbol: "RBTC" },
+});
+
+const ALIASES = new Map([
+  ["bob", 60808],
+  ["rootstock", 30],
+  ["rsk", 30],
+]);
+
+export const BTC_L2_DEFAULT_CHAIN_ID = 60808;
+
+/** Accepts a chainId (60808/30) or a name ("bob"/"rootstock"/"rsk"). */
+export function btcL2ChainId(value) {
+  if (value == null || value === "") return BTC_L2_DEFAULT_CHAIN_ID;
+  const asName = ALIASES.get(String(value).trim().toLowerCase());
+  if (asName) return asName;
+  const id = Number(value);
+  if (!BTC_L2_CHAINS[id]) {
+    throw new Error(`bob-rootstock: unsupported chain ${value} (supported: ${Object.keys(BTC_L2_CHAINS).join(", ")} / bob, rootstock)`);
+  }
+  return id;
+}
+
+function baseUrl(chainId, opts = {}) {
+  if (opts.baseUrl) return String(opts.baseUrl).replace(/\/$/, "");
+  const id = btcL2ChainId(chainId);
+  const env = id === 30 ? process.env.ROOTSTOCK_EXPLORER_URL : process.env.BOB_EXPLORER_URL;
+  return String(env || BTC_L2_CHAINS[id].url).replace(/\/$/, "");
+}
+
+function evmAddress(value, label = "address") {
+  const text = String(value || "").trim();
+  // Rootstock renders EIP-1191 checksums (chain-id salted), so case is NOT
+  // validated here — only shape. Blockscout accepts either casing.
+  if (!/^0x[0-9a-fA-F]{40}$/.test(text)) throw new Error(`bob-rootstock: ${label} must be a 0x EVM address`);
+  return text;
+}
+
+function get(chainId, path, opts = {}) {
+  return httpJson(`${baseUrl(chainId, opts)}${path.startsWith("/") ? path : `/${path}`}`, {
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs ?? 15_000,
+  });
+}
+
+export async function btcL2Health(opts = {}, args = {}) {
+  // Health accepts an optional chain so a sweep can probe either instance;
+  // default is BOB.
+  let chainId;
+  try {
+    chainId = btcL2ChainId(args.chainId ?? args.chain ?? opts.chainId);
+  } catch (error) {
+    return { ok: false, provider: "bob-rootstock", error: String(error?.message || error), exec: false };
+  }
+  const meta = BTC_L2_CHAINS[chainId];
+  try {
+    const stats = await get(chainId, "/api/v2/stats", opts);
+    return {
+      ok: stats?.total_blocks != null || stats?.total_transactions != null,
+      provider: "bob-rootstock",
+      chainId,
+      chain: meta.name,
+      baseUrl: baseUrl(chainId, opts),
+      totalBlocks: stats?.total_blocks ?? null,
+      averageBlockTimeMs: stats?.average_block_time ?? null,
+      exec: false,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      provider: "bob-rootstock",
+      chainId,
+      chain: meta.name,
+      baseUrl: baseUrl(chainId, opts),
+      error: String(error?.message || error),
+      exec: false,
+    };
+  }
+}
+
+/** Chain stats for one L2. Pass `chainId: "all"` to fan out across both. */
+export async function btcL2Stats(args = {}, opts = {}) {
+  const which = args.chainId ?? args.chain;
+  if (String(which).trim().toLowerCase() === "all") {
+    const ids = Object.keys(BTC_L2_CHAINS).map(Number);
+    const rows = await Promise.all(
+      ids.map(async (id) => {
+        try {
+          return await btcL2Stats({ chainId: id }, opts);
+        } catch (error) {
+          return { provider: "bob-rootstock", chainId: id, chain: BTC_L2_CHAINS[id].name, error: String(error?.message || error) };
+        }
+      })
+    );
+    return { provider: "bob-rootstock", chains: rows };
+  }
+  const chainId = btcL2ChainId(which);
+  const meta = BTC_L2_CHAINS[chainId];
+  const s = await get(chainId, "/api/v2/stats", opts);
+  return {
+    provider: "bob-rootstock",
+    chainId,
+    chain: meta.name,
+    label: meta.label,
+    nativeSymbol: meta.nativeSymbol,
+    // Blockscout reports average_block_time in MILLISECONDS. Emitting seconds
+    // too because a 29409 vs 2000 comparison across these two chains is
+    // otherwise easy to misread as blocks-per-second.
+    averageBlockTimeMs: s.average_block_time ?? null,
+    averageBlockTimeSec: s.average_block_time == null ? null : Number(s.average_block_time) / 1000,
+    gasPrices: s.gas_prices ?? null,
+    gasPriceUpdatedAt: s.gas_price_updated_at ?? null,
+    gasUsedToday: s.gas_used_today ?? null,
+    coinPrice: s.coin_price ?? null,
+    coinPriceChangePct: s.coin_price_change_percentage ?? null,
+    marketCap: s.market_cap ?? null,
+    tvl: s.tvl ?? null,
+    totalBlocks: s.total_blocks ?? null,
+    totalAddresses: s.total_addresses ?? null,
+    totalTransactions: s.total_transactions ?? null,
+    transactionsToday: s.transactions_today ?? null,
+    networkUtilizationPct: s.network_utilization_percentage ?? null,
+    raw: s,
+  };
+}
+
+/** Native balance + account flags for an address on either L2. */
+export async function btcL2AddressInfo(args = {}, opts = {}) {
+  const chainId = btcL2ChainId(args.chainId ?? args.chain);
+  const address = evmAddress(args.address || args.addr, "address");
+  const meta = BTC_L2_CHAINS[chainId];
+  const a = await get(chainId, `/api/v2/addresses/${encodeURIComponent(address)}`, opts);
+  return {
+    provider: "bob-rootstock",
+    chainId,
+    chain: meta.name,
+    address,
+    nativeSymbol: meta.nativeSymbol,
+    coinBalanceWei: a.coin_balance == null ? null : String(a.coin_balance),
+    coinBalance: a.coin_balance == null ? null : Number(a.coin_balance) / 1e18,
+    isContract: a.is_contract ?? null,
+    isVerified: a.is_verified ?? null,
+    name: a.name ?? null,
+    blockNumberBalanceUpdatedAt: a.block_number_balance_updated_at ?? null,
+    raw: a,
+  };
+}
+
+/** ERC-20 token holdings for an address on either L2. */
+export async function btcL2TokenBalances(args = {}, opts = {}) {
+  const chainId = btcL2ChainId(args.chainId ?? args.chain);
+  const address = evmAddress(args.address || args.addr, "address");
+  const rows = await get(chainId, `/api/v2/addresses/${encodeURIComponent(address)}/token-balances`, opts);
+  const list = Array.isArray(rows) ? rows : [];
+  const limit = Math.min(500, Math.max(1, Number(args.limit || list.length || 1)));
+  return {
+    provider: "bob-rootstock",
+    chainId,
+    chain: BTC_L2_CHAINS[chainId].name,
+    address,
+    count: list.length,
+    tokens: list.slice(0, limit).map((t) => ({
+      symbol: t.token?.symbol ?? null,
+      name: t.token?.name ?? null,
+      address: t.token?.address ?? t.token?.address_hash ?? null,
+      type: t.token?.type ?? null,
+      decimals: t.token?.decimals ?? null,
+      rawBalance: t.value == null ? null : String(t.value),
+      balance:
+        t.value == null || t.token?.decimals == null ? null : Number(t.value) / 10 ** Number(t.token.decimals),
+      exchangeRate: t.token?.exchange_rate ?? null,
+    })),
+  };
+}

package/src/data/providers/braiins-insights.mjs

@@ -0,0 +1,103 @@
+// Braiins mining insights — BTC price stats + pool distribution, keyless.
+//
+// HOST NOTE (measured): use insights.braiins.com. Two traps:
+//   - pool.braiins.com/api/... returns 403 (that host is the pool dashboard,
+//     not the public insights API).
+//   - insights.braiins.com/api/v1.0/* answers 302 and redirects to
+//     learn.braiins.com/api/v1.0/*. Following redirects is required; http.mjs
+//     follows same-scheme redirects for GET, so the documented host is kept
+//     here as the entry point and the redirect resolves transparently.
+//
+// Verified live (after redirect):
+//   GET /api/v1.0/price-stats  200  { price, percent_change_24h, timestamp }
+//   GET /api/v1.0/pool-stats   200  [ { pool_name, blocks_mined{1d,1w,5w}, … } ]
+//
+// Complements mempool-mining: mempool gives block-count pool share from chain
+// data; Braiins publishes miner-economics framing (block value, hashrate share)
+// plus a price tick to value it against.
+//
+// Read-only.
+
+import { httpJson } from "../http.mjs";
+
+export const BRAIINS_INSIGHTS_API = "https://insights.braiins.com/api/v1.0";
+
+function baseUrl(opts = {}) {
+  return String(opts.baseUrl || process.env.BRAIINS_INSIGHTS_URL || BRAIINS_INSIGHTS_API).replace(/\/$/, "");
+}
+
+function get(path, opts = {}) {
+  return httpJson(`${baseUrl(opts)}${path.startsWith("/") ? path : `/${path}`}`, {
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs ?? 15_000,
+    headers: { Accept: "application/json" },
+  });
+}
+
+export async function braiinsHealth(opts = {}) {
+  try {
+    const p = await get("/price-stats", opts);
+    const price = Number(p?.price ?? 0);
+    return {
+      ok: Number.isFinite(price) && price > 0,
+      provider: "braiins-insights",
+      baseUrl: baseUrl(opts),
+      btcUsd: Number.isFinite(price) ? price : null,
+      timestamp: p?.timestamp ?? null,
+      exec: false,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      provider: "braiins-insights",
+      baseUrl: baseUrl(opts),
+      error: String(error?.message || error),
+      exec: false,
+    };
+  }
+}
+
+export async function braiinsPriceStats(_args = {}, opts = {}) {
+  const p = await get("/price-stats", opts);
+  return {
+    provider: "braiins-insights",
+    btcUsd: p?.price == null ? null : Number(p.price),
+    percentChange24h: p?.percent_change_24h ?? null,
+    timestamp: p?.timestamp ?? null,
+    raw: p,
+  };
+}
+
+/**
+ * Per-pool mining stats. Braiins nests block counts by window
+ * ({ "1d": { absolute, relative_pct }, "1w": …, "5w": … }) — flattened here
+ * to the requested window so callers do not have to walk the shape.
+ */
+export async function braiinsPoolStats(args = {}, opts = {}) {
+  const res = await get("/pool-stats", opts);
+  const list = Array.isArray(res) ? res : Array.isArray(res?.pools) ? res.pools : [];
+  const win = String(args.window || "1w").trim().toLowerCase();
+  const pick = (row) => row?.blocks_mined?.[win] || null;
+  const rows = [...list].sort((a, b) => Number(pick(b)?.absolute || 0) - Number(pick(a)?.absolute || 0));
+  const limit = Math.min(200, Math.max(1, Number(args.limit || rows.length || 1)));
+  const windows = list.length ? Object.keys(list[0]?.blocks_mined || {}) : [];
+  if (windows.length && !windows.includes(win)) {
+    throw new Error(`braiins-insights: window must be one of ${windows.join(", ")}`);
+  }
+  return {
+    provider: "braiins-insights",
+    window: win,
+    availableWindows: windows,
+    count: rows.length,
+    pools: rows.slice(0, limit).map((r) => ({
+      name: r.pool_name ?? r.name ?? null,
+      blocksMined: pick(r)?.absolute ?? null,
+      sharePct: pick(r)?.relative_pct ?? null,
+      blockValueAvg: r.block_value_avg ?? null,
+      hashrate: r.hashrate ?? null,
+      luck: r.luck ?? null,
+      blocksMinedAllWindows: r.blocks_mined ?? null,
+    })),
+    raw: rows.slice(0, limit),
+  };
+}

package/src/data/providers/bridge-aggregator.mjs

@@ -0,0 +1,259 @@
+// Cross-chain bridge aggregator: 9 providers + revoke check.
+// Quotes every available route in parallel, ranks by net output.
+
+import { bestBridgeRoute } from "../../router/index.mjs";
+import { debridgeQuote, debridgeHealth, DEBRIDGE_API } from "./debridge.mjs";
+import { changenowQuote, changenowHealth, CHANGENOW_API } from "./changenow.mjs";
+import { squidQuote, squidHealth, SQUID_API } from "./squid-router.mjs";
+import { stargateQuote, stargateHealth, STARGATE_API } from "./stargate.mjs";
+import { thorchainQuote, thorchainHealth, THORCHAIN_API } from "./thorchain.mjs";
+import { bungeeQuote, bungeeHealth, BUNGEE_API } from "./bungee.mjs";
+import { connextQuote, connextHealth, CONNEXT_API } from "./connext.mjs";
+import { wormholeQuote, wormholeHealth, WORMHOLE_API } from "./wormhole.mjs";
+import { approvalsScan } from "./approvals.mjs";
+
+const PROVIDERS = Object.freeze(["debridge", "lifi-relay", "squid", "stargate", "thorchain", "bungee", "connext", "wormhole", "changenow"]);
+
+/**
+ * Quote all available bridge routes for a cross-chain transfer.
+ * Runs all providers concurrently; partial failures are non-fatal.
+ *
+ * @param {{ fromChainId: number, toChainId: number, tokenIn: string, tokenOut: string, amount: string, taker: string, fromSymbol?: string, toSymbol?: string, fromDecimals?: number, toDecimals?: number }} params
+ */
+export async function aggregateBridgeQuotes(params = {}) {
+  const {
+    fromChainId, toChainId, tokenIn, tokenOut, amount, taker,
+    fromSymbol = "?", toSymbol = "?", fromDecimals = 18, toDecimals = 18,
+  } = params;
+
+  const results = [];
+  const errors = [];
+
+  // ── deBridge ──
+  const debridgeP = debridgeQuote({
+    srcChainId: fromChainId,
+    srcChainTokenIn: tokenIn,
+    srcChainTokenInAmount: amount,
+    dstChainId: toChainId,
+    dstChainTokenOut: tokenOut,
+  }).then(r => {
+    if (r.error) { errors.push(`debridge: ${r.error}`); return null; }
+    return {
+      provider: "debridge",
+      amountOut: r.estimation?.dstChainTokenOut?.amount ?? r.estimation?.toAmount,
+      feeUsd: r.estimation?.fixFee ?? r.fixFee,
+      estimatedTime: r.estimation?.execution?.estimatedTransferTime
+        ? `${r.estimation.execution.estimatedTransferTime}s`
+        : "unknown",
+      preparable: true,
+      raw: r,
+    };
+  }).catch(e => { errors.push(`debridge: ${e.message}`); return null; });
+
+  // ── LI.FI / Relay (existing bridge router) ──
+  const lifiP = bestBridgeRoute({
+    fromChainId, toChainId, tokenIn, tokenOut, amountIn: amount, taker,
+  }).then(r => {
+    if (!r || r.error) { errors.push(`lifi: ${r?.error ?? "no route"}`); return null; }
+    return {
+      provider: "lifi-relay",
+      amountOut: r.amountOut ?? r.quote?.amountOut,
+      feeUsd: r.feeUsd ?? r.totalFee,
+      estimatedTime: r.estimatedTime ?? r.duration ?? "unknown",
+      preparable: !!r.transaction,
+      raw: r,
+    };
+  }).catch(e => { errors.push(`lifi: ${e.message}`); return null; });
+
+  // ── Squid (Axelar) ──
+  const squidP = squidQuote({
+    fromChain: fromChainId, toChain: toChainId,
+    fromToken: tokenIn, toToken: tokenOut,
+    fromAmount: amount, fromAddress: taker,
+  }).then(r => {
+    if (r.error) { errors.push(`squid: ${r.error}`); return null; }
+    return {
+      provider: "squid",
+      amountOut: r.toAmount,
+      feeUsd: Array.isArray(r.fee) ? r.fee.reduce((a, b) => a + (Number(b.amountUsd) || 0), 0) : null,
+      estimatedTime: "30s - 3min",
+      preparable: false,
+      raw: r,
+    };
+  }).catch(e => { errors.push(`squid: ${e.message}`); return null; });
+
+  // ── Stargate (LayerZero) ──
+  const stargateP = stargateQuote({
+    srcChainId: fromChainId, dstChainId: toChainId,
+    token: tokenIn, amount,
+  }).then(r => {
+    if (r.error) { errors.push(`stargate: ${r.error}`); return null; }
+    return {
+      provider: "stargate",
+      amountOut: r.amountOut,
+      feeUsd: r.fee,
+      estimatedTime: r.estimatedTime || "1-5 min",
+      preparable: false,
+      raw: r,
+    };
+  }).catch(e => { errors.push(`stargate: ${e.message}`); return null; });
+
+  // ── THORChain (native swaps) ──
+  const thorchainP = thorchainQuote({
+    fromAsset: fromSymbol, toAsset: toSymbol, amount, destination: taker,
+  }).then(r => {
+    if (r.error) { errors.push(`thorchain: ${r.error}`); return null; }
+    return {
+      provider: "thorchain",
+      amountOut: r.expectedAmountOut,
+      feeUsd: r.fees?.total,
+      estimatedTime: r.estimatedTime || "10-30 min",
+      preparable: false,
+      raw: r,
+    };
+  }).catch(e => { errors.push(`thorchain: ${e.message}`); return null; });
+
+  // ── ChangeNOW ──
+  const changenowP = (async () => {
+    if (!fromSymbol || !toSymbol || fromSymbol === "?" || toSymbol === "?") {
+      errors.push("changenow: ticker symbols required, skipping");
+      return null;
+    }
+    try {
+      const q = await changenowQuote({ fromTicker: fromSymbol, toTicker: toSymbol, fromAmount: amount });
+      if (q.error) { errors.push(`changenow: ${q.error}`); return null; }
+      return {
+        provider: "changenow",
+        amountOut: q.toAmount,
+        feeUsd: q.networkFee,
+        estimatedTime: q.flow === "standard" ? "5-30 min" : "instant",
+        preparable: false, // CEX - user sends funds themselves
+        kycRequired: q.kycRequired,
+        raw: q,
+      };
+    } catch (e) { errors.push(`changenow: ${e.message}`); return null; }
+  })();
+
+  // ── Bungee/Socket ──
+  const bungeeP = bungeeQuote({ fromChainId, toChainId, fromToken: tokenIn, toToken: tokenOut, fromAmount: amount, userAddress: taker }).then(r => {
+    if (r.error) { errors.push(`bungee: ${r.error}`); return null; }
+    return { provider: "bungee", amountOut: r.amountOut, feeUsd: r.feeUsd, estimatedTime: r.estimatedTime, preparable: false, raw: r };
+  }).catch(e => { errors.push(`bungee: ${e.message}`); return null; });
+
+  // ── Connext ──
+  const connextP = connextQuote({ originDomain: fromChainId, destinationDomain: toChainId, originToken: tokenIn, destinationToken: tokenOut, amount }).then(r => {
+    if (r.error) { errors.push(`connext: ${r.error}`); return null; }
+    return { provider: "connext", amountOut: r.amountOut, feeUsd: r.fee, estimatedTime: r.estimatedTime || "5-20 min", preparable: false, raw: r };
+  }).catch(e => { errors.push(`connext: ${e.message}`); return null; });
+
+  // ── Wormhole ──
+  const wormholeP = wormholeQuote({ fromChain: fromChainId, toChain: toChainId, token: tokenIn, amount }).then(r => {
+    if (r.error) { errors.push(`wormhole: ${r.error}`); return null; }
+    return { provider: "wormhole", amountOut: r.amountOut, feeUsd: r.fee, estimatedTime: r.estimatedTime || "5-15 min", preparable: false, raw: r };
+  }).catch(e => { errors.push(`wormhole: ${e.message}`); return null; });
+
+  const settled = await Promise.allSettled([debridgeP, lifiP, squidP, stargateP, thorchainP, bungeeP, connextP, wormholeP, changenowP]);
+  for (const s of settled) {
+    if (s.status === "fulfilled" && s.value) results.push(s.value);
+  }
+
+  // Rank by output amount (descending). Preparable routes preferred on tie.
+  results.sort((a, b) => {
+    const aOut = Number(a.amountOut ?? 0);
+    const bOut = Number(b.amountOut ?? 0);
+    if (aOut !== bOut) return bOut - aOut;
+    if (a.preparable && !b.preparable) return -1;
+    if (!a.preparable && b.preparable) return 1;
+    return 0;
+  });
+
+  return {
+    providers: results.map(r => r.provider),
+    bestRoute: results[0]?.provider ?? "none",
+    winner: results[0] ?? null,
+    runnersUp: results.slice(1),
+    errors: errors.length ? errors : null,
+  };
+}
+
+/**
+ * Check if the taker has any active ERC-20 approvals on the origin chain
+ * that should be revoked before bridging. Uses the existing approval scanner.
+ */
+export async function checkRevokeNeeded({ chainId, taker, tokenIn } = {}) {
+  if (!chainId || !taker) return { needsRevoke: false, note: "no wallet to check" };
+
+  try {
+    const result = await approvalsScan({ chainIds: [chainId], address: taker });
+    const approvals = result.approvals;
+    if (!approvals?.length) return { needsRevoke: false, note: "no active approvals found" };
+
+    // Token-specific: check if the token being bridged has active approvals
+    const tokenApproval = tokenIn
+      ? approvals.find(a => String(a.token).toLowerCase() === String(tokenIn).toLowerCase())
+      : null;
+
+    if (tokenApproval && BigInt(tokenApproval.allowance ?? "0") > 0n) {
+      return {
+        needsRevoke: true,
+        spender: tokenApproval.spender,
+        amount: tokenApproval.allowance,
+        symbol: tokenApproval.symbol ?? "?",
+        decimals: tokenApproval.decimals ?? 18,
+        note: `approval found for ${tokenApproval.spender}, revoke before bridging`,
+      };
+    }
+
+    return {
+      needsRevoke: false,
+      note: `no active approval for this token (${approvals.length} total approvals on chain)`,
+    };
+  } catch (e) {
+    return { needsRevoke: false, note: `revoke check unavailable: ${String(e.message || e).slice(0, 100)}` };
+  }
+}
+
+/**
+ * Full bridge scan: quote all routes + revoke check.
+ * Returns data shaped for the bridge card renderer.
+ */
+export async function scanBridgeRoutes(params = {}) {
+  const [quotes, revoke] = await Promise.all([
+    aggregateBridgeQuotes(params),
+    checkRevokeNeeded({ chainId: params.fromChainId, taker: params.taker, tokenIn: params.tokenIn }),
+  ]);
+
+  const best = quotes.winner ?? {};
+
+  return {
+    kind: "bridge",
+    fromChainId: params.fromChainId,
+    toChainId: params.toChainId,
+    fromSymbol: params.fromSymbol,
+    toSymbol: params.toSymbol,
+    amount: params.amount,
+    fromDecimals: params.fromDecimals ?? 18,
+    toDecimals: params.toDecimals ?? 18,
+    bestRoute: best.provider ?? "none",
+    amountOut: best.amountOut,
+    feeUsd: best.feeUsd,
+    estimatedTime: best.estimatedTime,
+    preparable: best.preparable ? "yes" : "no (manual send)",
+    providers: quotes.providers,
+    runnersUp: quotes.runnersUp,
+    revokeCheck: revoke,
+    errors: quotes.errors,
+    confidence: quotes.providers.length >= 2 ? 0.85 : quotes.providers.length === 1 ? 0.6 : 0.1,
+  };
+}
+
+/**
+ * Health check: verify all bridge providers are reachable.
+ */
+export async function bridgeAggregatorHealth() {
+  const [d, c] = await Promise.all([
+    debridgeHealth().catch(e => ({ ok: false, error: e.message })),
+    changenowHealth().catch(e => ({ ok: false, error: e.message })),
+  ]);
+  return { debridge: d, changenow: c, lifi: { ok: true, note: "integrated via router" } };
+}