@anywalletkit/protocol-swap2-lifi 0.0.0-stage → 0.2.2

package/dist/chunk-IOX56IRJ.js

@@ -0,0 +1,27 @@
+import {
+  lifiProvider
+} from "./chunk-2IAHMTPT.js";
+import {
+  lifi
+} from "./chunk-6N4HZ5XX.js";
+
+// src/protocol.ts
+import { SingleProviderSwap2 } from "@anywalletkit/protocol-swap2-core/swap2/single";
+var LifiSwap2Protocol = class extends SingleProviderSwap2 {
+  provider;
+  constructor(account, config) {
+    super(account, config);
+    this.provider = lifiProvider(config);
+  }
+  chainSupported(caip2) {
+    return lifi.supportsChain(caip2);
+  }
+  pairSupported(fromChain, toChain) {
+    return lifi.supports(fromChain, toChain);
+  }
+};
+
+export {
+  LifiSwap2Protocol
+};
+//# sourceMappingURL=chunk-IOX56IRJ.js.map

package/dist/chunk-IOX56IRJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/protocol.ts"],"sourcesContent":["import {SingleProviderSwap2} from \"@anywalletkit/protocol-swap2-core/swap2/single\";\nimport type {Swap2Account, Swap2EngineConfig} from \"@anywalletkit/protocol-swap2-core/swap2/base\";\nimport {lifi as lifiCfg} from \"./config.js\";\nimport {lifiProvider, type LifiProviderConfig} from \"./provider.js\";\n\nexport interface LifiSwap2Config extends Swap2EngineConfig, LifiProviderConfig {}\n\nexport class LifiSwap2Protocol extends SingleProviderSwap2 {\n  protected readonly provider;\n  constructor(account: Swap2Account | undefined, config: LifiSwap2Config) {\n    super(account, config);\n    this.provider = lifiProvider(config);\n  }\n  protected override chainSupported(caip2: string): boolean {\n    return lifiCfg.supportsChain(caip2);\n  }\n  protected override pairSupported(fromChain: string, toChain: string): boolean {\n    return lifiCfg.supports(fromChain, toChain);\n  }\n}\n"],"mappings":";;;;;;;;AAAA,SAAQ,2BAA0B;AAO3B,IAAM,oBAAN,cAAgC,oBAAoB;AAAA,EACtC;AAAA,EACnB,YAAY,SAAmC,QAAyB;AACtE,UAAM,SAAS,MAAM;AACrB,SAAK,WAAW,aAAa,MAAM;AAAA,EACrC;AAAA,EACmB,eAAe,OAAwB;AACxD,WAAO,KAAQ,cAAc,KAAK;AAAA,EACpC;AAAA,EACmB,cAAc,WAAmB,SAA0B;AAC5E,WAAO,KAAQ,SAAS,WAAW,OAAO;AAAA,EAC5C;AACF;","names":[]}

package/dist/config.cjs

@@ -0,0 +1,42 @@
+"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/config.ts
+var config_exports = {};
+__export(config_exports, {
+  LIFI_SOLANA_CAIP2: () => LIFI_SOLANA_CAIP2,
+  lifi: () => lifi
+});
+module.exports = __toCommonJS(config_exports);
+var import_util = require("@anywalletkit/protocol-swap2-core/util");
+var LIFI_SOLANA_CAIP2 = "solana:mainnet";
+var LIFI_EVM = /* @__PURE__ */ new Set([1, 8453, 56, 137, 42161, 10, 100, 143, 130, 999, 4663, 43114, 534352, 80094, 324, 42220, 4326, 9745, 59144, 146, 480, 1329, 57073, 98866, 196, 5042, 5e3, 747474, 2818, 14]);
+var lifi = {
+  enabled: () => true,
+  apiKey: () => void 0,
+  integrator: () => "",
+  supportsChain(chain) {
+    if ((0, import_util.isEvm)(chain)) return LIFI_EVM.has((0, import_util.evmRef)(chain));
+    return chain === LIFI_SOLANA_CAIP2;
+  },
+  supports(from, to) {
+    return this.supportsChain(from) && this.supportsChain(to);
+  }
+};
+//# sourceMappingURL=config.cjs.map

package/dist/config.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.ts"],"sourcesContent":["import {evmRef, isEvm} from \"@anywalletkit/protocol-swap2-core/util\";\n\n// ── LI.FI — EVM calldata routes implemented by this contribution adapter ─────\n// 2026-08 sweep (li.quest/v1/chains): + Avalanche 43114, Scroll 534352,\n// Berachain 80094 (HyperEVM 999 / Robinhood 4663 were already routed by the\n// provider's own chain map).\n/** The catalog's Solana id; LI.FI numbers it 1151111081099710. */\nexport const LIFI_SOLANA_CAIP2 = \"solana:mainnet\";\nconst LIFI_EVM = new Set([1, 8453, 56, 137, 42161, 10, 100, 143, 130, 999, 4663, 43114, 534352, 80094, 324, 42220, 4326, 9745, 59144, 146, 480, 1329, 57073, 98866, 196, 5042, 5000, 747474, 2818, 14]);\nexport const lifi = {\n  enabled: () => true,\n  apiKey: () => undefined,\n  integrator: () => \"\",\n  supportsChain(chain: string): boolean {\n    if (isEvm(chain)) return LIFI_EVM.has(evmRef(chain));\n    // Solana legs come back as a serialized transaction the account executes\n    // through its `sendSerializedTransaction` guard. Tron is still excluded.\n    return chain === LIFI_SOLANA_CAIP2;\n  },\n  supports(from: string, to: string): boolean {\n    return this.supportsChain(from) && this.supportsChain(to);\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA4B;AAOrB,IAAM,oBAAoB;AACjC,IAAM,WAAW,oBAAI,IAAI,CAAC,GAAG,MAAM,IAAI,KAAK,OAAO,IAAI,KAAK,KAAK,KAAK,KAAK,MAAM,OAAO,QAAQ,OAAO,KAAK,OAAO,MAAM,MAAM,OAAO,KAAK,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,KAAM,QAAQ,MAAM,EAAE,CAAC;AAC/L,IAAM,OAAO;AAAA,EAClB,SAAS,MAAM;AAAA,EACf,QAAQ,MAAM;AAAA,EACd,YAAY,MAAM;AAAA,EAClB,cAAc,OAAwB;AACpC,YAAI,mBAAM,KAAK,EAAG,QAAO,SAAS,QAAI,oBAAO,KAAK,CAAC;AAGnD,WAAO,UAAU;AAAA,EACnB;AAAA,EACA,SAAS,MAAc,IAAqB;AAC1C,WAAO,KAAK,cAAc,IAAI,KAAK,KAAK,cAAc,EAAE;AAAA,EAC1D;AACF;","names":[]}

package/dist/config.d.cts

@@ -0,0 +1,11 @@
+/** The catalog's Solana id; LI.FI numbers it 1151111081099710. */
+declare const LIFI_SOLANA_CAIP2 = "solana:mainnet";
+declare const lifi: {
+    enabled: () => boolean;
+    apiKey: () => undefined;
+    integrator: () => string;
+    supportsChain(chain: string): boolean;
+    supports(from: string, to: string): boolean;
+};
+
+export { LIFI_SOLANA_CAIP2, lifi };

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+/** The catalog's Solana id; LI.FI numbers it 1151111081099710. */
+declare const LIFI_SOLANA_CAIP2 = "solana:mainnet";
+declare const lifi: {
+    enabled: () => boolean;
+    apiKey: () => undefined;
+    integrator: () => string;
+    supportsChain(chain: string): boolean;
+    supports(from: string, to: string): boolean;
+};
+
+export { LIFI_SOLANA_CAIP2, lifi };

package/dist/config.js

@@ -0,0 +1,9 @@
+import {
+  LIFI_SOLANA_CAIP2,
+  lifi
+} from "./chunk-6N4HZ5XX.js";
+export {
+  LIFI_SOLANA_CAIP2,
+  lifi
+};
+//# 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,528 @@
+"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, {
+  LIFI_MODULE: () => LIFI_MODULE,
+  LIFI_SAME_CHAIN_SELECTORS: () => LIFI_SAME_CHAIN_SELECTORS,
+  LIFI_SOLANA_CAIP2: () => LIFI_SOLANA_CAIP2,
+  LifiSwap2Protocol: () => LifiSwap2Protocol,
+  default: () => LifiSwap2Protocol,
+  describeLifiActivity: () => describeLifiActivity,
+  lifi: () => lifi,
+  lifiProvider: () => lifiProvider
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var import_util = require("@anywalletkit/protocol-swap2-core/util");
+var LIFI_SOLANA_CAIP2 = "solana:mainnet";
+var LIFI_EVM = /* @__PURE__ */ new Set([1, 8453, 56, 137, 42161, 10, 100, 143, 130, 999, 4663, 43114, 534352, 80094, 324, 42220, 4326, 9745, 59144, 146, 480, 1329, 57073, 98866, 196, 5042, 5e3, 747474, 2818, 14]);
+var lifi = {
+  enabled: () => true,
+  apiKey: () => void 0,
+  integrator: () => "",
+  supportsChain(chain) {
+    if ((0, import_util.isEvm)(chain)) return LIFI_EVM.has((0, import_util.evmRef)(chain));
+    return chain === LIFI_SOLANA_CAIP2;
+  },
+  supports(from, to) {
+    return this.supportsChain(from) && this.supportsChain(to);
+  }
+};
+
+// src/activity.ts
+var import_activity = require("@anywalletkit/protocol-swap2-core/activity");
+var LIFI_MODULE = "@anywalletkit/protocol-swap2-lifi";
+var LIFI_SAME_CHAIN_SELECTORS = /* @__PURE__ */ new Set([
+  "0x4666fc80",
+  // swapTokensSingleV3ERC20ToERC20(bytes32,string,string,address,uint256,(address,address,address,address,uint256,bytes,bool))
+  "0x733214a3",
+  // swapTokensSingleV3ERC20ToNative(…)
+  "0xaf7060fd",
+  // swapTokensSingleV3NativeToERC20(…)
+  "0x5fd9ae2e",
+  // swapTokensMultipleV3ERC20ToERC20(bytes32,string,string,address,uint256,(…)[])
+  "0x2c57e884",
+  // swapTokensMultipleV3ERC20ToNative(…[])
+  "0x736eac0b"
+  // swapTokensMultipleV3NativeToERC20(…[])
+]);
+function describeLifiActivity(tx, ctx, isDiamond) {
+  if (!tx.chain.startsWith("eip155:")) return null;
+  const to = (0, import_activity.calledContract)(tx);
+  if (!to || !isDiamond(tx.chain, to)) return null;
+  const selector = (0, import_activity.callSelector)(tx);
+  const sameChain = selector !== void 0 && LIFI_SAME_CHAIN_SELECTORS.has(selector);
+  return (0, import_activity.describeSwapLike)(tx, ctx, {
+    protocol: LIFI_MODULE,
+    subtitle: "LI.FI",
+    // Unknown selector: trust the legs — both netted here means a same-chain route.
+    kind: sameChain ? "swap" : selector === void 0 ? "auto" : "bridge"
+  });
+}
+
+// src/provider.ts
+var import_swap2_assets = require("@anywalletkit/swap2-assets");
+var import_util2 = require("@anywalletkit/protocol-swap2-core/util");
+var DEFAULT_LIFI_BASE = "https://li.quest/v1";
+var LIFI_CHAIN = {
+  "eip155:1": "1",
+  "eip155:8453": "8453",
+  "eip155:56": "56",
+  "eip155:137": "137",
+  "eip155:42161": "42161",
+  "eip155:10": "10",
+  "eip155:100": "100",
+  "eip155:143": "143",
+  "eip155:130": "130",
+  "eip155:999": "999",
+  "eip155:4663": "4663",
+  // 2026-08 sweep additions (all live on li.quest/v1/chains).
+  "eip155:43114": "43114",
+  "eip155:534352": "534352",
+  "eip155:80094": "80094",
+  // 2026-10-12: zkSync Era, Celo, MegaETH (live on li.quest/v1/chains).
+  "eip155:324": "324",
+  "eip155:42220": "42220",
+  "eip155:4326": "4326",
+  "eip155:9745": "9745",
+  "eip155:59144": "59144",
+  "eip155:146": "146",
+  // 2026-10-13: World Chain, Sei, Ink, Plume, X Layer (live on li.quest/v1/chains).
+  "eip155:480": "480",
+  "eip155:1329": "1329",
+  "eip155:57073": "57073",
+  "eip155:98866": "98866",
+  "eip155:196": "196",
+  // 2026-10-14: Arc, Mantle, Katana, Morph, Flare (live on li.quest/v1/chains). On Arc LI.FI's "native" is the USDC
+  // ERC-20 interface 0x3600…: a 0x0 fromToken is rewritten to it and the Diamond pulls via transferFrom (value 0), so
+  // the catalog lists Arc USDC as that token — the engine then runs the ordinary approve + call path.
+  "eip155:5042": "5042",
+  "eip155:5000": "5000",
+  "eip155:747474": "747474",
+  "eip155:2818": "2818",
+  "eip155:14": "14",
+  [LIFI_SOLANA_CAIP2]: "1151111081099710"
+};
+var CAIP2_BY_LIFI_CHAIN = Object.fromEntries(Object.entries(LIFI_CHAIN).map(([caip2, id]) => [id, caip2]));
+var EVM_ZERO = "0x0000000000000000000000000000000000000000";
+var SOLANA_NATIVE = "11111111111111111111111111111111";
+var EVM_PLACEHOLDER = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
+var SOLANA_PLACEHOLDER = "HAgk14JpMQLgt6rVgv7cBQFJWFto5Dqxi472uT3DKpqk";
+var isSolana = (chain) => chain === LIFI_SOLANA_CAIP2;
+var BASE58 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+var BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var SAME_CHAIN_MAX_SECONDS = 90;
+var MAX_INPUT_FEE_BPS = 300;
+function sameChainAddress(chain, actual, expected) {
+  if (isSolana(chain)) return !!actual && BASE58.test(actual) && actual === expected;
+  return sameAddress(actual, expected);
+}
+function nativeFor(chain, token) {
+  if (/^0x0+$/.test(token) || token === SOLANA_NATIVE) return isSolana(chain) ? SOLANA_NATIVE : EVM_ZERO;
+  return token;
+}
+var LIFI_DIAMOND = "0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE";
+var LIFI_DIAMONDS = {
+  "eip155:4663": "0xB477751B76CF82d00a686A1232f5fCD772414Af3",
+  // Robinhood Chain (deployments/robinhood.json, verified 2026-10-09)
+  "eip155:999": "0x0a0758d937d1059c356D4714e57F5df0239bce1A",
+  // HyperEVM (deployments/hyperevm.json, verified 2026-10-09)
+  "eip155:143": "0x026F252016A7C47CDEf1F05a3Fc9E20C92a49C37",
+  // Monad (deployments/monad.json, verified 2026-10-11)
+  "eip155:130": "0x864b314D4C5a0399368609581d3E8933a63b9232",
+  // Unichain (deployments/unichain.json, verified 2026-10-11)
+  "eip155:80094": "0xf909c4Ae16622898b885B89d7F839E0244851c66",
+  // Berachain (deployments/berachain.json, verified 2026-10-11)
+  "eip155:324": "0x341e94069f53234fE6DabeF707aD424830525715",
+  // zkSync Era (deployments/zksync.json, matches a live quote 2026-10-12)
+  "eip155:9745": "0x026F252016A7C47CDEf1F05a3Fc9E20C92a49C37",
+  // Plasma (deployments/plasma.json, 2026-10-13)
+  "eip155:59144": "0xDE1E598b81620773454588B85D6b5D4eEC32573e",
+  // Linea (deployments/linea.json, 2026-10-13)
+  "eip155:57073": "0x864b314D4C5a0399368609581d3E8933a63b9232",
+  // Ink (deployments/ink.json, 2026-10-13)
+  "eip155:98866": "0x6f5C8Bb0C5Fe4ECeAC40EE1C238EaB6bbb29761c",
+  // Plume (deployments/plume.json, 2026-10-13)
+  // 2026-10-14: li.quest/v1/chains `diamondAddress`, eth_getCode non-empty on each. Mantle and Flare carry the canonical
+  // 0x1231… Diamond (the default).
+  "eip155:5042": "0xA4072583658Fae592A3506A42431cb6316a8d40b",
+  // Arc
+  "eip155:747474": "0xC59fe32C9549e3E8B5dCcdAbC45BD287Bd5bA2bc",
+  // Katana
+  "eip155:2818": "0xF7aB42D00D2399f8A4Fba2F15466Be40709fe307",
+  // Morph
+  "eip155:14": "0x198FC70Dfe05E755C81e54bd67Bff3F729344B9b",
+  // Flare (li.quest diamondAddress 2026-10-14; the canonical 0x1231… has no code there)
+  "eip155:4326": "0x026F252016A7C47CDEf1F05a3Fc9E20C92a49C37"
+  // MegaETH (deployments/megaeth.json, matches a live quote 2026-10-12)
+};
+var diamondFor = (chain) => LIFI_DIAMONDS[chain] ?? LIFI_DIAMOND;
+var DEFAULT_QUOTE_TTL_MS = 55e3;
+function normalizeAddress(value) {
+  return value && /^0x[0-9a-fA-F]{40}$/.test(value) ? value.toLowerCase() : null;
+}
+function sameAddress(actual, expected) {
+  return normalizeAddress(actual) === normalizeAddress(expected);
+}
+function isHexData(value) {
+  return !!value && /^0x(?:[0-9a-fA-F]{2})+$/.test(value);
+}
+function trustedAddress(chain, address, configured) {
+  const normalized = normalizeAddress(address);
+  if (!normalized) return false;
+  return normalizeAddress(diamondFor(chain)) === normalized || configured.get(chain)?.has(normalized) === true;
+}
+function trustMap(input, label) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [chain, addresses] of Object.entries(input ?? {})) {
+    const normalized = /* @__PURE__ */ new Set();
+    for (const address of addresses) {
+      const value = normalizeAddress(address);
+      if (!value) throw new Error(`lifi: invalid ${label} address for ${chain}`);
+      normalized.add(value);
+    }
+    out.set(chain, normalized);
+  }
+  return out;
+}
+function lifiToken(sourceChain, symbol) {
+  const asset = (0, import_swap2_assets.ccAsset)(sourceChain, symbol);
+  if (!asset) return null;
+  if (asset.contract) return asset.contract;
+  return isSolana(sourceChain) ? SOLANA_NATIVE : EVM_ZERO;
+}
+function headers(key) {
+  const h = { accept: "application/json" };
+  if (key) h["x-lifi-api-key"] = key;
+  return h;
+}
+var TOOL_KEY = /^[A-Za-z0-9_-]{1,64}$/;
+function routeOptions(body) {
+  const routes = body?.routes;
+  if (!Array.isArray(routes)) return [];
+  const out = [];
+  for (const r of routes) {
+    if (!Array.isArray(r?.steps) || r.steps.length !== 1 || r.containsSwitchChain === true) continue;
+    const step = r.steps[0];
+    const cross = Array.isArray(step.includedSteps) ? step.includedSteps.find((i) => i?.type === "cross")?.tool : void 0;
+    const tool = typeof cross === "string" ? cross : step.tool;
+    const eta = step.estimate?.executionDuration;
+    if (typeof tool !== "string" || !TOOL_KEY.test(tool) || typeof eta !== "number" || !Number.isFinite(eta) || eta < 0) continue;
+    if (typeof r.toAmount !== "string" || typeof r.toAmountMin !== "string" || !/^\d{1,60}$/.test(r.toAmount) || !/^\d{1,60}$/.test(r.toAmountMin)) continue;
+    out.push({
+      tool,
+      toAmount: BigInt(r.toAmount),
+      toAmountMin: BigInt(r.toAmountMin),
+      etaSeconds: eta,
+      gasCostUsd: Number(r.gasCostUSD ?? 0) || 0,
+      tags: Array.isArray(r.tags) ? r.tags.filter((t) => typeof t === "string") : []
+    });
+  }
+  return out;
+}
+function cleanChoice(choice) {
+  if (!choice) return null;
+  const allow = (choice.allowBridges ?? []).filter((t) => TOOL_KEY.test(t));
+  const deny = (choice.denyBridges ?? []).filter((t) => TOOL_KEY.test(t));
+  const order = choice.order === "CHEAPEST" || choice.order === "FASTEST" ? choice.order : void 0;
+  if (!allow.length && !deny.length && !order) return null;
+  return { ...allow.length ? { allowBridges: allow } : {}, ...deny.length ? { denyBridges: deny } : {}, ...order ? { order } : {} };
+}
+function lifiProvider(config = {}) {
+  config = Object.freeze({ ...config });
+  const apiKey = () => config.apiKey;
+  const integrator = () => config.integrator ?? "";
+  const parsedApiUrl = new URL(config.apiUrl ?? DEFAULT_LIFI_BASE);
+  if (parsedApiUrl.protocol !== "https:" && parsedApiUrl.protocol !== "http:") {
+    throw new Error("lifi: apiUrl must use http or https");
+  }
+  const apiBase = parsedApiUrl.toString().replace(/\/$/, "");
+  const trustedTransactionTargets = trustMap(config.trustedTransactionTargets, "transaction target");
+  const trustedApprovalAddresses = trustMap(config.trustedApprovalAddresses, "approval");
+  const quoteTtlMs = config.quoteTtlMs ?? DEFAULT_QUOTE_TTL_MS;
+  const defaultSlippageBps = config.defaultSlippageBps ?? 50;
+  if (!Number.isInteger(defaultSlippageBps) || defaultSlippageBps <= 0 || defaultSlippageBps >= 1e4) {
+    throw new Error("lifi: defaultSlippageBps must be an integer between 1 and 9999");
+  }
+  if (!Number.isInteger(quoteTtlMs) || quoteTtlMs <= 0 || quoteTtlMs > 6e4) {
+    throw new Error("lifi: quoteTtlMs must be an integer between 1 and 60000");
+  }
+  return {
+    name: "lifi",
+    describeActivity: (tx, ctx) => describeLifiActivity(tx, ctx, (chain, address) => trustedAddress(chain, address, trustedTransactionTargets)),
+    supportsSameChain: true,
+    enabled: () => config.enabled ?? true,
+    // Capability discovery comes from the provider itself, so it can run alone
+    // or inside the optional aggregator without a central capability table.
+    supportsChain: (chain) => lifi.supportsChain(chain),
+    supportsChainPair: (fromChain, toChain) => lifi.supports(fromChain, toChain),
+    supportsRoute(from, to) {
+      return !!LIFI_CHAIN[from.chain] && !!LIFI_CHAIN[to.chain];
+    },
+    async getQuote(params, signal) {
+      const reject = (why) => {
+        params.onRefusal?.(`lifi: ${why}`);
+        return null;
+      };
+      if (params.flex) return null;
+      const fromChain = LIFI_CHAIN[params.sourceChain];
+      const toChain = LIFI_CHAIN[params.destChain];
+      if (!fromChain || !toChain) return null;
+      const fromToken = lifiToken(params.sourceChain, params.sourceToken);
+      if (!fromToken) return null;
+      const solanaSource = isSolana(params.sourceChain);
+      const fromAddress = params.refundAddress ?? (solanaSource ? SOLANA_PLACEHOLDER : EVM_PLACEHOLDER);
+      const slippageBps = params.slippageBps ?? defaultSlippageBps;
+      let sentSlippage = slippageBps / 1e4;
+      let deadline;
+      let choice = null;
+      if (config.chooseRoute && params.sourceChain !== params.destChain) {
+        try {
+          const res = await fetch(`${apiBase}/advanced/routes`, {
+            method: "POST",
+            headers: { ...headers(apiKey()), "content-type": "application/json" },
+            body: JSON.stringify({
+              fromChainId: Number(fromChain),
+              toChainId: Number(toChain),
+              fromTokenAddress: fromToken,
+              toTokenAddress: nativeFor(params.destChain, params.destToken),
+              fromAmount: params.amountIn,
+              fromAddress,
+              toAddress: params.destAddress || fromAddress,
+              options: { slippage: slippageBps / 1e4, ...integrator().trim() ? { integrator: integrator().trim() } : {} }
+            }),
+            signal: signal ?? (0, import_util2.timeoutSignal)(8e3)
+          });
+          if (res.ok) {
+            const options = routeOptions(await res.json());
+            if (options.length) choice = cleanChoice(config.chooseRoute(options, params));
+          }
+        } catch {
+        }
+      }
+      for (let attempt = 0; attempt < 2; attempt++) try {
+        const url = new URL(`${apiBase}/quote`);
+        url.searchParams.set("fromChain", fromChain);
+        url.searchParams.set("toChain", toChain);
+        url.searchParams.set("fromToken", fromToken);
+        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);
+        if (sentSlippage !== void 0) {
+          url.searchParams.set("slippage", String(sentSlippage));
+        }
+        for (const t of choice?.allowBridges ?? []) url.searchParams.append("allowBridges", t);
+        for (const t of choice?.denyBridges ?? []) url.searchParams.append("denyBridges", t);
+        if (choice?.order) url.searchParams.set("order", choice.order);
+        deadline = signal ? void 0 : (0, import_util2.timeoutSignal)(12e3);
+        const res = await fetch(url, { headers: headers(apiKey()), signal: signal ?? deadline });
+        if (!res.ok && choice) {
+          choice = null;
+          attempt--;
+          continue;
+        }
+        if (!res.ok) {
+          const body = await res.json().catch(() => null);
+          const reasons = [...new Set((body?.errors?.filteredOut ?? []).map((f) => f.reason).filter((r) => typeof r === "string"))];
+          const why = reasons.length === 1 ? ` (${reasons[0].slice(0, 200)})` : "";
+          params.onRefusal?.(`lifi: ${typeof body?.message === "string" ? body.message.slice(0, 200) : `HTTP ${res.status}`}${why}`);
+          return null;
+        }
+        const q = await res.json();
+        const receivedAt = Date.now();
+        const action = q.action;
+        const est = q.estimate;
+        const tr = q.transactionRequest;
+        const expectedToToken = nativeFor(params.destChain, params.destToken);
+        const expectedFromChain = Number(fromChain);
+        const expectedToChain = Number(toChain);
+        if (q.type !== "lifi" || !q.id || !action || !est?.toAmount || !est.fromAmount || !tr) return reject("incomplete quote (no action, estimate or transaction)");
+        const mismatch = [
+          action.fromChainId !== expectedFromChain && "source chain",
+          action.toChainId !== expectedToChain && "destination chain",
+          (action.fromToken?.chainId !== expectedFromChain || !sameChainAddress(params.sourceChain, action.fromToken?.address, fromToken)) && "source token",
+          (action.toToken?.chainId !== expectedToChain || !sameChainAddress(params.destChain, action.toToken?.address, expectedToToken)) && "destination token",
+          action.fromAmount !== params.amountIn && "amount spent",
+          !sameChainAddress(params.sourceChain, action.fromAddress, fromAddress) && "sender",
+          !sameChainAddress(params.destChain, action.toAddress, toAddress) && "recipient"
+        ].filter(Boolean);
+        if (mismatch.length) return reject(`quote does not match the request (${mismatch.join(", ")})`);
+        const bridged = BigInt(est.fromAmount);
+        const spent = BigInt(params.amountIn);
+        if (bridged > spent) return reject(`the estimate bridges ${est.fromAmount}, more than the ${params.amountIn} spent`);
+        if ((spent - bridged) * 10000n > spent * BigInt(MAX_INPUT_FEE_BPS)) {
+          return reject(`the route takes ${Number((spent - bridged) * 10000n / spent) / 100}% of the input as a fee (over ${MAX_INPUT_FEE_BPS / 100}%)`);
+        }
+        if (solanaSource) {
+          if (!tr.data || tr.data.length < 64 || tr.data.length % 4 !== 0 || !BASE64.test(tr.data)) return reject("the Solana transaction is not base64");
+          if (tr.to !== void 0 || tr.value !== void 0 || tr.gasLimit !== void 0) return reject("the Solana transaction carries EVM fields");
+        } else if (!isHexData(tr.data) || !normalizeAddress(tr.to) || !normalizeAddress(tr.from) || tr.chainId !== expectedFromChain || !tr.value || !tr.gasLimit || !trustedAddress(params.sourceChain, tr.to, trustedTransactionTargets) || !sameAddress(tr.from, fromAddress)) return reject("the transaction is malformed or targets an untrusted contract");
+        if (sentSlippage !== void 0 && (typeof action.slippage !== "number" || Math.abs(action.slippage - sentSlippage) > 1e-12)) return reject("the quote ignored the requested slippage");
+        const sourceIsToken = fromToken !== EVM_ZERO && fromToken !== SOLANA_NATIVE;
+        if (solanaSource) {
+        } else if (sourceIsToken) {
+          if (!trustedAddress(params.sourceChain, est.approvalAddress, trustedApprovalAddresses)) return reject("the approval target is not a trusted LI.FI contract");
+        } else if (est.approvalAddress !== void 0) {
+          if (!trustedAddress(params.sourceChain, est.approvalAddress, trustedApprovalAddresses)) return reject("the approval target is not a trusted LI.FI contract");
+        }
+        let txRequest;
+        if (solanaSource) {
+          txRequest = { serializedTx: tr.data, value: sourceIsToken ? "0" : params.amountIn };
+        } else {
+          try {
+            if (BigInt(tr.value) < 0n || BigInt(tr.gasLimit) <= 0n) return reject("the transaction has a negative value or no gas limit");
+          } catch {
+            return reject("the transaction value or gas limit is not a number");
+          }
+          const value = BigInt(tr.value);
+          const nativeFee = sourceIsToken ? value : value > BigInt(params.amountIn) ? value - BigInt(params.amountIn) : 0n;
+          if (!sourceIsToken && value < BigInt(params.amountIn)) return reject("the transaction sends less native coin than the input");
+          txRequest = {
+            to: tr.to,
+            data: tr.data,
+            value: value.toString(),
+            chainId: tr.chainId,
+            gasLimit: BigInt(tr.gasLimit).toString(),
+            ...sourceIsToken && est.approvalAddress ? { approvalAddress: est.approvalAddress } : {},
+            ...nativeFee > 0n ? { nativeFee: nativeFee.toString() } : {}
+          };
+        }
+        const feeUsd = (est.feeCosts ?? []).reduce((a, f) => a + Number(f.amountUSD ?? 0), 0);
+        if (!est.toAmountMin) return reject("the quote has no minimum output");
+        const minDestAmount = est.toAmountMin;
+        if (sentSlippage !== void 0) {
+          const dest = BigInt(est.toAmount);
+          const min = BigInt(minDestAmount);
+          if (dest > 0n && min < dest * BigInt(1e4 - slippageBps) / 10000n) {
+            const effective = Number((dest - min) * 1000000n / dest) / 1e6;
+            const requested = slippageBps / 1e4;
+            const scaled = Math.floor(sentSlippage * requested / effective * 0.995 * 1e6) / 1e6;
+            if (attempt === 0 && effective > 0 && scaled > 0) {
+              sentSlippage = scaled;
+              continue;
+            }
+            params.onRefusal?.(
+              `lifi: this route's minimum is ${(effective * 100).toFixed(2)}% under the quote (LI.FI applies slippage on every step) \u2014 more than the requested ${slippageBps / 100}%`
+            );
+            return null;
+          }
+        }
+        if (params.minAmountOut !== void 0 && BigInt(minDestAmount) < BigInt(params.minAmountOut)) {
+          params.onRefusal?.(`lifi: floor breach (min=${minDestAmount} < floor=${params.minAmountOut})`);
+          return null;
+        }
+        const duration = est.executionDuration ?? 0;
+        if (fromChain === toChain && duration > SAME_CHAIN_MAX_SECONDS) {
+          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;
+        }
+        return {
+          provider: "lifi",
+          // Status is tracked by SOURCE TX HASH + the chain pair.
+          intentId: `lifi:${fromChain}:${toChain}`,
+          depositAddress: "",
+          depositMemo: null,
+          txRequest,
+          // What the wallet spends (action.fromAmount, = the input); an input-side bridge fee is inside destAmount.
+          sourceAmount: params.amountIn,
+          destAmount: est.toAmount,
+          minDestAmount,
+          feeUsd,
+          etaSeconds: est.executionDuration ?? 120,
+          reliability: 0.97,
+          // LI.FI documents an approximately 60-second lifetime. Use a slightly
+          // shorter local deadline and re-quote again at execution time.
+          validUntilMs: receivedAt + quoteTtlMs
+        };
+      } catch {
+        if (deadline?.aborted) params.onRefusal?.("lifi: no quote within 12 s");
+        return null;
+      }
+      return null;
+    },
+    async buildDeposit(quote) {
+      const tx = quote.txRequest;
+      if (!tx) throw new Error("swap2: LI.FI quote has no transaction request");
+      const [, fromChain] = quote.intentId.split(":");
+      return {
+        chain: tx.serializedTx ? CAIP2_BY_LIFI_CHAIN[fromChain ?? ""] ?? "" : "",
+        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 } : {},
+        ...tx.serializedTx ? { serializedTx: tx.serializedTx } : {}
+      };
+    },
+    async trackIntent(ref) {
+      if (!ref.sourceTxHash) return { state: "pending" };
+      const [, fromChain, toChain] = ref.intentId.split(":");
+      try {
+        const url = new URL(`${apiBase}/status`);
+        url.searchParams.set("txHash", ref.sourceTxHash);
+        if (fromChain) url.searchParams.set("fromChain", fromChain);
+        if (toChain) url.searchParams.set("toChain", toChain);
+        const res = await fetch(url, { headers: headers(apiKey()), signal: (0, import_util2.timeoutSignal)(12e3) });
+        if (!res.ok) return { state: "pending" };
+        const s = await res.json();
+        const map = {
+          DONE: "completed",
+          FAILED: "failed",
+          PENDING: "pending",
+          NOT_FOUND: "pending"
+        };
+        const state = s.substatus === "REFUNDED" ? "refunded" : s.substatus === "EXPIRED" ? "expired" : s.substatus === "NOT_PROCESSABLE_REFUND_NEEDED" ? "action-required" : s.substatus === "REFUND_IN_PROGRESS" ? "refund-pending" : s.status === "DONE" && s.substatus === "PARTIAL" ? "partial" : map[s.status ?? "PENDING"] ?? "pending";
+        const depositReceived = state === "pending" && s.status === "PENDING";
+        const destTxHash = typeof s.receiving?.txHash === "string" && s.receiving.txHash.length > 0 ? s.receiving.txHash : void 0;
+        return {
+          state,
+          depositReceived,
+          ...destTxHash ? { destTxHash } : {}
+        };
+      } catch {
+        return { state: "pending" };
+      }
+    }
+  };
+}
+
+// src/protocol.ts
+var import_single = require("@anywalletkit/protocol-swap2-core/swap2/single");
+var LifiSwap2Protocol = class extends import_single.SingleProviderSwap2 {
+  provider;
+  constructor(account, config) {
+    super(account, config);
+    this.provider = lifiProvider(config);
+  }
+  chainSupported(caip2) {
+    return lifi.supportsChain(caip2);
+  }
+  pairSupported(fromChain, toChain) {
+    return lifi.supports(fromChain, toChain);
+  }
+};
+//# sourceMappingURL=index.cjs.map