@oracle-agent/oracle 0.14.1 → 0.15.0

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

@@ -1,198 +0,0 @@
-// 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

@@ -1,103 +0,0 @@
-// 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

@@ -1,259 +0,0 @@
-// 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" } };
-}