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

package/dist/chunk-UVHDMGM5.js

@@ -0,0 +1,190 @@
+// src/order.ts
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { hashMessage, hashStruct, hexToBytes, keccak256 } from "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 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 = 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 = hexToBytes(hashMessage({ raw: id }));
+    const key = secp256k1.recoverPublicKey(recoverable, digest, { prehash: false });
+    if (!secp256k1.verify(sig.subarray(0, 64), digest, key, { prehash: false })) return null;
+    const uncompressed = secp256k1.Point.fromBytes(key).toBytes(false);
+    return `0x${keccak256(uncompressed.subarray(1)).slice(-40)}`.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+
+export {
+  RelayRefusal,
+  RELAY_ORDER_TYPES,
+  parseRelayOrder,
+  relayOrderId,
+  relayOrderSigner
+};
+//# sourceMappingURL=chunk-UVHDMGM5.js.map

package/dist/chunk-UVHDMGM5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/order.ts"],"sourcesContent":["/**\n * A Relay order, read strictly, hashed and attributed here.\n *\n *  - The order id is the EIP-712 `hashStruct` of the order under {@link RELAY_ORDER_TYPES} (no domain separator), as\n *    github.com/relayprotocol/relay-protocol-sdk (src/order/index.ts) computes it. Chain ids are STRINGS (Relay's own\n *    chain names), addresses and currencies are `bytes` (20 raw bytes on an EVM chain).\n *  - `orderSignature` is the solver's EIP-191 `personal_sign` over the 32 raw bytes of that id.\n *\n * The id a deposit names is a commitment to everything in the order — recipient, chain, token, minimum, refunds — so\n * recomputing it from the order the API hands over, and reading that same parsed order, is what binds the deposit\n * to terms the device has seen.\n */\nimport {secp256k1} from \"@noble/curves/secp256k1.js\";\nimport {hashMessage, hashStruct, hexToBytes, keccak256, type Hex} from \"viem\";\n\n/** Why an order, a quote or a deposit was refused. One code per check; the message says what was found. */\nexport type RelayRefusalCode =\n  | \"request-invalid\"\n  | \"chain-unsupported\"\n  | \"protocol-data-missing\"\n  | \"hub-type\"\n  | \"order-malformed\"\n  | \"order-version\"\n  | \"order-inputs\"\n  | \"order-payments\"\n  | \"order-calls\"\n  | \"order-fees\"\n  | \"solver-not-pinned\"\n  | \"input-chain\"\n  | \"input-currency\"\n  | \"input-amount\"\n  | \"input-weight\"\n  | \"output-chain\"\n  | \"output-recipient\"\n  | \"output-currency\"\n  | \"output-minimum\"\n  | \"output-expected\"\n  | \"output-deadline\"\n  | \"refund-missing\"\n  | \"refund-chain\"\n  | \"refund-recipient\"\n  | \"refund-currency\"\n  | \"refund-deadline\"\n  | \"order-id-mismatch\"\n  | \"signature-invalid\"\n  | \"payment-details\"\n  | \"tx-chain\"\n  | \"tx-target\"\n  | \"tx-selector\"\n  | \"tx-calldata\"\n  | \"tx-depositor\"\n  | \"tx-token\"\n  | \"tx-amount\"\n  | \"tx-id\"\n  | \"tx-value\"\n  | \"order-reused\"\n  | \"app-fee\"\n  | \"gas-topup\"\n  | \"quote-gas\"\n  | \"quote-expiry\"\n  | \"quote-steps\"\n  | \"quote-amounts\"\n  | \"quote-approval\"\n  | \"quote-shape\";\n\nexport class RelayRefusal extends Error {\n  readonly code: RelayRefusalCode;\n  constructor(code: RelayRefusalCode, detail: string) {\n    super(`relay: ${detail} [${code}]`);\n    this.name = \"RelayRefusal\";\n    this.code = code;\n  }\n}\n\nexport const RELAY_ORDER_TYPES = {\n  Order: [\n    {name: \"version\", type: \"string\"},\n    {name: \"solverChainId\", type: \"string\"},\n    {name: \"solver\", type: \"address\"},\n    {name: \"salt\", type: \"uint256\"},\n    {name: \"inputs\", type: \"Input[]\"},\n    {name: \"output\", type: \"Output\"},\n    {name: \"fees\", type: \"Fee[]\"},\n  ],\n  Input: [\n    {name: \"payment\", type: \"InputPayment\"},\n    {name: \"refunds\", type: \"InputRefund[]\"},\n  ],\n  InputPayment: [\n    {name: \"chainId\", type: \"string\"},\n    {name: \"currency\", type: \"bytes\"},\n    {name: \"amount\", type: \"uint256\"},\n    {name: \"weight\", type: \"uint256\"},\n  ],\n  InputRefund: [\n    {name: \"chainId\", type: \"string\"},\n    {name: \"recipient\", type: \"bytes\"},\n    {name: \"currency\", type: \"bytes\"},\n    {name: \"minimumAmount\", type: \"uint256\"},\n    {name: \"deadline\", type: \"uint32\"},\n    {name: \"extraData\", type: \"bytes\"},\n  ],\n  Output: [\n    {name: \"chainId\", type: \"string\"},\n    {name: \"payments\", type: \"OutputPayment[]\"},\n    {name: \"deadline\", type: \"uint32\"},\n    {name: \"calls\", type: \"bytes[]\"},\n    {name: \"extraData\", type: \"bytes\"},\n  ],\n  OutputPayment: [\n    {name: \"recipient\", type: \"bytes\"},\n    {name: \"currency\", type: \"bytes\"},\n    {name: \"minimumAmount\", type: \"uint256\"},\n    {name: \"expectedAmount\", type: \"uint256\"},\n  ],\n  Fee: [\n    {name: \"recipientChainId\", type: \"string\"},\n    {name: \"recipient\", type: \"bytes\"},\n    {name: \"currencyChainId\", type: \"string\"},\n    {name: \"currency\", type: \"bytes\"},\n    {name: \"amount\", type: \"uint256\"},\n  ],\n} as const;\n\nexport interface RelayInputRefund {chainId: string; recipient: Hex; currency: Hex; minimumAmount: bigint; deadline: number; extraData: Hex}\nexport interface RelayInput {payment: {chainId: string; currency: Hex; amount: bigint; weight: bigint}; refunds: RelayInputRefund[]}\nexport interface RelayOutputPayment {recipient: Hex; currency: Hex; minimumAmount: bigint; expectedAmount: bigint}\nexport interface RelayFee {recipientChainId: string; recipient: Hex; currencyChainId: string; currency: Hex; amount: bigint}\n/** An order after {@link parseRelayOrder}: hex lowercased, integers exact. Every field below is hashed into the id. */\nexport interface RelayOrder {\n  version: string;\n  solverChainId: string;\n  solver: Hex;\n  salt: bigint;\n  inputs: RelayInput[];\n  output: {chainId: string; payments: RelayOutputPayment[]; deadline: number; calls: Hex[]; extraData: Hex};\n  fees: RelayFee[];\n}\n\nconst MAX_LIST = 8;\nconst MAX_BYTES_HEX = 2 + 2 * 1024;\nconst MAX_TEXT = 64;\nconst U256_MAX = (1n << 256n) - 1n;\n\nconst bad = (what: string): never => { throw new RelayRefusal(\"order-malformed\", `the order's ${what}`); };\n\nfunction rec(v: unknown, what: string): Record<string, unknown> {\n  if (v === null || typeof v !== \"object\" || Array.isArray(v)) bad(`${what} is not an object`);\n  return v as Record<string, unknown>;\n}\nfunction list(v: unknown, what: string): unknown[] {\n  if (!Array.isArray(v)) bad(`${what} is not a list`);\n  if ((v as unknown[]).length > MAX_LIST) bad(`${what} has more than ${MAX_LIST} entries`);\n  return v as unknown[];\n}\n/** Own property only: a field missing from the JSON is never read off a prototype. */\nfunction own(o: Record<string, unknown>, key: string): unknown {\n  return Object.prototype.hasOwnProperty.call(o, key) ? o[key] : undefined;\n}\nfunction text(v: unknown, what: string): string {\n  if (typeof v !== \"string\" || v.length === 0 || v.length > MAX_TEXT) bad(`${what} is not a short string`);\n  return v as string;\n}\n/** `bytes`: 0x-hex of whole bytes, lowercased. */\nfunction bytes(v: unknown, what: string): Hex {\n  if (typeof v !== \"string\" || v.length > MAX_BYTES_HEX || !/^0x(?:[0-9a-fA-F]{2})*$/.test(v)) bad(`${what} is not hex bytes`);\n  return (v as string).toLowerCase() as Hex;\n}\n/** `uint256`: a decimal string, a 0x-hex string (Relay writes the salt that way) or a safe non-negative integer. */\nfunction uint(v: unknown, what: string, max: bigint = U256_MAX): bigint {\n  let n: bigint | null = null;\n  if (typeof v === \"string\" && (/^(?:0|[1-9]\\d{0,77})$/.test(v) || /^0x[0-9a-fA-F]{1,64}$/.test(v))) n = BigInt(v);\n  else if (typeof v === \"number\" && Number.isSafeInteger(v) && v >= 0) n = BigInt(v);\n  if (n === null || n > max) bad(`${what} is not an unsigned integer in range`);\n  return n as bigint;\n}\nfunction uint32(v: unknown, what: string): number {\n  // Below 2^32, so the conversion is exact.\n  return parseInt(uint(v, what, 0xffff_ffffn).toString(10), 10);\n}\nfunction address(v: unknown, what: string): Hex {\n  if (typeof v !== \"string\" || !/^0x[0-9a-fA-F]{40}$/.test(v)) bad(`${what} is not an address`);\n  return (v as string).toLowerCase() as Hex;\n}\n\n/**\n * Read an order as the API gives it (`protocol.v2.orderData`, already JSON-parsed) into the one typed form the id,\n * the signature and every check are computed from. Anything that is not exactly the documented shape is refused\n * (`order-malformed`); keys the type does not have are ignored — they are outside the hash, and nothing reads them.\n */\nexport function parseRelayOrder(raw: unknown): RelayOrder {\n  const o = rec(raw, \"body\");\n  const output = rec(own(o, \"output\"), \"output\");\n  return {\n    version: text(own(o, \"version\"), \"version\"),\n    solverChainId: text(own(o, \"solverChainId\"), \"solver chain\"),\n    solver: address(own(o, \"solver\"), \"solver\"),\n    salt: uint(own(o, \"salt\"), \"salt\"),\n    inputs: list(own(o, \"inputs\"), \"inputs\").map((x, i) => {\n      const input = rec(x, `input ${i}`);\n      const p = rec(own(input, \"payment\"), `input ${i} payment`);\n      return {\n        payment: {\n          chainId: text(own(p, \"chainId\"), `input ${i} chain`),\n          currency: bytes(own(p, \"currency\"), `input ${i} currency`),\n          amount: uint(own(p, \"amount\"), `input ${i} amount`),\n          weight: uint(own(p, \"weight\"), `input ${i} weight`),\n        },\n        refunds: list(own(input, \"refunds\"), `input ${i} refunds`).map((y, j) => {\n          const r = rec(y, `refund ${j}`);\n          return {\n            chainId: text(own(r, \"chainId\"), `refund ${j} chain`),\n            recipient: bytes(own(r, \"recipient\"), `refund ${j} recipient`),\n            currency: bytes(own(r, \"currency\"), `refund ${j} currency`),\n            minimumAmount: uint(own(r, \"minimumAmount\"), `refund ${j} minimum`),\n            deadline: uint32(own(r, \"deadline\"), `refund ${j} deadline`),\n            extraData: bytes(own(r, \"extraData\"), `refund ${j} extra data`),\n          };\n        }),\n      };\n    }),\n    output: {\n      chainId: text(own(output, \"chainId\"), \"output chain\"),\n      payments: list(own(output, \"payments\"), \"output payments\").map((x, i) => {\n        const p = rec(x, `output payment ${i}`);\n        return {\n          recipient: bytes(own(p, \"recipient\"), `output payment ${i} recipient`),\n          currency: bytes(own(p, \"currency\"), `output payment ${i} currency`),\n          minimumAmount: uint(own(p, \"minimumAmount\"), `output payment ${i} minimum`),\n          expectedAmount: uint(own(p, \"expectedAmount\"), `output payment ${i} expected amount`),\n        };\n      }),\n      deadline: uint32(own(output, \"deadline\"), \"output deadline\"),\n      calls: list(own(output, \"calls\"), \"output calls\").map((x, i) => bytes(x, `output call ${i}`)),\n      extraData: bytes(own(output, \"extraData\"), \"output extra data\"),\n    },\n    fees: list(own(o, \"fees\"), \"fees\").map((x, i) => {\n      const f = rec(x, `fee ${i}`);\n      return {\n        recipientChainId: text(own(f, \"recipientChainId\"), `fee ${i} recipient chain`),\n        recipient: bytes(own(f, \"recipient\"), `fee ${i} recipient`),\n        currencyChainId: text(own(f, \"currencyChainId\"), `fee ${i} currency chain`),\n        currency: bytes(own(f, \"currency\"), `fee ${i} currency`),\n        amount: uint(own(f, \"amount\"), `fee ${i} amount`),\n      };\n    }),\n  };\n}\n\n/** The order id: `hashStruct(Order)`, no domain. */\nexport function relayOrderId(order: RelayOrder): Hex {\n  return hashStruct({types: RELAY_ORDER_TYPES, primaryType: \"Order\", data: order as never});\n}\n\n/**\n * The address whose `personal_sign` over the id's 32 bytes this signature is (lowercase), or null when it is not a\n * 65-byte secp256k1 signature that recovers at all. Synchronous on purpose: the same check runs wherever the order\n * is read, with nothing left for a later asynchronous step.\n */\nexport function relayOrderSigner(id: Hex, signature: unknown): Hex | null {\n  if (typeof signature !== \"string\" || !/^0x[0-9a-fA-F]{130}$/.test(signature)) return null;\n  const sig = hexToBytes(signature as Hex);\n  const v = sig[64]!;\n  const recovery = v === 27 || v === 28 ? v - 27 : v === 0 || v === 1 ? v : -1;\n  if (recovery < 0) return null;\n  try {\n    const recoverable = new Uint8Array(65);\n    recoverable[0] = recovery;\n    recoverable.set(sig.subarray(0, 64), 1);\n    const digest = hexToBytes(hashMessage({raw: id}));\n    const key = secp256k1.recoverPublicKey(recoverable, digest, {prehash: false});\n    // The recovery must also verify: a malformed (r, s) never passes as a signer.\n    if (!secp256k1.verify(sig.subarray(0, 64), digest, key, {prehash: false})) return null;\n    const uncompressed = secp256k1.Point.fromBytes(key).toBytes(false);\n    return `0x${keccak256(uncompressed.subarray(1)).slice(-40)}`.toLowerCase() as Hex;\n  } catch {\n    return null;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-WRIKAUWI.js

@@ -0,0 +1,384 @@
+import {
+  RelayRefusal,
+  parseRelayOrder,
+  relayOrderId,
+  relayOrderSigner
+} from "./chunk-UVHDMGM5.js";
+import {
+  RELAY_CLOCK_SKEW_S,
+  RELAY_DEPOSIT_ERC20,
+  RELAY_DEPOSIT_ERC20_ALLOWANCE,
+  RELAY_DEPOSIT_NATIVE,
+  RELAY_MAX_ORDER_AGE_S,
+  RELAY_NATIVE,
+  RELAY_ORDER_LIFETIME_S,
+  RELAY_ORDER_VERSION,
+  RELAY_SOLVERS,
+  relayChain
+} from "./chunk-JQAN7HB5.js";
+
+// src/verify.ts
+import { encodeFunctionData, parseAbi } from "viem";
+import { sourceAssetOf } from "@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 = 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_MAX = (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_MAX) 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: encodeFunctionData({ abi: DEPOSITORY_ABI, functionName: "depositNative", args: [lower(depositor), id] }),
+      value: amount.toString(10),
+      chainId: source.chainId
+    };
+  }
+  return {
+    to: source.depository,
+    data: 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_MAX) 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 = (bytes, addr) => bytes.length === 42 && bytes === 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 = 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 c = relayChain(chain);
+    return c ? [c.depository] : [];
+  },
+  spenders: (chain) => {
+    const c = relayChain(chain);
+    return c ? [c.depository] : [];
+  },
+  verifyQuote: relayVerifyQuote,
+  verifyBuild: relayVerifyBuild
+});
+
+export {
+  relayClearOrder,
+  RELAY_MAX_SLIPPAGE_BPS,
+  RELAY_DEFAULT_SLIPPAGE_BPS,
+  RELAY_GAS_FLOOR_NATIVE,
+  RELAY_GAS_FLOOR_ERC20,
+  RELAY_GAS_CAP,
+  RELAY_MAX_QUOTE_LIFE_MS,
+  buildRelayDeposit,
+  verifyRelayOrder,
+  relayRefusalReason,
+  relayRequestOf,
+  relayProtocolOf,
+  checkRelayQuote,
+  relayVerifyQuote,
+  relayVerifyBuild,
+  relayPins
+};
+//# sourceMappingURL=chunk-WRIKAUWI.js.map