@stablechain/sdk 1.0.4 → 1.0.6

package/dist/index.js

@@ -1,3 +1,25 @@
+import {
+  ERC3009_ABI,
+  STABLE_USDT_ADDRESS,
+  STABLE_VAULT_ADDRESS,
+  StableBulkError,
+  StableError,
+  StableNetworkError,
+  StableQuoteError,
+  StableTransactionError,
+  StableValidationError,
+  cancelAuthorization,
+  erc3009Actions,
+  getAuthorizationState,
+  getAuthorizationUsage,
+  prepareTransferWithAuthorization,
+  receiveWithAuthorization,
+  signReceiveAuthorization,
+  signTransferAuthorization,
+  transferWithAuthorization,
+  verifyAuthorization
+} from "./chunk-VS6GBRDF.js";
+
 // src/stable.ts
 import {
   http as http6,
@@ -25,85 +47,6 @@ import {
   parseUnits
 } from "viem";
 
-// src/errors.ts
-import { BaseError } from "viem";
-var StableError = class extends BaseError {
-};
-var StableValidationError = class extends StableError {
-  constructor(field, value, reason, opts) {
-    super(reason, {
-      name: "StableValidationError",
-      cause: opts?.cause,
-      metaMessages: [`Field: ${field}`, `Value: ${formatValue(value)}`]
-    });
-    this.field = field;
-    this.value = value;
-  }
-};
-var StableQuoteError = class extends StableError {
-  constructor(args) {
-    const meta = [`Provider: ${args.provider}`];
-    if (args.httpStatus !== void 0)
-      meta.push(`HTTP status: ${args.httpStatus}`);
-    if (args.providerCode) meta.push(`Provider code: ${args.providerCode}`);
-    super(args.shortMessage, {
-      name: "StableQuoteError",
-      cause: args.cause,
-      metaMessages: meta
-    });
-    this.provider = args.provider;
-    this.httpStatus = args.httpStatus;
-    this.providerCode = args.providerCode;
-    this.body = args.body;
-  }
-};
-var StableTransactionError = class extends StableError {
-  constructor(args) {
-    const meta = [`Phase: ${args.phase}`];
-    if (args.chainId !== void 0) meta.push(`Chain ID: ${args.chainId}`);
-    if (args.txHash) meta.push(`Tx hash: ${args.txHash}`);
-    if (args.revertReason) meta.push(`Revert reason: ${args.revertReason}`);
-    super(args.shortMessage, {
-      name: "StableTransactionError",
-      cause: args.cause,
-      metaMessages: meta
-    });
-    this.phase = args.phase;
-    this.txHash = args.txHash;
-    this.chainId = args.chainId;
-    this.revertReason = args.revertReason;
-  }
-};
-var StableNetworkError = class extends StableError {
-  constructor(args) {
-    super(args.shortMessage, {
-      name: "StableNetworkError",
-      cause: args.cause,
-      metaMessages: args.url ? [`URL: ${args.url}`] : void 0
-    });
-    this.url = args.url;
-  }
-};
-var StableBulkError = class extends StableError {
-  constructor(args) {
-    super(args.shortMessage, { name: "StableBulkError" });
-    this.results = args.results;
-    this.succeeded = args.succeeded;
-    this.failed = args.failed;
-  }
-};
-function formatValue(v) {
-  if (typeof v === "bigint") return `${v}n`;
-  if (typeof v === "string") return JSON.stringify(v);
-  if (v === null) return "null";
-  if (v === void 0) return "undefined";
-  try {
-    return JSON.stringify(v);
-  } catch {
-    return String(v);
-  }
-}
-
 // src/helpers/chain.ts
 import { defineChain } from "viem";
 function makeChain(id, rpc) {
@@ -807,19 +750,27 @@ import {
 import { stable as stableMainnet, stableTestnet } from "viem/chains";
 
 // src/types.ts
-var Chain = /* @__PURE__ */ ((Chain3) => {
-  Chain3["Sepolia"] = "sepolia";
-  Chain3["StableTestnet"] = "stable-testnet";
-  Chain3["Stable"] = "stable";
-  Chain3["Ethereum"] = "ethereum";
-  Chain3["Arbitrum"] = "arbitrum";
-  Chain3["Ink"] = "ink";
-  Chain3["Bera"] = "bera";
-  Chain3["MegaETH"] = "megaeth";
-  Chain3["Base"] = "base";
-  Chain3["BSC"] = "bsc";
-  Chain3["HyperEVM"] = "hyperevm";
-  return Chain3;
+var Chain = /* @__PURE__ */ ((Chain2) => {
+  Chain2["Sepolia"] = "sepolia";
+  Chain2["StableTestnet"] = "stable-testnet";
+  Chain2["Stable"] = "stable";
+  Chain2["Ethereum"] = "ethereum";
+  Chain2["Arbitrum"] = "arbitrum";
+  Chain2["Ink"] = "ink";
+  Chain2["Bera"] = "bera";
+  Chain2["MegaETH"] = "megaeth";
+  Chain2["Base"] = "base";
+  Chain2["BSC"] = "bsc";
+  Chain2["HyperEVM"] = "hyperevm";
+  Chain2["Polygon"] = "polygon";
+  Chain2["Plasma"] = "plasma";
+  Chain2["Optimism"] = "optimism";
+  Chain2["Unichain"] = "unichain";
+  Chain2["Sei"] = "sei";
+  Chain2["Flare"] = "flare";
+  Chain2["XLayer"] = "xlayer";
+  Chain2["Rootstock"] = "rootstock";
+  return Chain2;
 })(Chain || {});
 var Network = /* @__PURE__ */ ((Network2) => {
   Network2["Mainnet"] = "mainnet";
@@ -1259,7 +1210,7 @@ var CHAIN_CONFIGS = {
     id: 11155111,
     rpc: "https://ethereum-sepolia-rpc.publicnode.com",
     usdt: "0xc4DCC311c028e341fd8602D8eB89c5de94625927",
-    decimals: 18
+    decimals: 6
   },
   ["stable-testnet" /* StableTestnet */]: {
     id: 2201,
@@ -1277,13 +1228,15 @@ var CHAIN_CONFIGS = {
   ["ethereum" /* Ethereum */]: {
     id: 1,
     rpc: "https://ethereum-rpc.publicnode.com",
-    usdt: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
+    // Canonical USDT. Not the OFT adapter — this field is used as an ERC-20
+    // (allowance/approve/balanceOf) and as the token address for LI.FI.
+    usdt: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
     decimals: 6
   },
   ["arbitrum" /* Arbitrum */]: {
     id: 42161,
     rpc: "https://arbitrum-one-rpc.publicnode.com",
-    usdt: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92",
+    usdt: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
     decimals: 6
   },
   ["ink" /* Ink */]: {
@@ -1300,7 +1253,7 @@ var CHAIN_CONFIGS = {
   },
   ["megaeth" /* MegaETH */]: {
     id: 4326,
-    rpc: "https://carrot.megaeth.com",
+    rpc: "https://mainnet.megaeth.com/rpc",
     usdt: "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
     decimals: 6
   },
@@ -1321,6 +1274,55 @@ var CHAIN_CONFIGS = {
     rpc: "https://rpc.hyperliquid.xyz/evm",
     usdt: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
     decimals: 6
+  },
+  ["polygon" /* Polygon */]: {
+    id: 137,
+    rpc: "https://polygon-bor-rpc.publicnode.com",
+    // Polygon's canonical USDT, migrated to USDT0
+    usdt: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+    decimals: 6
+  },
+  ["plasma" /* Plasma */]: {
+    id: 9745,
+    rpc: "https://rpc.plasma.to",
+    usdt: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+    decimals: 6
+  },
+  ["optimism" /* Optimism */]: {
+    id: 10,
+    rpc: "https://optimism-rpc.publicnode.com",
+    usdt: "0x01bFF41798a0BcF287b996046Ca68b395DbC1071",
+    decimals: 6
+  },
+  ["unichain" /* Unichain */]: {
+    id: 130,
+    rpc: "https://unichain-rpc.publicnode.com",
+    usdt: "0x9151434b16b9763660705744891fA906F660EcC5",
+    decimals: 6
+  },
+  ["sei" /* Sei */]: {
+    id: 1329,
+    rpc: "https://sei-evm-rpc.publicnode.com",
+    usdt: "0x9151434b16b9763660705744891fA906F660EcC5",
+    decimals: 6
+  },
+  ["flare" /* Flare */]: {
+    id: 14,
+    rpc: "https://flare-api.flare.network/ext/C/rpc",
+    usdt: "0xe7cd86e13AC4309349F30B3435a9d337750fC82D",
+    decimals: 6
+  },
+  ["xlayer" /* XLayer */]: {
+    id: 196,
+    rpc: "https://rpc.xlayer.tech",
+    usdt: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    decimals: 6
+  },
+  ["rootstock" /* Rootstock */]: {
+    id: 30,
+    rpc: "https://public-node.rsk.co",
+    usdt: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    decimals: 6
   }
 };
 
@@ -1733,40 +1735,83 @@ import {
   isAddress as isAddress4,
   numberToHex,
   padHex,
+  formatUnits as formatUnits5,
   parseUnits as parseUnits4
 } from "viem";
 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 }
+};
+function bridgeChain(chain, lzEid, blockTimeSec, usdt0Adapter) {
+  const base = C[chain];
+  const tokens = {};
+  if (usdt0Adapter) {
+    tokens.usdt0 = { address: base.usdt, decimals: base.decimals, oftAdapter: usdt0Adapter };
+  }
+  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" },
-  ["stable-testnet" /* StableTestnet */]: { ...C["stable-testnet" /* StableTestnet */], lzEid: 40374, oftAdapter: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736" },
+  ["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" },
-  ["ethereum" /* Ethereum */]: { ...C["ethereum" /* Ethereum */], lzEid: 30101, oftAdapter: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee" },
-  ["arbitrum" /* Arbitrum */]: { ...C["arbitrum" /* Arbitrum */], lzEid: 30110, oftAdapter: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92" },
-  ["ink" /* Ink */]: { ...C["ink" /* Ink */], lzEid: 30339, oftAdapter: "0x1cB6De532588fCA4a21B7209DE7C456AF8434A65" },
-  ["bera" /* Bera */]: { ...C["bera" /* Bera */], lzEid: 30362, oftAdapter: "0x3Dc96399109df5ceb2C226664A086140bD0379cB" },
-  ["megaeth" /* MegaETH */]: { ...C["megaeth" /* MegaETH */], lzEid: 30398, oftAdapter: "0x9151434b16b9763660705744891fa906f660ecc5" },
-  ["hyperevm" /* HyperEVM */]: { ...C["hyperevm" /* HyperEVM */], lzEid: 30367, oftAdapter: "0x904861a24F30EC96ea7CFC3bE9EA4B476d237e98" }
+  ["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) => cfg.tokens[asset]?.address.toLowerCase() === 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: [
@@ -1782,22 +1827,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",
@@ -1812,51 +1883,295 @@ var OFT_ADAPTER_ABI = [
     stateMutability: "payable"
   }
 ];
-function buildLzOptions(gasLimit = 0n) {
+var OAPP_ABI = [
+  { name: "endpoint", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] }
+];
+var ENDPOINT_V2_ABI = [
+  {
+    name: "getSendLibrary",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "_sender", type: "address" }, { name: "_dstEid", type: "uint32" }],
+    outputs: [{ type: "address" }]
+  }
+];
+var SEND_ULN_ABI = [
+  {
+    name: "getUlnConfig",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "_oapp", type: "address" }, { name: "_remoteEid", type: "uint32" }],
+    outputs: [
+      {
+        name: "rtnConfig",
+        type: "tuple",
+        components: [
+          { name: "confirmations", type: "uint64" },
+          { name: "requiredDVNCount", type: "uint8" },
+          { name: "optionalDVNCount", type: "uint8" },
+          { name: "optionalDVNThreshold", type: "uint8" },
+          { name: "requiredDVNs", type: "address[]" },
+          { name: "optionalDVNs", type: "address[]" }
+        ]
+      }
+    ]
+  }
+];
+var LZ_SCAN_API = "https://scan.layerzero-api.com/v1";
+var LZ_SCAN_UI = "https://layerzeroscan.com";
+var CACHE_TTL_MS = 5 * 6e4;
+var cache = /* @__PURE__ */ new Map();
+function clearBridgeEstimateCache() {
+  cache.clear();
+}
+async function cached(key, ttlMs, load) {
+  const hit = cache.get(key);
+  if (hit && Date.now() - hit.at < ttlMs) return hit.value;
+  const value = await load();
+  cache.set(key, { at: Date.now(), value });
+  return value;
+}
+var ScanHttpError = class extends Error {
+  constructor(status, path) {
+    super(`LayerZero Scan ${status} for ${path}`);
+    this.status = status;
+    this.name = "ScanHttpError";
+  }
+};
+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 await res.json();
+}
+var TERMINAL_FAILURE_STATUSES = /* @__PURE__ */ new Set([
+  "FAILED",
+  "BLOCKED",
+  "PAYLOAD_STORED",
+  "APPLICATION_BURNED",
+  "APPLICATION_SKIPPED",
+  "UNRESOLVABLE_COMMAND",
+  "MALFORMED_COMMAND"
+]);
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+var WORKER_EXECUTOR = 1;
+var OPTION_LZRECEIVE = 1;
+var OPTION_NATIVE_DROP = 2;
+function lzOption(optionType, payload) {
+  const payloadBytes = (payload.length - 2) / 2;
+  return concat([
+    numberToHex(WORKER_EXECUTOR, { size: 1 }),
+    numberToHex(1 + payloadBytes, { size: 2 }),
+    numberToHex(optionType, { size: 1 }),
+    payload
+  ]);
+}
+function buildLzOptions(gasLimit = 0n, nativeDrop = 0n, dropReceiver) {
+  const options = [
+    lzOption(OPTION_LZRECEIVE, numberToHex(gasLimit, { size: 16 }))
+  ];
+  if (nativeDrop > 0n) {
+    if (!dropReceiver) {
+      throw new StableValidationError(
+        "recipient",
+        dropReceiver,
+        "buildLzOptions: a native drop needs a receiver address"
+      );
+    }
+    options.push(
+      lzOption(
+        OPTION_NATIVE_DROP,
+        concat([
+          numberToHex(nativeDrop, { size: 16 }),
+          padHex(dropReceiver, { dir: "left", size: 32 })
+        ])
+      )
+    );
+  }
   return concat([
     numberToHex(3, { size: 2 }),
     // TYPE_3 header
-    numberToHex(1, { size: 1 }),
-    // Executor worker ID
-    numberToHex(17, { size: 2 }),
-    // option payload length = 17 bytes
-    numberToHex(1, { size: 1 }),
-    // LzReceive option type
-    numberToHex(gasLimit, { size: 16 })
-    // gas limit as uint128
+    ...options
   ]);
 }
+var FALLBACK_SEND_GAS = 400000n;
+function usableQuote(quote, amountLD) {
+  if (!quote?.oft) return quote;
+  return quote.oft.amountSentLD <= amountLD ? quote : void 0;
+}
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var LayerZeroService = class {
   constructor(config) {
     this.config = config;
   }
-  async quoteBridge({ fromChain, toChain, fromToken, toToken, amount, recipient }) {
-    const recipientAddr = recipient ?? "0x0000000000000000000000000000000000000000";
-    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, "quoteBridge");
-    const { src, dst } = this.resolveChains(fromChain, toChain, fromToken, toToken);
-    const oftAdapter = src.oftAdapter;
-    const amountLD = parseUnits4(String(amount), src.decimals);
-    try {
-      const { nativeFee, lzTokenFee } = await createPublicClient5({
-        chain: makeChain(src.id, src.rpc),
-        transport: http5(src.rpc)
-      }).readContract({
-        address: oftAdapter,
+  async quoteBridge(params) {
+    const plan = this.plan(params, "quoteBridge");
+    const [{ fee, oft }, estimate] = await Promise.all([
+      this.quotePathway(plan, "quoteBridge"),
+      this.estimateBridgeTime(params).catch(() => void 0)
+    ]);
+    const srcGas = await this.estimateSendGas(plan, fee, oft);
+    return {
+      ...fee,
+      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: oft?.amountReceived ?? params.amount,
+      srcGas,
+      totalCostWei: srcGas ? srcGas.costWei + fee.nativeFee : void 0,
+      estimate
+    };
+  }
+  /**
+   * 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: an adapter that does not answer `quoteOFT` costs us the fee
+   * breakdown and the exact output amount, not the whole quote.
+   */
+  async quotePathway(plan, method) {
+    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 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)
+    ]);
+    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. Resolves to `undefined` rather than throwing — see `quoteSend`.
+   */
+  async readOftQuote(plan, sendParam) {
+    try {
+      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(formatUnits5(receipt.amountReceivedLD, decimals)),
+        fees: feeDetails.map((detail) => ({
+          amountLD: detail.feeAmountLD,
+          amount: Number(formatUnits5(detail.feeAmountLD, decimals)),
+          description: detail.description
+        })),
+        minAmountLD: limit.minAmountLD,
+        maxAmountLD: limit.maxAmountLD
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * 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) {
+    const gasPriceWei = await this.gasPrice(plan);
+    if (gasPriceWei === void 0) return void 0;
+    let gas = FALLBACK_SEND_GAS;
+    let source = "fallback";
+    const account = this.signerAddress();
+    if (account) {
+      try {
+        gas = await plan.pc.estimateContractGas({
+          address: plan.oftAdapter,
+          abi: OFT_ADAPTER_ABI,
+          functionName: "send",
+          args: [
+            this.buildSendParams(plan, oft?.amountReceivedLD ?? plan.amountLD),
+            fee,
+            account
+          ],
+          account,
+          value: fee.nativeFee
+        });
+        source = "simulated";
+      } catch {
+      }
+    }
+    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 = fees.maxFeePerGas ?? fees.gasPrice;
+      if (price !== void 0) return price;
+    } catch {
+    }
+    try {
+      return await plan.pc.getGasPrice();
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Top the adapter's allowance up to `amountLD` when it is short. Only the
+   * lockbox chain reaches here — remote deployments burn from the caller.
+   */
+  async ensureAllowance(plan, wc, owner, amountLD) {
+    const { src, asset, srcToken, oftAdapter, pc, chain: srcChain } = plan;
+    const allowance = await pc.readContract({
+      address: srcToken.address,
+      abi: erc20Abi4,
+      functionName: "allowance",
+      args: [owner, oftAdapter]
+    });
+    if (allowance >= amountLD) return;
+    let approveHash;
+    try {
+      approveHash = await wc.writeContract({
+        address: srcToken.address,
+        abi: erc20Abi4,
+        functionName: "approve",
+        args: [oftAdapter, amountLD],
+        account: wc.account,
+        chain: srcChain
       });
-      return { nativeFee, lzTokenFee, toAmount: amount };
     } catch (err) {
-      throw new StableQuoteError({
-        provider: "layerzero",
-        shortMessage: "quoteBridge: quoteSend call failed",
+      throw new StableTransactionError({
+        phase: "approve",
+        shortMessage: `bridge: ${asset} approve failed`,
+        chainId: src.id,
         cause: err
       });
     }
+    const approveReceipt = await pc.waitForTransactionReceipt({ hash: approveHash });
+    if (approveReceipt.status === "reverted") {
+      throw new StableTransactionError({
+        phase: "approve",
+        shortMessage: `bridge: ${asset} approve reverted on-chain`,
+        txHash: approveReceipt.transactionHash,
+        chainId: src.id
+      });
+    }
   }
-  async bridge({ fromChain, toChain, fromToken, toToken, amount, recipient, quote }) {
-    const from = this.config.walletClient?.account?.address ?? this.config.account?.address;
+  async bridge(params) {
+    const from = this.signerAddress();
     if (!from) {
       throw new StableValidationError(
         "signer",
@@ -1864,17 +2179,13 @@ var LayerZeroService = class {
         "bridge: requires a signer \u2014 set walletClient or account in StableConfig"
       );
     }
-    const recipientAddr = 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: params.recipient ?? from }, "bridge");
+    const { src, srcToken, oftAdapter, amountLD, chain: srcChain } = plan;
     const wc = this.config.walletClient ?? createWalletClient4({
       account: this.config.account,
       chain: srcChain,
       transport: this.config.transport ?? http5(src.rpc)
     });
-    const pc = createPublicClient5({ chain: srcChain, transport: http5(src.rpc) });
     try {
       await wc.switchChain({ id: src.id });
     } catch (err) {
@@ -1885,44 +2196,11 @@ var LayerZeroService = class {
         cause: err
       });
     }
-    const amountLD = parseUnits4(String(amount), src.decimals);
-    const sendParams = this.buildSendParams(dst, amountLD, recipientAddr);
-    const lzFee = quote?.nativeFee !== void 0 && quote?.lzTokenFee !== void 0 ? { nativeFee: quote.nativeFee, lzTokenFee: quote.lzTokenFee } : await this.quoteBridge({ fromChain, toChain, fromToken, toToken, amount, recipient: recipientAddr });
-    const { nativeFee = 0n, lzTokenFee = 0n } = lzFee;
-    const allowance = await pc.readContract({
-      address: src.usdt,
-      abi: erc20Abi4,
-      functionName: "allowance",
-      args: [from, oftAdapter]
-    });
-    if (allowance < amountLD) {
-      let approveHash;
-      try {
-        approveHash = await wc.writeContract({
-          address: src.usdt,
-          abi: erc20Abi4,
-          functionName: "approve",
-          args: [oftAdapter, amountLD],
-          account: wc.account,
-          chain: srcChain
-        });
-      } catch (err) {
-        throw new 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 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 } = quote?.nativeFee !== void 0 && quote?.lzTokenFee !== void 0 ? { nativeFee: quote.nativeFee, lzTokenFee: quote.lzTokenFee, oft: quote.oft } : await this.quotePathway(plan, "bridge").then((r) => ({ ...r.fee, oft: r.oft }));
+    const sendParams = this.buildSendParams(plan, oft?.amountReceivedLD ?? amountLD);
+    if (srcToken.approvalRequired !== false) {
+      await this.ensureAllowance(plan, wc, from, amountLD);
     }
     try {
       const hash = await wc.writeContract({
@@ -1934,7 +2212,7 @@ var LayerZeroService = class {
         account: wc.account,
         chain: srcChain
       });
-      return { txHash: hash, toAmount: amount };
+      return { txHash: hash, toAmount: oft?.amountReceived ?? params.amount };
     } catch (err) {
       throw new StableTransactionError({
         phase: "send",
@@ -1944,6 +2222,132 @@ var LayerZeroService = class {
       });
     }
   }
+  /**
+   * Estimate how long a USDT0 bridge will take, end to end.
+   *
+   * Two independent inputs, both cheap:
+   *  - **observed** — median delivery time of recent messages LayerZero Scan has
+   *    already settled on this exact pathway.
+   *  - **formula** — LayerZero's documented estimate from the on-chain ULN config:
+   *    `srcBlockTime × confirmations + dstBlockTime × (2 + dvnCount)`.
+   *
+   * `observed` wins when available. The formula assumes `confirmations` is the whole
+   * wait, which holds for L1 sources but badly understates rollups: Arbitrum→Stable
+   * 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,
+    fromToken,
+    toToken
+  }) {
+    const src = BRIDGE_CHAIN_CONFIGS[fromChain];
+    const dst = BRIDGE_CHAIN_CONFIGS[toChain];
+    const from = fromToken ?? src?.tokens.usdt0?.address;
+    const to = toToken ?? dst?.tokens.usdt0?.address;
+    if (!(src && from)) {
+      throw new StableValidationError("fromChain", fromChain, `estimateBridgeTime: no OFT adapter for "${fromChain}"`);
+    }
+    if (!(dst && to)) {
+      throw new 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, 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;
+    if (uln && dvnCount !== void 0 && src.blockTimeSec && dst.blockTimeSec) {
+      const computed = Math.round(
+        uln.confirmations * src.blockTimeSec + dst.blockTimeSec * (2 + dvnCount)
+      );
+      formulaSeconds = Number.isFinite(computed) ? computed : void 0;
+    }
+    const seconds = observedSeconds ?? formulaSeconds;
+    if (seconds === void 0) {
+      throw new StableQuoteError({
+        provider: "layerzero",
+        shortMessage: `estimateBridgeTime: no pathway data for ${fromChain}\u2192${toChain}`
+      });
+    }
+    return {
+      seconds,
+      source: observedSeconds !== void 0 ? "observed" : "formula",
+      observedSeconds,
+      formulaSeconds,
+      confirmations: Number.isFinite(uln?.confirmations) ? uln?.confirmations : void 0,
+      dvnCount: Number.isFinite(dvnCount) ? dvnCount : void 0
+    };
+  }
+  /**
+   * Follow an in-flight bridge by its source transaction hash. Poll this after
+   * `bridge()` to drive a progress UI; a message LayerZero Scan has not indexed
+   * yet reports `"pending"` rather than throwing.
+   */
+  async trackBridge(srcTxHash) {
+    const scanUrl = `${LZ_SCAN_UI}/tx/${srcTxHash}`;
+    let message;
+    try {
+      message = (await scanFetch(`/messages/tx/${srcTxHash}`))?.data?.[0];
+    } catch (err) {
+      if (err instanceof ScanHttpError && err.status === 404) {
+        return { state: "pending", srcTxHash, scanUrl };
+      }
+      throw new StableQuoteError({
+        provider: "layerzero",
+        shortMessage: `trackBridge: LayerZero Scan lookup failed for ${srcTxHash}`,
+        cause: err
+      });
+    }
+    if (!message) return { state: "pending", srcTxHash, scanUrl };
+    const raw = message.status?.name ?? "";
+    const sentAt = message.source?.tx?.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: message.destination?.tx?.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, oapp) {
+    return cached(`uln:${src.lzEid}-${dst.lzEid}-${oapp.toLowerCase()}`, CACHE_TTL_MS, async () => {
+      const pc = createPublicClient5({ chain: makeChain(src.id, src.rpc), transport: http5(src.rpc) });
+      const endpoint = await pc.readContract({ address: oapp, abi: OAPP_ABI, functionName: "endpoint" });
+      const sendLib = await pc.readContract({
+        address: endpoint,
+        abi: ENDPOINT_V2_ABI,
+        functionName: "getSendLibrary",
+        args: [oapp, dst.lzEid]
+      });
+      const cfg = await pc.readContract({
+        address: sendLib,
+        abi: SEND_ULN_ABI,
+        functionName: "getUlnConfig",
+        args: [oapp, dst.lzEid]
+      });
+      return {
+        confirmations: Number(cfg.confirmations),
+        requiredDVNCount: Number(cfg.requiredDVNCount),
+        optionalDVNCount: Number(cfg.optionalDVNCount)
+      };
+    });
+  }
+  /** Median delivery time of recently delivered messages on this pathway, in seconds. */
+  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 = (data ?? []).filter((m) => m.status?.name === "DELIVERED").map((m) => (m.destination?.tx?.blockTimestamp ?? 0) - (m.source?.tx?.blockTimestamp ?? 0)).filter((d) => d > 0);
+      return durations.length >= 3 ? Math.round(median(durations)) : void 0;
+    });
+  }
   validateBridgeParams(params, method) {
     if (!isAddress4(params.recipient)) {
       throw new StableValidationError(
@@ -1967,37 +2371,95 @@ 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 StableValidationError("fromChain", fromChain, `Unsupported source chain: "${fromChain}"`);
     if (!dst) throw new StableValidationError("toChain", toChain, `Unsupported destination chain: "${toChain}"`);
-    if (!src.oftAdapter) {
-      throw new StableValidationError("fromChain", fromChain, `No OFT adapter configured for "${fromChain}"`);
-    }
-    if (fromToken.toLowerCase() !== src.usdt.toLowerCase()) {
+    const asset = bridgeAssetFor(src, fromToken);
+    if (!asset) {
       throw new 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.`
       );
     }
-    if (toToken.toLowerCase() !== dst.usdt.toLowerCase()) {
+    const srcToken = src.tokens[asset];
+    const dstToken = dst.tokens[asset];
+    if (!dstToken) {
+      throw new StableValidationError(
+        "toChain",
+        toChain,
+        `Native OFT bridge cannot deliver ${asset} to "${toChain}" \u2014 no ${asset} deployment there. Use route "lifi" instead.`
+      );
+    }
+    if (dstToken.address.toLowerCase() !== toToken.toLowerCase()) {
       throw new 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 };
+  }
+  /**
+   * 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 = recipient ?? ZERO_ADDRESS;
+    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, method);
+    if (dstNativeDrop !== void 0 && dstNativeDrop < 0n) {
+      throw new StableValidationError(
+        "dstNativeDrop",
+        dstNativeDrop,
+        `${method}: dstNativeDrop must not be negative`
+      );
+    }
+    const { src, dst, asset, srcToken, dstToken } = this.resolveRoute(
+      fromChain,
+      toChain,
+      fromToken,
+      toToken
+    );
+    const chain = makeChain(src.id, src.rpc);
+    return {
+      src,
+      dst,
+      asset,
+      srcToken,
+      dstToken,
+      oftAdapter: srcToken.oftAdapter,
+      amountLD: parseUnits4(String(amount), srcToken.decimals),
+      recipient: recipientAddr,
+      nativeDrop: dstNativeDrop ?? 0n,
+      chain,
+      pc: createPublicClient5({ chain, transport: http5(src.rpc) })
+    };
+  }
+  /** The address that will sign, or undefined when this service has no signer. */
+  signerAddress() {
+    return this.config.walletClient?.account?.address ?? this.config.account?.address;
   }
-  buildSendParams(dst, amountLD, recipient) {
+  /**
+   * `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: dst.lzEid,
-      to: padHex(recipient, { dir: "left", size: 32 }),
-      amountLD,
-      minAmountLD: amountLD,
-      extraOptions: buildLzOptions(),
+      dstEid: plan.dst.lzEid,
+      to: padHex(plan.recipient, { dir: "left", size: 32 }),
+      amountLD: plan.amountLD,
+      minAmountLD,
+      extraOptions: buildLzOptions(0n, plan.nativeDrop, plan.recipient),
       composeMsg: "0x",
       oftCmd: "0x"
     };
@@ -2005,21 +2467,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" && (params.dstNativeDrop ?? 0n) > 0n) {
+    throw new 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 = 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,
@@ -2119,6 +2597,12 @@ function createStable({
     chainId: chain.id,
     vault: earnConfig.vault
   }) : null;
+  const erc3009Client = walletClient ? walletClient : account ? createWalletClient5({
+    account,
+    chain,
+    transport: transport ?? http6(rpc)
+  }) : createPublicClient6({ chain, transport: http6(rpc) });
+  const authorization = erc3009Actions(erc3009Client);
   function requireEarn() {
     if (!morpho) {
       throw new StableValidationError(
@@ -2195,10 +2679,15 @@ 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),
+    estimateBridgeTime: (params) => lz.estimateBridgeTime(params),
+    trackBridge: (srcTxHash) => lz.trackBridge(srcTxHash),
     quoteSwap: (params) => lifi.quoteSwap(params),
     swap: (params) => lifi.swap(params),
+    authorization,
     earn: {
       deposit: (params) => requireEarn().deposit(params),
       bulkDeposit: (items, options) => requireEarn().bulkDeposit(items, options),
@@ -2234,14 +2723,11 @@ function createStableReader(config) {
     }
   };
 }
-
-// src/constants.ts
-var STABLE_USDT_ADDRESS = "0x779ded0c9e1022225f8e0630b35a9b54be713736";
-var STABLE_VAULT_ADDRESS = "0xb7Df8db22A5DBBFA9ebeb94b3910aec6a4f05c08";
 export {
   BRIDGE_CHAIN_CONFIGS,
   CHAIN_CONFIGS,
   Chain,
+  ERC3009_ABI,
   Network,
   STABLE_USDT_ADDRESS,
   STABLE_VAULT_ADDRESS,
@@ -2251,6 +2737,18 @@ export {
   StableQuoteError,
   StableTransactionError,
   StableValidationError,
+  bridgeAssetFor,
+  cancelAuthorization,
+  clearBridgeEstimateCache,
   createStable,
-  createStableReader
+  createStableReader,
+  erc3009Actions,
+  getAuthorizationState,
+  getAuthorizationUsage,
+  prepareTransferWithAuthorization,
+  receiveWithAuthorization,
+  signReceiveAuthorization,
+  signTransferAuthorization,
+  transferWithAuthorization,
+  verifyAuthorization
 };