@anywalletkit/protocol-swap2-relay 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,965 @@
+"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, {
+  RELAY_ALLOCATOR: () => RELAY_ALLOCATOR,
+  RELAY_API: () => RELAY_API,
+  RELAY_CHAINS: () => RELAY_CHAINS,
+  RELAY_CLOCK_SKEW_S: () => RELAY_CLOCK_SKEW_S,
+  RELAY_DEFAULT_SLIPPAGE_BPS: () => RELAY_DEFAULT_SLIPPAGE_BPS,
+  RELAY_DEPOSIT_ERC20: () => RELAY_DEPOSIT_ERC20,
+  RELAY_DEPOSIT_ERC20_ALLOWANCE: () => RELAY_DEPOSIT_ERC20_ALLOWANCE,
+  RELAY_DEPOSIT_NATIVE: () => RELAY_DEPOSIT_NATIVE,
+  RELAY_GAS_CAP: () => RELAY_GAS_CAP,
+  RELAY_GAS_FLOOR_ERC20: () => RELAY_GAS_FLOOR_ERC20,
+  RELAY_GAS_FLOOR_NATIVE: () => RELAY_GAS_FLOOR_NATIVE,
+  RELAY_MAX_ORDER_AGE_S: () => RELAY_MAX_ORDER_AGE_S,
+  RELAY_MAX_QUOTE_LIFE_MS: () => RELAY_MAX_QUOTE_LIFE_MS,
+  RELAY_MAX_SLIPPAGE_BPS: () => RELAY_MAX_SLIPPAGE_BPS,
+  RELAY_MODULE: () => RELAY_MODULE,
+  RELAY_NATIVE: () => RELAY_NATIVE,
+  RELAY_ORDER_LIFETIME_S: () => RELAY_ORDER_LIFETIME_S,
+  RELAY_ORDER_TYPES: () => RELAY_ORDER_TYPES,
+  RELAY_ORDER_VERSION: () => RELAY_ORDER_VERSION,
+  RELAY_OWNER: () => RELAY_OWNER,
+  RELAY_SOLVERS: () => RELAY_SOLVERS,
+  RELAY_STATUS_MAP: () => RELAY_STATUS_MAP,
+  RelayRefusal: () => RelayRefusal,
+  RelaySwap2Protocol: () => RelaySwap2Protocol,
+  buildRelayDeposit: () => buildRelayDeposit,
+  checkRelayQuote: () => checkRelayQuote,
+  default: () => RelaySwap2Protocol,
+  describeRelayActivity: () => describeRelayActivity,
+  parseRelayOrder: () => parseRelayOrder,
+  relay: () => relay,
+  relayChain: () => relayChain,
+  relayClearOrder: () => relayClearOrder,
+  relayOrderId: () => relayOrderId,
+  relayOrderSigner: () => relayOrderSigner,
+  relayPins: () => relayPins,
+  relayProtocolOf: () => relayProtocolOf,
+  relayProvider: () => relayProvider,
+  relayRefusalReason: () => relayRefusalReason,
+  relayRequestOf: () => relayRequestOf,
+  relayVerifyBuild: () => relayVerifyBuild,
+  relayVerifyQuote: () => relayVerifyQuote,
+  verifyRelayOrder: () => verifyRelayOrder
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var DEPOSITORY = "0x4cd00e387622c35bddb9b4c962c136462338bc31";
+var DEPOSITORY_B = "0x59916da825d2d2ec1bf878d71c88826f6633ecca";
+var c = (chainId, slug, name, depository = DEPOSITORY) => Object.freeze({ caip2: `eip155:${chainId}`, chainId, slug, name, depository });
+var RELAY_CHAINS = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), Object.fromEntries([
+  c(1, "ethereum", "Ethereum"),
+  c(10, "optimism", "OP Mainnet"),
+  c(56, "bnb", "BNB Chain"),
+  c(100, "gnosis", "Gnosis"),
+  c(130, "unichain", "Unichain"),
+  c(137, "polygon", "Polygon"),
+  c(143, "monad", "Monad"),
+  c(146, "sonic", "Sonic"),
+  c(196, "xlayer", "X Layer"),
+  c(324, "zksync", "zkSync Era"),
+  c(480, "worldchain", "World Chain"),
+  c(999, "hyperevm", "HyperEVM"),
+  c(2818, "morph", "Morph"),
+  c(4326, "megaeth", "MegaETH"),
+  c(4663, "robinhood", "Robinhood Chain"),
+  c(5e3, "mantle", "Mantle", DEPOSITORY_B),
+  c(5042, "arc", "Arc"),
+  c(8453, "base", "Base"),
+  c(9745, "plasma", "Plasma"),
+  c(42161, "arbitrum", "Arbitrum"),
+  c(42220, "celo", "Celo"),
+  c(43114, "avalanche", "Avalanche"),
+  c(57073, "ink", "Ink"),
+  c(59144, "linea", "Linea", DEPOSITORY_B),
+  c(80094, "berachain", "Berachain"),
+  c(98866, "plume", "Plume"),
+  c(99901, "elysium", "Elysium"),
+  c(534352, "scroll", "Scroll"),
+  c(747474, "katana", "Katana")
+].map((x) => [x.caip2, x]))));
+function relayChain(caip2) {
+  return typeof caip2 === "string" && Object.prototype.hasOwnProperty.call(RELAY_CHAINS, caip2) ? RELAY_CHAINS[caip2] : void 0;
+}
+var RELAY_SOLVERS = Object.freeze([
+  Object.freeze({ chainId: "base", address: "0xf70da97812cb96acdf810712aa562db8dfa3dbef" })
+]);
+var RELAY_ALLOCATOR = "0x63c1d3e9c646184529c5694630a01c00df171b56";
+var RELAY_OWNER = "0xf61a305199fa1135d76ffab3752d42f55cbd775a";
+var RELAY_API = "https://api.relay.link";
+var RELAY_NATIVE = "0x0000000000000000000000000000000000000000";
+var RELAY_DEPOSIT_NATIVE = "0x49290c1c";
+var RELAY_DEPOSIT_ERC20 = "0xe8017952";
+var RELAY_DEPOSIT_ERC20_ALLOWANCE = "0x5a1ee3ac";
+var RELAY_ORDER_VERSION = "v1";
+var RELAY_ORDER_LIFETIME_S = 604800;
+var RELAY_MAX_ORDER_AGE_S = 600;
+var RELAY_CLOCK_SKEW_S = 300;
+var relay = {
+  supportsChain(chain) {
+    return relayChain(chain) !== void 0;
+  },
+  /** Two different pinned EVM chains. */
+  supports(from, to) {
+    return from !== to && relayChain(from) !== void 0 && relayChain(to) !== void 0;
+  }
+};
+
+// src/order.ts
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_viem = require("viem");
+var RelayRefusal = class extends Error {
+  code;
+  constructor(code, detail) {
+    super(`relay: ${detail} [${code}]`);
+    this.name = "RelayRefusal";
+    this.code = code;
+  }
+};
+var RELAY_ORDER_TYPES = {
+  Order: [
+    { name: "version", type: "string" },
+    { name: "solverChainId", type: "string" },
+    { name: "solver", type: "address" },
+    { name: "salt", type: "uint256" },
+    { name: "inputs", type: "Input[]" },
+    { name: "output", type: "Output" },
+    { name: "fees", type: "Fee[]" }
+  ],
+  Input: [
+    { name: "payment", type: "InputPayment" },
+    { name: "refunds", type: "InputRefund[]" }
+  ],
+  InputPayment: [
+    { name: "chainId", type: "string" },
+    { name: "currency", type: "bytes" },
+    { name: "amount", type: "uint256" },
+    { name: "weight", type: "uint256" }
+  ],
+  InputRefund: [
+    { name: "chainId", type: "string" },
+    { name: "recipient", type: "bytes" },
+    { name: "currency", type: "bytes" },
+    { name: "minimumAmount", type: "uint256" },
+    { name: "deadline", type: "uint32" },
+    { name: "extraData", type: "bytes" }
+  ],
+  Output: [
+    { name: "chainId", type: "string" },
+    { name: "payments", type: "OutputPayment[]" },
+    { name: "deadline", type: "uint32" },
+    { name: "calls", type: "bytes[]" },
+    { name: "extraData", type: "bytes" }
+  ],
+  OutputPayment: [
+    { name: "recipient", type: "bytes" },
+    { name: "currency", type: "bytes" },
+    { name: "minimumAmount", type: "uint256" },
+    { name: "expectedAmount", type: "uint256" }
+  ],
+  Fee: [
+    { name: "recipientChainId", type: "string" },
+    { name: "recipient", type: "bytes" },
+    { name: "currencyChainId", type: "string" },
+    { name: "currency", type: "bytes" },
+    { name: "amount", type: "uint256" }
+  ]
+};
+var MAX_LIST = 8;
+var MAX_BYTES_HEX = 2 + 2 * 1024;
+var MAX_TEXT = 64;
+var U256_MAX = (1n << 256n) - 1n;
+var bad = (what) => {
+  throw new RelayRefusal("order-malformed", `the order's ${what}`);
+};
+function rec(v, what) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) bad(`${what} is not an object`);
+  return v;
+}
+function list(v, what) {
+  if (!Array.isArray(v)) bad(`${what} is not a list`);
+  if (v.length > MAX_LIST) bad(`${what} has more than ${MAX_LIST} entries`);
+  return v;
+}
+function own(o, key) {
+  return Object.prototype.hasOwnProperty.call(o, key) ? o[key] : void 0;
+}
+function text(v, what) {
+  if (typeof v !== "string" || v.length === 0 || v.length > MAX_TEXT) bad(`${what} is not a short string`);
+  return v;
+}
+function bytes(v, what) {
+  if (typeof v !== "string" || v.length > MAX_BYTES_HEX || !/^0x(?:[0-9a-fA-F]{2})*$/.test(v)) bad(`${what} is not hex bytes`);
+  return v.toLowerCase();
+}
+function uint(v, what, max = U256_MAX) {
+  let n = null;
+  if (typeof v === "string" && (/^(?:0|[1-9]\d{0,77})$/.test(v) || /^0x[0-9a-fA-F]{1,64}$/.test(v))) n = BigInt(v);
+  else if (typeof v === "number" && Number.isSafeInteger(v) && v >= 0) n = BigInt(v);
+  if (n === null || n > max) bad(`${what} is not an unsigned integer in range`);
+  return n;
+}
+function uint32(v, what) {
+  return parseInt(uint(v, what, 0xffffffffn).toString(10), 10);
+}
+function address(v, what) {
+  if (typeof v !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(v)) bad(`${what} is not an address`);
+  return v.toLowerCase();
+}
+function parseRelayOrder(raw) {
+  const o = rec(raw, "body");
+  const output = rec(own(o, "output"), "output");
+  return {
+    version: text(own(o, "version"), "version"),
+    solverChainId: text(own(o, "solverChainId"), "solver chain"),
+    solver: address(own(o, "solver"), "solver"),
+    salt: uint(own(o, "salt"), "salt"),
+    inputs: list(own(o, "inputs"), "inputs").map((x, i) => {
+      const input = rec(x, `input ${i}`);
+      const p = rec(own(input, "payment"), `input ${i} payment`);
+      return {
+        payment: {
+          chainId: text(own(p, "chainId"), `input ${i} chain`),
+          currency: bytes(own(p, "currency"), `input ${i} currency`),
+          amount: uint(own(p, "amount"), `input ${i} amount`),
+          weight: uint(own(p, "weight"), `input ${i} weight`)
+        },
+        refunds: list(own(input, "refunds"), `input ${i} refunds`).map((y, j) => {
+          const r = rec(y, `refund ${j}`);
+          return {
+            chainId: text(own(r, "chainId"), `refund ${j} chain`),
+            recipient: bytes(own(r, "recipient"), `refund ${j} recipient`),
+            currency: bytes(own(r, "currency"), `refund ${j} currency`),
+            minimumAmount: uint(own(r, "minimumAmount"), `refund ${j} minimum`),
+            deadline: uint32(own(r, "deadline"), `refund ${j} deadline`),
+            extraData: bytes(own(r, "extraData"), `refund ${j} extra data`)
+          };
+        })
+      };
+    }),
+    output: {
+      chainId: text(own(output, "chainId"), "output chain"),
+      payments: list(own(output, "payments"), "output payments").map((x, i) => {
+        const p = rec(x, `output payment ${i}`);
+        return {
+          recipient: bytes(own(p, "recipient"), `output payment ${i} recipient`),
+          currency: bytes(own(p, "currency"), `output payment ${i} currency`),
+          minimumAmount: uint(own(p, "minimumAmount"), `output payment ${i} minimum`),
+          expectedAmount: uint(own(p, "expectedAmount"), `output payment ${i} expected amount`)
+        };
+      }),
+      deadline: uint32(own(output, "deadline"), "output deadline"),
+      calls: list(own(output, "calls"), "output calls").map((x, i) => bytes(x, `output call ${i}`)),
+      extraData: bytes(own(output, "extraData"), "output extra data")
+    },
+    fees: list(own(o, "fees"), "fees").map((x, i) => {
+      const f = rec(x, `fee ${i}`);
+      return {
+        recipientChainId: text(own(f, "recipientChainId"), `fee ${i} recipient chain`),
+        recipient: bytes(own(f, "recipient"), `fee ${i} recipient`),
+        currencyChainId: text(own(f, "currencyChainId"), `fee ${i} currency chain`),
+        currency: bytes(own(f, "currency"), `fee ${i} currency`),
+        amount: uint(own(f, "amount"), `fee ${i} amount`)
+      };
+    })
+  };
+}
+function relayOrderId(order) {
+  return (0, import_viem.hashStruct)({ types: RELAY_ORDER_TYPES, primaryType: "Order", data: order });
+}
+function relayOrderSigner(id, signature) {
+  if (typeof signature !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(signature)) return null;
+  const sig = (0, import_viem.hexToBytes)(signature);
+  const v = sig[64];
+  const recovery = v === 27 || v === 28 ? v - 27 : v === 0 || v === 1 ? v : -1;
+  if (recovery < 0) return null;
+  try {
+    const recoverable = new Uint8Array(65);
+    recoverable[0] = recovery;
+    recoverable.set(sig.subarray(0, 64), 1);
+    const digest = (0, import_viem.hexToBytes)((0, import_viem.hashMessage)({ raw: id }));
+    const key = import_secp256k1.secp256k1.recoverPublicKey(recoverable, digest, { prehash: false });
+    if (!import_secp256k1.secp256k1.verify(sig.subarray(0, 64), digest, key, { prehash: false })) return null;
+    const uncompressed = import_secp256k1.secp256k1.Point.fromBytes(key).toBytes(false);
+    return `0x${(0, import_viem.keccak256)(uncompressed.subarray(1)).slice(-40)}`.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+
+// src/verify.ts
+var import_viem2 = require("viem");
+var import_util = require("@anywalletkit/protocol-swap2-core/util");
+
+// src/cleared.ts
+var CLEARED_TTL_MS = (RELAY_MAX_ORDER_AGE_S + 2 * RELAY_CLOCK_SKEW_S) * 1e3;
+var CLEARED_MAX = 4096;
+var clearedOrders = /* @__PURE__ */ new Map();
+function relayClearOrder(id, stage, nowMs = Date.now()) {
+  const key = `${stage}:${id.toLowerCase()}`;
+  const until = clearedOrders.get(key);
+  if (until !== void 0 && until > nowMs) throw new RelayRefusal("order-reused", `order ${id} was already cleared for a deposit \u2014 quote again`);
+  if (clearedOrders.size >= CLEARED_MAX) {
+    for (const [k, t] of clearedOrders) if (t <= nowMs) clearedOrders.delete(k);
+    if (clearedOrders.size >= CLEARED_MAX) throw new RelayRefusal("order-reused", "too many deposits cleared in the last minutes \u2014 try again later");
+  }
+  clearedOrders.set(key, nowMs + CLEARED_TTL_MS);
+}
+
+// src/verify.ts
+var DEPOSITORY_ABI = (0, import_viem2.parseAbi)([
+  "function depositNative(address depositor, bytes32 id) payable",
+  "function depositErc20(address depositor, address token, uint256 amount, bytes32 id)"
+]);
+var RELAY_MAX_SLIPPAGE_BPS = 5e3;
+var RELAY_DEFAULT_SLIPPAGE_BPS = 200;
+var RELAY_GAS_FLOOR_NATIVE = 90000n;
+var RELAY_GAS_FLOOR_ERC20 = 180000n;
+var RELAY_GAS_CAP = 60000000n;
+var RELAY_MAX_QUOTE_LIFE_MS = 3e5 + RELAY_CLOCK_SKEW_S * 1e3;
+var ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+var U256_MAX2 = (1n << 256n) - 1n;
+var lower = (s) => s.toLowerCase();
+var isNative = (token) => lower(token) === RELAY_NATIVE;
+function buildRelayDeposit(source, depositor, token, amount, id) {
+  if (!ADDRESS.test(depositor) || /^0x0{40}$/.test(depositor)) throw new RelayRefusal("request-invalid", "the depositor is not an address");
+  if (!ADDRESS.test(token)) throw new RelayRefusal("request-invalid", "the input token is not an address");
+  if (amount <= 0n || amount > U256_MAX2) throw new RelayRefusal("request-invalid", "the amount is not a positive integer");
+  if (!/^0x[0-9a-f]{64}$/.test(id)) throw new RelayRefusal("order-id-mismatch", "the order id is not 32 bytes");
+  if (isNative(token)) {
+    return {
+      to: source.depository,
+      data: (0, import_viem2.encodeFunctionData)({ abi: DEPOSITORY_ABI, functionName: "depositNative", args: [lower(depositor), id] }),
+      value: amount.toString(10),
+      chainId: source.chainId
+    };
+  }
+  return {
+    to: source.depository,
+    data: (0, import_viem2.encodeFunctionData)({ abi: DEPOSITORY_ABI, functionName: "depositErc20", args: [lower(depositor), lower(token), amount, id] }),
+    value: "0",
+    chainId: source.chainId,
+    approvalAddress: source.depository
+  };
+}
+function checkRequest(r) {
+  const invalid = (what) => {
+    throw new RelayRefusal("request-invalid", what);
+  };
+  if (r === null || typeof r !== "object") invalid("no request to check the order against");
+  const source = relayChain(r.sourceChain);
+  const dest = relayChain(r.destChain);
+  if (!source) throw new RelayRefusal("chain-unsupported", `source chain ${String(r.sourceChain)} is not a pinned Relay chain`);
+  if (!dest) throw new RelayRefusal("chain-unsupported", `destination chain ${String(r.destChain)} is not a pinned Relay chain`);
+  if (source === dest) throw new RelayRefusal("chain-unsupported", "source and destination are the same chain");
+  for (const [what, v] of [["input token", r.sourceToken], ["output token", r.destToken], ["depositor", r.depositor], ["recipient", r.recipient]]) {
+    if (typeof v !== "string" || !ADDRESS.test(v)) invalid(`the ${what} is not an address`);
+  }
+  if (/^0x0{40}$/.test(r.depositor)) invalid("the depositor is the zero address");
+  if (/^0x0{40}$/.test(r.recipient)) invalid("the recipient is the zero address");
+  if (typeof r.amount !== "bigint" || r.amount <= 0n || r.amount > U256_MAX2) invalid("the amount is not a positive integer");
+  if (r.minAmountOut !== void 0 && (typeof r.minAmountOut !== "bigint" || r.minAmountOut < 0n)) invalid("the output floor is not an unsigned integer");
+  if (r.slippageBps !== void 0 && (!Number.isInteger(r.slippageBps) || r.slippageBps < 0 || r.slippageBps > RELAY_MAX_SLIPPAGE_BPS)) {
+    invalid(`slippage must be a whole number of basis points up to ${RELAY_MAX_SLIPPAGE_BPS}`);
+  }
+  const nowMs = r.nowMs ?? Date.now();
+  if (!Number.isFinite(nowMs) || nowMs <= 0) invalid("the clock is not a time");
+  return { source, dest, nowS: Math.floor(nowMs / 1e3) };
+}
+var isAddr = (bytes2, addr) => bytes2.length === 42 && bytes2 === lower(addr);
+function checkDeadline(code, what, deadline, nowS) {
+  const left = deadline - nowS;
+  if (left > RELAY_ORDER_LIFETIME_S + RELAY_CLOCK_SKEW_S) {
+    throw new RelayRefusal(code, `${what} is ${left} s away, past the ${RELAY_ORDER_LIFETIME_S} s an order lives`);
+  }
+  if (left < RELAY_ORDER_LIFETIME_S - RELAY_MAX_ORDER_AGE_S) {
+    throw new RelayRefusal(code, `${what} is ${left} s away: the order is older than ${RELAY_MAX_ORDER_AGE_S} s or already past it`);
+  }
+}
+function wordAddress(word) {
+  return /^0{24}/.test(word) ? `0x${word.slice(24)}` : null;
+}
+function checkDepositTarget(tx, source) {
+  if (tx === null || typeof tx !== "object") throw new RelayRefusal("tx-calldata", "there is no deposit transaction");
+  if (tx.chainId !== source.chainId) {
+    throw new RelayRefusal("tx-chain", `the deposit is for chain ${String(tx.chainId)}, not ${source.chainId}`);
+  }
+  if (typeof tx.to !== "string" || !ADDRESS.test(tx.to) || lower(tx.to) !== source.depository) {
+    throw new RelayRefusal("tx-target", `the deposit calls ${String(tx.to)}, not the ${source.name} depository ${source.depository} \u2014 routes that first swap on the source chain go through a router and are not signed by this module`);
+  }
+}
+function checkDepositTx(tx, source, request, order, id) {
+  checkDepositTarget(tx, source);
+  if (typeof tx.data !== "string" || !/^0x(?:[0-9a-fA-F]{2})*$/.test(tx.data) || tx.data.length < 10) {
+    throw new RelayRefusal("tx-calldata", "the deposit has no calldata");
+  }
+  const data = lower(tx.data);
+  const selector = data.slice(0, 10);
+  const input = order.inputs[0].payment;
+  const native = isNative(input.currency);
+  if (selector === RELAY_DEPOSIT_ERC20_ALLOWANCE) {
+    throw new RelayRefusal("tx-selector", "the deposit uses depositErc20 without an amount, which takes the whole allowance");
+  }
+  if (selector !== RELAY_DEPOSIT_NATIVE && selector !== RELAY_DEPOSIT_ERC20) {
+    throw new RelayRefusal("tx-selector", `the deposit calls ${selector}, not a known deposit function`);
+  }
+  if (selector === RELAY_DEPOSIT_NATIVE !== native) {
+    throw new RelayRefusal("tx-selector", `the deposit calls ${native ? "depositErc20" : "depositNative"} for an order whose input is ${native ? "the native coin" : "a token"}`);
+  }
+  const words = native ? 2 : 4;
+  if (data.length !== 10 + 64 * words) {
+    throw new RelayRefusal("tx-calldata", `the deposit calldata is ${(data.length - 2) / 2} bytes, not ${4 + 32 * words}`);
+  }
+  const word = (i) => data.slice(10 + 64 * i, 74 + 64 * i);
+  const depositor = wordAddress(word(0));
+  if (depositor === null) throw new RelayRefusal("tx-calldata", "the depositor argument is not a padded address");
+  if (depositor !== lower(request.depositor)) {
+    throw new RelayRefusal("tx-depositor", `the deposit is credited to ${depositor}, not to the sender ${lower(request.depositor)}`);
+  }
+  if (!native) {
+    const token = wordAddress(word(1));
+    if (token === null) throw new RelayRefusal("tx-calldata", "the token argument is not a padded address");
+    if (token !== input.currency) throw new RelayRefusal("tx-token", `the deposit moves ${token}, the order's input is ${input.currency}`);
+    const amount = BigInt(`0x${word(2)}`);
+    if (amount !== input.amount) throw new RelayRefusal("tx-amount", `the deposit moves ${amount}, the order's input is ${input.amount}`);
+  }
+  const txId = `0x${word(native ? 1 : 3)}`;
+  if (txId !== id) throw new RelayRefusal("tx-id", `the deposit names order ${txId}, the order received hashes to ${id}`);
+  const value = typeof tx.value === "string" && /^(?:0|[1-9]\d{0,77})$/.test(tx.value) ? BigInt(tx.value) : null;
+  const wantValue = native ? input.amount : 0n;
+  if (value === null || value !== wantValue) {
+    throw new RelayRefusal("tx-value", `the deposit sends ${String(tx.value)} wei, it must send ${wantValue}`);
+  }
+}
+function verifyRelayOrder(request, protocol, deposit) {
+  const { source, dest, nowS } = checkRequest(request);
+  if (deposit !== void 0) checkDepositTarget(deposit, source);
+  if (protocol === null || typeof protocol !== "object") {
+    throw new RelayRefusal("protocol-data-missing", "the quote carries no order (protocol.v2) \u2014 nothing to check the deposit against");
+  }
+  if (protocol.orderData === void 0 || protocol.orderData === null) {
+    throw new RelayRefusal("protocol-data-missing", "the quote carries no order data \u2014 nothing to check the deposit against");
+  }
+  if (protocol.hubType !== "onchain") {
+    throw new RelayRefusal("hub-type", `the order settles through a "${String(protocol.hubType)}" hub, only "onchain" is read`);
+  }
+  const order = parseRelayOrder(protocol.orderData);
+  if (order.version !== RELAY_ORDER_VERSION) throw new RelayRefusal("order-version", `order version "${order.version}" is not ${RELAY_ORDER_VERSION}`);
+  if (order.inputs.length !== 1) throw new RelayRefusal("order-inputs", `the order has ${order.inputs.length} inputs, exactly one is signed for`);
+  if (order.output.payments.length !== 1) throw new RelayRefusal("order-payments", `the order pays ${order.output.payments.length} outputs, exactly one is accepted`);
+  if (order.output.calls.length !== 0) throw new RelayRefusal("order-calls", "the order runs calls on the destination \u2014 only plain payments are accepted");
+  if (order.fees.length !== 0) throw new RelayRefusal("order-fees", "the order carries order-level fees, which this module does not show and does not accept");
+  const input = order.inputs[0];
+  const pay = order.output.payments[0];
+  if (input.payment.weight === 0n) throw new RelayRefusal("input-weight", "the order's input has zero weight");
+  if (!RELAY_SOLVERS.some((s) => s.address === order.solver && s.chainId === order.solverChainId)) {
+    throw new RelayRefusal("solver-not-pinned", `solver ${order.solver} on "${order.solverChainId}" is not a pinned Relay solver`);
+  }
+  if (order.output.chainId !== dest.slug) throw new RelayRefusal("output-chain", `the order pays on "${order.output.chainId}", the request is for ${dest.name} ("${dest.slug}")`);
+  if (!isAddr(pay.recipient, request.recipient)) throw new RelayRefusal("output-recipient", `the order pays ${pay.recipient}, not the recipient ${lower(request.recipient)}`);
+  if (!isAddr(pay.currency, request.destToken)) throw new RelayRefusal("output-currency", `the order pays in ${pay.currency}, the request is for ${lower(request.destToken)}`);
+  if (pay.minimumAmount <= 0n) throw new RelayRefusal("output-minimum", "the order's minimum output is zero");
+  if (request.minAmountOut !== void 0 && pay.minimumAmount < request.minAmountOut) {
+    throw new RelayRefusal("output-minimum", `the order's minimum output ${pay.minimumAmount} is under the caller's floor ${request.minAmountOut}`);
+  }
+  if (pay.expectedAmount < pay.minimumAmount) throw new RelayRefusal("output-expected", `the order expects ${pay.expectedAmount}, less than its own minimum ${pay.minimumAmount}`);
+  const slippage = BigInt(request.slippageBps ?? RELAY_DEFAULT_SLIPPAGE_BPS);
+  const floor = pay.expectedAmount * (10000n - slippage) / 10000n;
+  if (pay.minimumAmount < floor) {
+    throw new RelayRefusal("output-minimum", `the order's minimum output ${pay.minimumAmount} is more than ${slippage} bps under its expected ${pay.expectedAmount}`);
+  }
+  checkDeadline("output-deadline", "the output deadline", order.output.deadline, nowS);
+  if (input.payment.chainId !== source.slug) throw new RelayRefusal("input-chain", `the order is funded on "${input.payment.chainId}", the request sends on ${source.name} ("${source.slug}")`);
+  if (!isAddr(input.payment.currency, request.sourceToken)) throw new RelayRefusal("input-currency", `the order is funded in ${input.payment.currency}, the request sends ${lower(request.sourceToken)}`);
+  if (input.payment.amount !== request.amount) throw new RelayRefusal("input-amount", `the order is funded with ${input.payment.amount}, the request sends ${request.amount}`);
+  let originRefund = false;
+  for (const refund of input.refunds) {
+    if (refund.chainId === source.slug) {
+      if (!isAddr(refund.recipient, request.depositor)) throw new RelayRefusal("refund-recipient", `a source-chain refund goes to ${refund.recipient}, not the sender ${lower(request.depositor)}`);
+      if (refund.currency !== input.payment.currency) throw new RelayRefusal("refund-currency", `a source-chain refund is in ${refund.currency}, not the token sent`);
+      originRefund = true;
+    } else if (refund.chainId === dest.slug) {
+      if (!isAddr(refund.recipient, request.recipient) && !isAddr(refund.recipient, request.depositor)) {
+        throw new RelayRefusal("refund-recipient", `a destination-chain refund goes to ${refund.recipient}, neither the recipient nor the sender`);
+      }
+      if (refund.currency.length !== 42) throw new RelayRefusal("refund-currency", "a destination-chain refund names no token");
+    } else {
+      throw new RelayRefusal("refund-chain", `a refund is payable on "${refund.chainId}", neither the source nor the destination chain`);
+    }
+    checkDeadline("refund-deadline", "a refund deadline", refund.deadline, nowS);
+  }
+  if (!originRefund) throw new RelayRefusal("refund-missing", "the order has no refund to the sender on the source chain");
+  const id = relayOrderId(order);
+  if (typeof protocol.orderId !== "string" || lower(protocol.orderId) !== id) {
+    throw new RelayRefusal("order-id-mismatch", `the quote names order ${String(protocol.orderId)}, the order data hashes to ${id}`);
+  }
+  const signer = relayOrderSigner(id, protocol.orderSignature);
+  if (signer === null || signer !== order.solver) {
+    throw new RelayRefusal("signature-invalid", signer === null ? "the order signature is not a valid signature" : `the order is signed by ${signer}, not by its solver ${order.solver}`);
+  }
+  const pd = protocol.paymentDetails;
+  if (pd === null || typeof pd !== "object") throw new RelayRefusal("payment-details", "the quote has no payment details");
+  if (pd.chainId !== source.slug || typeof pd.depository !== "string" || lower(pd.depository) !== source.depository || typeof pd.currency !== "string" || lower(pd.currency) !== input.payment.currency || typeof pd.amount !== "string" || pd.amount !== input.payment.amount.toString(10)) {
+    throw new RelayRefusal("payment-details", "the quote's payment details do not describe the order's input on the pinned depository");
+  }
+  const built = buildRelayDeposit(source, request.depositor, input.payment.currency, input.payment.amount, id);
+  if (deposit !== void 0) {
+    checkDepositTx(deposit, source, request, order, id);
+    if (lower(deposit.data) !== built.data || lower(deposit.to) !== built.to || deposit.value !== built.value) {
+      throw new RelayRefusal("tx-calldata", "the deposit is not the call this module builds for the order");
+    }
+  }
+  return { order, id, deposit: built, expectedAmount: pay.expectedAmount, minimumAmount: pay.minimumAmount, source, dest };
+}
+function relayRefusalReason(err) {
+  if (err instanceof RelayRefusal) return err.message;
+  throw err;
+}
+function relayRequestOf(params, opts = {}) {
+  const invalid = (what) => {
+    throw new RelayRefusal("request-invalid", what);
+  };
+  if (params.flex) invalid("the amount is sealed into the order (no flexible deposits)");
+  if (!relayChain(params.sourceChain)) throw new RelayRefusal("chain-unsupported", `source chain ${params.sourceChain} is not a pinned Relay chain`);
+  if (!relayChain(params.destChain)) throw new RelayRefusal("chain-unsupported", `destination chain ${params.destChain} is not a pinned Relay chain`);
+  if (params.sourceChain === params.destChain) throw new RelayRefusal("chain-unsupported", "same-chain swaps are not served through the depository");
+  let sourceToken;
+  if (typeof params.sourceToken === "string" && ADDRESS.test(params.sourceToken)) sourceToken = params.sourceToken;
+  else {
+    const asset = (0, import_util.sourceAssetOf)(params);
+    if (!asset) invalid(`source token ${String(params.sourceToken)} is not known on ${params.sourceChain}`);
+    sourceToken = asset.contract ?? RELAY_NATIVE;
+    if (!ADDRESS.test(sourceToken)) invalid(`source token ${String(params.sourceToken)} has no EVM contract`);
+  }
+  if (typeof params.destToken !== "string" || !ADDRESS.test(params.destToken)) invalid("the destination token must be an EVM address (zero for the native coin)");
+  if (typeof params.amountIn !== "string" || !/^[1-9]\d{0,77}$/.test(params.amountIn)) invalid("amount must be a positive base-unit integer");
+  if (params.minAmountOut !== void 0 && !/^(?:0|[1-9]\d{0,77})$/.test(params.minAmountOut)) invalid("the output floor must be a base-unit integer");
+  const recipient = params.destAddress || opts.placeholder || "";
+  if (!recipient) invalid("a live quote needs a recipient");
+  if (!ADDRESS.test(recipient)) invalid("the recipient must be an EVM address");
+  const depositor = params.refundAddress || opts.placeholder || "";
+  if (!depositor) invalid("a live quote needs the sender's address (refundAddress)");
+  if (!ADDRESS.test(depositor)) invalid("the sender's address must be an EVM address");
+  return {
+    sourceChain: params.sourceChain,
+    destChain: params.destChain,
+    sourceToken,
+    destToken: params.destToken,
+    amount: BigInt(params.amountIn),
+    depositor,
+    recipient,
+    ...params.minAmountOut !== void 0 ? { minAmountOut: BigInt(params.minAmountOut) } : {},
+    ...params.slippageBps !== void 0 ? { slippageBps: params.slippageBps } : {},
+    ...opts.nowMs !== void 0 ? { nowMs: opts.nowMs } : {}
+  };
+}
+function relayProtocolOf(quote) {
+  const pd = quote.providerData;
+  if (!pd || typeof pd.orderData !== "string") return null;
+  let orderData;
+  let paymentDetails;
+  try {
+    orderData = JSON.parse(pd.orderData);
+    paymentDetails = typeof pd.paymentDetails === "string" ? JSON.parse(pd.paymentDetails) : void 0;
+  } catch {
+    return null;
+  }
+  return { orderId: pd.orderId, hubType: pd.hubType, orderData, orderSignature: pd.orderSignature, paymentDetails };
+}
+function checkRelayQuote(request, quote, tx) {
+  if (quote === null || typeof quote !== "object" || quote.provider !== "relay") throw new RelayRefusal("quote-shape", "not a Relay quote");
+  const t = tx ?? quote.txRequest;
+  if (!t) throw new RelayRefusal("quote-shape", "the quote has no transaction");
+  if (quote.depositAddress) throw new RelayRefusal("quote-shape", "a Relay quote pays the depository through its calldata, never a deposit address");
+  if (quote.txRequest?.serializedTx !== void 0 || quote.txRequest?.nativeFee !== void 0) {
+    throw new RelayRefusal("quote-shape", "a Relay deposit carries no extra native fee and no serialized transaction");
+  }
+  const v = verifyRelayOrder(request, relayProtocolOf(quote), t);
+  const approval = t.approvalAddress;
+  if (v.deposit.approvalAddress === void 0 ? approval !== void 0 && approval !== "" : typeof approval !== "string" || lower(approval) !== v.deposit.approvalAddress) {
+    throw new RelayRefusal("quote-approval", `the quote approves ${String(approval)}, the order needs ${v.deposit.approvalAddress ?? "no approval"}`);
+  }
+  if (quote.sourceAmount !== request.amount.toString(10) || quote.minDestAmount !== v.minimumAmount.toString(10) || quote.destAmount !== v.expectedAmount.toString(10)) {
+    throw new RelayRefusal("quote-amounts", "the amounts the quote shows are not the order's");
+  }
+  const gas = t.gasLimit;
+  if (gas !== void 0) {
+    const floor = v.deposit.approvalAddress === void 0 ? RELAY_GAS_FLOOR_NATIVE : RELAY_GAS_FLOOR_ERC20;
+    if (typeof gas !== "string" || !/^[1-9]\d{0,10}$/.test(gas) || BigInt(gas) < floor || BigInt(gas) > RELAY_GAS_CAP) {
+      throw new RelayRefusal("quote-gas", `the gas limit ${String(gas).slice(0, 40)} is outside ${floor}\u2013${RELAY_GAS_CAP}`);
+    }
+  }
+  const now = request.nowMs ?? Date.now();
+  if (typeof quote.validUntilMs !== "number" || !Number.isFinite(quote.validUntilMs) || quote.validUntilMs > now + RELAY_MAX_QUOTE_LIFE_MS) {
+    throw new RelayRefusal("quote-expiry", "the quote claims to live longer than a Relay quote may");
+  }
+  if (typeof quote.intentId !== "string" || quote.intentId !== `relay:${String(quote.providerData?.requestId)}` || !/^relay:0x[0-9a-f]{64}$/.test(quote.intentId)) {
+    throw new RelayRefusal("quote-shape", "the quote's id is not its Relay request id");
+  }
+  return v;
+}
+function relayVerifyQuote(params, quote) {
+  try {
+    checkRelayQuote(relayRequestOf(params), quote);
+    return null;
+  } catch (err) {
+    return relayRefusalReason(err);
+  }
+}
+function relayVerifyBuild(quote, tx, params) {
+  try {
+    if (!params) throw new RelayRefusal("request-invalid", "the request this quote answered is not known on this side \u2014 quote again");
+    if (tx.chain !== params.sourceChain) throw new RelayRefusal("tx-chain", `the build is for ${tx.chain}, not ${params.sourceChain}`);
+    if (tx.serializedTx !== void 0 || tx.memo !== void 0 || tx.typedData !== void 0 || tx.bodyBoc !== void 0) {
+      throw new RelayRefusal("quote-shape", "a Relay deposit is one EVM call");
+    }
+    const v = checkRelayQuote(relayRequestOf(params), quote, tx);
+    relayClearOrder(v.id, "build");
+    return null;
+  } catch (err) {
+    return relayRefusalReason(err);
+  }
+}
+var relayPins = Object.freeze({
+  callTargets: (chain) => {
+    const c2 = relayChain(chain);
+    return c2 ? [c2.depository] : [];
+  },
+  spenders: (chain) => {
+    const c2 = relayChain(chain);
+    return c2 ? [c2.depository] : [];
+  },
+  verifyQuote: relayVerifyQuote,
+  verifyBuild: relayVerifyBuild
+});
+
+// src/provider.ts
+var import_util2 = require("@anywalletkit/protocol-swap2-core/util");
+
+// src/activity.ts
+var import_activity = require("@anywalletkit/protocol-swap2-core/activity");
+var RELAY_MODULE = "@anywalletkit/protocol-swap2-relay";
+function describeRelayActivity(tx, ctx) {
+  const chain = relayChain(tx.chain);
+  if (!chain) return null;
+  if (!(0, import_activity.matchesCall)(tx, [chain.depository], [RELAY_DEPOSIT_NATIVE, RELAY_DEPOSIT_ERC20, RELAY_DEPOSIT_ERC20_ALLOWANCE])) return null;
+  return (0, import_activity.describeSwapLike)(tx, ctx, { protocol: RELAY_MODULE, subtitle: `Relay \xB7 ${(0, import_activity.chainLabel)(tx.chain)}`, kind: "bridge", outVerb: "Bridged" });
+}
+
+// src/provider.ts
+var EVM_PLACEHOLDER = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
+var DEFAULT_QUOTE_TTL_MS = 6e4;
+var QUOTE_TIMEOUT_MS = 2e4;
+var STATUS_TIMEOUT_MS = 12e3;
+var INTENT_PREFIX = "relay:";
+var REQUEST_ID = /^0x[0-9a-f]{64}$/;
+var MAX_BODY = 512 * 1024;
+var MAX_REMEMBERED = 256;
+var RELAY_STATUS_MAP = Object.freeze({
+  waiting: "pending",
+  depositing: "pending",
+  pending: "pending",
+  submitted: "pending",
+  delayed: "pending",
+  unknown: "pending",
+  success: "completed",
+  refund: "refunded",
+  refunded: "refunded",
+  failure: "refund-pending"
+});
+function clip(text2, max = 240) {
+  const t = (0, import_util2.redactUrls)(text2).replace(/\s+/g, " ").trim();
+  return t.length > max ? `${t.slice(0, max)}\u2026` : t;
+}
+function depositStep(body) {
+  const steps = body.steps;
+  if (!Array.isArray(steps) || steps.length === 0 || steps.length > 8) throw new RelayRefusal("quote-steps", "the quote has no steps");
+  let found = null;
+  for (const s of steps) {
+    if (s === null || typeof s !== "object") throw new RelayRefusal("quote-steps", "the quote has a malformed step");
+    if (s.id === "approve") continue;
+    if (s.id !== "deposit") throw new RelayRefusal("quote-steps", `the quote needs a "${clip(String(s.id), 40)}" step, only a single deposit is signed`);
+    if (found) throw new RelayRefusal("quote-steps", "the quote has more than one deposit step");
+    found = s;
+  }
+  if (!found) throw new RelayRefusal("quote-steps", "the quote has no deposit step");
+  const items = found.items;
+  if (!Array.isArray(items) || items.length !== 1) throw new RelayRefusal("quote-steps", "the deposit step is not a single transaction");
+  const data = items[0]?.data;
+  if (data === null || typeof data !== "object") throw new RelayRefusal("quote-steps", "the deposit step has no transaction");
+  const requestId = typeof found.requestId === "string" ? found.requestId.toLowerCase() : "";
+  if (!REQUEST_ID.test(requestId)) throw new RelayRefusal("quote-steps", "the quote has no request id to track the deposit by");
+  return { requestId, tx: data };
+}
+function relayProvider(config = {}) {
+  config = Object.freeze({ ...config });
+  const base = (config.baseUrl ?? RELAY_API).replace(/\/+$/, "");
+  if (!/^https?:\/\//.test(base)) throw new Error("relay: baseUrl must use http or https");
+  const quoteTtlMs = config.quoteTtlMs ?? DEFAULT_QUOTE_TTL_MS;
+  if (!Number.isInteger(quoteTtlMs) || quoteTtlMs <= 0 || quoteTtlMs > 3e5) throw new Error("relay: quoteTtlMs must be an integer between 1 and 300000");
+  if (config.apiKey !== void 0 && (typeof config.apiKey !== "string" || !/^[\x21-\x7e]{1,256}$/.test(config.apiKey))) throw new Error("relay: apiKey must be a printable string");
+  const doFetch = (input, init) => (config.fetchImpl ?? fetch)(input, init);
+  const headers = (json) => ({
+    accept: "application/json",
+    ...json ? { "content-type": "application/json" } : {},
+    ...config.apiKey ? { "x-api-key": config.apiKey } : {}
+  });
+  const issued = /* @__PURE__ */ new Map();
+  const remember = (m, k, v) => {
+    m.delete(k);
+    m.set(k, v);
+    if (m.size > MAX_REMEMBERED) m.delete(m.keys().next().value);
+  };
+  function requestOf(quote) {
+    const pd = quote.providerData ?? {};
+    const sealed = {
+      sourceChain: pd.sourceChain ?? "",
+      destChain: pd.destChain ?? "",
+      sourceToken: pd.sourceToken ?? "",
+      destToken: pd.destToken ?? "",
+      amount: /^[1-9]\d{0,77}$/.test(pd.amount ?? "") ? BigInt(pd.amount) : 0n,
+      depositor: pd.depositor ?? "",
+      recipient: pd.recipient ?? "",
+      .../^\d{1,78}$/.test(pd.minAmountOut ?? "") ? { minAmountOut: BigInt(pd.minAmountOut) } : {},
+      .../^\d{1,5}$/.test(pd.slippageBps ?? "") ? { slippageBps: Number(pd.slippageBps) } : {}
+    };
+    if (sealed.depositor.toLowerCase() === EVM_PLACEHOLDER.toLowerCase() || sealed.recipient.toLowerCase() === EVM_PLACEHOLDER.toLowerCase()) {
+      throw new RelayRefusal("request-invalid", "a quote priced without the real addresses is never built or signed \u2014 quote again with them");
+    }
+    const mine = issued.get(quote.intentId);
+    if (!mine) return sealed;
+    const same = mine.sourceChain === sealed.sourceChain && mine.destChain === sealed.destChain && mine.amount === sealed.amount && mine.sourceToken.toLowerCase() === sealed.sourceToken.toLowerCase() && mine.destToken.toLowerCase() === sealed.destToken.toLowerCase() && mine.depositor.toLowerCase() === sealed.depositor.toLowerCase() && mine.recipient.toLowerCase() === sealed.recipient.toLowerCase();
+    if (!same) throw new RelayRefusal("request-invalid", "the quote no longer says what was asked when it was issued \u2014 quote again");
+    return mine;
+  }
+  async function readJson(res) {
+    const text2 = await res.text();
+    if (text2.length > MAX_BODY) throw new Error("relay: response too large");
+    return JSON.parse(text2);
+  }
+  return {
+    name: "relay",
+    describeActivity: describeRelayActivity,
+    enabled: () => config.enabled ?? true,
+    supportsChain: (chain) => relay.supportsChain(chain),
+    supportsChainPair: (from, to) => relay.supports(from, to),
+    supportsRoute: (from, to) => relay.supports(from.chain, to.chain),
+    async getQuote(params, signal) {
+      const refuse = (reason) => {
+        params.onRefusal?.(reason);
+        return null;
+      };
+      const dry = params.dry !== false;
+      const placeholder = dry && (!params.destAddress || !params.refundAddress);
+      let request;
+      try {
+        request = relayRequestOf(params, dry ? { placeholder: EVM_PLACEHOLDER } : {});
+      } catch (err) {
+        if (err instanceof RelayRefusal) return refuse(err.message);
+        throw err;
+      }
+      const src = relayChain(request.sourceChain);
+      const dst = relayChain(request.destChain);
+      let body;
+      try {
+        const res = await doFetch(`${base}/quote/v2`, {
+          method: "POST",
+          headers: headers(true),
+          body: JSON.stringify({
+            user: request.depositor,
+            recipient: request.recipient,
+            refundTo: request.depositor,
+            originChainId: src.chainId,
+            destinationChainId: dst.chainId,
+            originCurrency: request.sourceToken.toLowerCase(),
+            destinationCurrency: request.destToken.toLowerCase(),
+            amount: request.amount.toString(10),
+            tradeType: "EXACT_INPUT",
+            includeProtocolData: true,
+            // Always named: Relay's "auto" would leave the distance between expected and minimum to the answering side.
+            slippageTolerance: String(request.slippageBps ?? RELAY_DEFAULT_SLIPPAGE_BPS)
+          }),
+          signal: signal ? (0, import_util2.anySignal)([signal, (0, import_util2.timeoutSignal)(QUOTE_TIMEOUT_MS)]) : (0, import_util2.timeoutSignal)(QUOTE_TIMEOUT_MS)
+        });
+        let parsed;
+        try {
+          parsed = await readJson(res);
+        } catch {
+          parsed = null;
+        }
+        if (!res.ok) {
+          const e = parsed ?? {};
+          const why = typeof e.message === "string" ? clip(e.message) : `HTTP ${res.status}`;
+          return refuse(`relay: no quote \u2014 ${typeof e.errorCode === "string" ? `${clip(e.errorCode, 60)}: ` : ""}${why}`);
+        }
+        if (parsed === null || typeof parsed !== "object") return refuse("relay: the quote response is not JSON");
+        body = parsed;
+      } catch (err) {
+        return refuse(`relay: quote request failed \u2014 ${clip(err instanceof Error ? err.message : String(err))}`);
+      }
+      try {
+        const step = depositStep(body);
+        const proto = body.protocol?.v2 ?? null;
+        const v = verifyRelayOrder(request, proto, step.tx);
+        const extra = (x) => x !== void 0 && x !== null && x !== "0" && x !== 0;
+        if (extra(body.fees?.app?.amount)) throw new RelayRefusal("app-fee", "the quote charges an app fee this module did not ask for");
+        if (extra(body.details?.currencyGasTopup?.amount)) throw new RelayRefusal("gas-topup", "the quote converts part of the output into a gas top-up this module did not ask for");
+        const native = v.deposit.approvalAddress === void 0;
+        const floor = native ? RELAY_GAS_FLOOR_NATIVE : RELAY_GAS_FLOOR_ERC20;
+        const apiGas = typeof step.tx.gas === "string" && /^[1-9]\d{0,9}$/.test(step.tx.gas) ? BigInt(step.tx.gas) * 2n : 0n;
+        const gasLimit = apiGas > RELAY_GAS_CAP ? RELAY_GAS_CAP : apiGas > floor ? apiGas : floor;
+        const relayer = body.fees?.relayer;
+        const usd = typeof relayer?.amountUsd === "string" && /^\d{1,12}(?:\.\d{1,18})?$/.test(relayer.amountUsd) ? parseFloat(relayer.amountUsd) : 0;
+        const feeToken = relayer?.currency?.address;
+        const fees = typeof relayer?.amount === "string" && /^[1-9]\d{0,77}$/.test(relayer.amount) && typeof feeToken === "string" && /^0x[0-9a-fA-F]{40}$/.test(feeToken) ? [{ type: "protocol", amount: relayer.amount, token: feeToken.toLowerCase(), included: true, description: "Relay fee" }] : [];
+        const eta = body.details?.timeEstimate;
+        const etaSeconds = typeof eta === "number" && Number.isFinite(eta) && eta > 0 ? Math.min(Math.ceil(eta), 86400) : 60;
+        const intentId = `${INTENT_PREFIX}${step.requestId}`;
+        if (!placeholder) remember(issued, intentId, request);
+        return {
+          provider: "relay",
+          intentId,
+          depositAddress: "",
+          depositMemo: null,
+          txRequest: {
+            to: v.deposit.to,
+            data: v.deposit.data,
+            value: v.deposit.value,
+            chainId: v.deposit.chainId,
+            gasLimit: gasLimit.toString(10),
+            ...v.deposit.approvalAddress ? { approvalAddress: v.deposit.approvalAddress } : {}
+          },
+          sourceAmount: request.amount.toString(10),
+          destAmount: v.expectedAmount.toString(10),
+          minDestAmount: v.minimumAmount.toString(10),
+          feeUsd: usd,
+          fees,
+          etaSeconds,
+          reliability: 0.97,
+          validUntilMs: Date.now() + quoteTtlMs,
+          providerData: {
+            requestId: step.requestId,
+            orderId: v.id,
+            hubType: "onchain",
+            // The order as received, re-read by the same parser before a build and before a signature.
+            orderData: JSON.stringify(proto.orderData),
+            orderSignature: String(proto.orderSignature).toLowerCase(),
+            paymentDetails: JSON.stringify(proto.paymentDetails),
+            sourceChain: request.sourceChain,
+            destChain: request.destChain,
+            sourceToken: request.sourceToken.toLowerCase(),
+            destToken: request.destToken.toLowerCase(),
+            amount: request.amount.toString(10),
+            depositor: request.depositor.toLowerCase(),
+            recipient: request.recipient.toLowerCase(),
+            ...request.minAmountOut !== void 0 ? { minAmountOut: request.minAmountOut.toString(10) } : {},
+            ...request.slippageBps !== void 0 ? { slippageBps: String(request.slippageBps) } : {},
+            ...placeholder ? { placeholder: "1" } : {}
+          }
+        };
+      } catch (err) {
+        if (err instanceof RelayRefusal) return refuse(err.message);
+        return refuse(`relay: unreadable quote \u2014 ${clip(err instanceof Error ? err.message : String(err))}`);
+      }
+    },
+    /** The quote's own transaction — after the order it carries has been verified once more. */
+    async buildDeposit(quote) {
+      const tx = quote.txRequest;
+      if (!tx || !quote.intentId.startsWith(INTENT_PREFIX)) throw new Error("swap2: Relay quote has no transaction request");
+      if (quote.providerData?.placeholder === "1") throw new RelayRefusal("request-invalid", "a quote priced without the real addresses is never built \u2014 quote again with them");
+      const request = requestOf(quote);
+      const v = checkRelayQuote(request, quote);
+      return {
+        chain: request.sourceChain,
+        to: v.deposit.to,
+        value: v.deposit.value,
+        data: v.deposit.data,
+        chainId: v.deposit.chainId,
+        ...tx.gasLimit ? { gasLimit: tx.gasLimit } : {},
+        ...v.deposit.approvalAddress ? { approvalAddress: v.deposit.approvalAddress } : {}
+      };
+    },
+    /**
+     * Right before signing: the whole verification again, against the request this instance issued the quote for
+     * and the exact transaction about to be signed — and each order is cleared for one deposit only.
+     */
+    async preflightDeposit(quote, tx) {
+      if (quote.providerData?.placeholder === "1") throw new RelayRefusal("request-invalid", "a quote priced without the real addresses is never signed");
+      const request = requestOf(quote);
+      if (tx.chain !== request.sourceChain) throw new RelayRefusal("tx-chain", `the deposit is for ${tx.chain}, not ${request.sourceChain}`);
+      if (tx.serializedTx !== void 0 || tx.memo !== void 0 || tx.typedData !== void 0 || tx.bodyBoc !== void 0) {
+        throw new RelayRefusal("quote-shape", "a Relay deposit is one EVM call");
+      }
+      const v = checkRelayQuote(request, quote, tx);
+      const store = config.clearedStore;
+      if (store && await store.has(v.id)) throw new RelayRefusal("order-reused", `order ${v.id} was already cleared for a deposit \u2014 quote again`);
+      relayClearOrder(v.id, "sign");
+      if (store) await store.add(v.id, v.order.output.deadline * 1e3);
+    },
+    async trackIntent(ref) {
+      if (typeof ref.intentId !== "string" || !ref.intentId.startsWith(INTENT_PREFIX)) return { state: "failed" };
+      const requestId = ref.intentId.slice(INTENT_PREFIX.length);
+      if (!REQUEST_ID.test(requestId)) return { state: "failed" };
+      if (!ref.sourceTxHash) return { state: "pending" };
+      try {
+        const res = await doFetch(`${base}/intents/status/v3?requestId=${requestId}`, { headers: headers(false), signal: (0, import_util2.timeoutSignal)(STATUS_TIMEOUT_MS) });
+        if (!res.ok) return { state: "pending" };
+        const s = await readJson(res);
+        const status = typeof s?.status === "string" ? s.status.toLowerCase() : "";
+        const state = Object.prototype.hasOwnProperty.call(RELAY_STATUS_MAP, status) ? RELAY_STATUS_MAP[status] : "pending";
+        const seen = status !== "waiting" && status !== "unknown" && status !== "";
+        if (state === "completed") {
+          const hashes = Array.isArray(s?.txHashes) ? s.txHashes.filter((h) => typeof h === "string" && /^0x[0-9a-fA-F]{64}$/.test(h)) : [];
+          const dest = hashes[hashes.length - 1] ?? ref.destTxHash ?? void 0;
+          return { state, depositReceived: true, ...dest ? { destTxHash: dest } : {} };
+        }
+        if (status === "failure") {
+          const why = typeof s?.refundFailReason === "string" ? s.refundFailReason.trim() : "";
+          return { state: why !== "" && why.toUpperCase() !== "N/A" ? "failed" : "refund-pending", depositReceived: true };
+        }
+        return { state, ...seen ? { depositReceived: true } : {} };
+      } catch {
+        return { state: "pending" };
+      }
+    }
+  };
+}
+
+// src/protocol.ts
+var import_single = require("@anywalletkit/protocol-swap2-core/swap2/single");
+var RelaySwap2Protocol = class extends import_single.SingleProviderSwap2 {
+  provider;
+  constructor(account, config) {
+    super(account, config);
+    this.provider = relayProvider(config);
+  }
+  chainSupported(caip2) {
+    return relay.supportsChain(caip2);
+  }
+  pairSupported(fromChain, toChain) {
+    return relay.supports(fromChain, toChain);
+  }
+};
+//# sourceMappingURL=index.cjs.map