@anywalletkit/protocol-swap2-lifi 0.2.5 → 0.2.7

package/dist/provider.cjs

@@ -72,8 +72,257 @@ function describeLifiActivity(tx, ctx, isDiamond) {
   });
 }
 
+// src/calldata.ts
+var GENERIC_SWAPS = {
+  "0x4630a0d8": { single: false },
+  // swapTokensGeneric
+  "0x4666fc80": { single: true },
+  // swapTokensSingleV3ERC20ToERC20
+  "0x733214a3": { single: true },
+  // swapTokensSingleV3ERC20ToNative
+  "0xaf7060fd": { single: true },
+  // swapTokensSingleV3NativeToERC20
+  "0x5fd9ae2e": { single: false },
+  // swapTokensMultipleV3ERC20ToERC20
+  "0x2c57e884": { single: false },
+  // swapTokensMultipleV3ERC20ToNative
+  "0x736eac0b": { single: false }
+  // swapTokensMultipleV3NativeToERC20
+};
+var BRIDGE_CALLS = {
+  "0x1fd8010c": { sourceSwaps: false },
+  // startBridgeTokensViaAcross (AcrossFacet)
+  "0x3a3f7332": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaAcross (AcrossFacet)
+  "0xa1f1ce43": { sourceSwaps: false },
+  // startBridgeTokensViaAcrossV4 (AcrossFacetV4)
+  "0x1794958f": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaAcrossV4 (AcrossFacetV4)
+  "0x6a90d66e": { sourceSwaps: false },
+  // startBridgeTokensViaAcrossV4Swap (AcrossV4SwapFacet)
+  "0x9b054bc4": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaAcrossV4Swap (AcrossV4SwapFacet)
+  "0x6a51e9a9": { sourceSwaps: false },
+  // startBridgeTokensViaAllBridge (AllBridgeFacet)
+  "0x63267469": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaAllBridge (AllBridgeFacet)
+  "0xc9851d0b": { sourceSwaps: false },
+  // startBridgeTokensViaArbitrumBridge (ArbitrumBridgeFacet)
+  "0x3cc9517b": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaArbitrumBridge (ArbitrumBridgeFacet)
+  "0xe0a4201c": { sourceSwaps: false },
+  // startBridgeTokensViaCelerCircleBridge (CelerCircleBridgeFacet)
+  "0x4f3b0759": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaCelerCircleBridge (CelerCircleBridgeFacet)
+  "0x0315138f": { sourceSwaps: false },
+  // startBridgeTokensViaCentrifuge (CentrifugeFacet)
+  "0x8fd4d4dd": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaCentrifuge (CentrifugeFacet)
+  "0x0ad553b3": { sourceSwaps: false },
+  // startBridgeTokensViaChainflip (ChainflipFacet)
+  "0xee3314a1": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaChainflip (ChainflipFacet)
+  "0x4004633e": { sourceSwaps: false },
+  // startBridgeTokensViaDeBridgeDln (DeBridgeDlnFacet)
+  "0x2c7d2db0": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaDeBridgeDln (DeBridgeDlnFacet)
+  "0xbff90b61": { sourceSwaps: false },
+  // startBridgeTokensViaEco (EcoFacet)
+  "0x762aea18": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaEco (EcoFacet)
+  "0x678786ea": { sourceSwaps: false },
+  // startBridgeTokensViaFrax (FraxFacet)
+  "0x07b8e4c7": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaFrax (FraxFacet)
+  "0x5f9af35d": { sourceSwaps: false },
+  // startBridgeTokensViaGarden (GardenFacet)
+  "0x76ad76fe": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaGarden (GardenFacet)
+  "0xfc5f1003": { sourceSwaps: false },
+  // startBridgeTokensViaGasZip (GasZipFacet)
+  "0x606326ff": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaGasZip (GasZipFacet)
+  "0x6f9206ba": { sourceSwaps: false },
+  // startBridgeTokensViaGlacis (GlacisFacet)
+  "0x9c4b6dd9": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaGlacis (GlacisFacet)
+  "0xf66fe519": { sourceSwaps: false },
+  // startBridgeTokensViaGnosisBridge (GnosisBridgeFacet)
+  "0x7bf96e0a": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaGnosisBridge (GnosisBridgeFacet)
+  "0xee9e98e0": { sourceSwaps: false },
+  // startBridgeTokensViaLayerSwap (LayerSwapFacet)
+  "0x4c279d6b": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaLayerSwap (LayerSwapFacet)
+  "0x7dbcf1d9": { sourceSwaps: false },
+  // startBridgeTokensViaLiFiIntentEscrowV2 (LiFiIntentEscrowFacetV2)
+  "0x6d21c5df": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaLiFiIntentEscrowV2 (LiFiIntentEscrowFacetV2)
+  "0x65782c4b": { sourceSwaps: false },
+  // startBridgeTokensViaM0 (M0Facet)
+  "0xb9eaf86d": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaM0 (M0Facet)
+  "0xb4875292": { sourceSwaps: false },
+  // startBridgeTokensViaMayan (MayanFacet)
+  "0x80c65808": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaMayan (MayanFacet)
+  "0x4213dfff": { sourceSwaps: false },
+  // startBridgeTokensViaMegaETHBridge (MegaETHBridgeFacet)
+  "0x22256e89": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaMegaETHBridge (MegaETHBridgeFacet)
+  "0x4698f032": { sourceSwaps: false },
+  // startBridgeTokensViaNEARIntents (NEARIntentsFacet)
+  "0x02631b09": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaNEARIntents (NEARIntentsFacet)
+  "0x782621d8": { sourceSwaps: false },
+  // startBridgeTokensViaOmniBridge (OmniBridgeFacet)
+  "0x95726782": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaOmniBridge (OmniBridgeFacet)
+  "0xce8a97a5": { sourceSwaps: false },
+  // startBridgeTokensViaOptimismBridge (OptimismBridgeFacet)
+  "0x5bb5d448": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaOptimismBridge (OptimismBridgeFacet)
+  "0xaf62c7d6": { sourceSwaps: false },
+  // startBridgeTokensViaPolygonBridge (PolygonBridgeFacet)
+  "0xb4f37581": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaPolygonBridge (PolygonBridgeFacet)
+  "0xf434d6ca": { sourceSwaps: false },
+  // startBridgeTokensViaPolymerCCTP (PolymerCCTPFacet)
+  "0x17917a4e": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaPolymerCCTP (PolymerCCTPFacet)
+  "0x092e8fa4": { sourceSwaps: false },
+  // startBridgeTokensViaRelayDepository (RelayDepositoryFacet)
+  "0xa3443faa": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaRelayDepository (RelayDepositoryFacet)
+  "0x3f313808": { sourceSwaps: false },
+  // startBridgeTokensViaSquid (SquidFacet)
+  "0xa8f66666": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaSquid (SquidFacet)
+  "0x14d53077": { sourceSwaps: false },
+  // startBridgeTokensViaStargate (StargateFacetV2)
+  "0xa6010a66": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaStargate (StargateFacetV2)
+  "0x0691ff78": { sourceSwaps: false },
+  // startBridgeTokensViaSuperset (SupersetFacet)
+  "0xf26e657f": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaSuperset (SupersetFacet)
+  "0xe23b7a08": { sourceSwaps: false },
+  // startBridgeTokensViaSymbiosis (SymbiosisFacet)
+  "0xc46059b2": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaSymbiosis (SymbiosisFacet)
+  "0x2541ec57": { sourceSwaps: false },
+  // startBridgeTokensViaThorSwap (ThorSwapFacet)
+  "0xad673d88": { sourceSwaps: true },
+  // swapAndStartBridgeTokensViaThorSwap (ThorSwapFacet)
+  "0x64261d58": { sourceSwaps: false },
+  // startBridgeTokensViaUnit (UnitFacet)
+  "0x21a3af52": { sourceSwaps: true }
+  // swapAndStartBridgeTokensViaUnit (UnitFacet)
+};
+var Reader = class {
+  b;
+  constructor(hex) {
+    if (!/^0x([0-9a-fA-F]{2})*$/.test(hex)) throw new Error("not hex");
+    this.b = Uint8Array.from(hex.slice(2).match(/../g) ?? [], (h) => Number.parseInt(h, 16));
+  }
+  get length() {
+    return this.b.length;
+  }
+  word(at) {
+    if (at < 0 || at + 32 > this.b.length) throw new Error("out of bounds");
+    let v = 0n;
+    for (let i = at; i < at + 32; i++) v = v << 8n | BigInt(this.b[i]);
+    return v;
+  }
+  /** A word that must fit a JS offset / length (bounded by the calldata). */
+  small(at) {
+    const v = this.word(at);
+    if (v > BigInt(this.b.length)) throw new Error("offset out of bounds");
+    return Number(v.toString());
+  }
+  address(at) {
+    const v = this.word(at);
+    if (v >> 160n !== 0n) throw new Error("not an address");
+    return `0x${v.toString(16).padStart(40, "0")}`;
+  }
+  bool(at) {
+    const v = this.word(at);
+    if (v > 1n) throw new Error("not a bool");
+    return v === 1n;
+  }
+};
+var same = (a, b) => a.toLowerCase() === b.toLowerCase();
+function swapAt(r, at) {
+  r.address(at);
+  r.address(at + 32);
+  const step = { sendingAssetId: r.address(at + 64), receivingAssetId: r.address(at + 96), fromAmount: r.word(at + 128) };
+  const bytesAt = at + r.small(at + 160);
+  r.small(bytesAt);
+  r.bool(at + 192);
+  return step;
+}
+function swapsAt(r, base, head) {
+  const array = base + r.small(head);
+  const n = r.small(array);
+  if (n === 0 || n > 16) throw new Error("bad swap count");
+  const items = array + 32;
+  return Array.from({ length: n }, (_, i) => swapAt(r, items + r.small(items + 32 * i)));
+}
+function checkSteps(steps, e, finalAsset) {
+  const first = steps[0];
+  const last = steps[steps.length - 1];
+  if (!same(first.sendingAssetId, e.fromToken)) return `spends ${first.sendingAssetId}, not ${e.fromToken}`;
+  if (first.fromAmount === 0n || first.fromAmount > e.amountIn) return `swaps ${first.fromAmount}, not the ${e.amountIn} spent`;
+  if (!same(last.receivingAssetId, finalAsset)) return `delivers ${last.receivingAssetId}, not ${finalAsset}`;
+  return null;
+}
+function diamondCallMismatch(data, e) {
+  let r;
+  try {
+    r = new Reader(data);
+  } catch {
+    return "the calldata is not hex";
+  }
+  if (r.length < 4 + 32 * 2) return "the calldata is too short";
+  const selector = data.slice(0, 10).toLowerCase();
+  const generic = GENERIC_SWAPS[selector];
+  try {
+    if (generic) {
+      if (!e.sameChain) return "a same-chain swap call on a cross-chain route";
+      const receiver2 = r.address(4 + 96);
+      const minAmount2 = r.word(4 + 128);
+      const steps = generic.single ? [swapAt(r, 4 + r.small(4 + 160))] : swapsAt(r, 4, 4 + 160);
+      if (!e.evmDestination || !same(receiver2, e.receiver)) return `pays ${receiver2}, not ${e.receiver}`;
+      if (minAmount2 < e.minOut) return `accepts ${minAmount2}, below the ${e.minOut} shown`;
+      return checkSteps(steps, e, e.toToken);
+    }
+    const bridge = BRIDGE_CALLS[selector];
+    if (!bridge) return `unknown Diamond call ${selector}`;
+    const head = r.small(4);
+    if (head < (bridge.sourceSwaps ? 96 : 64) || head % 32 !== 0 || head > 32 * 32) return `unknown Diamond call ${selector}`;
+    const at = 4 + head;
+    if (r.small(at + 32) !== 320) return `unknown Diamond call ${selector}`;
+    const sendingAssetId = r.address(at + 128);
+    const receiver = r.address(at + 160);
+    const minAmount = r.word(at + 192);
+    const destinationChainId = r.word(at + 224);
+    const hasSourceSwaps = r.bool(at + 256);
+    const hasDestinationCall = r.bool(at + 288);
+    if (e.sameChain) return "a bridge call on a same-chain route";
+    if (destinationChainId !== e.destChainId) return `bridges to chain ${destinationChainId}, not ${e.destChainId}`;
+    if (hasDestinationCall) return "the route runs a call on the destination chain, whose recipient cannot be checked here";
+    if (!e.evmDestination) return "the recipient on a non-EVM destination sits in bridge-specific data and cannot be checked here";
+    if (!same(receiver, e.receiver)) return `pays ${receiver}, not ${e.receiver}`;
+    if (hasSourceSwaps !== bridge.sourceSwaps) return `unknown Diamond call ${selector}`;
+    if (hasSourceSwaps) return checkSteps(swapsAt(r, 4, 4 + 32), e, sendingAssetId);
+    if (minAmount === 0n || minAmount > e.amountIn) return `bridges ${minAmount}, not the ${e.amountIn} spent`;
+    return same(sendingAssetId, e.fromToken) ? null : `bridges ${sendingAssetId}, not ${e.fromToken}`;
+  } catch (err) {
+    return `the Diamond calldata does not decode (${err instanceof Error ? err.message : String(err)})`;
+  }
+}
+
 // src/provider.ts
-var import_swap2_assets = require("@anywalletkit/swap2-assets");
 var import_util2 = require("@anywalletkit/protocol-swap2-core/util");
 var import_core = require("@anywalletkit/core");
 var DEFAULT_LIFI_BASE = "https://li.quest/v1";
@@ -198,8 +447,9 @@ function trustMap(input, label) {
   }
   return out;
 }
-function lifiToken(sourceChain, symbol) {
-  const asset = (0, import_swap2_assets.ccAsset)(sourceChain, symbol);
+function lifiToken(params) {
+  const sourceChain = params.sourceChain;
+  const asset = (0, import_util2.sourceAssetOf)(params);
   if (!asset) return null;
   if (asset.contract) return asset.contract;
   return isSolana(sourceChain) ? SOLANA_NATIVE : EVM_ZERO;
@@ -281,10 +531,14 @@ function lifiProvider(config = {}) {
       const fromChain = LIFI_CHAIN[params.sourceChain];
       const toChain = LIFI_CHAIN[params.destChain];
       if (!fromChain || !toChain) return null;
-      const fromToken = lifiToken(params.sourceChain, params.sourceToken);
+      const fromToken = lifiToken(params);
       if (!fromToken) return null;
       const solanaSource = isSolana(params.sourceChain);
-      const fromAddress = params.refundAddress ?? (solanaSource ? SOLANA_PLACEHOLDER : EVM_PLACEHOLDER);
+      const dry = params.dry !== false;
+      const fromAddress = params.refundAddress || (dry ? solanaSource ? SOLANA_PLACEHOLDER : EVM_PLACEHOLDER : "");
+      const toAddress = params.destAddress || (dry ? fromAddress : "");
+      if (!fromAddress) return reject("a live quote needs the sender's address");
+      if (!toAddress) return reject("a live quote needs a recipient");
       const slippageBps = params.slippageBps ?? defaultSlippageBps;
       let sentSlippage = slippageBps / 1e4;
       let deadline;
@@ -301,7 +555,7 @@ function lifiProvider(config = {}) {
               toTokenAddress: nativeFor(params.destChain, params.destToken),
               fromAmount: params.amountIn,
               fromAddress,
-              toAddress: params.destAddress || fromAddress,
+              toAddress,
               options: { slippage: slippageBps / 1e4, ...integrator().trim() ? { integrator: integrator().trim() } : {} }
             }),
             signal: signal ?? (0, import_util2.timeoutSignal)(8e3)
@@ -321,7 +575,6 @@ function lifiProvider(config = {}) {
         url.searchParams.set("toToken", nativeFor(params.destChain, params.destToken));
         url.searchParams.set("fromAmount", params.amountIn);
         url.searchParams.set("fromAddress", fromAddress);
-        const toAddress = params.destAddress || fromAddress;
         url.searchParams.set("toAddress", toAddress);
         const integratorId = integrator().trim();
         if (integratorId) url.searchParams.set("integrator", integratorId);
@@ -433,6 +686,19 @@ function lifiProvider(config = {}) {
           params.onRefusal?.(`lifi: same-chain route settles asynchronously (${duration} s via ${q.tool ?? "unknown tool"}) \u2014 a same-chain swap must deliver in the same transaction`);
           return null;
         }
+        if (!solanaSource) {
+          const why = diamondCallMismatch(tr.data, {
+            fromToken,
+            toToken: expectedToToken,
+            amountIn: BigInt(params.amountIn),
+            receiver: toAddress,
+            minOut: BigInt(minDestAmount),
+            destChainId: BigInt(toChain),
+            sameChain: fromChain === toChain,
+            evmDestination: !isSolana(params.destChain)
+          });
+          if (why) return reject(`the transaction does not match the quote: ${why}`);
+        }
         return {
           provider: "lifi",
           // Status is tracked by SOURCE TX HASH + the chain pair.
@@ -486,6 +752,8 @@ function lifiProvider(config = {}) {
         const map = {
           DONE: "completed",
           FAILED: "failed",
+          // LI.FI cannot process the transaction: it never completes (round 3, L17).
+          INVALID: "failed",
           PENDING: "pending",
           NOT_FOUND: "pending"
         };