@stablechain/sdk 1.0.5 → 1.0.7

package/dist/index.cjs

@@ -1737,46 +1737,88 @@ function isLiFiQuoteShape(v) {
 
 
 
+
+
 var C = CHAIN_CONFIGS;
+var XAUT0_DEPLOYMENTS = {
+  ["ethereum" /* Ethereum */]: { address: "0x68749665FF8D2d112Fa859AA293F07A622782F38", decimals: 6, oftAdapter: "0xb9c2321BB7D0Db468f570D10A424d1Cc8EFd696C", approvalRequired: true },
+  ["stable" /* Stable */]: { address: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb", decimals: 6, oftAdapter: "0xD8479f87686ed263D00Ca7505F86327dbeD4171A", approvalRequired: false },
+  ["arbitrum" /* Arbitrum */]: { address: "0x40461291347e1eCbb09499F3371D3f17f10d7159", decimals: 6, oftAdapter: "0xf40542a7B66AD7C68C459EE3679635D2fDB6dF39", approvalRequired: false },
+  ["ink" /* Ink */]: { address: "0xF50258D3c1dd88946C567920B986A12e65b50dAc", decimals: 6, oftAdapter: "0xA1bE1572B4beef24f812EfDc58bdc41D56a0dAB2", approvalRequired: false },
+  ["hyperevm" /* HyperEVM */]: { address: "0xf4D9235269a96aaDaFc9aDAe454a0618eBE37949", decimals: 6, oftAdapter: "0x4E41cfc3F3B19E29E323D2c36F8f202a1e151dAF", approvalRequired: false },
+  ["polygon" /* Polygon */]: { address: "0xF1815bd50389c46847f0Bda824eC8da914045D14", decimals: 6, oftAdapter: "0x5421Cf4288d8007D3c43AC4246eaFCe5b049e352", approvalRequired: false },
+  ["plasma" /* Plasma */]: { address: "0x1B64B9025EEbb9A6239575dF9Ea4b9Ac46D4d193", decimals: 6, oftAdapter: "0x63aB93cBC9d4ecD9c4947b1A38F458147C08E6F7", approvalRequired: false },
+  ["bsc" /* BSC */]: { address: "0x21cAef8A43163Eea865baeE23b9C2E327696A3bf", decimals: 6, oftAdapter: "0x53C3A64c8942288e12813C1F8457Db45980BcfC2", approvalRequired: false }
+};
+var USDT0_LOCKBOX_CHAINS = /* @__PURE__ */ new Set(["ethereum" /* Ethereum */, "sepolia" /* Sepolia */]);
+function bridgeChain(chain, lzEid, blockTimeSec, usdt0Adapter) {
+  const base = C[chain];
+  const tokens = {};
+  if (usdt0Adapter) {
+    tokens.usdt0 = {
+      address: base.usdt,
+      decimals: base.decimals,
+      oftAdapter: usdt0Adapter,
+      approvalRequired: USDT0_LOCKBOX_CHAINS.has(chain)
+    };
+  }
+  const xaut0 = XAUT0_DEPLOYMENTS[chain];
+  if (xaut0) tokens.xaut0 = xaut0;
+  return { ...base, lzEid, blockTimeSec, tokens, oftAdapter: usdt0Adapter };
+}
 var BRIDGE_CHAIN_CONFIGS = {
   // ─── Testnet ───────────────────────────────────────────────────────────────
-  ["sepolia" /* Sepolia */]: { ...C["sepolia" /* Sepolia */], lzEid: 40161, oftAdapter: "0xc099cD946d5efCC35A99D64E808c1430cEf08126", blockTimeSec: 12 },
-  ["stable-testnet" /* StableTestnet */]: { ...C["stable-testnet" /* StableTestnet */], lzEid: 40374, oftAdapter: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736", blockTimeSec: 0.7 },
+  ["sepolia" /* Sepolia */]: bridgeChain("sepolia" /* Sepolia */, 40161, 12, "0xc099cD946d5efCC35A99D64E808c1430cEf08126"),
+  ["stable-testnet" /* StableTestnet */]: bridgeChain("stable-testnet" /* StableTestnet */, 40374, 0.7, "0x779Ded0c9e1022225f8E0630b35a9b54bE713736"),
   // ─── Mainnet ──────────────────────────────────────────────────────────────
-  ["stable" /* Stable */]: { ...C["stable" /* Stable */], lzEid: 30396, oftAdapter: "0xedaba024be4d87974d5aB11C6Dd586963CcCB027", blockTimeSec: 0.7 },
-  ["ethereum" /* Ethereum */]: { ...C["ethereum" /* Ethereum */], lzEid: 30101, oftAdapter: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee", blockTimeSec: 12 },
-  ["arbitrum" /* Arbitrum */]: { ...C["arbitrum" /* Arbitrum */], lzEid: 30110, oftAdapter: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92", blockTimeSec: 0.25 },
-  ["ink" /* Ink */]: { ...C["ink" /* Ink */], lzEid: 30339, oftAdapter: "0x1cB6De532588fCA4a21B7209DE7C456AF8434A65", blockTimeSec: 1 },
-  ["bera" /* Bera */]: { ...C["bera" /* Bera */], lzEid: 30362, oftAdapter: "0x3Dc96399109df5ceb2C226664A086140bD0379cB", blockTimeSec: 2 },
-  ["megaeth" /* MegaETH */]: { ...C["megaeth" /* MegaETH */], lzEid: 30398, oftAdapter: "0x9151434b16b9763660705744891fa906f660ecc5", blockTimeSec: 1 },
-  ["hyperevm" /* HyperEVM */]: { ...C["hyperevm" /* HyperEVM */], lzEid: 30367, oftAdapter: "0x904861a24F30EC96ea7CFC3bE9EA4B476d237e98", blockTimeSec: 1 },
-  ["polygon" /* Polygon */]: { ...C["polygon" /* Polygon */], lzEid: 30109, oftAdapter: "0x6BA10300f0DC58B7a1e4c0e41f5daBb7D7829e13", blockTimeSec: 1.5 },
-  ["plasma" /* Plasma */]: { ...C["plasma" /* Plasma */], lzEid: 30383, oftAdapter: "0x02ca37966753bDdDf11216B73B16C1dE756A7CF9", blockTimeSec: 1 },
-  ["optimism" /* Optimism */]: { ...C["optimism" /* Optimism */], lzEid: 30111, oftAdapter: "0xF03b4d9AC1D5d1E7c4cEf54C2A313b9fe051A0aD", blockTimeSec: 2 },
-  ["unichain" /* Unichain */]: { ...C["unichain" /* Unichain */], lzEid: 30320, oftAdapter: "0xc07bE8994D035631c36fb4a89C918CeFB2f03EC3", blockTimeSec: 1 },
-  ["sei" /* Sei */]: { ...C["sei" /* Sei */], lzEid: 30280, oftAdapter: "0x56Fe74A2e3b484b921c447357203431a3485CC60", blockTimeSec: 0.5 },
-  ["flare" /* Flare */]: { ...C["flare" /* Flare */], lzEid: 30295, oftAdapter: "0x567287d2A9829215a37e3B88843d32f9221E7588", blockTimeSec: 1.1 },
-  ["xlayer" /* XLayer */]: { ...C["xlayer" /* XLayer */], lzEid: 30274, oftAdapter: "0x94BCCa6bdfd6A61817Ab0E960bFedE4984505554", blockTimeSec: 1 },
-  ["rootstock" /* Rootstock */]: { ...C["rootstock" /* Rootstock */], lzEid: 30333, oftAdapter: "0x1a594d5d5d1c426281C1064B07f23F57B2716B61", blockTimeSec: 31 }
+  ["stable" /* Stable */]: bridgeChain("stable" /* Stable */, 30396, 0.7, "0xedaba024be4d87974d5aB11C6Dd586963CcCB027"),
+  ["ethereum" /* Ethereum */]: bridgeChain("ethereum" /* Ethereum */, 30101, 12, "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee"),
+  ["arbitrum" /* Arbitrum */]: bridgeChain("arbitrum" /* Arbitrum */, 30110, 0.25, "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92"),
+  ["ink" /* Ink */]: bridgeChain("ink" /* Ink */, 30339, 1, "0x1cB6De532588fCA4a21B7209DE7C456AF8434A65"),
+  ["bera" /* Bera */]: bridgeChain("bera" /* Bera */, 30362, 2, "0x3Dc96399109df5ceb2C226664A086140bD0379cB"),
+  ["megaeth" /* MegaETH */]: bridgeChain("megaeth" /* MegaETH */, 30398, 1, "0x9151434b16b9763660705744891fa906f660ecc5"),
+  ["hyperevm" /* HyperEVM */]: bridgeChain("hyperevm" /* HyperEVM */, 30367, 1, "0x904861a24F30EC96ea7CFC3bE9EA4B476d237e98"),
+  ["polygon" /* Polygon */]: bridgeChain("polygon" /* Polygon */, 30109, 1.5, "0x6BA10300f0DC58B7a1e4c0e41f5daBb7D7829e13"),
+  ["plasma" /* Plasma */]: bridgeChain("plasma" /* Plasma */, 30383, 1, "0x02ca37966753bDdDf11216B73B16C1dE756A7CF9"),
+  ["optimism" /* Optimism */]: bridgeChain("optimism" /* Optimism */, 30111, 2, "0xF03b4d9AC1D5d1E7c4cEf54C2A313b9fe051A0aD"),
+  ["unichain" /* Unichain */]: bridgeChain("unichain" /* Unichain */, 30320, 1, "0xc07bE8994D035631c36fb4a89C918CeFB2f03EC3"),
+  ["sei" /* Sei */]: bridgeChain("sei" /* Sei */, 30280, 0.5, "0x56Fe74A2e3b484b921c447357203431a3485CC60"),
+  ["flare" /* Flare */]: bridgeChain("flare" /* Flare */, 30295, 1.1, "0x567287d2A9829215a37e3B88843d32f9221E7588"),
+  ["xlayer" /* XLayer */]: bridgeChain("xlayer" /* XLayer */, 30274, 1, "0x94BCCa6bdfd6A61817Ab0E960bFedE4984505554"),
+  ["rootstock" /* Rootstock */]: bridgeChain("rootstock" /* Rootstock */, 30333, 31, "0x1a594d5d5d1c426281C1064B07f23F57B2716B61"),
+  // XAUt0 only — BSC has no USDT0 deployment. Block time measured 2026-08-20.
+  ["bsc" /* BSC */]: bridgeChain("bsc" /* BSC */, 30102, 0.45)
+};
+function bridgeAssetFor(cfg, token) {
+  const needle = token.toLowerCase();
+  return Object.keys(cfg.tokens).find(
+    (asset) => _optionalChain([cfg, 'access', _36 => _36.tokens, 'access', _37 => _37[asset], 'optionalAccess', _38 => _38.address, 'access', _39 => _39.toLowerCase, 'call', _40 => _40()]) === needle
+  );
+}
+function describeAssets(cfg) {
+  const assets = Object.entries(cfg.tokens);
+  if (assets.length === 0) return "no OFT assets";
+  return assets.map(([asset, token]) => `${asset} (${token.address})`).join(" or ");
+}
+var SEND_PARAM_INPUT = {
+  name: "_sendParam",
+  type: "tuple",
+  components: [
+    { name: "dstEid", type: "uint32" },
+    { name: "to", type: "bytes32" },
+    { name: "amountLD", type: "uint256" },
+    { name: "minAmountLD", type: "uint256" },
+    { name: "extraOptions", type: "bytes" },
+    { name: "composeMsg", type: "bytes" },
+    { name: "oftCmd", type: "bytes" }
+  ]
 };
 var OFT_ADAPTER_ABI = [
   {
     name: "quoteSend",
     type: "function",
     inputs: [
-      {
-        name: "_sendParam",
-        type: "tuple",
-        components: [
-          { name: "dstEid", type: "uint32" },
-          { name: "to", type: "bytes32" },
-          { name: "amountLD", type: "uint256" },
-          { name: "minAmountLD", type: "uint256" },
-          { name: "extraOptions", type: "bytes" },
-          { name: "composeMsg", type: "bytes" },
-          { name: "oftCmd", type: "bytes" }
-        ]
-      },
+      SEND_PARAM_INPUT,
       { name: "_payInLzToken", type: "bool" }
     ],
     outputs: [
@@ -1792,22 +1834,48 @@ var OFT_ADAPTER_ABI = [
     stateMutability: "view"
   },
   {
-    name: "send",
+    // OFT-level accounting, independent of the LayerZero messaging fee: the
+    // pathway's accepted range, any fee the adapter charges itself, and what the
+    // recipient actually ends up credited.
+    name: "quoteOFT",
     type: "function",
     inputs: [
+      SEND_PARAM_INPUT
+    ],
+    outputs: [
       {
-        name: "_sendParam",
+        name: "oftLimit",
         type: "tuple",
         components: [
-          { name: "dstEid", type: "uint32" },
-          { name: "to", type: "bytes32" },
-          { name: "amountLD", type: "uint256" },
           { name: "minAmountLD", type: "uint256" },
-          { name: "extraOptions", type: "bytes" },
-          { name: "composeMsg", type: "bytes" },
-          { name: "oftCmd", type: "bytes" }
+          { name: "maxAmountLD", type: "uint256" }
         ]
       },
+      {
+        name: "oftFeeDetails",
+        type: "tuple[]",
+        components: [
+          // Signed: a negative detail is a credit to the sender, not a charge.
+          { name: "feeAmountLD", type: "int256" },
+          { name: "description", type: "string" }
+        ]
+      },
+      {
+        name: "oftReceipt",
+        type: "tuple",
+        components: [
+          { name: "amountSentLD", type: "uint256" },
+          { name: "amountReceivedLD", type: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    name: "send",
+    type: "function",
+    inputs: [
+      SEND_PARAM_INPUT,
       {
         name: "_fee",
         type: "tuple",
@@ -1880,7 +1948,7 @@ var ScanHttpError = class extends Error {
 async function scanFetch(path, timeoutMs = 8e3) {
   const res = await fetch(`${LZ_SCAN_API}${path}`, { signal: AbortSignal.timeout(timeoutMs) });
   if (!res.ok) throw new ScanHttpError(res.status, path);
-  return res.json();
+  return await res.json();
 }
 var TERMINAL_FAILURE_STATUSES = /* @__PURE__ */ new Set([
   "FAILED",
@@ -1896,62 +1964,293 @@ function median(values) {
   const mid = Math.floor(sorted.length / 2);
   return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
 }
-function buildLzOptions(gasLimit = 0n) {
+var WORKER_EXECUTOR = 1;
+var OPTION_LZRECEIVE = 1;
+var OPTION_NATIVE_DROP = 2;
+function lzOption(optionType, payload) {
+  const payloadBytes = (payload.length - 2) / 2;
+  return _viem.concat.call(void 0, [
+    _viem.numberToHex.call(void 0, WORKER_EXECUTOR, { size: 1 }),
+    _viem.numberToHex.call(void 0, 1 + payloadBytes, { size: 2 }),
+    _viem.numberToHex.call(void 0, optionType, { size: 1 }),
+    payload
+  ]);
+}
+function buildLzOptions(gasLimit = 0n, nativeDrop = 0n, dropReceiver) {
+  const options = [
+    lzOption(OPTION_LZRECEIVE, _viem.numberToHex.call(void 0, gasLimit, { size: 16 }))
+  ];
+  if (nativeDrop > 0n) {
+    if (!dropReceiver) {
+      throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+        "recipient",
+        dropReceiver,
+        "buildLzOptions: a native drop needs a receiver address"
+      );
+    }
+    options.push(
+      lzOption(
+        OPTION_NATIVE_DROP,
+        _viem.concat.call(void 0, [
+          _viem.numberToHex.call(void 0, nativeDrop, { size: 16 }),
+          _viem.padHex.call(void 0, dropReceiver, { dir: "left", size: 32 })
+        ])
+      )
+    );
+  }
   return _viem.concat.call(void 0, [
     _viem.numberToHex.call(void 0, 3, { size: 2 }),
     // TYPE_3 header
-    _viem.numberToHex.call(void 0, 1, { size: 1 }),
-    // Executor worker ID
-    _viem.numberToHex.call(void 0, 17, { size: 2 }),
-    // option payload length = 17 bytes
-    _viem.numberToHex.call(void 0, 1, { size: 1 }),
-    // LzReceive option type
-    _viem.numberToHex.call(void 0, gasLimit, { size: 16 })
-    // gas limit as uint128
+    ...options
   ]);
 }
+var FALLBACK_SEND_GAS = 400000n;
+var DEFAULT_FEE_BUFFER_BPS = 500;
+var MAX_FEE_BUFFER_BPS = 1e4;
+function padFee(nativeFee, bufferBps) {
+  return nativeFee * BigInt(1e4 + bufferBps) / 10000n;
+}
+function resolveFeeBuffer(feeBufferBps, method) {
+  if (feeBufferBps === void 0) return DEFAULT_FEE_BUFFER_BPS;
+  if (!Number.isInteger(feeBufferBps) || feeBufferBps < 0 || feeBufferBps > MAX_FEE_BUFFER_BPS) {
+    throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+      "feeBufferBps",
+      feeBufferBps,
+      `${method}: feeBufferBps must be an integer between 0 and ${MAX_FEE_BUFFER_BPS}`
+    );
+  }
+  return feeBufferBps;
+}
+function usableQuote(quote, amountLD) {
+  if (!_optionalChain([quote, 'optionalAccess', _41 => _41.oft])) return quote;
+  return quote.oft.amountSentLD <= amountLD ? quote : void 0;
+}
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var LayerZeroService = class {
   constructor(config) {
     this.config = config;
+    this.rpcById = new Map(
+      Object.entries(_nullishCoalesce(config.rpcOverrides, () => ( {}))).flatMap(([chain, rpc]) => {
+        const id = _optionalChain([CHAIN_CONFIGS, 'access', _42 => _42[chain], 'optionalAccess', _43 => _43.id]);
+        return id === void 0 || !rpc ? [] : [[id, rpc.replace(/\/$/, "")]];
+      })
+    );
+  }
+  /**
+   * The RPC to read and broadcast on for a chain: the caller's override when they
+   * gave one, else the built-in public endpoint. Every bridge read goes through
+   * here — a backend quoting on a loop needs an endpoint it controls.
+   */
+  rpcFor(cfg) {
+    return _nullishCoalesce(this.rpcById.get(cfg.id), () => ( cfg.rpc));
   }
   async quoteBridge(params) {
-    const [fee, estimate] = await Promise.all([
-      this.quoteFee(params, "quoteBridge"),
+    return this.buildQuote(this.plan(params, "quoteBridge"), params, "quoteBridge");
+  }
+  /**
+   * The full quote for a planned send. `quoteBridge` reports one; the unsigned
+   * build needs the same numbers and must not disagree with what a caller was
+   * shown, so both come from here.
+   *
+   * `account` is who the gas simulation runs as — this service's signer when it
+   * has one, and the address a prepared send will be signed by when it does not.
+   */
+  async buildQuote(plan, params, method, opts = {}) {
+    const [{ fee, oft }, estimate] = await Promise.all([
+      this.quotePathway(plan, method, opts.requireOft),
       this.estimateBridgeTime(params).catch(() => void 0)
     ]);
-    return { ...fee, toAmount: params.amount, estimate };
+    const srcGas = await this.estimateSendGas(plan, fee, oft, opts.account);
+    return {
+      ...fee,
+      // What a send built from this quote will actually carry as its `value`.
+      nativeFeeMax: padFee(fee.nativeFee, plan.feeBufferBps),
+      oft,
+      // What the recipient is actually credited: input minus any OFT fee and
+      // minus dust. Falls back to the input when quoteOFT could not be read.
+      toAmount: _nullishCoalesce(_optionalChain([oft, 'optionalAccess', _44 => _44.amountReceived]), () => ( params.amount)),
+      srcGas,
+      totalCostWei: srcGas ? srcGas.costWei + fee.nativeFee : void 0,
+      estimate
+    };
   }
   /**
-   * LayerZero messaging fee for a send, with no delivery estimate attached — the
-   * send path needs the fee and nothing else, and must not wait on Scan for it.
+   * The LayerZero messaging fee for a send, plus the OFT's own accounting.
+   *
+   * The fee is required — a send cannot be built without it. The OFT accounting is
+   * best-effort for a quote: an adapter that does not answer `quoteOFT` costs a
+   * caller the fee breakdown and the exact output amount, not the whole quote.
+   *
+   * `requireOft` flips that for the paths that go on to build a send. Without the
+   * receipt the only slippage floor left is the full input amount, which reverts
+   * with `SlippageExceeded` the moment a pathway charges a fee — so a send that
+   * cannot read `quoteOFT` is one to refuse loudly rather than assemble blind.
    */
-  async quoteFee({ fromChain, toChain, fromToken, toToken, amount, recipient }, method) {
-    const recipientAddr = _nullishCoalesce(recipient, () => ( "0x0000000000000000000000000000000000000000"));
-    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, method);
-    const { src, dst } = this.resolveChains(fromChain, toChain, fromToken, toToken);
-    const oftAdapter = src.oftAdapter;
-    const amountLD = _viem.parseUnits.call(void 0, String(amount), src.decimals);
-    try {
-      const { nativeFee, lzTokenFee } = await _viem.createPublicClient.call(void 0, {
-        chain: makeChain(src.id, src.rpc),
-        transport: _viem.http.call(void 0, src.rpc)
-      }).readContract({
-        address: oftAdapter,
+  async quotePathway(plan, method, requireOft = false) {
+    const sendParam = this.buildSendParams(plan, 0n);
+    const [msgFee, oft] = await Promise.all([
+      plan.pc.readContract({
+        address: plan.oftAdapter,
         abi: OFT_ADAPTER_ABI,
         functionName: "quoteSend",
-        args: [this.buildSendParams(dst, amountLD, recipientAddr), false]
+        args: [sendParam, false]
+      }).catch((err) => {
+        throw new (0, _chunkQQ26UI3Fcjs.StableQuoteError)({
+          provider: "layerzero",
+          shortMessage: plan.nativeDrop > 0n ? `${method}: quoteSend call failed \u2014 a dstNativeDrop over the pathway's executor nativeCap is the usual cause` : `${method}: quoteSend call failed`,
+          cause: err
+        });
+      }),
+      this.readOftQuote(plan, sendParam).catch((err) => {
+        if (!requireOft) return void 0;
+        throw new (0, _chunkQQ26UI3Fcjs.StableQuoteError)({
+          provider: "layerzero",
+          shortMessage: `${method}: quoteOFT call failed \u2014 the adapter's receipt is what floors the send at what it would actually deliver, and there is no safe default for it`,
+          cause: err
+        });
+      })
+    ]);
+    const { nativeFee, lzTokenFee } = msgFee;
+    return { fee: { nativeFee, lzTokenFee }, oft };
+  }
+  /**
+   * The adapter's own view of a send: accepted range, its fees, and what lands on
+   * the far side. Throws when the adapter will not answer; `quotePathway` decides
+   * whether that is fatal for the caller it is serving.
+   */
+  async readOftQuote(plan, sendParam) {
+    const [limit, feeDetails, receipt] = await plan.pc.readContract({
+      address: plan.oftAdapter,
+      abi: OFT_ADAPTER_ABI,
+      functionName: "quoteOFT",
+      args: [sendParam]
+    });
+    const decimals = plan.srcToken.decimals;
+    return {
+      amountSentLD: receipt.amountSentLD,
+      amountReceivedLD: receipt.amountReceivedLD,
+      amountReceived: Number(_viem.formatUnits.call(void 0, receipt.amountReceivedLD, decimals)),
+      fees: feeDetails.map((detail) => ({
+        amountLD: detail.feeAmountLD,
+        amount: Number(_viem.formatUnits.call(void 0, detail.feeAmountLD, decimals)),
+        description: detail.description
+      })),
+      minAmountLD: limit.minAmountLD,
+      maxAmountLD: limit.maxAmountLD
+    };
+  }
+  /**
+   * Source-chain cost of the `send` transaction.
+   *
+   * Simulating the real call is the only honest answer, and it needs a sender with
+   * the allowance and the native balance already in place — which a quote taken
+   * before approving does not have. When the simulation reverts, fall back to a
+   * measured constant so the caller still has a cost to show, flagged as such.
+   */
+  async estimateSendGas(plan, fee, oft, sender) {
+    const gasPriceWei = await this.gasPrice(plan);
+    if (gasPriceWei === void 0) return void 0;
+    let gas = FALLBACK_SEND_GAS;
+    let source = "fallback";
+    const account = _nullishCoalesce(sender, () => ( this.signerAddress()));
+    if (account) {
+      const sendFee = {
+        nativeFee: padFee(fee.nativeFee, plan.feeBufferBps),
+        lzTokenFee: fee.lzTokenFee
+      };
+      try {
+        gas = await plan.pc.estimateContractGas({
+          address: plan.oftAdapter,
+          abi: OFT_ADAPTER_ABI,
+          functionName: "send",
+          args: [
+            this.buildSendParams(plan, _nullishCoalesce(_optionalChain([oft, 'optionalAccess', _45 => _45.amountReceivedLD]), () => ( plan.amountLD))),
+            sendFee,
+            account
+          ],
+          account,
+          value: sendFee.nativeFee
+        });
+        source = "simulated";
+      } catch (e5) {
+      }
+    }
+    return { gas, gasPriceWei, costWei: gas * gasPriceWei, source };
+  }
+  /** Price per gas unit on the source chain, or undefined if the RPC won't say. */
+  async gasPrice(plan) {
+    try {
+      const fees = await plan.pc.estimateFeesPerGas();
+      const price = _nullishCoalesce(fees.maxFeePerGas, () => ( fees.gasPrice));
+      if (price !== void 0) return price;
+    } catch (e6) {
+    }
+    try {
+      return await plan.pc.getGasPrice();
+    } catch (e7) {
+      return void 0;
+    }
+  }
+  /**
+   * The `approve` amounts to send, in order, before `send` can pull `amountLD` —
+   * empty when the adapter needs no allowance or the existing one already covers
+   * the send.
+   *
+   * A short but non-zero allowance takes two approvals, not one. Legacy USDT on
+   * Ethereum — the only token a lockbox pathway ever approves — refuses to
+   * overwrite a non-zero allowance with another non-zero value:
+   *
+   *     require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)))
+   *
+   * so a holder who once approved 5 USDT and now bridges 10 gets a reverted
+   * approve and pays the gas for nothing. Zeroing first is harmless on every
+   * other ERC-20, so it is unconditional rather than sniffed per token.
+   */
+  async approvalPlan(plan, owner, amountLD) {
+    if (plan.srcToken.approvalRequired === false) return [];
+    const allowance = await plan.pc.readContract({
+      address: plan.srcToken.address,
+      abi: _viem.erc20Abi,
+      functionName: "allowance",
+      args: [owner, plan.oftAdapter]
+    });
+    if (allowance >= amountLD) return [];
+    return allowance > 0n ? [0n, amountLD] : [amountLD];
+  }
+  /** Send one `approve` and wait for it to land. */
+  async sendApprove(plan, wc, value) {
+    const { src, asset, srcToken, oftAdapter, pc, chain: srcChain } = plan;
+    const what = value === 0n ? "allowance reset" : "approve";
+    let approveHash;
+    try {
+      approveHash = await wc.writeContract({
+        address: srcToken.address,
+        abi: _viem.erc20Abi,
+        functionName: "approve",
+        args: [oftAdapter, value],
+        account: wc.account,
+        chain: srcChain
       });
-      return { nativeFee, lzTokenFee };
     } catch (err) {
-      throw new (0, _chunkQQ26UI3Fcjs.StableQuoteError)({
-        provider: "layerzero",
-        shortMessage: `${method}: quoteSend call failed`,
+      throw new (0, _chunkQQ26UI3Fcjs.StableTransactionError)({
+        phase: "approve",
+        shortMessage: `bridge: ${asset} ${what} failed`,
+        chainId: src.id,
         cause: err
       });
     }
+    const approveReceipt = await pc.waitForTransactionReceipt({ hash: approveHash });
+    if (approveReceipt.status === "reverted") {
+      throw new (0, _chunkQQ26UI3Fcjs.StableTransactionError)({
+        phase: "approve",
+        shortMessage: `bridge: ${asset} ${what} reverted on-chain`,
+        txHash: approveReceipt.transactionHash,
+        chainId: src.id
+      });
+    }
   }
-  async bridge({ fromChain, toChain, fromToken, toToken, amount, recipient, quote }) {
-    const from = _nullishCoalesce(_optionalChain([this, 'access', _36 => _36.config, 'access', _37 => _37.walletClient, 'optionalAccess', _38 => _38.account, 'optionalAccess', _39 => _39.address]), () => ( _optionalChain([this, 'access', _40 => _40.config, 'access', _41 => _41.account, 'optionalAccess', _42 => _42.address])));
+  async bridge(params) {
+    const from = this.signerAddress();
     if (!from) {
       throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
         "signer",
@@ -1959,17 +2258,20 @@ var LayerZeroService = class {
         "bridge: requires a signer \u2014 set walletClient or account in StableConfig"
       );
     }
-    const recipientAddr = _nullishCoalesce(recipient, () => ( from));
-    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, "bridge");
-    const { src, dst } = this.resolveChains(fromChain, toChain, fromToken, toToken);
-    const oftAdapter = src.oftAdapter;
-    const srcChain = makeChain(src.id, src.rpc);
+    const plan = this.plan({ ...params, recipient: _nullishCoalesce(params.recipient, () => ( from)) }, "bridge");
+    const { src, oftAdapter, amountLD, chain: srcChain } = plan;
+    const refundAddress = this.resolveRefundAddress(params.refundAddress, from, "bridge");
     const wc = _nullishCoalesce(this.config.walletClient, () => ( _viem.createWalletClient.call(void 0, {
       account: this.config.account,
       chain: srcChain,
-      transport: _nullishCoalesce(this.config.transport, () => ( _viem.http.call(void 0, src.rpc)))
+      // `config.transport` is the caller's *Stable-chain* transport. A browser
+      // wallet transport is chain-agnostic — the wallet holds the keys and picks
+      // the network — but an HTTP one is a broadcast channel bound to a single
+      // chain, and broadcasting an Ethereum send to the Stable RPC fails. With a
+      // local account we sign here and only need somewhere to broadcast, so the
+      // source chain's own endpoint is always the right answer.
+      transport: this.config.account ? _viem.http.call(void 0, plan.rpc) : _nullishCoalesce(this.config.transport, () => ( _viem.http.call(void 0, plan.rpc)))
     })));
-    const pc = _viem.createPublicClient.call(void 0, { chain: srcChain, transport: _viem.http.call(void 0, src.rpc) });
     try {
       await wc.switchChain({ id: src.id });
     } catch (err) {
@@ -1980,55 +2282,24 @@ var LayerZeroService = class {
         cause: err
       });
     }
-    const amountLD = _viem.parseUnits.call(void 0, String(amount), src.decimals);
-    const sendParams = this.buildSendParams(dst, amountLD, recipientAddr);
-    const { nativeFee, lzTokenFee } = _optionalChain([quote, 'optionalAccess', _43 => _43.nativeFee]) !== void 0 && _optionalChain([quote, 'optionalAccess', _44 => _44.lzTokenFee]) !== void 0 ? { nativeFee: quote.nativeFee, lzTokenFee: quote.lzTokenFee } : await this.quoteFee({ fromChain, toChain, fromToken, toToken, amount, recipient: recipientAddr }, "bridge");
-    const allowance = await pc.readContract({
-      address: src.usdt,
-      abi: _viem.erc20Abi,
-      functionName: "allowance",
-      args: [from, oftAdapter]
-    });
-    if (allowance < amountLD) {
-      let approveHash;
-      try {
-        approveHash = await wc.writeContract({
-          address: src.usdt,
-          abi: _viem.erc20Abi,
-          functionName: "approve",
-          args: [oftAdapter, amountLD],
-          account: wc.account,
-          chain: srcChain
-        });
-      } catch (err) {
-        throw new (0, _chunkQQ26UI3Fcjs.StableTransactionError)({
-          phase: "approve",
-          shortMessage: "bridge: USDT0 approve failed",
-          chainId: src.id,
-          cause: err
-        });
-      }
-      const approveReceipt = await pc.waitForTransactionReceipt({ hash: approveHash });
-      if (approveReceipt.status === "reverted") {
-        throw new (0, _chunkQQ26UI3Fcjs.StableTransactionError)({
-          phase: "approve",
-          shortMessage: "bridge: USDT0 approve reverted on-chain",
-          txHash: approveReceipt.transactionHash,
-          chainId: src.id
-        });
-      }
+    const quote = usableQuote(params.quote, amountLD);
+    const { nativeFee, lzTokenFee, oft } = _optionalChain([quote, 'optionalAccess', _46 => _46.nativeFee]) !== void 0 && _optionalChain([quote, 'optionalAccess', _47 => _47.lzTokenFee]) !== void 0 ? { nativeFee: quote.nativeFee, lzTokenFee: quote.lzTokenFee, oft: quote.oft } : await this.quotePathway(plan, "bridge", true).then((r) => ({ ...r.fee, oft: r.oft }));
+    const sendParams = this.buildSendParams(plan, _nullishCoalesce(_optionalChain([oft, 'optionalAccess', _48 => _48.amountReceivedLD]), () => ( amountLD)));
+    const sendFee = padFee(nativeFee, plan.feeBufferBps);
+    for (const value of await this.approvalPlan(plan, from, amountLD)) {
+      await this.sendApprove(plan, wc, value);
     }
     try {
       const hash = await wc.writeContract({
         address: oftAdapter,
         abi: OFT_ADAPTER_ABI,
         functionName: "send",
-        args: [sendParams, { nativeFee, lzTokenFee }, from],
-        value: nativeFee,
+        args: [sendParams, { nativeFee: sendFee, lzTokenFee }, refundAddress],
+        value: sendFee,
         account: wc.account,
         chain: srcChain
       });
-      return { txHash: hash, toAmount: amount };
+      return { txHash: hash, toAmount: _nullishCoalesce(_optionalChain([oft, 'optionalAccess', _49 => _49.amountReceived]), () => ( params.amount)) };
     } catch (err) {
       throw new (0, _chunkQQ26UI3Fcjs.StableTransactionError)({
         phase: "send",
@@ -2038,6 +2309,77 @@ var LayerZeroService = class {
       });
     }
   }
+  /**
+   * Everything needed to send a bridge, without signing or sending any of it: the
+   * ordered transactions, the quote they were built from, and the `SendParam` the
+   * send step encodes, decoded.
+   *
+   * This is the split-responsibility shape — a backend quotes, builds and checks
+   * while the holder's wallet only signs — and the only way to inspect a bridge
+   * before it exists. Send `steps` in order from `from`, each one confirmed before
+   * the next: an allowance reset and an approve where the lockbox pathway needs
+   * them, then the OFT `send` carrying its fee as `value`.
+   *
+   * Refuses to build when the adapter will not answer `quoteOFT`: the receipt is
+   * what floors the send at what it would actually deliver, and guessing the floor
+   * is how a send reverts with `SlippageExceeded` after the gas is spent.
+   */
+  async prepareBridgeCalldata(params) {
+    const method = "prepareBridgeCalldata";
+    const from = params.from;
+    if (!_viem.isAddress.call(void 0, from)) {
+      throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+        "from",
+        params.from,
+        `${method}: invalid from address "${params.from}" \u2014 the address that will sign these transactions`
+      );
+    }
+    const refundAddress = this.resolveRefundAddress(params.refundAddress, from, method);
+    const plan = this.plan({ ...params, recipient: _nullishCoalesce(params.recipient, () => ( from)) }, method);
+    const supplied = usableQuote(params.quote, plan.amountLD);
+    const quote = _optionalChain([supplied, 'optionalAccess', _50 => _50.oft]) && supplied.nativeFee !== void 0 && supplied.lzTokenFee !== void 0 ? supplied : await this.buildQuote(plan, params, method, { account: from, requireOft: true });
+    const oft = quote.oft;
+    const nativeFee = padFee(quote.nativeFee, plan.feeBufferBps);
+    const lzTokenFee = quote.lzTokenFee;
+    const sendParam = this.buildSendParams(plan, oft.amountReceivedLD);
+    const steps = (await this.approvalPlan(plan, from, plan.amountLD)).map((value) => ({
+      chainId: plan.src.id,
+      to: plan.srcToken.address,
+      data: _viem.encodeFunctionData.call(void 0, {
+        abi: _viem.erc20Abi,
+        functionName: "approve",
+        args: [plan.oftAdapter, value]
+      }),
+      value: 0n
+    }));
+    steps.push({
+      chainId: plan.src.id,
+      to: plan.oftAdapter,
+      data: _viem.encodeFunctionData.call(void 0, {
+        abi: OFT_ADAPTER_ABI,
+        functionName: "send",
+        args: [sendParam, { nativeFee, lzTokenFee }, refundAddress]
+      }),
+      value: nativeFee
+    });
+    return {
+      steps,
+      chainId: plan.src.id,
+      asset: plan.asset,
+      quote,
+      send: {
+        dstEid: sendParam.dstEid,
+        recipient: plan.recipient,
+        to: sendParam.to,
+        amountLD: sendParam.amountLD,
+        minAmountLD: sendParam.minAmountLD,
+        extraOptions: sendParam.extraOptions,
+        nativeFee,
+        lzTokenFee,
+        refundAddress
+      }
+    };
+  }
   /**
    * Estimate how long a USDT0 bridge will take, end to end.
    *
@@ -2052,18 +2394,26 @@ var LayerZeroService = class {
    * computes to ~15s (60 blocks × 0.25s) while real deliveries take ~18min, because
    * the DVNs wait for the L2 batch to finalize on L1.
    */
-  async estimateBridgeTime({ fromChain, toChain }) {
+  async estimateBridgeTime({
+    fromChain,
+    toChain,
+    fromToken,
+    toToken
+  }) {
     const src = BRIDGE_CHAIN_CONFIGS[fromChain];
     const dst = BRIDGE_CHAIN_CONFIGS[toChain];
-    if (!_optionalChain([src, 'optionalAccess', _45 => _45.oftAdapter])) {
+    const from = _nullishCoalesce(fromToken, () => ( _optionalChain([src, 'optionalAccess', _51 => _51.tokens, 'access', _52 => _52.usdt0, 'optionalAccess', _53 => _53.address])));
+    const to = _nullishCoalesce(toToken, () => ( _optionalChain([dst, 'optionalAccess', _54 => _54.tokens, 'access', _55 => _55.usdt0, 'optionalAccess', _56 => _56.address])));
+    if (!(src && from)) {
       throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)("fromChain", fromChain, `estimateBridgeTime: no OFT adapter for "${fromChain}"`);
     }
-    if (!_optionalChain([dst, 'optionalAccess', _46 => _46.oftAdapter])) {
+    if (!(dst && to)) {
       throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)("toChain", toChain, `estimateBridgeTime: no OFT adapter for "${toChain}"`);
     }
+    const { srcToken, dstToken } = this.resolveRoute(fromChain, toChain, from, to);
     const [uln, observedSeconds] = await Promise.all([
-      this.getUlnConfig(src, dst).catch(() => void 0),
-      this.observedBridgeSeconds(src, dst).catch(() => void 0)
+      this.getUlnConfig(src, dst, srcToken.oftAdapter).catch(() => void 0),
+      this.observedBridgeSeconds(src, dst, srcToken.oftAdapter, dstToken.oftAdapter).catch(() => void 0)
     ]);
     const dvnCount = uln ? uln.requiredDVNCount + uln.optionalDVNCount : void 0;
     let formulaSeconds;
@@ -2085,7 +2435,7 @@ var LayerZeroService = class {
       source: observedSeconds !== void 0 ? "observed" : "formula",
       observedSeconds,
       formulaSeconds,
-      confirmations: Number.isFinite(_optionalChain([uln, 'optionalAccess', _47 => _47.confirmations])) ? _optionalChain([uln, 'optionalAccess', _48 => _48.confirmations]) : void 0,
+      confirmations: Number.isFinite(_optionalChain([uln, 'optionalAccess', _57 => _57.confirmations])) ? _optionalChain([uln, 'optionalAccess', _58 => _58.confirmations]) : void 0,
       dvnCount: Number.isFinite(dvnCount) ? dvnCount : void 0
     };
   }
@@ -2098,7 +2448,7 @@ var LayerZeroService = class {
     const scanUrl = `${LZ_SCAN_UI}/tx/${srcTxHash}`;
     let message;
     try {
-      message = await _asyncOptionalChain([(await scanFetch(`/messages/tx/${srcTxHash}`)), 'optionalAccess', async _49 => _49.data, 'optionalAccess', async _50 => _50[0]]);
+      message = await _asyncOptionalChain([(await scanFetch(`/messages/tx/${srcTxHash}`)), 'optionalAccess', async _59 => _59.data, 'optionalAccess', async _60 => _60[0]]);
     } catch (err) {
       if (err instanceof ScanHttpError && err.status === 404) {
         return { state: "pending", srcTxHash, scanUrl };
@@ -2110,24 +2460,24 @@ var LayerZeroService = class {
       });
     }
     if (!message) return { state: "pending", srcTxHash, scanUrl };
-    const raw = _nullishCoalesce(_optionalChain([message, 'access', _51 => _51.status, 'optionalAccess', _52 => _52.name]), () => ( ""));
-    const sentAt = _optionalChain([message, 'access', _53 => _53.source, 'optionalAccess', _54 => _54.tx, 'optionalAccess', _55 => _55.blockTimestamp]);
+    const raw = _nullishCoalesce(_optionalChain([message, 'access', _61 => _61.status, 'optionalAccess', _62 => _62.name]), () => ( ""));
+    const sentAt = _optionalChain([message, 'access', _63 => _63.source, 'optionalAccess', _64 => _64.tx, 'optionalAccess', _65 => _65.blockTimestamp]);
     return {
       // Everything terminal that is not DELIVERED means the tokens will not land
       // on their own; `raw` carries which of those it was.
       state: raw === "DELIVERED" ? "delivered" : TERMINAL_FAILURE_STATUSES.has(raw) ? "failed" : "inflight",
       raw,
       srcTxHash,
-      dstTxHash: _optionalChain([message, 'access', _56 => _56.destination, 'optionalAccess', _57 => _57.tx, 'optionalAccess', _58 => _58.txHash]),
+      dstTxHash: _optionalChain([message, 'access', _66 => _66.destination, 'optionalAccess', _67 => _67.tx, 'optionalAccess', _68 => _68.txHash]),
       elapsedSeconds: sentAt ? Math.max(0, Math.floor(Date.now() / 1e3) - sentAt) : void 0,
       scanUrl
     };
   }
   /** Effective ULN config the DVNs enforce for this pathway, read from the source chain. */
-  async getUlnConfig(src, dst) {
-    return cached(`uln:${src.lzEid}-${dst.lzEid}`, CACHE_TTL_MS, async () => {
-      const pc = _viem.createPublicClient.call(void 0, { chain: makeChain(src.id, src.rpc), transport: _viem.http.call(void 0, src.rpc) });
-      const oapp = src.oftAdapter;
+  async getUlnConfig(src, dst, oapp) {
+    return cached(`uln:${src.lzEid}-${dst.lzEid}-${oapp.toLowerCase()}`, CACHE_TTL_MS, async () => {
+      const rpc = this.rpcFor(src);
+      const pc = _viem.createPublicClient.call(void 0, { chain: makeChain(src.id, rpc), transport: _viem.http.call(void 0, rpc) });
       const endpoint = await pc.readContract({ address: oapp, abi: OAPP_ABI, functionName: "endpoint" });
       const sendLib = await pc.readContract({
         address: endpoint,
@@ -2149,11 +2499,11 @@ var LayerZeroService = class {
     });
   }
   /** Median delivery time of recently delivered messages on this pathway, in seconds. */
-  async observedBridgeSeconds(src, dst) {
-    const pathwayId = `${src.lzEid}-${dst.lzEid}-${src.oftAdapter.toLowerCase()}-${dst.oftAdapter.toLowerCase()}`;
+  async observedBridgeSeconds(src, dst, srcOapp, dstOapp) {
+    const pathwayId = `${src.lzEid}-${dst.lzEid}-${srcOapp.toLowerCase()}-${dstOapp.toLowerCase()}`;
     return cached(`observed:${pathwayId}`, CACHE_TTL_MS, async () => {
       const { data } = await scanFetch(`/messages/pathway/${pathwayId}?limit=50`);
-      const durations = (_nullishCoalesce(data, () => ( []))).filter((m) => _optionalChain([m, 'access', _59 => _59.status, 'optionalAccess', _60 => _60.name]) === "DELIVERED").map((m) => (_nullishCoalesce(_optionalChain([m, 'access', _61 => _61.destination, 'optionalAccess', _62 => _62.tx, 'optionalAccess', _63 => _63.blockTimestamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([m, 'access', _64 => _64.source, 'optionalAccess', _65 => _65.tx, 'optionalAccess', _66 => _66.blockTimestamp]), () => ( 0)))).filter((d) => d > 0);
+      const durations = (_nullishCoalesce(data, () => ( []))).filter((m) => _optionalChain([m, 'access', _69 => _69.status, 'optionalAccess', _70 => _70.name]) === "DELIVERED").map((m) => (_nullishCoalesce(_optionalChain([m, 'access', _71 => _71.destination, 'optionalAccess', _72 => _72.tx, 'optionalAccess', _73 => _73.blockTimestamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([m, 'access', _74 => _74.source, 'optionalAccess', _75 => _75.tx, 'optionalAccess', _76 => _76.blockTimestamp]), () => ( 0)))).filter((d) => d > 0);
       return durations.length >= 3 ? Math.round(median(durations)) : void 0;
     });
   }
@@ -2180,37 +2530,122 @@ var LayerZeroService = class {
       );
     }
   }
-  resolveChains(fromChain, toChain, fromToken, toToken) {
+  /**
+   * Resolve a bridge request to one OFT mesh and its two endpoints.
+   *
+   * Both sides must name the same asset. An OFT escrows one specific ERC-20 and
+   * mints its own peer on the far side — it cannot hand back a different token,
+   * so a USDT0→XAUt0 request is a trade, not a bridge, and belongs to LI.FI.
+   */
+  resolveRoute(fromChain, toChain, fromToken, toToken) {
     const src = BRIDGE_CHAIN_CONFIGS[fromChain];
     const dst = BRIDGE_CHAIN_CONFIGS[toChain];
     if (!src) throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)("fromChain", fromChain, `Unsupported source chain: "${fromChain}"`);
     if (!dst) throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)("toChain", toChain, `Unsupported destination chain: "${toChain}"`);
-    if (!src.oftAdapter) {
-      throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)("fromChain", fromChain, `No OFT adapter configured for "${fromChain}"`);
-    }
-    if (fromToken.toLowerCase() !== src.usdt.toLowerCase()) {
+    const asset = bridgeAssetFor(src, fromToken);
+    if (!asset) {
       throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
         "fromToken",
         fromToken,
-        `USDT0 bridge only moves USDT0 \u2014 fromToken must be ${src.usdt} on "${fromChain}", got "${fromToken}". Use route "lifi" to bridge other tokens.`
+        `Native OFT bridge does not recognize "${fromToken}" on "${fromChain}" \u2014 it moves ${describeAssets(src)}. Use route "lifi" to bridge other tokens.`
+      );
+    }
+    const srcToken = src.tokens[asset];
+    const dstToken = dst.tokens[asset];
+    if (!dstToken) {
+      throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+        "toChain",
+        toChain,
+        `Native OFT bridge cannot deliver ${asset} to "${toChain}" \u2014 no ${asset} deployment there. Use route "lifi" instead.`
       );
     }
-    if (toToken.toLowerCase() !== dst.usdt.toLowerCase()) {
+    if (dstToken.address.toLowerCase() !== toToken.toLowerCase()) {
       throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
         "toToken",
         toToken,
-        `USDT0 bridge only moves USDT0 \u2014 toToken must be ${dst.usdt} on "${toChain}", got "${toToken}". Use route "lifi" to bridge other tokens.`
+        `Native OFT bridge moves ${asset} to itself \u2014 toToken must be ${dstToken.address} on "${toChain}", got "${toToken}". Use route "lifi" to bridge between different tokens.`
       );
     }
-    return { src, dst };
+    return { src, dst, asset, srcToken, dstToken };
   }
-  buildSendParams(dst, amountLD, recipient) {
+  /**
+   * Validate a request and resolve it to a single OFT pathway. No network calls —
+   * everything here is config, arithmetic and encoding.
+   */
+  plan(params, method) {
+    const { fromChain, toChain, fromToken, toToken, amount, recipient, dstNativeDrop } = params;
+    const recipientAddr = _nullishCoalesce(recipient, () => ( ZERO_ADDRESS));
+    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, method);
+    if (dstNativeDrop !== void 0 && dstNativeDrop < 0n) {
+      throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+        "dstNativeDrop",
+        dstNativeDrop,
+        `${method}: dstNativeDrop must not be negative`
+      );
+    }
+    const feeBufferBps = resolveFeeBuffer(params.feeBufferBps, method);
+    const { src, dst, asset, srcToken, dstToken } = this.resolveRoute(
+      fromChain,
+      toChain,
+      fromToken,
+      toToken
+    );
+    if (params.fromDecimals !== void 0 && params.fromDecimals !== srcToken.decimals) {
+      throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+        "fromDecimals",
+        params.fromDecimals,
+        `${method}: ${asset} has ${srcToken.decimals} decimals on "${fromChain}", not ${params.fromDecimals}. The native OFT route parses the amount with the token's own decimals; fromDecimals applies to LI.FI routes only.`
+      );
+    }
+    const rpc = this.rpcFor(src);
+    const chain = makeChain(src.id, rpc);
     return {
-      dstEid: dst.lzEid,
-      to: _viem.padHex.call(void 0, recipient, { dir: "left", size: 32 }),
-      amountLD,
-      minAmountLD: amountLD,
-      extraOptions: buildLzOptions(),
+      src,
+      dst,
+      asset,
+      srcToken,
+      dstToken,
+      oftAdapter: srcToken.oftAdapter,
+      amountLD: _viem.parseUnits.call(void 0, String(amount), srcToken.decimals),
+      recipient: recipientAddr,
+      nativeDrop: _nullishCoalesce(dstNativeDrop, () => ( 0n)),
+      rpc,
+      feeBufferBps,
+      chain,
+      pc: _viem.createPublicClient.call(void 0, { chain, transport: _viem.http.call(void 0, rpc) })
+    };
+  }
+  /**
+   * Where `send` returns messaging fee it did not need. Defaults to the sender,
+   * which is what a caller wants unless they are routing refunds somewhere of
+   * their own — a backend paying the fee on a user's behalf, say.
+   */
+  resolveRefundAddress(refundAddress, sender, method) {
+    if (refundAddress === void 0) return sender;
+    if (!_viem.isAddress.call(void 0, refundAddress)) {
+      throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+        "refundAddress",
+        refundAddress,
+        `${method}: invalid refundAddress "${refundAddress}"`
+      );
+    }
+    return refundAddress;
+  }
+  /** The address that will sign, or undefined when this service has no signer. */
+  signerAddress() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _77 => _77.config, 'access', _78 => _78.walletClient, 'optionalAccess', _79 => _79.account, 'optionalAccess', _80 => _80.address]), () => ( _optionalChain([this, 'access', _81 => _81.config, 'access', _82 => _82.account, 'optionalAccess', _83 => _83.address])));
+  }
+  /**
+   * `SendParam` for one call. `minAmountLD` is the caller's slippage floor: 0 when
+   * asking what a send would yield, and the quoted output when actually sending.
+   */
+  buildSendParams(plan, minAmountLD) {
+    return {
+      dstEid: plan.dst.lzEid,
+      to: _viem.padHex.call(void 0, plan.recipient, { dir: "left", size: 32 }),
+      amountLD: plan.amountLD,
+      minAmountLD,
+      extraOptions: buildLzOptions(0n, plan.nativeDrop, plan.recipient),
       composeMsg: "0x",
       oftCmd: "0x"
     };
@@ -2218,21 +2653,37 @@ var LayerZeroService = class {
 };
 
 // src/stable.ts
-function isUsdt0Route(fromChain, toChain, fromToken, toToken) {
+function isNativeOftRoute(fromChain, toChain, fromToken, toToken) {
   const src = BRIDGE_CHAIN_CONFIGS[fromChain];
   const dst = BRIDGE_CHAIN_CONFIGS[toChain];
-  return !!src && !!dst && !!src.oftAdapter && src.lzOutbound !== false && src.usdt.toLowerCase() === fromToken.toLowerCase() && dst.usdt.toLowerCase() === toToken.toLowerCase();
+  if (!(src && dst)) return false;
+  const asset = bridgeAssetFor(src, fromToken);
+  if (!asset) return false;
+  const srcToken = src.tokens[asset];
+  const dstToken = dst.tokens[asset];
+  return src.lzOutbound !== false && !!srcToken && srcToken.lzOutbound !== false && !!dstToken && dstToken.address.toLowerCase() === toToken.toLowerCase();
 }
 function selectBridge(params) {
+  const selected = resolveBridge(params);
+  if (selected === "lifi" && (_nullishCoalesce(params.dstNativeDrop, () => ( 0n))) > 0n) {
+    throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+      "dstNativeDrop",
+      params.dstNativeDrop,
+      `bridge: dstNativeDrop is only supported on the native OFT route, and ${params.fromChain}\u2192${params.toChain} resolved to LI.FI`
+    );
+  }
+  return selected;
+}
+function resolveBridge(params) {
   const route = _nullishCoalesce(params.route, () => ( "auto"));
-  if (route === "usdt0") return "usdt0";
+  if (route === "oft" || route === "usdt0") return "oft";
   if (route === "lifi") return "lifi";
-  return isUsdt0Route(
+  return isNativeOftRoute(
     params.fromChain,
     params.toChain,
     params.fromToken,
     params.toToken
-  ) ? "usdt0" : "lifi";
+  ) ? "oft" : "lifi";
 }
 function validateTransferParams({
   to,
@@ -2277,7 +2728,7 @@ async function resolveTokenDecimals(publicClient, token, tokenDecimals) {
       abi: _viem.erc20Abi,
       functionName: "decimals"
     });
-  } catch (e5) {
+  } catch (e8) {
     throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
       "tokenDecimals",
       void 0,
@@ -2311,6 +2762,7 @@ async function executeTokenTransfer(wc, publicClient, token, to, amount, tokenDe
 function createStable({
   network = "mainnet" /* Mainnet */,
   rpc: rpcOverride,
+  rpcOverrides,
   account,
   transport,
   walletClient,
@@ -2324,7 +2776,7 @@ function createStable({
   );
   const signerConfig = { account, transport, walletClient };
   const lifi = new LiFiService({ ...signerConfig, rpc, chainId: chain.id });
-  const lz = new LayerZeroService(signerConfig);
+  const lz = new LayerZeroService({ ...signerConfig, rpcOverrides });
   const merkl = new MerklService({ ...signerConfig, rpc, chainId: chain.id, merklApiBase });
   const morpho = earnConfig ? new MorphoService({
     ...signerConfig,
@@ -2349,7 +2801,7 @@ function createStable({
     return morpho;
   }
   function requireSignerAddress() {
-    const from = _nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _67 => _67.account, 'optionalAccess', _68 => _68.address]), () => ( _optionalChain([account, 'optionalAccess', _69 => _69.address])));
+    const from = _nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _84 => _84.account, 'optionalAccess', _85 => _85.address]), () => ( _optionalChain([account, 'optionalAccess', _86 => _86.address])));
     if (!from) {
       throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
         "signer",
@@ -2362,7 +2814,7 @@ function createStable({
   async function transfer(params) {
     validateTransferParams(params);
     const { from, to, amount, token, tokenDecimals } = params;
-    const acc = _nullishCoalesce(_nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _70 => _70.account]), () => ( account)), () => ( from));
+    const acc = _nullishCoalesce(_nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _87 => _87.account]), () => ( account)), () => ( from));
     const wc = _nullishCoalesce(walletClient, () => ( _viem.createWalletClient.call(void 0, {
       account: acc,
       chain,
@@ -2414,8 +2866,20 @@ function createStable({
   }
   return {
     transfer,
-    quoteBridge: (params) => selectBridge(params) === "usdt0" ? lz.quoteBridge(params) : lifi.quoteBridge(params),
-    bridge: (params) => selectBridge(params) === "usdt0" ? lz.bridge(params) : lifi.bridge(params),
+    // `async` so a rejected route (see selectBridge) surfaces as a rejected
+    // promise like every other validation error, not a synchronous throw.
+    quoteBridge: async (params) => selectBridge(params) === "oft" ? lz.quoteBridge(params) : lifi.quoteBridge(params),
+    bridge: async (params) => selectBridge(params) === "oft" ? lz.bridge(params) : lifi.bridge(params),
+    prepareBridgeCalldata: async (params) => {
+      if (selectBridge(params) !== "oft") {
+        throw new (0, _chunkQQ26UI3Fcjs.StableValidationError)(
+          "route",
+          _nullishCoalesce(params.route, () => ( "auto")),
+          `prepareBridgeCalldata: only the native OFT route can be built unsigned, and ${params.fromChain}\u2192${params.toChain} resolved to LI.FI`
+        );
+      }
+      return lz.prepareBridgeCalldata(params);
+    },
     estimateBridgeTime: (params) => lz.estimateBridgeTime(params),
     trackBridge: (srcTxHash) => lz.trackBridge(srcTxHash),
     quoteSwap: (params) => lifi.quoteSwap(params),
@@ -2483,4 +2947,7 @@ function createStableReader(config) {
 
 
 
-exports.BRIDGE_CHAIN_CONFIGS = BRIDGE_CHAIN_CONFIGS; exports.CHAIN_CONFIGS = CHAIN_CONFIGS; exports.Chain = Chain; exports.ERC3009_ABI = _chunkQQ26UI3Fcjs.ERC3009_ABI; exports.Network = Network; exports.STABLE_USDT_ADDRESS = _chunkQQ26UI3Fcjs.STABLE_USDT_ADDRESS; exports.STABLE_VAULT_ADDRESS = _chunkQQ26UI3Fcjs.STABLE_VAULT_ADDRESS; exports.StableBulkError = _chunkQQ26UI3Fcjs.StableBulkError; exports.StableError = _chunkQQ26UI3Fcjs.StableError; exports.StableNetworkError = _chunkQQ26UI3Fcjs.StableNetworkError; exports.StableQuoteError = _chunkQQ26UI3Fcjs.StableQuoteError; exports.StableTransactionError = _chunkQQ26UI3Fcjs.StableTransactionError; exports.StableValidationError = _chunkQQ26UI3Fcjs.StableValidationError; exports.cancelAuthorization = _chunkQQ26UI3Fcjs.cancelAuthorization; exports.clearBridgeEstimateCache = clearBridgeEstimateCache; exports.createStable = createStable; exports.createStableReader = createStableReader; exports.erc3009Actions = _chunkQQ26UI3Fcjs.erc3009Actions; exports.getAuthorizationState = _chunkQQ26UI3Fcjs.getAuthorizationState; exports.getAuthorizationUsage = _chunkQQ26UI3Fcjs.getAuthorizationUsage; exports.prepareTransferWithAuthorization = _chunkQQ26UI3Fcjs.prepareTransferWithAuthorization; exports.receiveWithAuthorization = _chunkQQ26UI3Fcjs.receiveWithAuthorization; exports.signReceiveAuthorization = _chunkQQ26UI3Fcjs.signReceiveAuthorization; exports.signTransferAuthorization = _chunkQQ26UI3Fcjs.signTransferAuthorization; exports.transferWithAuthorization = _chunkQQ26UI3Fcjs.transferWithAuthorization; exports.verifyAuthorization = _chunkQQ26UI3Fcjs.verifyAuthorization;
+
+
+
+exports.BRIDGE_CHAIN_CONFIGS = BRIDGE_CHAIN_CONFIGS; exports.CHAIN_CONFIGS = CHAIN_CONFIGS; exports.Chain = Chain; exports.ERC3009_ABI = _chunkQQ26UI3Fcjs.ERC3009_ABI; exports.Network = Network; exports.OFT_ADAPTER_ABI = OFT_ADAPTER_ABI; exports.STABLE_USDT_ADDRESS = _chunkQQ26UI3Fcjs.STABLE_USDT_ADDRESS; exports.STABLE_VAULT_ADDRESS = _chunkQQ26UI3Fcjs.STABLE_VAULT_ADDRESS; exports.StableBulkError = _chunkQQ26UI3Fcjs.StableBulkError; exports.StableError = _chunkQQ26UI3Fcjs.StableError; exports.StableNetworkError = _chunkQQ26UI3Fcjs.StableNetworkError; exports.StableQuoteError = _chunkQQ26UI3Fcjs.StableQuoteError; exports.StableTransactionError = _chunkQQ26UI3Fcjs.StableTransactionError; exports.StableValidationError = _chunkQQ26UI3Fcjs.StableValidationError; exports.bridgeAssetFor = bridgeAssetFor; exports.buildLzOptions = buildLzOptions; exports.cancelAuthorization = _chunkQQ26UI3Fcjs.cancelAuthorization; exports.clearBridgeEstimateCache = clearBridgeEstimateCache; exports.createStable = createStable; exports.createStableReader = createStableReader; exports.erc3009Actions = _chunkQQ26UI3Fcjs.erc3009Actions; exports.getAuthorizationState = _chunkQQ26UI3Fcjs.getAuthorizationState; exports.getAuthorizationUsage = _chunkQQ26UI3Fcjs.getAuthorizationUsage; exports.prepareTransferWithAuthorization = _chunkQQ26UI3Fcjs.prepareTransferWithAuthorization; exports.receiveWithAuthorization = _chunkQQ26UI3Fcjs.receiveWithAuthorization; exports.signReceiveAuthorization = _chunkQQ26UI3Fcjs.signReceiveAuthorization; exports.signTransferAuthorization = _chunkQQ26UI3Fcjs.signTransferAuthorization; exports.transferWithAuthorization = _chunkQQ26UI3Fcjs.transferWithAuthorization; exports.verifyAuthorization = _chunkQQ26UI3Fcjs.verifyAuthorization;