@anywalletkit/protocol-swap2-usdt0 0.0.0-stage → 0.1.2

package/dist/config.d.cts

@@ -0,0 +1,34 @@
+interface Usdt0Chain {
+    caip2: string;
+    chainId: number;
+    /** LayerZero V2 endpoint id. */
+    eid: number;
+    name: string;
+    /** The ERC-20 the user holds: USDT on Ethereum, USDT0 elsewhere (6 decimals everywhere). */
+    token: string;
+    /**
+     * The OFT contract `quoteSend` / `send` are called on. On Ethereum it is the
+     * OFT *adapter* that locks USDT (`approvalRequired()` = true, approve the
+     * token to it); elsewhere it is the OUpgradeable OFT that burns the caller's
+     * USDT0 through the token's mint/burn role — no approval.
+     */
+    oft: string;
+    /** LayerZero V2 EndpointV2 on that chain (`lzReceive` retries of a stored payload go here). */
+    endpoint: string;
+    /** True on Ethereum: the OFT is a lockbox adapter in front of plain USDT. */
+    adapter: boolean;
+}
+/** CAIP-2 → USDT0 deployment. */
+declare const USDT0_CHAINS: Readonly<Record<string, Usdt0Chain>>;
+/** LayerZero eid → deployment. */
+declare const USDT0_BY_EID: Readonly<Record<number, Usdt0Chain>>;
+/** LayerZero Scan — message status by source transaction hash. */
+declare const LZ_SCAN_API = "https://scan.layerzero-api.com";
+/** Token symbols the catalog uses for the same asset across chains. */
+declare const USDT0_SYMBOLS: readonly string[];
+declare const usdt0: {
+    supportsChain(chain: string): boolean;
+    supports(from: string, to: string): boolean;
+};
+
+export { LZ_SCAN_API, USDT0_BY_EID, USDT0_CHAINS, USDT0_SYMBOLS, type Usdt0Chain, usdt0 };

package/dist/config.d.ts

@@ -0,0 +1,34 @@
+interface Usdt0Chain {
+    caip2: string;
+    chainId: number;
+    /** LayerZero V2 endpoint id. */
+    eid: number;
+    name: string;
+    /** The ERC-20 the user holds: USDT on Ethereum, USDT0 elsewhere (6 decimals everywhere). */
+    token: string;
+    /**
+     * The OFT contract `quoteSend` / `send` are called on. On Ethereum it is the
+     * OFT *adapter* that locks USDT (`approvalRequired()` = true, approve the
+     * token to it); elsewhere it is the OUpgradeable OFT that burns the caller's
+     * USDT0 through the token's mint/burn role — no approval.
+     */
+    oft: string;
+    /** LayerZero V2 EndpointV2 on that chain (`lzReceive` retries of a stored payload go here). */
+    endpoint: string;
+    /** True on Ethereum: the OFT is a lockbox adapter in front of plain USDT. */
+    adapter: boolean;
+}
+/** CAIP-2 → USDT0 deployment. */
+declare const USDT0_CHAINS: Readonly<Record<string, Usdt0Chain>>;
+/** LayerZero eid → deployment. */
+declare const USDT0_BY_EID: Readonly<Record<number, Usdt0Chain>>;
+/** LayerZero Scan — message status by source transaction hash. */
+declare const LZ_SCAN_API = "https://scan.layerzero-api.com";
+/** Token symbols the catalog uses for the same asset across chains. */
+declare const USDT0_SYMBOLS: readonly string[];
+declare const usdt0: {
+    supportsChain(chain: string): boolean;
+    supports(from: string, to: string): boolean;
+};
+
+export { LZ_SCAN_API, USDT0_BY_EID, USDT0_CHAINS, USDT0_SYMBOLS, type Usdt0Chain, usdt0 };

package/dist/config.js

@@ -0,0 +1,15 @@
+import {
+  LZ_SCAN_API,
+  USDT0_BY_EID,
+  USDT0_CHAINS,
+  USDT0_SYMBOLS,
+  usdt0
+} from "./chunk-AGN4M7OO.js";
+export {
+  LZ_SCAN_API,
+  USDT0_BY_EID,
+  USDT0_CHAINS,
+  USDT0_SYMBOLS,
+  usdt0
+};
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.cjs

@@ -0,0 +1,485 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  LZ_RECEIVE: () => LZ_RECEIVE,
+  LZ_SCAN_API: () => LZ_SCAN_API,
+  USDT0_BY_EID: () => USDT0_BY_EID,
+  USDT0_CHAINS: () => USDT0_CHAINS,
+  USDT0_MODULE: () => USDT0_MODULE,
+  USDT0_SEND: () => USDT0_SEND,
+  USDT0_STATUS_MAP: () => USDT0_STATUS_MAP,
+  USDT0_SYMBOLS: () => USDT0_SYMBOLS,
+  USDT0_ZERO_PEER: () => ZERO_B32,
+  Usdt0Swap2Protocol: () => Usdt0Swap2Protocol,
+  default: () => Usdt0Swap2Protocol,
+  describeUsdt0Activity: () => describeUsdt0Activity,
+  usdt0: () => usdt0,
+  usdt0Provider: () => usdt0Provider
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var import_util = require("@anywalletkit/protocol-swap2-core/util");
+var LZ_ENDPOINT_A = "0x1a44076050125825900e736c501f859c50fE728c";
+var LZ_ENDPOINT_B = "0x6F475642a6e85809B1c36Fa62763669b1b48DD5B";
+var c = (chainId, eid, name, token, oft, endpoint, adapter = false) => ({
+  caip2: `eip155:${chainId}`,
+  chainId,
+  eid,
+  name,
+  token,
+  oft,
+  endpoint,
+  adapter
+});
+var USDT0_CHAINS = Object.freeze(Object.fromEntries([
+  c(1, 30101, "Ethereum", "0xdAC17F958D2ee523a2206206994597C13D831ec7", "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee", LZ_ENDPOINT_A, true),
+  c(42161, 30110, "Arbitrum", "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92", LZ_ENDPOINT_A),
+  c(10, 30111, "OP Mainnet", "0x01bFF41798a0BcF287b996046Ca68b395DbC1071", "0xF03b4d9AC1D5d1E7c4cEf54C2A313b9fe051A0aD", LZ_ENDPOINT_A),
+  c(137, 30109, "Polygon PoS", "0xc2132D05D31c914a87C6611C10748AEb04B58e8F", "0x6BA10300f0DC58B7a1e4c0e41f5daBb7D7829e13", LZ_ENDPOINT_A),
+  c(999, 30367, "HyperEVM", "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb", "0x904861a24F30EC96ea7CFC3bE9EA4B476d237e98", "0x3A73033C0b1407574C76BdBAc67f126f6b4a9AA9"),
+  c(57073, 30339, "Ink", "0x0200C29006150606B650577BBE7B6248F58470c1", "0x1cB6De532588fCA4a21B7209DE7C456AF8434A65", "0xca29f3A6f966Cb2fc0dE625F8f325c0C46dbE958"),
+  c(80094, 30362, "Berachain", "0x779Ded0c9e1022225f8E0630b35a9b54bE713736", "0x3Dc96399109df5ceb2C226664A086140bD0379cB", LZ_ENDPOINT_B),
+  c(130, 30320, "Unichain", "0x9151434b16b9763660705744891fA906F660EcC5", "0xc07bE8994D035631c36fb4a89C918CeFB2f03EC3", LZ_ENDPOINT_B),
+  c(1329, 30280, "Sei", "0x9151434b16b9763660705744891fA906F660EcC5", "0x56Fe74A2e3b484b921c447357203431a3485CC60", LZ_ENDPOINT_A),
+  c(9745, 30383, "Plasma", "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb", "0x02ca37966753bDdDf11216B73B16C1dE756A7CF9", LZ_ENDPOINT_B),
+  c(143, 30390, "Monad", "0xe7cd86e13AC4309349F30B3435a9d337750fC82D", "0x9151434b16b9763660705744891fA906F660EcC5", LZ_ENDPOINT_B),
+  c(4326, 30398, "MegaETH", "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb", "0x9151434b16b9763660705744891fA906F660EcC5", LZ_ENDPOINT_B),
+  c(196, 30274, "X Layer", "0x779Ded0c9e1022225f8E0630b35a9b54bE713736", "0x94bcCa6BdfD6a61817aB0E960BfedE4984505554", LZ_ENDPOINT_A),
+  // 2026-10-20 (evm-chains-6 batch): docs.usdt0.to deployments, re-read on-chain (token(), approvalRequired() = false,
+  // sharedDecimals() = 6, endpoint(), peers(30110) = the Arbitrum OFT).
+  c(5e3, 30181, "Mantle", "0x779Ded0c9e1022225f8E0630b35a9b54bE713736", "0xcb768e263FB1C62214E7cab4AA8d036D76dc59CC", LZ_ENDPOINT_A),
+  c(2818, 30322, "Morph", "0xe7cd86e13AC4309349F30B3435a9d337750fC82D", "0xcb768e263FB1C62214E7cab4AA8d036D76dc59CC", LZ_ENDPOINT_B),
+  c(14, 30295, "Flare", "0xe7cd86e13AC4309349F30B3435a9d337750fC82D", "0x567287d2A9829215a37e3B88843d32f9221E7588", LZ_ENDPOINT_A)
+].map((x) => [x.caip2, x])));
+var USDT0_BY_EID = Object.freeze(
+  Object.fromEntries(Object.values(USDT0_CHAINS).map((x) => [x.eid, x]))
+);
+var LZ_SCAN_API = "https://scan.layerzero-api.com";
+var USDT0_SYMBOLS = Object.freeze(["USDT0", "USDT", "USD\u20AE0", "USD\u20AE"]);
+var usdt0 = {
+  supportsChain(chain) {
+    return (0, import_util.isEvm)(chain) && !!USDT0_CHAINS[`eip155:${(0, import_util.evmRef)(chain)}`];
+  },
+  supports(from, to) {
+    return from !== to && this.supportsChain(from) && this.supportsChain(to);
+  }
+};
+
+// src/provider.ts
+var import_viem2 = require("viem");
+
+// src/activity.ts
+var import_activity = require("@anywalletkit/protocol-swap2-core/activity");
+var import_viem = require("viem");
+var SEND_ABI = (0, import_viem.parseAbi)([
+  "struct SendParam { uint32 dstEid; bytes32 to; uint256 amountLD; uint256 minAmountLD; bytes extraOptions; bytes composeMsg; bytes oftCmd; }",
+  "struct MessagingFee { uint256 nativeFee; uint256 lzTokenFee; }",
+  "function send(SendParam sp, MessagingFee fee, address refundAddress)"
+]);
+var USDT0_MODULE = "@anywalletkit/protocol-swap2-usdt0";
+var USDT0_SEND = "0xc7c7f5b3";
+var LZ_RECEIVE = "0x0c0c389e";
+var ZERO = "0x0000000000000000000000000000000000000000";
+function symbolFor(chain) {
+  return chain.adapter || [42161, 10, 137].includes(chain.chainId) ? "USDT" : "USDT0";
+}
+function sendDestination(tx) {
+  const data = tx.call?.data;
+  if (!data || data.length < 10 + 64 * 2) return null;
+  try {
+    const [sp] = (0, import_viem.decodeFunctionData)({ abi: SEND_ABI, data }).args;
+    return USDT0_BY_EID[sp.dstEid] ?? null;
+  } catch {
+    return null;
+  }
+}
+var lc = (a) => a.toLowerCase();
+function describeUsdt0Activity(tx, ctx) {
+  const chain = USDT0_CHAINS[tx.chain];
+  if (!chain) return null;
+  const subtitle = `USDT0 \xB7 ${(0, import_activity.chainLabel)(tx.chain)}`;
+  if ((0, import_activity.matchesCall)(tx, [chain.oft], [USDT0_SEND])) {
+    const dst = sendDestination(tx);
+    const item = (0, import_activity.describeSwapLike)(tx, ctx, { protocol: USDT0_MODULE, subtitle, kind: "bridge", outVerb: "Bridged" });
+    if (!item) return null;
+    const native = item.assetsOut.filter((a) => a.token === null).reduce((sum, a) => sum + a.amount, 0n);
+    item.assetsOut = item.assetsOut.filter((a) => a.token !== null);
+    if (native > 0n) item.fee = (item.fee ?? 0n) + native;
+    const srcSym = item.assetsOut[0]?.symbol ?? symbolFor(chain);
+    if (dst) {
+      item.title = `Bridged ${srcSym} \u2192 ${symbolFor(dst)}`;
+      item.subtitle = `USDT0 \xB7 ${(0, import_activity.chainLabel)(tx.chain)} \u2192 ${dst.name}`;
+    } else item.title = `Bridged ${srcSym}`;
+    return item;
+  }
+  if ((0, import_activity.matchesCall)(tx, [chain.endpoint], [LZ_RECEIVE])) {
+    return (0, import_activity.describeSwapLike)(tx, ctx, { protocol: USDT0_MODULE, subtitle, kind: "bridge", inSuffix: "via LayerZero" });
+  }
+  const called = (0, import_activity.calledContract)(tx);
+  if (called && called === lc(chain.token)) return null;
+  const own = new Set([...ctx.own].map(lc));
+  const origin = chain.adapter ? lc(chain.oft) : ZERO;
+  const delivered = tx.transfers.some((t) => t.token !== null && lc(t.token) === lc(chain.token) && lc(t.from) === origin && own.has(lc(t.to)));
+  if (!delivered || own.has(lc(tx.from))) return null;
+  return (0, import_activity.describeSwapLike)(tx, ctx, { protocol: USDT0_MODULE, subtitle, kind: "bridge", inSuffix: "via LayerZero", counterparty: chain.oft });
+}
+
+// src/provider.ts
+var import_swap2_assets = require("@anywalletkit/swap2-assets");
+var import_util2 = require("@anywalletkit/protocol-swap2-core/util");
+var OFT_ABI = (0, import_viem2.parseAbi)([
+  "struct SendParam { uint32 dstEid; bytes32 to; uint256 amountLD; uint256 minAmountLD; bytes extraOptions; bytes composeMsg; bytes oftCmd; }",
+  "struct MessagingFee { uint256 nativeFee; uint256 lzTokenFee; }",
+  "struct OFTLimit { uint256 minAmountLD; uint256 maxAmountLD; }",
+  "struct OFTFeeDetail { int256 feeAmountLD; string description; }",
+  "struct OFTReceipt { uint256 amountSentLD; uint256 amountReceivedLD; }",
+  "struct MessagingReceipt { bytes32 guid; uint64 nonce; MessagingFee fee; }",
+  "function quoteSend(SendParam s, bool payInLzToken) view returns (MessagingFee)",
+  "function quoteOFT(SendParam s) view returns (OFTLimit, OFTFeeDetail[], OFTReceipt)",
+  "function send(SendParam s, MessagingFee fee, address refundAddress) payable returns (MessagingReceipt, OFTReceipt)",
+  "function token() view returns (address)",
+  "function approvalRequired() view returns (bool)",
+  "function peers(uint32 eid) view returns (bytes32)"
+]);
+var ENDPOINT_ABI = (0, import_viem2.parseAbi)([
+  "struct Origin { uint32 srcEid; bytes32 sender; uint64 nonce; }",
+  "function lzReceive(Origin origin, address receiver, bytes32 guid, bytes message, bytes extraData) payable"
+]);
+var EVM_PLACEHOLDER = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
+var DEFAULT_QUOTE_TTL_MS = 6e4;
+var RPC_TIMEOUT_MS = 12e3;
+var SCAN_TIMEOUT_MS = 12e3;
+var GAS_SEND = "450000";
+var FEE_HEADROOM_BPS = 2500n;
+var GAS_CLAIM = "300000";
+var ZERO_B32 = `0x${"00".repeat(32)}`;
+var same = (a, b) => !!a && a.toLowerCase() === b.toLowerCase();
+var isHexData = (v) => typeof v === "string" && /^0x(?:[0-9a-fA-F]{2})*$/.test(v);
+function tokenMatches(chain, symbolOrAddress) {
+  if (symbolOrAddress.startsWith("0x")) return same(symbolOrAddress, chain.token);
+  if (!USDT0_SYMBOLS.includes(symbolOrAddress.toUpperCase().replace("USD\u20AE", "USDT"))) return false;
+  const known = (0, import_swap2_assets.ccAsset)(chain.caip2, symbolOrAddress);
+  return !known || same(known.contract ?? "", chain.token);
+}
+function rpcSafeReason(err, chainName) {
+  const e = err;
+  const text = `${e?.shortMessage ?? ""}
+${e?.message ?? String(err)}`;
+  if (/HttpRequestError|TimeoutError|RpcRequestError|WebSocketRequestError/.test(String(e?.name)) || /\bURL: |HTTP request failed|request timed out|took too long to respond/i.test(text)) {
+    return `usdt0: RPC for ${chainName} unavailable \u2014 try again`;
+  }
+  return (0, import_util2.redactUrls)(err instanceof Error ? err.message : String(err));
+}
+function usdt0Provider(config = {}) {
+  config = Object.freeze({ ...config });
+  const scan = (config.scanUrl ?? LZ_SCAN_API).replace(/\/+$/, "");
+  if (!/^https?:\/\//.test(scan)) throw new Error("usdt0: scanUrl must use http or https");
+  const quoteTtlMs = config.quoteTtlMs ?? DEFAULT_QUOTE_TTL_MS;
+  if (!Number.isInteger(quoteTtlMs) || quoteTtlMs <= 0 || quoteTtlMs > 3e5) throw new Error("usdt0: quoteTtlMs must be an integer between 1 and 300000");
+  const rpcUrls = Object.freeze({ ...config.rpcUrls ?? {} });
+  const doFetch = (input, init) => (config.fetchImpl ?? fetch)(input, init);
+  const client = (caip2) => {
+    const raw = rpcUrls[caip2];
+    const urls = typeof raw === "string" ? [raw] : [...raw ?? []];
+    if (urls.length === 0) return null;
+    const opts = { timeout: RPC_TIMEOUT_MS, ...config.fetchImpl ? { fetchFn: config.fetchImpl } : {} };
+    return (0, import_viem2.createPublicClient)({ transport: urls.length === 1 ? (0, import_viem2.http)(urls[0], opts) : (0, import_viem2.fallback)(urls.map((u) => (0, import_viem2.http)(u, opts))) });
+  };
+  const verified = /* @__PURE__ */ new Map();
+  function verifyChain(chain) {
+    let p = verified.get(chain.caip2);
+    if (!p) {
+      p = (async () => {
+        const c2 = client(chain.caip2);
+        if (!c2) throw new Error(`usdt0: no RPC for ${chain.caip2}`);
+        const [token, approval] = await Promise.all([
+          c2.readContract({ address: (0, import_viem2.getAddress)(chain.oft), abi: OFT_ABI, functionName: "token" }),
+          c2.readContract({ address: (0, import_viem2.getAddress)(chain.oft), abi: OFT_ABI, functionName: "approvalRequired" })
+        ]);
+        if (!same(token, chain.token)) throw new Error(`usdt0: OFT ${chain.oft} on ${chain.name} reports token ${token}, expected ${chain.token}`);
+        if (approval !== chain.adapter) throw new Error(`usdt0: OFT ${chain.oft} on ${chain.name} reports approvalRequired=${String(approval)}, expected ${String(chain.adapter)}`);
+      })();
+      p.catch(() => verified.delete(chain.caip2));
+      verified.set(chain.caip2, p);
+    }
+    return p;
+  }
+  const peers = /* @__PURE__ */ new Map();
+  function verifyPeer(src, dst) {
+    const key = `${src.eid}>${dst.eid}`;
+    let p = peers.get(key);
+    if (!p) {
+      p = (async () => {
+        const c2 = client(src.caip2);
+        if (!c2) throw new Error(`usdt0: no RPC for ${src.caip2}`);
+        const peer = await c2.readContract({ address: (0, import_viem2.getAddress)(src.oft), abi: OFT_ABI, functionName: "peers", args: [dst.eid] });
+        if (!same(peer, (0, import_viem2.pad)((0, import_viem2.getAddress)(dst.oft), { size: 32 }))) throw new Error(`usdt0: ${src.name} OFT has no peer for ${dst.name} (eid ${dst.eid}) \u2014 route not wired`);
+      })();
+      p.catch(() => peers.delete(key));
+      peers.set(key, p);
+    }
+    return p;
+  }
+  function parseIntent(intentId) {
+    const [tag, s, d] = intentId.split(":");
+    if (tag !== "usdt0") return null;
+    const src = USDT0_BY_EID[Number(s)];
+    const dst = USDT0_BY_EID[Number(d)];
+    return src && dst && src !== dst ? { src, dst } : null;
+  }
+  const sendParam = (dstEid, recipient, amountLD, minAmountLD) => ({
+    dstEid,
+    to: (0, import_viem2.pad)((0, import_viem2.getAddress)(recipient), { size: 32 }),
+    amountLD,
+    minAmountLD,
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  });
+  async function scanMessage(src, dst, sourceTxHash) {
+    const res = await doFetch(`${scan}/v1/messages/tx/${encodeURIComponent(sourceTxHash)}`, { headers: { accept: "application/json" }, signal: (0, import_util2.timeoutSignal)(SCAN_TIMEOUT_MS) });
+    if (res.status === 404) return null;
+    if (!res.ok) throw new Error(`usdt0: LayerZero Scan \u2192 ${res.status}`);
+    const body = await res.json();
+    const list = Array.isArray(body?.data) ? body.data : [];
+    if (list.length === 0) return null;
+    const m = list.find((x) => x.pathway?.srcEid === src.eid && x.pathway?.dstEid === dst.eid && same(x.pathway?.sender?.address, src.oft));
+    return m ?? "foreign";
+  }
+  return {
+    name: "usdt0",
+    describeActivity: describeUsdt0Activity,
+    enabled: () => config.enabled ?? true,
+    supportsChain: (chain) => usdt0.supportsChain(chain) && client(chain) !== null,
+    supportsChainPair: (from, to) => usdt0.supports(from, to) && client(from) !== null,
+    supportsRoute(from, to) {
+      const src = USDT0_CHAINS[from.chain];
+      const dst = USDT0_CHAINS[to.chain];
+      if (!src || !dst || src === dst || client(from.chain) === null) return false;
+      return tokenMatches(src, from.token) && tokenMatches(dst, to.token);
+    },
+    async getQuote(params, signal) {
+      const refuse = (reason) => {
+        params.onRefusal?.(reason);
+        return null;
+      };
+      if (params.flex) return refuse("the amount is sealed into the calldata (no flexible deposits)");
+      const src = USDT0_CHAINS[params.sourceChain];
+      const dst = USDT0_CHAINS[params.destChain];
+      if (!src || !dst) return refuse("USDT0 is not deployed on this chain");
+      if (src === dst) return refuse("same-chain transfers are not a bridge");
+      if (!tokenMatches(src, params.sourceToken)) return refuse(`source token ${params.sourceToken} is not USDT0 (${src.token}) on ${src.name}`);
+      if (!tokenMatches(dst, params.destToken)) return refuse(`destination token ${params.destToken} is not USDT0 (${dst.token}) on ${dst.name}`);
+      if (!/^\d+$/.test(params.amountIn)) return refuse("amount must be a base-unit integer");
+      const amount = BigInt(params.amountIn);
+      if (amount <= 0n) return refuse("amount must be positive");
+      const recipient = params.destAddress || EVM_PLACEHOLDER;
+      if (!(0, import_viem2.isAddress)(recipient)) return refuse("destination must be an EVM address");
+      const refund = params.refundAddress || EVM_PLACEHOLDER;
+      if (!(0, import_viem2.isAddress)(refund)) return refuse("refund address must be an EVM address");
+      const c2 = client(src.caip2);
+      if (!c2) return refuse(`no RPC configured for ${src.caip2}`);
+      try {
+        await Promise.all([verifyChain(src), verifyPeer(src, dst)]);
+        const probe = sendParam(dst.eid, recipient, amount, 0n);
+        const [limit, feeDetails, receipt] = await c2.readContract({ address: (0, import_viem2.getAddress)(src.oft), abi: OFT_ABI, functionName: "quoteOFT", args: [probe] });
+        if (amount < limit.minAmountLD) return refuse(`amount ${amount} is below the OFT minimum ${limit.minAmountLD}`);
+        if (amount > limit.maxAmountLD) return refuse(`amount ${amount} exceeds the OFT maximum ${limit.maxAmountLD}`);
+        const received = receipt.amountReceivedLD;
+        if (received <= 0n) return refuse("amount is below the OFT dust threshold \u2014 nothing would arrive");
+        if (received > amount) return refuse("OFT reports more received than sent \u2014 refusing");
+        if (params.minAmountOut !== void 0 && received < BigInt(params.minAmountOut)) return refuse(`received ${received} is below the caller's floor ${params.minAmountOut}`);
+        const sp = sendParam(dst.eid, recipient, amount, received);
+        const fee = await c2.readContract({ address: (0, import_viem2.getAddress)(src.oft), abi: OFT_ABI, functionName: "quoteSend", args: [sp, false] });
+        if (fee.lzTokenFee !== 0n) return refuse("OFT asks for a fee in LZ token \u2014 unsupported");
+        const nativeFee = fee.nativeFee + fee.nativeFee * FEE_HEADROOM_BPS / 10000n;
+        const data = (0, import_viem2.encodeFunctionData)({ abi: OFT_ABI, functionName: "send", args: [sp, { nativeFee, lzTokenFee: 0n }, (0, import_viem2.getAddress)(refund)] });
+        const protocolFees = feeDetails.filter((f) => f.feeAmountLD > 0n).map((f) => ({ type: "protocol", amount: f.feeAmountLD.toString(), token: src.token, included: true, description: f.description || "OFT fee" }));
+        const feeUsd = protocolFees.reduce((a, f) => a + Number(f.amount) / 1e6, 0);
+        const eta = src.chainId === 1 ? 1e3 : 240;
+        return {
+          provider: "usdt0",
+          intentId: `usdt0:${src.eid}:${dst.eid}`,
+          depositAddress: "",
+          depositMemo: null,
+          txRequest: {
+            to: src.oft,
+            data,
+            value: nativeFee.toString(),
+            chainId: src.chainId,
+            gasLimit: GAS_SEND,
+            ...src.adapter ? { approvalAddress: src.oft } : {},
+            ...nativeFee > 0n ? { nativeFee: nativeFee.toString() } : {}
+          },
+          sourceAmount: amount.toString(),
+          destAmount: received.toString(),
+          minDestAmount: received.toString(),
+          feeUsd,
+          fees: protocolFees,
+          etaSeconds: eta,
+          reliability: 0.98,
+          validUntilMs: Date.now() + quoteTtlMs,
+          providerData: {
+            srcEid: String(src.eid),
+            dstEid: String(dst.eid),
+            oft: src.oft,
+            token: src.token,
+            recipient: (0, import_viem2.getAddress)(recipient),
+            refundAddress: (0, import_viem2.getAddress)(refund),
+            amountLD: amount.toString(),
+            minAmountLD: received.toString(),
+            nativeFee: nativeFee.toString()
+          }
+        };
+      } catch (err) {
+        return refuse(rpcSafeReason(err, src.name));
+      }
+    },
+    async buildDeposit(quote) {
+      const tx = quote.txRequest;
+      const parsed = parseIntent(quote.intentId);
+      if (!tx || !parsed) throw new Error("swap2: USDT0 quote has no transaction request");
+      return {
+        chain: parsed.src.caip2,
+        to: tx.to ?? "",
+        value: tx.value ?? "0",
+        ...tx.data ? { data: tx.data } : {},
+        ...tx.chainId !== void 0 ? { chainId: tx.chainId } : {},
+        ...tx.gasLimit ? { gasLimit: tx.gasLimit } : {},
+        ...tx.approvalAddress ? { approvalAddress: tx.approvalAddress } : {}
+      };
+    },
+    /**
+     * Right before signing: the target is the source OFT, the peer is still the
+     * destination OFT, and the CURRENT LayerZero fee still fits the sealed
+     * `msg.value` (quote + headroom) — the endpoint reverts a send that
+     * underpays, so a fee past the headroom means re-quote rather than a
+     * wasted broadcast.
+     */
+    async preflightDeposit(quote, tx) {
+      const parsed = parseIntent(quote.intentId);
+      if (!parsed) throw new Error("usdt0: malformed intent id");
+      const { src, dst } = parsed;
+      if (!same(tx.to, src.oft)) throw new Error(`usdt0: deposit target ${tx.to} is not the ${src.name} OFT`);
+      const pd = quote.providerData ?? {};
+      if (!/^\d+$/.test(pd.amountLD ?? "") || !/^\d+$/.test(pd.minAmountLD ?? "") || !/^\d+$/.test(pd.nativeFee ?? "") || !(0, import_viem2.isAddress)(pd.recipient ?? "")) {
+        throw new Error("usdt0: quote carries no sealed send parameters");
+      }
+      const c2 = client(src.caip2);
+      if (!c2) throw new Error(`usdt0: no RPC for ${src.caip2}`);
+      const sp = sendParam(dst.eid, pd.recipient, BigInt(pd.amountLD), BigInt(pd.minAmountLD));
+      let fee;
+      try {
+        await Promise.all([verifyChain(src), verifyPeer(src, dst)]);
+        fee = await c2.readContract({ address: (0, import_viem2.getAddress)(src.oft), abi: OFT_ABI, functionName: "quoteSend", args: [sp, false] });
+      } catch (err) {
+        throw new Error(rpcSafeReason(err, src.name));
+      }
+      const sealed = BigInt(pd.nativeFee);
+      if (fee.nativeFee > sealed) throw new Error(`usdt0: LayerZero fee rose to ${fee.nativeFee} above the sealed ${sealed} (quote + ${FEE_HEADROOM_BPS / 100n} % headroom) \u2014 re-quote`);
+      if (BigInt(tx.value) !== sealed) throw new Error(`usdt0: transaction value ${tx.value} is not the quoted fee ${sealed}`);
+    },
+    async trackIntent(ref) {
+      const parsed = parseIntent(ref.intentId);
+      if (!parsed) return { state: "failed" };
+      const { src, dst } = parsed;
+      if (!ref.sourceTxHash) return { state: "pending" };
+      try {
+        const m = await scanMessage(src, dst, ref.sourceTxHash);
+        if (m === null) return { state: "pending", depositReceived: false };
+        if (m === "foreign") return { state: "failed" };
+        const name = (m.status?.name ?? "").toUpperCase();
+        const destHash = m.destination?.tx?.txHash;
+        if (name === "DELIVERED") return { state: "completed", depositReceived: true, ...destHash ? { destTxHash: destHash } : ref.destTxHash ? { destTxHash: ref.destTxHash } : {} };
+        if (name === "PAYLOAD_STORED") return { state: "action-required", depositReceived: true, claim: { chain: dst.caip2, ready: true } };
+        if (["FAILED", "APPLICATION_BURNED", "APPLICATION_SKIPPED", "UNRESOLVABLE_COMMAND", "MALFORMED_COMMAND"].includes(name)) return { state: "failed", depositReceived: true };
+        return { state: "pending", depositReceived: true };
+      } catch {
+        return { state: "pending" };
+      }
+    },
+    /**
+     * A delivery that reverted on the destination (PAYLOAD_STORED — out of
+     * executor gas, paused token) is retried by anyone through the endpoint:
+     * `lzReceive(origin, receiver, guid, message, extraData)` with the exact
+     * packet LayerZero Scan recorded. Null while nothing is stored.
+     */
+    async buildClaim(ref) {
+      const parsed = parseIntent(ref.intentId);
+      if (!parsed || !ref.sourceTxHash) return null;
+      const { src, dst } = parsed;
+      const m = await scanMessage(src, dst, ref.sourceTxHash);
+      if (!m || m === "foreign" || (m.status?.name ?? "").toUpperCase() !== "PAYLOAD_STORED") return null;
+      const nonce = m.pathway?.nonce;
+      const guid = m.guid;
+      const message = m.source?.tx?.payload;
+      if (!Number.isInteger(nonce) || !isHexData(guid) || guid.length !== 66 || !isHexData(message) || message.length <= 2) {
+        throw new Error("usdt0: LayerZero Scan has no complete packet for the stored payload");
+      }
+      if (!same(m.pathway?.receiver?.address, dst.oft)) throw new Error("usdt0: stored payload is addressed to another receiver");
+      const valueRaw = m.source?.tx?.options?.lzReceive?.value ?? "0";
+      const value = /^\d+$/.test(valueRaw) ? valueRaw : "0";
+      return {
+        chain: dst.caip2,
+        to: dst.endpoint,
+        value,
+        data: (0, import_viem2.encodeFunctionData)({
+          abi: ENDPOINT_ABI,
+          functionName: "lzReceive",
+          args: [{ srcEid: src.eid, sender: (0, import_viem2.pad)((0, import_viem2.getAddress)(src.oft), { size: 32 }), nonce: BigInt(nonce) }, (0, import_viem2.getAddress)(dst.oft), guid, message, "0x"]
+        }),
+        chainId: dst.chainId,
+        gasLimit: GAS_CLAIM
+      };
+    }
+  };
+}
+var USDT0_STATUS_MAP = Object.freeze({
+  INFLIGHT: "pending",
+  CONFIRMING: "pending",
+  BLOCKED: "pending",
+  DELIVERED: "completed",
+  PAYLOAD_STORED: "action-required",
+  FAILED: "failed",
+  APPLICATION_BURNED: "failed",
+  APPLICATION_SKIPPED: "failed",
+  UNRESOLVABLE_COMMAND: "failed",
+  MALFORMED_COMMAND: "failed"
+});
+
+// src/protocol.ts
+var import_single = require("@anywalletkit/protocol-swap2-core/swap2/single");
+var Usdt0Swap2Protocol = class extends import_single.SingleProviderSwap2 {
+  provider;
+  constructor(account, config) {
+    super(account, config);
+    this.provider = usdt0Provider(config);
+  }
+  chainSupported(caip2) {
+    return usdt0.supportsChain(caip2);
+  }
+  pairSupported(fromChain, toChain) {
+    return usdt0.supports(fromChain, toChain);
+  }
+};
+//# sourceMappingURL=index.cjs.map