@anywalletkit/protocol-swap2-thorchain 0.0.0-stage → 0.1.3

package/dist/chunk-AVFULD4D.js

@@ -0,0 +1,565 @@
+import {
+  describeThorchainActivity
+} from "./chunk-DIQDMNP7.js";
+import {
+  thorchain
+} from "./chunk-X6XXFQ2M.js";
+
+// src/provider.ts
+import { decodeFunctionData, encodeFunctionData } from "viem";
+import { timeoutSignal } from "@anywalletkit/protocol-swap2-core/util";
+import { ccAsset, ccAssetByToken } from "@anywalletkit/swap2-assets";
+var HOSTS = [
+  "https://gateway.liquify.com/chain/thorchain_api",
+  "https://thornode.thorchain.network"
+];
+var DEFAULT_CLIENT_ID = "anywalletkit";
+var NATIVE = "0x0000000000000000000000000000000000000000";
+var TOLERANCE_BPS = "300";
+var MAX_TOLERANCE_BPS = 500n;
+var QUOTE_VALIDITY_MS = 5 * 6e4;
+var THOR_CHAIN = {
+  "eip155:1": "ETH",
+  "eip155:8453": "BASE",
+  "eip155:56": "BSC",
+  // 2026-09-16: AVAX.AVAX/USDC/USDT pools Available (≈$2.5M/$0.3M/$0.2M),
+  // router 0x00dc61…f1d4 live in inbound_addresses; same depositWithExpiry ABI.
+  // Polygon has no THORChain pool any more — deliberately absent.
+  "eip155:43114": "AVAX",
+  "tron:728126428": "TRON",
+  "bitcoin:mainnet": "BTC",
+  // 2026-08 (pools verified live via the Liquify gateway): THORChain added
+  // SOL/XRP, and our catalog now carries LTC/DOGE/BCH/ATOM — destination legs
+  // for the step-2 off-ramp (source stays EVM/Tron, see supportsRoute).
+  "solana:mainnet": "SOL",
+  "xrp:mainnet": "XRP",
+  "litecoin:mainnet": "LTC",
+  "doge:mainnet": "DOGE",
+  "bch:mainnet": "BCH",
+  "cosmos:cosmoshub-4": "GAIA"
+};
+var CHAIN_ID = { "eip155:1": 1, "eip155:8453": 8453, "eip155:56": 56, "eip155:43114": 43114 };
+var TRON_CAIP2 = "tron:728126428";
+var DEPOSIT_SOURCES = /* @__PURE__ */ new Set([TRON_CAIP2]);
+var NATIVE_ASSET = {
+  ETH: "ETH.ETH",
+  BASE: "BASE.ETH",
+  BSC: "BSC.BNB",
+  AVAX: "AVAX.AVAX",
+  TRON: "TRON.TRX",
+  BTC: "BTC.BTC",
+  SOL: "SOL.SOL",
+  XRP: "XRP.XRP",
+  LTC: "LTC.LTC",
+  DOGE: "DOGE.DOGE",
+  BCH: "BCH.BCH",
+  GAIA: "GAIA.ATOM"
+};
+var TOKEN_ASSET = {
+  "ETH:USDC": "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+  "ETH:USDT": "ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7",
+  "BASE:USDC": "BASE.USDC-0X833589FCD6EDB6E08F4C7C32D4F71B54BDA02913",
+  "BSC:USDC": "BSC.USDC-0X8AC76A51CC950D9822D68B83FE1AD97B32CD580D",
+  "BSC:USDT": "BSC.USDT-0X55D398326F99059FF775485246999027B3197955",
+  "AVAX:USDC": "AVAX.USDC-0XB97EF9EF8734C71904D8002F8B6BC66DD9C48A6E",
+  "AVAX:USDT": "AVAX.USDT-0X9702230A8EA53601F5CD2DC00FDBC13D4DF4A8C7",
+  "TRON:USDT": "TRON.USDT-TR7NHQJEKQXGTCI8Q8ZY4PL8OTSZGJLJ6T"
+};
+var ROUTER_ABI = [
+  {
+    type: "function",
+    name: "depositWithExpiry",
+    stateMutability: "payable",
+    inputs: [
+      { name: "vault", type: "address" },
+      { name: "asset", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "memo", type: "string" },
+      { name: "expiration", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+function isEvm(caip2) {
+  return caip2.startsWith("eip155:");
+}
+function thorAsset(caip2, symbol) {
+  const chain = THOR_CHAIN[caip2];
+  if (!chain) return void 0;
+  const sym = symbol.toUpperCase();
+  const token = TOKEN_ASSET[`${chain}:${sym}`];
+  if (token) return token;
+  const native = NATIVE_ASSET[chain];
+  return native && native.split(".")[1] === sym ? native : void 0;
+}
+function destAsset(destChain, destToken) {
+  const a = ccAssetByToken(destChain, destToken);
+  if (!a) return void 0;
+  const asset = thorAsset(destChain, a.symbol);
+  return asset ? { asset, decimals: a.decimals } : void 0;
+}
+var HostUnavailable = class extends Error {
+  constructor(host, reason) {
+    super(`thorchain: ${host} unavailable (${reason})`);
+  }
+};
+async function hostGet(host, path, clientId, signal) {
+  let res;
+  try {
+    res = await fetch(`${host}${path}`, {
+      headers: { accept: "application/json", "x-client-id": clientId },
+      cache: "no-store",
+      signal: signal ?? timeoutSignal(8e3)
+    });
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    throw new HostUnavailable(host, error instanceof Error ? error.message : "fetch failed");
+  }
+  if (res.status >= 500 || res.status === 429 || res.status === 403) {
+    throw new HostUnavailable(host, `HTTP ${res.status}`);
+  }
+  const body = await res.json().catch(() => null);
+  return { ok: res.ok, status: res.status, body };
+}
+async function thornodeGet(path, signal, hosts, clientId) {
+  for (const host of hosts) {
+    try {
+      const res = await hostGet(host, path, clientId, signal);
+      if (!res.ok) continue;
+      return Array.isArray(res.body) ? null : res.body;
+    } catch (error) {
+      if (error instanceof HostUnavailable) continue;
+      throw error;
+    }
+  }
+  return null;
+}
+function belowThorMinimums(amount1e8, inbound, quote) {
+  const dust = inbound?.dust_threshold;
+  if (dust !== void 0 && (!/^\d+$/.test(String(dust)) || amount1e8 <= BigInt(dust))) return "amount at or below THORChain dust threshold";
+  const min = quote?.recommended_min_amount_in;
+  if (min !== void 0 && (!/^\d+$/.test(String(min)) || amount1e8 < BigInt(min))) return "amount below THORChain recommended minimum";
+  return null;
+}
+async function inboundAddressesOn(host, clientId) {
+  const res = await hostGet(host, "/thorchain/inbound_addresses", clientId);
+  if (!res.ok || !Array.isArray(res.body)) throw new HostUnavailable(host, `inbound_addresses HTTP ${res.status}`);
+  return res.body;
+}
+async function inboundAddresses(hosts, clientId) {
+  for (const host of hosts) {
+    try {
+      return await inboundAddressesOn(host, clientId);
+    } catch (error) {
+      if (error instanceof HostUnavailable) continue;
+      throw error;
+    }
+  }
+  return null;
+}
+function paused(entry) {
+  return !entry || entry.halted === true || entry.global_trading_paused === true || entry.chain_trading_paused === true;
+}
+function sameTarget(a, b) {
+  if (!a || !b) return false;
+  return a.startsWith("0x") || b.startsWith("0x") ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function verifiedMemo(memo, expectedAsset, expectedDestination, expectedRefund, expectedAffiliate, expectedAffiliateBps) {
+  if (memo.includes("|")) return null;
+  const parts = memo.split(":");
+  if (parts.length !== 4 && parts.length !== 6) return null;
+  const [op, asset, destination, limit, affiliate, bps] = parts;
+  if (op !== "=" || !asset || !/^[A-Za-z0-9._~\-]+$/.test(asset)) return null;
+  const expectedTarget = expectedRefund ? `${expectedDestination}/${expectedRefund}` : expectedDestination;
+  if (!sameTarget(destination, expectedTarget)) return null;
+  if (parts.length === 6) {
+    if (!expectedAffiliate || affiliate !== expectedAffiliate || bps !== expectedAffiliateBps) return null;
+  } else if (expectedAffiliate || expectedAffiliateBps) {
+    return null;
+  }
+  const stream = (limit ?? "").split("/");
+  if (stream.length !== 1 || stream.some((v) => !/^\d+$/.test(v))) return null;
+  const floor = BigInt(stream[0] ?? "0");
+  if (floor <= 0n) return null;
+  const canonical = `=:${expectedAsset}:${expectedTarget}:${stream.join("/")}${expectedAffiliate ? `:${expectedAffiliate}:${expectedAffiliateBps}` : ""}`;
+  return { limit: floor, canonical };
+}
+function toThorUnitsCeil(amount, decimals) {
+  const scale = 10n ** BigInt(decimals);
+  return (amount * 100000000n + scale - 1n) / scale;
+}
+function thorchainProvider(config = {}) {
+  config = Object.freeze({ ...config });
+  const configuredHosts = (Array.isArray(config.nodeUrl) ? config.nodeUrl : (config.nodeUrl ?? "").split(",")).map((h) => h.trim()).filter(Boolean);
+  const hosts = [...new Set((configuredHosts.length ? configuredHosts : HOSTS).map((h) => {
+    let url;
+    try {
+      url = new URL(h);
+    } catch {
+      throw new Error("thorchain: nodeUrl must be an absolute http(s) URL");
+    }
+    if (url.protocol !== "https:" && url.protocol !== "http:") throw new Error("thorchain: nodeUrl must use http or https");
+    return url.toString().replace(/\/$/, "");
+  }))];
+  const configuredAffiliate = config.affiliate ?? "";
+  const configuredAffiliateBps = config.affiliateBps ?? "";
+  if (!!configuredAffiliate !== !!configuredAffiliateBps) {
+    throw new Error("thorchain: affiliate and affiliateBps must be configured together");
+  }
+  if (configuredAffiliate && !/^[A-Za-z0-9._~-]+$/.test(configuredAffiliate)) {
+    throw new Error("thorchain: affiliate contains unsupported memo characters");
+  }
+  if (configuredAffiliateBps && (!/^\d+$/.test(configuredAffiliateBps) || BigInt(configuredAffiliateBps) > 10000n)) {
+    throw new Error("thorchain: affiliateBps must be an integer between 0 and 10000");
+  }
+  const clientId = config.clientId?.trim() || DEFAULT_CLIENT_ID;
+  if (!/^[\x21-\x7e]{1,128}$/.test(clientId)) throw new Error("thorchain: clientId must contain 1-128 visible ASCII characters");
+  const tronSource = config.tronSource === true;
+  const isDepositSource = (caip2) => tronSource && DEPOSIT_SOURCES.has(caip2);
+  return {
+    name: "thorchain",
+    describeActivity: describeThorchainActivity,
+    enabled: () => config.enabled ?? true,
+    // Capability discovery comes from the provider itself, so it can run alone
+    // or inside the optional aggregator without a central capability table.
+    supportsChain: (chain) => thorchain.supportsChain(chain),
+    supportsChainPair: (fromChain, toChain) => thorchain.supports(fromChain, toChain),
+    // Inbound: EVM/Tron source → the mainnet vault. Outbound (step-2 off-ramp):
+    // EVM source (Ethereum) → any THOR-supported chain. The SOURCE must be EVM
+    // (router calldata) or, when opted in, Tron (send + memo); both legs must
+    // be THOR chains and differ.
+    supportsRoute(from, to) {
+      const srcExec = isEvm(from.chain) || isDepositSource(from.chain);
+      if (!(srcExec && !!THOR_CHAIN[from.chain] && !!THOR_CHAIN[to.chain] && from.chain !== to.chain)) return false;
+      const fromAsset = thorAsset(from.chain, from.token) ?? thorAsset(from.chain, ccAssetByToken(from.chain, from.token)?.symbol ?? "");
+      const toAsset = destAsset(to.chain, to.token) ?? (thorAsset(to.chain, to.token) ? { asset: thorAsset(to.chain, to.token) } : void 0);
+      return !!fromAsset && !!toAsset && fromAsset !== toAsset.asset;
+    },
+    async getQuote(params, signal) {
+      if (!(config.enabled ?? true)) return null;
+      if (params.flex) return null;
+      const chainId = CHAIN_ID[params.sourceChain];
+      if (!chainId && !isDepositSource(params.sourceChain)) return null;
+      if (params.sourceChain === params.destChain) return null;
+      const src = ccAsset(params.sourceChain, params.sourceToken);
+      const fromAsset = thorAsset(params.sourceChain, params.sourceToken);
+      const dst = destAsset(params.destChain, params.destToken);
+      if (!src || !fromAsset || !dst || fromAsset === dst.asset) {
+        params.onRefusal?.(`thorchain: no pool for ${params.sourceToken} on ${params.sourceChain} \u2192 ${params.destToken} on ${params.destChain}`);
+        return null;
+      }
+      const amountIn = BigInt(params.amountIn);
+      const amount1e8 = amountIn * 100000000n / 10n ** BigInt(src.decimals);
+      if (amount1e8 <= 0n) return null;
+      if (amount1e8 * 10n ** BigInt(src.decimals) !== amountIn * 100000000n) {
+        params.onRefusal?.(`thorchain: amount has more precision than THORChain's 8 decimals \u2014 round it to 8 decimals`);
+        return null;
+      }
+      const requestedTolerance = params.slippageBps ?? Number(TOLERANCE_BPS);
+      if (!Number.isInteger(requestedTolerance) || requestedTolerance < 0 || requestedTolerance > Number(MAX_TOLERANCE_BPS)) {
+        params.onRefusal?.(`thorchain: slippage ${String(params.slippageBps)} bps is outside 0\u2013${MAX_TOLERANCE_BPS} bps`);
+        return null;
+      }
+      const explicitSlippage = params.slippageBps !== void 0;
+      const liquidityBps = explicitSlippage ? dst.decimals > 8 ? requestedTolerance - 1 : requestedTolerance : 0;
+      const limitMode = liquidityBps > 0 ? "liquidity_tolerance_bps" : "tolerance_bps";
+      const quoteOn = async (host, bps, limitMode2 = "tolerance_bps") => {
+        const qs = new URLSearchParams({
+          from_asset: fromAsset,
+          to_asset: dst.asset,
+          amount: amount1e8.toString(),
+          destination: params.destAddress,
+          [limitMode2]: bps,
+          // Pin a single (non-streaming) swap. Left to itself the node picks
+          // streaming for thin pools (max_streaming_quantity > 1) and then
+          // simulates the LIM per sub-swap — the adaptive retry could never
+          // pass on BASE.ETH / BSC stables (verified 2026-09-16). We reject
+          // streaming memos anyway, so the quote must be simulated atomically.
+          streaming_quantity: "1"
+        });
+        if (configuredAffiliate && configuredAffiliateBps) {
+          qs.set("affiliate", configuredAffiliate);
+          qs.set("affiliate_bps", configuredAffiliateBps);
+        }
+        if (params.refundAddress) qs.set("refund_address", params.refundAddress);
+        const res = await hostGet(host, `/thorchain/quote/swap?${qs.toString()}`, clientId, signal);
+        if (Array.isArray(res.body)) return null;
+        return res.body ?? (res.ok ? null : { error: `HTTP ${res.status}` });
+      };
+      let q = null;
+      let checkedMemo = null;
+      let inbounds = null;
+      for (const host of hosts) {
+        try {
+          if (limitMode === "liquidity_tolerance_bps") {
+            q = await quoteOn(host, String(liquidityBps), "liquidity_tolerance_bps");
+            const feeBps = Number(q?.fees?.total_bps);
+            if (Number.isFinite(feeBps) && feeBps > Number(MAX_TOLERANCE_BPS)) {
+              params.onRefusal?.(`thorchain: THORChain fees ${(feeBps / 100).toFixed(2)}% \u2014 too expensive at this amount (cap ${Number(MAX_TOLERANCE_BPS) / 100}%)`);
+              return null;
+            }
+          } else {
+            q = await quoteOn(host, String(requestedTolerance));
+            const rejected = (q?.error ?? q?.message)?.match(/emit asset (\d+) less than price limit (\d+)/);
+            if (rejected && !explicitSlippage) {
+              const emit = BigInt(rejected[1] ?? "0");
+              const limit = BigInt(rejected[2] ?? "0");
+              if (emit > 0n && limit > emit) {
+                const spot = limit * 10000n / (10000n - BigInt(requestedTolerance));
+                const needed = 10000n - emit * 10000n / spot + 50n;
+                if (needed <= MAX_TOLERANCE_BPS) q = await quoteOn(host, needed.toString());
+              }
+            }
+          }
+          if (q?.error || q?.message) {
+            params.onRefusal?.(`thorchain: ${String(q.error ?? q.message).slice(0, 200)}`);
+            return null;
+          }
+          if (!q || !q.expected_amount_out || !q.inbound_address || !q.memo || !q.expiry) {
+            params.onRefusal?.(`thorchain: incomplete quote from ${host} (expected_amount_out / inbound_address / memo / expiry missing)`);
+            return null;
+          }
+          if (chainId ? !q.router : !!q.router) {
+            params.onRefusal?.(chainId ? "thorchain: quote has no router for an EVM source" : "thorchain: quote names a router for a deposit source \u2014 execution model changed");
+            return null;
+          }
+          checkedMemo = verifiedMemo(q.memo, dst.asset, params.destAddress, params.refundAddress ?? "", configuredAffiliate, configuredAffiliateBps);
+          if (!checkedMemo) {
+            params.onRefusal?.(`thorchain: memo failed verification (${String(q.memo).slice(0, 80)})`);
+            return null;
+          }
+          const floor1e8 = params.minAmountOut !== void 0 ? toThorUnitsCeil(BigInt(params.minAmountOut), dst.decimals) : void 0;
+          if (floor1e8 !== void 0 && checkedMemo.limit < floor1e8) {
+            params.onRefusal?.(`thorchain: floor breach (limit=${checkedMemo.limit} < floor=${floor1e8}, 1e8 units)`);
+            return null;
+          }
+          inbounds = await inboundAddressesOn(host, clientId);
+          break;
+        } catch (error) {
+          if (error instanceof HostUnavailable) {
+            q = null;
+            checkedMemo = null;
+            inbounds = null;
+            continue;
+          }
+          throw error;
+        }
+      }
+      if (!q?.expected_amount_out || !q.inbound_address || !q.expiry || !checkedMemo || !inbounds) {
+        params.onRefusal?.(!inbounds ? "thorchain: inbound addresses unavailable from every node" : "thorchain: no quote from any node");
+        return null;
+      }
+      const limit1e8 = checkedMemo.limit;
+      const srcInbound = inbounds.find((entry) => entry.chain === THOR_CHAIN[params.sourceChain]);
+      const dstInbound = inbounds.find((entry) => entry.chain === THOR_CHAIN[params.destChain]);
+      if (paused(srcInbound) || paused(dstInbound)) {
+        params.onRefusal?.(`thorchain: ${paused(srcInbound) ? THOR_CHAIN[params.sourceChain] : THOR_CHAIN[params.destChain]} chain is halted / paused on THORChain`);
+        return null;
+      }
+      if (!sameTarget(srcInbound?.address, q.inbound_address)) {
+        params.onRefusal?.("thorchain: quote inbound address differs from the node's current inbound (vault rotated) \u2014 retry");
+        return null;
+      }
+      if (chainId && !sameTarget(srcInbound?.router, q.router)) {
+        params.onRefusal?.("thorchain: quote router differs from the node's current router \u2014 retry");
+        return null;
+      }
+      const tooSmall = belowThorMinimums(amount1e8, srcInbound, q);
+      if (tooSmall) {
+        params.onRefusal?.(`thorchain: ${tooSmall}`);
+        return null;
+      }
+      const outUnits = BigInt(q.expected_amount_out) * 10n ** BigInt(dst.decimals) / 100000000n;
+      if (outUnits <= 0n) {
+        params.onRefusal?.("thorchain: expected output rounds to zero");
+        return null;
+      }
+      const memoMinUnits = limit1e8 * 10n ** BigInt(dst.decimals) / 100000000n;
+      const minUnits = memoMinUnits;
+      if (minUnits <= 0n || minUnits > outUnits) {
+        params.onRefusal?.(`thorchain: memo limit ${limit1e8} inconsistent with expected output ${q.expected_amount_out}`);
+        return null;
+      }
+      if (params.slippageBps !== void 0) {
+        const slippageFloor = outUnits * BigInt(1e4 - params.slippageBps) / 10000n;
+        if (minUnits < slippageFloor) {
+          params.onRefusal?.(`thorchain: memo limit ${limit1e8} is below expected ${q.expected_amount_out} minus ${params.slippageBps} bps slippage (1e8 units)`);
+          return null;
+        }
+      }
+      const nowSeconds = Math.floor(Date.now() / 1e3);
+      const executionExpiry = Math.min(q.expiry, nowSeconds + 15 * 60);
+      if (!Number.isInteger(executionExpiry) || executionExpiry <= nowSeconds + 30) {
+        params.onRefusal?.(`thorchain: quote expires in ${Number.isInteger(executionExpiry) ? executionExpiry - nowSeconds : "?"} s \u2014 too soon to execute`);
+        return null;
+      }
+      const assetAddr = src.contract ? src.contract : NATIVE;
+      const common = {
+        provider: "thorchain",
+        intentId: `thorchain:${chainId ?? THOR_CHAIN[params.sourceChain]}`,
+        sourceAmount: params.amountIn,
+        destAmount: outUnits.toString(),
+        minDestAmount: minUnits.toString(),
+        feeUsd: 0,
+        // destAmount is already net of THORChain fees
+        etaSeconds: q.total_swap_seconds ?? 120,
+        reliability: 0.9,
+        // Validity must outlive the ERC-20 approval leg: for USDT that is
+        // approve(0) + approve(n), each awaited to inclusion (≈2 blocks), so a
+        // 60 s window expired before the deposit and only the revoke went out
+        // (2026-09-16). The on-chain LIM bounds price movement and preflight
+        // re-checks vault/router/halts right before broadcast, so a longer
+        // window costs nothing in safety.
+        validUntilMs: Math.min(Date.now() + QUOTE_VALIDITY_MS, executionExpiry * 1e3),
+        providerData: {
+          sourceChain: params.sourceChain,
+          destChain: params.destChain,
+          inboundAddress: q.inbound_address,
+          router: q.router ?? "",
+          assetAddress: assetAddr,
+          expiry: String(executionExpiry),
+          memo: checkedMemo.canonical
+        }
+      };
+      if (!chainId) {
+        return { ...common, depositAddress: q.inbound_address, depositMemo: checkedMemo.canonical };
+      }
+      const data = encodeFunctionData({
+        abi: ROUTER_ABI,
+        functionName: "depositWithExpiry",
+        args: [q.inbound_address, assetAddr, amountIn, checkedMemo.canonical, BigInt(executionExpiry)]
+      });
+      return {
+        ...common,
+        depositAddress: "",
+        depositMemo: null,
+        txRequest: {
+          to: q.router,
+          data,
+          value: src.contract ? "0" : params.amountIn,
+          chainId,
+          ...src.contract ? { approvalAddress: q.router } : {}
+        }
+      };
+    },
+    async buildDeposit(quote) {
+      if (!quote.txRequest) {
+        const sourceChain = quote.providerData?.sourceChain ?? "";
+        if (!isDepositSource(sourceChain) || !quote.depositAddress || !quote.depositMemo) {
+          throw new Error("thorchain: deposit-address execution is only supported for an opted-in Tron source");
+        }
+        return { chain: sourceChain, to: quote.depositAddress, value: quote.sourceAmount, memo: quote.depositMemo };
+      }
+      return {
+        chain: "",
+        to: quote.txRequest?.to ?? "",
+        value: quote.txRequest?.value ?? "0",
+        ...quote.txRequest?.data ? { data: quote.txRequest.data } : {},
+        ...quote.txRequest?.chainId !== void 0 ? { chainId: quote.txRequest.chainId } : {},
+        ...quote.txRequest?.gasLimit ? { gasLimit: quote.txRequest.gasLimit } : {},
+        ...quote.txRequest?.approvalAddress ? { approvalAddress: quote.txRequest.approvalAddress } : {}
+      };
+    },
+    async preflightDeposit(quote, tx) {
+      const data = quote.providerData;
+      if (!data?.sourceChain || !data.destChain || !data.inboundAddress || !data.assetAddress || !data.expiry || !data.memo) {
+        throw new Error("thorchain: quote is missing execution-bound metadata");
+      }
+      const evmSource = CHAIN_ID[data.sourceChain] !== void 0;
+      if (evmSource && !data.router) throw new Error("thorchain: quote is missing execution-bound metadata");
+      if (!evmSource && !isDepositSource(data.sourceChain)) throw new Error("thorchain: source chain has no executor");
+      if (!/^\d+$/.test(data.expiry) || BigInt(data.expiry) <= BigInt(Math.floor(Date.now() / 1e3))) {
+        throw new Error("thorchain: quote expired before broadcast");
+      }
+      const inbounds = await inboundAddresses(hosts, clientId);
+      if (!inbounds) throw new Error("thorchain: cannot refresh inbound addresses before broadcast");
+      const src = inbounds.find((entry) => entry.chain === THOR_CHAIN[data.sourceChain]);
+      const dst = inbounds.find((entry) => entry.chain === THOR_CHAIN[data.destChain]);
+      if (paused(src) || paused(dst)) throw new Error("thorchain: source or destination chain trading is paused");
+      if (!sameTarget(src?.address, data.inboundAddress)) throw new Error("thorchain: inbound vault rotated after quote");
+      if (!evmSource) {
+        if (tx.data !== void 0 || tx.approvalAddress !== void 0 || tx.bodyBoc !== void 0 || tx.typedData !== void 0 || tx.serializedTx !== void 0 || tx.stateInitBoc !== void 0) {
+          throw new Error("thorchain: deposit-address execution must be a plain send with memo");
+        }
+        if (!sameTarget(tx.to, data.inboundAddress) || tx.memo !== data.memo || tx.value !== quote.sourceAmount || tx.chain && tx.chain !== data.sourceChain) {
+          throw new Error("thorchain: deposit does not match the validated quote");
+        }
+        const srcAsset = ccAssetByToken(data.sourceChain, sameTarget(data.assetAddress, NATIVE) ? "" : data.assetAddress);
+        if (!srcAsset) throw new Error("thorchain: unknown source asset");
+        const amount1e8 = BigInt(quote.sourceAmount) * 100000000n / 10n ** BigInt(srcAsset.decimals);
+        const tooSmall = belowThorMinimums(amount1e8, src, null);
+        if (tooSmall) throw new Error(`thorchain: ${tooSmall}`);
+        return;
+      }
+      if (!sameTarget(src?.router, data.router) || !sameTarget(tx.to, data.router)) {
+        throw new Error("thorchain: router rotated after quote");
+      }
+      if (!tx.data) throw new Error("thorchain: missing depositWithExpiry calldata");
+      let decoded;
+      try {
+        decoded = decodeFunctionData({ abi: ROUTER_ABI, data: tx.data });
+      } catch {
+        throw new Error("thorchain: malformed depositWithExpiry calldata");
+      }
+      const args = decoded.args;
+      if (decoded.functionName !== "depositWithExpiry" || !args || args.length !== 5 || !sameTarget(String(args[0]), data.inboundAddress) || !sameTarget(String(args[1]), data.assetAddress) || BigInt(args[2]) !== BigInt(quote.sourceAmount) || String(args[3]) !== data.memo || BigInt(args[4]) !== BigInt(data.expiry) || tx.chainId !== CHAIN_ID[data.sourceChain]) {
+        throw new Error("thorchain: calldata does not match the validated quote");
+      }
+      const tokenSource = !sameTarget(data.assetAddress, NATIVE);
+      if (tx.value !== (tokenSource ? "0" : quote.sourceAmount) || (tokenSource ? !sameTarget(tx.approvalAddress, data.router) : tx.approvalAddress !== void 0)) {
+        throw new Error("thorchain: value/approval does not match the validated source asset");
+      }
+    },
+    async trackIntent(ref) {
+      if (!ref.sourceTxHash) return { state: "pending" };
+      if (!/^(?:0x)?[0-9a-fA-F]{64}$/.test(ref.sourceTxHash)) {
+        throw new Error("thorchain: source transaction hash must be 32-byte hex");
+      }
+      const hash = ref.sourceTxHash.replace(/^0x/i, "").toUpperCase();
+      const j = await thornodeGet(`/thorchain/tx/status/${hash}`, void 0, hosts, clientId) ?? await thornodeGet(`/thorchain/tx/${hash}`, void 0, hosts, clientId);
+      if (!j) return { state: "pending" };
+      const stages = j.stages;
+      if (stages) {
+        const planned = j.planned_out_txs ?? [];
+        const refunded = planned.some((out) => out.refund === true);
+        const delivered = planned.some((out) => out.refund === false);
+        const outTxs = j.out_txs ?? [];
+        const outHash2 = outTxs.find((out) => typeof out.id === "string" && out.id.length > 0 && !/^0+$/.test(out.id))?.id;
+        const deliveredHash = outTxs.find(
+          (out) => typeof out.id === "string" && out.id.length > 0 && !/^0+$/.test(out.id) && typeof out.memo === "string" && !/^REFUND/i.test(out.memo)
+        )?.id;
+        if (stages.outbound_signed?.completed) {
+          if (!refunded && !delivered || !outHash2) {
+            return { state: "pending", depositReceived: true };
+          }
+          return refunded && delivered ? { state: "partial", depositReceived: true, ...deliveredHash ? { destTxHash: deliveredHash } : {} } : refunded ? { state: "refunded", depositReceived: true } : { state: "completed", depositReceived: true, ...outHash2 ? { destTxHash: outHash2 } : {} };
+        }
+        return {
+          state: "pending",
+          depositReceived: !!(stages.inbound_observed?.started || stages.inbound_observed?.completed || stages.inbound_finalised?.completed)
+        };
+      }
+      const obs = j.observed_tx;
+      const outHash = obs?.out_hashes?.find((h) => typeof h === "string" && h.length > 0 && !/^0+$/.test(h));
+      if (obs?.status === "done") {
+        const planned = j.planned_out_txs ?? j.out_txs ?? [];
+        const refunded = planned.some(
+          (o) => o?.refund === true || /^REFUND/i.test(o?.memo ?? "")
+        );
+        const delivered = planned.some(
+          (o) => o?.refund === false && !/^REFUND/i.test(o?.memo ?? "")
+        );
+        if (!refunded && !delivered || !outHash) return { state: "pending", depositReceived: true };
+        if (refunded && delivered) return { state: "partial", depositReceived: true };
+        if (refunded) return { state: "refunded", depositReceived: true };
+        return { state: "completed", ...outHash ? { destTxHash: outHash } : {} };
+      }
+      return { state: "pending", depositReceived: !!obs };
+    }
+  };
+}
+
+export {
+  thorchainProvider
+};
+//# sourceMappingURL=chunk-AVFULD4D.js.map