@recoilpay/intent-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1160 @@
+"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 index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  CHAIN_ALIASES: () => CHAIN_ALIASES,
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  DEFAULT_INTENT_MODEL: () => DEFAULT_INTENT_MODEL,
+  EMPTY_SUPPORTED: () => EMPTY_SUPPORTED,
+  HF_ROUTER_URL: () => HF_ROUTER_URL,
+  MAX_UINT256: () => MAX_UINT256,
+  PERMIT2_ADDRESS: () => PERMIT2_ADDRESS,
+  SOLANA_CHAIN_IDS: () => SOLANA_CHAIN_IDS,
+  TEMPLATE_HINT: () => TEMPLATE_HINT,
+  TOKEN_ALIASES: () => TOKEN_ALIASES,
+  buildOrderRequest: () => buildOrderRequest,
+  buildPermit2ApproveRequest: () => buildPermit2ApproveRequest,
+  buildQuoteRequest: () => buildQuoteRequest,
+  buildSupportedSet: () => buildSupportedSet,
+  chainName: () => chainName,
+  createApiClient: () => createApiClient,
+  createIntentSession: () => createIntentSession,
+  explorerUrl: () => explorerUrl,
+  extractIntents: () => extractIntents,
+  findAsset: () => findAsset,
+  getPermit2Allowance: () => getPermit2Allowance,
+  hasPermit2Allowance: () => hasPermit2Allowance,
+  interopAddress: () => interopAddress,
+  isTerminalStatus: () => isTerminalStatus,
+  normalizeChain: () => normalizeChain,
+  normalizeToken: () => normalizeToken,
+  parseIntent: () => parseIntent,
+  resolveIntent: () => resolveIntent,
+  rpcReaders: () => rpcReaders,
+  signQuote: () => signQuote,
+  stripDomainType: () => stripDomainType,
+  validateIntent: () => validateIntent,
+  viemWallet: () => viemWallet
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/session.ts
+var import_viem4 = require("viem");
+
+// src/api.ts
+var DEFAULT_API_URL = "https://api.recoilpay.com";
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiError";
+  }
+  status;
+  code;
+};
+function createApiClient(options = {}) {
+  const base = `${(options.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "")}/api/v1`;
+  const doFetch = options.fetch ?? ((...args) => fetch(...args));
+  async function request(path, init) {
+    const res = await doFetch(`${base}${path}`, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        ...init?.body ? { "Content-Type": "application/json" } : {},
+        ...init?.headers
+      }
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => null);
+      throw new ApiError(res.status, body?.error ?? "HTTP_ERROR", body?.message ?? `${path} \u2192 ${res.status} ${res.statusText}`);
+    }
+    return await res.json();
+  }
+  const post = (path, body) => request(path, { method: "POST", body: JSON.stringify(body) });
+  return {
+    /** The fetch this client uses (shared with the session's parser). */
+    fetch: doFetch,
+    /** Supported chains with RPC endpoints and settlement contracts. */
+    async getChains() {
+      return (await request("/chains")).data;
+    },
+    getSolvers: () => request("/solvers"),
+    /**
+     * Every asset an active solver can fill, de-duplicated — the set that
+     * decides whether an intent is executable right now.
+     */
+    async getSupportedAssets() {
+      const { solvers } = await request("/solvers");
+      const seen = /* @__PURE__ */ new Map();
+      for (const solver of solvers) {
+        if (solver.status !== "active") continue;
+        for (const asset of solver.supportedAssets.assets ?? []) {
+          const key = `${asset.chainId}:${asset.address.toLowerCase()}`;
+          if (!seen.has(key)) seen.set(key, { ...asset, address: asset.address.toLowerCase() });
+        }
+      }
+      return [...seen.values()];
+    },
+    getQuotes: (req) => post("/quotes", req),
+    submitOrder: (req) => post("/orders", req),
+    getOrder: (id) => request(`/orders/${encodeURIComponent(id)}`)
+  };
+}
+
+// src/parse.ts
+var TEMPLATE_HINT = "Try: swap <amount> <token> on <chain> for <token> on <chain> [to <address>] (e.g. swap 10 USDC on Base for ETH on Arbitrum) OR send <amount> <token> on <chain> to <address>";
+var HF_ROUTER_URL = "https://router.huggingface.co/v1/chat/completions";
+var DEFAULT_INTENT_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct";
+var SYSTEM_PROMPT = `You are an intent extraction engine for a cross-chain swap protocol.
+Your job is to parse the user's natural language request into a strict JSON array of objects representing their intents.
+If the user specifies multiple intents (e.g. "swap X and then send Y"), return multiple objects in the array.
+The JSON objects must perfectly match the following TypeScript interface:
+
+type AmountKind = "token" | "usd";
+type IntentAction = "swap" | "send";
+
+interface RawIntent {
+  action: IntentAction;
+  amount: string | null;          // numeric string, no leading '$'. e.g. "100" (null if not stated)
+  amountKind: AmountKind;         // "usd" if they mention dollars/bucks, "token" otherwise
+  tokenIn: string | null;         // raw token symbol/alias as typed, e.g. "USDC"
+  chainIn: string | null;         // raw chain alias as typed, e.g. "Base"
+  tokenOut: string | null;        // target token (optional for send)
+  chainOut: string | null;        // target chain (optional for send)
+  recipient: string | null;       // address/ens (required for 'send', optional for 'swap')
+}
+
+Return ONLY the JSON array, nothing else. If you absolutely cannot determine any intents, return {"error": "unrecognized"}. Do not make up information that is missing; use null.`;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var readString = (v) => typeof v === "string" && v.trim().length > 0 ? v : null;
+var readAmount = (v) => v === null || v === void 0 ? null : String(v);
+var readAmountKind = (v) => v === "usd" ? "usd" : "token";
+var readAction = (v) => v === "swap" || v === "send" ? v : null;
+var offTemplate = (message = TEMPLATE_HINT) => ({ ok: false, offTemplate: true, message });
+function extractIntents(content) {
+  let json = content.trim();
+  const fenced = json.match(/```json\n([\s\S]*?)\n```/) || json.match(/```\n([\s\S]*?)\n```/);
+  if (fenced) {
+    json = fenced[1];
+  } else {
+    const first = Math.min(...["{", "["].map((c) => json.indexOf(c) === -1 ? Infinity : json.indexOf(c)));
+    const last = Math.max(json.lastIndexOf("}"), json.lastIndexOf("]"));
+    if (first !== Infinity && last !== -1) json = json.slice(first, last + 1);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return offTemplate();
+  }
+  if (isRecord(parsed) && parsed.error || !Array.isArray(parsed) && !isRecord(parsed)) return offTemplate();
+  const items = Array.isArray(parsed) ? parsed : [parsed];
+  if (items.length === 0 || !items.every(isRecord)) return offTemplate();
+  const intents = [];
+  for (const item of items) {
+    const action = readAction(item.action);
+    if (!action) return offTemplate();
+    intents.push({
+      action,
+      amount: readAmount(item.amount),
+      amountKind: readAmountKind(item.amountKind),
+      tokenIn: readString(item.tokenIn),
+      chainIn: readString(item.chainIn),
+      tokenOut: readString(item.tokenOut),
+      chainOut: readString(item.chainOut),
+      recipient: readString(item.recipient)
+    });
+  }
+  return { ok: true, intents };
+}
+async function parseIntent(text, options = {}) {
+  const norm = text.trim();
+  if (!norm) return offTemplate();
+  const token = options.hfAccessToken?.trim();
+  if (!token) return offTemplate(`Natural-language parsing isn't set up here. ${TEMPLATE_HINT}`);
+  const doFetch = options.fetch ?? ((...args) => fetch(...args));
+  let res;
+  try {
+    res = await doFetch(HF_ROUTER_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: options.model ?? DEFAULT_INTENT_MODEL,
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: norm }
+        ],
+        max_tokens: 250,
+        temperature: 0.1
+      })
+    });
+  } catch {
+    return offTemplate(`Could not reach the intent parser. Check your connection and try again.`);
+  }
+  if (!res.ok) {
+    if (res.status === 429) return offTemplate("Too many requests \u2014 wait a moment and try again.");
+    return offTemplate(`Failed to understand that. ${TEMPLATE_HINT}`);
+  }
+  const body = await res.json().catch(() => null);
+  return extractIntents(body?.choices?.[0]?.message?.content ?? "");
+}
+
+// src/chains.ts
+var import_viem = require("viem");
+var import_actions = require("viem/actions");
+var CHAIN_NAMES = {
+  1: "Ethereum",
+  10: "Optimism",
+  137: "Polygon",
+  8453: "Base",
+  42161: "Arbitrum",
+  56: "BNB Chain",
+  43114: "Avalanche",
+  11155111: "Ethereum Sepolia",
+  84532: "Base Sepolia",
+  11155420: "OP Sepolia",
+  421614: "Arbitrum Sepolia",
+  80002: "Polygon Amoy",
+  9000000001: "Solana",
+  9000000002: "Solana Devnet"
+};
+var EXPLORERS = {
+  1: "https://etherscan.io",
+  10: "https://optimistic.etherscan.io",
+  137: "https://polygonscan.com",
+  8453: "https://basescan.org",
+  42161: "https://arbiscan.io",
+  56: "https://bscscan.com",
+  43114: "https://snowtrace.io",
+  11155111: "https://sepolia.etherscan.io",
+  84532: "https://sepolia.basescan.org",
+  11155420: "https://sepolia-optimism.etherscan.io",
+  421614: "https://sepolia.arbiscan.io",
+  80002: "https://amoy.polygonscan.com"
+};
+var SOLANA_CHAIN_IDS = /* @__PURE__ */ new Set([9000000001, 9000000002]);
+function chainName(chainId, info) {
+  return CHAIN_NAMES[chainId] ?? info?.name ?? `Chain ${chainId}`;
+}
+function explorerUrl(chainId) {
+  return EXPLORERS[chainId];
+}
+function rpcReaders(chains) {
+  const cache = /* @__PURE__ */ new Map();
+  return async (chainId) => {
+    const hit = cache.get(chainId);
+    if (hit) return hit;
+    const info = (await chains()).find((c) => c.chain_id === chainId);
+    if (!info?.rpc_url) return null;
+    const client = (0, import_viem.createClient)({ transport: (0, import_viem.http)(info.rpc_url) });
+    const reader = {
+      readContract: (args) => (0, import_actions.readContract)(client, args),
+      waitForTransactionReceipt: (args) => (0, import_actions.waitForTransactionReceipt)(client, args)
+    };
+    cache.set(chainId, reader);
+    return reader;
+  };
+}
+
+// src/intent/registry.ts
+var TOKEN_ALIASES = {
+  usdc: "USDC",
+  usdt: "USDT",
+  tether: "USDT",
+  dai: "DAI",
+  eth: "ETH",
+  ether: "ETH",
+  ethereum: "ETH",
+  weth: "WETH",
+  wbtc: "WBTC",
+  btc: "WBTC",
+  bitcoin: "WBTC",
+  sol: "SOL",
+  solana: "SOL",
+  arb: "ARB",
+  arbitrum: "ARB",
+  op: "OP",
+  optimism: "OP",
+  matic: "MATIC",
+  pol: "MATIC",
+  polygon: "MATIC"
+};
+var CHAIN_ALIASES = {
+  ethereum: { id: 1, name: "Ethereum" },
+  eth: { id: 1, name: "Ethereum" },
+  mainnet: { id: 1, name: "Ethereum" },
+  base: { id: 8453, name: "Base" },
+  arbitrum: { id: 42161, name: "Arbitrum" },
+  arb: { id: 42161, name: "Arbitrum" },
+  optimism: { id: 10, name: "Optimism" },
+  op: { id: 10, name: "Optimism" },
+  polygon: { id: 137, name: "Polygon" },
+  matic: { id: 137, name: "Polygon" },
+  solana: { id: 9000000002, name: "Solana Devnet" },
+  "sol network": { id: 9000000002, name: "Solana Devnet" },
+  // testnets — the solver settles across these five
+  "base sepolia": { id: 84532, name: "Base Sepolia" },
+  "op sepolia": { id: 11155420, name: "OP Sepolia" },
+  "optimism sepolia": { id: 11155420, name: "OP Sepolia" },
+  "arbitrum sepolia": { id: 421614, name: "Arbitrum Sepolia" },
+  "arb sepolia": { id: 421614, name: "Arbitrum Sepolia" },
+  "ethereum sepolia": { id: 11155111, name: "Ethereum Sepolia" },
+  "eth sepolia": { id: 11155111, name: "Ethereum Sepolia" },
+  sepolia: { id: 11155111, name: "Ethereum Sepolia" },
+  "polygon amoy": { id: 80002, name: "Polygon Amoy" },
+  amoy: { id: 80002, name: "Polygon Amoy" }
+};
+function normalizeToken(raw) {
+  if (!raw) return null;
+  return TOKEN_ALIASES[raw.trim().toLowerCase()] ?? null;
+}
+function normalizeChain(raw) {
+  if (!raw) return null;
+  return CHAIN_ALIASES[raw.trim().toLowerCase()] ?? null;
+}
+var EMPTY_SUPPORTED = { chains: /* @__PURE__ */ new Set(), assets: /* @__PURE__ */ new Map() };
+function buildSupportedSet(assets) {
+  const chains = /* @__PURE__ */ new Set();
+  const map = /* @__PURE__ */ new Map();
+  for (const a of assets) {
+    chains.add(a.chainId);
+    map.set(`${a.chainId}:${a.symbol.toUpperCase()}`, a);
+  }
+  return { chains, assets: map };
+}
+function findAsset(set, chainId, symbol) {
+  return set.assets.get(`${chainId}:${symbol.toUpperCase()}`);
+}
+
+// src/intent/resolve.ts
+var import_viem2 = require("viem");
+function resolveIntent(raw, supported, user, solanaUser) {
+  const chainIn = normalizeChain(raw.chainIn);
+  const symIn = normalizeToken(raw.tokenIn);
+  if (!chainIn || typeof chainIn.id !== "number" || !symIn || !raw.amount) {
+    throw new Error("resolveIntent called on an unvalidated/invalid intent");
+  }
+  const srcChainId = chainIn.id;
+  const inAsset = findAsset(supported, srcChainId, symIn);
+  if (!inAsset) throw new Error(`No supported asset for ${symIn} on ${chainIn.name}`);
+  const inputToken = isSolana(srcChainId) ? inAsset.address : (0, import_viem2.getAddress)(inAsset.address);
+  const inputAmount = (0, import_viem2.parseUnits)(raw.amount, inAsset.decimals);
+  let dstChainId;
+  let outputToken;
+  let recipient;
+  if (raw.action === "swap") {
+    const chainOut = normalizeChain(raw.chainOut);
+    const symOut = normalizeToken(raw.tokenOut);
+    if (!chainOut || typeof chainOut.id !== "number" || !symOut) {
+      throw new Error("resolveIntent: unresolved destination on a swap");
+    }
+    dstChainId = chainOut.id;
+    const outAsset = findAsset(supported, dstChainId, symOut);
+    if (!outAsset) throw new Error(`No supported asset for ${symOut} on ${chainOut.name}`);
+    outputToken = isSolana(dstChainId) ? outAsset.address : (0, import_viem2.getAddress)(outAsset.address);
+    recipient = raw.recipient ? isSolana(dstChainId) ? raw.recipient : (0, import_viem2.getAddress)(raw.recipient) : isSolana(dstChainId) ? solanaUser ?? user : user;
+  } else {
+    if (!raw.recipient) throw new Error("resolveIntent: send without recipient");
+    if (raw.chainOut) {
+      const chainOut = normalizeChain(raw.chainOut);
+      if (!chainOut || typeof chainOut.id !== "number") {
+        throw new Error("resolveIntent: unresolved destination chain on a send");
+      }
+      dstChainId = chainOut.id;
+    } else {
+      dstChainId = srcChainId;
+    }
+    if (raw.tokenOut) {
+      const symOut = normalizeToken(raw.tokenOut);
+      if (!symOut) throw new Error("resolveIntent: unresolved destination token on a send");
+      const outAsset = findAsset(supported, dstChainId, symOut);
+      if (!outAsset) throw new Error(`No supported asset for ${symOut} on destination chain`);
+      outputToken = isSolana(dstChainId) ? outAsset.address : (0, import_viem2.getAddress)(outAsset.address);
+    } else {
+      if (dstChainId !== srcChainId) {
+        const outAsset = findAsset(supported, dstChainId, symIn);
+        if (!outAsset) throw new Error(`No supported asset for ${symIn} on destination chain`);
+        outputToken = isSolana(dstChainId) ? outAsset.address : (0, import_viem2.getAddress)(outAsset.address);
+      } else {
+        outputToken = inputToken;
+      }
+    }
+    recipient = isSolana(dstChainId) ? raw.recipient : (0, import_viem2.getAddress)(raw.recipient);
+  }
+  return {
+    action: raw.action,
+    user,
+    srcChainId,
+    dstChainId,
+    inputToken,
+    inputDecimals: inAsset.decimals,
+    inputAmount,
+    outputToken,
+    recipient
+  };
+}
+function isSolana(chainId) {
+  return chainId === 9000000001 || chainId === 9000000002;
+}
+
+// src/intent/validate.ts
+var LABEL = {
+  amount: "Amount",
+  tokenIn: "Source token",
+  chainIn: "Source chain",
+  tokenOut: "Destination token",
+  chainOut: "Destination chain",
+  recipient: "Recipient"
+};
+var EVM_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+var SOLANA_ADDRESS_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+function checkChain(field, raw, supported, issues) {
+  if (!raw) {
+    issues.push({ field, kind: "missing", message: `${LABEL[field]} is not stated.` });
+    return null;
+  }
+  const c = normalizeChain(raw);
+  if (!c) {
+    issues.push({ field, kind: "unknown", message: `Chain '${raw}' isn't recognized.` });
+    return null;
+  }
+  if (typeof c.id !== "number" || !supported.chains.has(c.id)) {
+    issues.push({ field, kind: "unsupported", message: `${c.name} isn't supported yet.` });
+    return null;
+  }
+  return c;
+}
+function checkToken(field, raw, chain, supported, issues) {
+  if (!raw) {
+    issues.push({ field, kind: "missing", message: `${LABEL[field]} is not stated.` });
+    return;
+  }
+  const sym = normalizeToken(raw);
+  if (!sym) {
+    issues.push({ field, kind: "unknown", message: `Token '${raw}' isn't recognized.` });
+    return;
+  }
+  if (chain && typeof chain.id === "number") {
+    if (!findAsset(supported, chain.id, sym)) {
+      issues.push({
+        field,
+        kind: "unsupported",
+        message: `${sym} isn't supported on ${chain.name} yet.`
+      });
+    }
+  }
+}
+function checkRecipient(raw, chainOutId, issues) {
+  if (!raw) {
+    issues.push({ field: "recipient", kind: "missing", message: "Recipient is not stated." });
+    return;
+  }
+  if (chainOutId === 9000000001 || chainOutId === 9000000002) {
+    if (SOLANA_ADDRESS_RE.test(raw)) return;
+    issues.push({
+      field: "recipient",
+      kind: "unknown",
+      message: `Recipient '${raw}' isn\u2019t a valid Solana address.`
+    });
+    return;
+  }
+  if (EVM_ADDRESS_RE.test(raw)) return;
+  if (raw.endsWith(".eth")) {
+    issues.push({
+      field: "recipient",
+      kind: "unsupported",
+      message: "ENS recipients aren\u2019t supported yet \u2014 use a 0x address."
+    });
+    return;
+  }
+  issues.push({
+    field: "recipient",
+    kind: "unknown",
+    message: `Recipient '${raw}' isn\u2019t a valid 0x address.`
+  });
+}
+function validateIntent(raw, supported) {
+  const issues = [];
+  if (!raw.amount) {
+    issues.push({ field: "amount", kind: "missing", message: "Amount is not stated." });
+  } else if (!(Number(raw.amount) > 0)) {
+    issues.push({ field: "amount", kind: "unknown", message: "Amount must be a positive number." });
+  }
+  const chainIn = checkChain("chainIn", raw.chainIn, supported, issues);
+  checkToken("tokenIn", raw.tokenIn, chainIn, supported, issues);
+  if (raw.action === "swap") {
+    const chainOut = checkChain("chainOut", raw.chainOut, supported, issues);
+    checkToken("tokenOut", raw.tokenOut, chainOut, supported, issues);
+    if (raw.recipient) {
+      checkRecipient(raw.recipient, chainOut?.id, issues);
+    }
+  } else {
+    let chainOut = chainIn;
+    if (raw.chainOut) {
+      chainOut = checkChain("chainOut", raw.chainOut, supported, issues);
+    }
+    checkRecipient(raw.recipient, chainOut?.id, issues);
+    if (raw.tokenOut) {
+      checkToken("tokenOut", raw.tokenOut, chainOut, supported, issues);
+    } else if (chainOut && chainOut.id !== chainIn?.id) {
+      checkToken("tokenOut", raw.tokenIn, chainOut, supported, issues);
+    }
+  }
+  return issues;
+}
+
+// src/oif/interop.ts
+function hexToBytes(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = [];
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes.push(parseInt(cleanHex.slice(i, i + 2), 16));
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return "0x" + bytes.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function chainIdToBytes(chainId) {
+  const bytes = [];
+  let value = chainId;
+  while (value > 0) {
+    bytes.unshift(value & 255);
+    value >>= 8;
+  }
+  if (bytes.length === 0) bytes.push(0);
+  return bytes;
+}
+function toInteropAddress(address, chainId) {
+  const version = "0001";
+  const chainType = "0000";
+  const chainRefBytes = chainIdToBytes(chainId);
+  const chainRefHex = bytesToHex(chainRefBytes).slice(2);
+  const chainRefLength = chainRefBytes.length.toString(16).padStart(2, "0");
+  const addressBytes = hexToBytes(address);
+  const addressHex = bytesToHex(addressBytes).slice(2);
+  const addressLength = addressBytes.length.toString(16).padStart(2, "0");
+  return `0x${version}${chainType}${chainRefLength}${chainRefHex}${addressLength}${addressHex}`;
+}
+function interopAddress(chainId, address) {
+  return toInteropAddress(address, chainId);
+}
+
+// src/oif/buildQuoteRequest.ts
+function buildQuoteRequest(resolved) {
+  const {
+    user,
+    recipient,
+    srcChainId,
+    dstChainId,
+    inputToken,
+    outputToken,
+    inputAmount
+  } = resolved;
+  const userInterop = interopAddress(srcChainId, user);
+  return {
+    user: userInterop,
+    intent: {
+      intentType: "oif-swap",
+      inputs: [
+        {
+          user: userInterop,
+          asset: interopAddress(srcChainId, inputToken),
+          amount: inputAmount.toString()
+        }
+      ],
+      outputs: [
+        {
+          receiver: interopAddress(dstChainId, recipient),
+          asset: interopAddress(dstChainId, outputToken)
+        }
+      ],
+      swapType: "exact-input",
+      // NOTE: do NOT send minValidUntil. This deployment copies it verbatim into
+      // the 3009 authorization's `validBefore`, so a relative value like 600 makes
+      // the order "expired since 1970". Omitting it lets the solver set a proper
+      // absolute deadline (~now+300s), matching the aggregator demo.
+      originSubmission: {
+        mode: "user",
+        schemes: ["permit2"]
+      }
+    },
+    supportedTypes: ["oif-escrow-v0"],
+    solverOptions: {
+      timeout: 8e3,
+      solverTimeout: 5e3,
+      minQuotes: 1
+    }
+  };
+}
+function buildOrderRequest(quote, signature) {
+  return {
+    quoteResponse: quote,
+    signature
+  };
+}
+
+// src/oif/permit2.ts
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var MAX_UINT256 = (1n << 256n) - 1n;
+var ERC20_ALLOWANCE_ABI = [
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var ERC20_APPROVE_ABI = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+function getPermit2Allowance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "allowance",
+    args: [owner, PERMIT2_ADDRESS]
+  });
+}
+async function hasPermit2Allowance(publicClient, token, owner, required) {
+  const allowance = await getPermit2Allowance(publicClient, token, owner);
+  return allowance >= required;
+}
+function buildPermit2ApproveRequest(token, amount = MAX_UINT256) {
+  return {
+    address: token,
+    abi: ERC20_APPROVE_ABI,
+    functionName: "approve",
+    args: [PERMIT2_ADDRESS, amount]
+  };
+}
+
+// src/oif/sign.ts
+var import_viem3 = require("viem");
+var PERMIT2_TYPES = {
+  PermitBatchWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions[]" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "Permit2Witness" }
+  ],
+  MandateOutput: [
+    { name: "oracle", type: "bytes32" },
+    { name: "settler", type: "bytes32" },
+    { name: "chainId", type: "uint256" },
+    { name: "token", type: "bytes32" },
+    { name: "amount", type: "uint256" },
+    { name: "recipient", type: "bytes32" },
+    { name: "callbackData", type: "bytes" },
+    { name: "context", type: "bytes" }
+  ],
+  Permit2Witness: [
+    { name: "user", type: "address" },
+    { name: "expires", type: "uint32" },
+    { name: "inputOracle", type: "address" },
+    { name: "outputs", type: "MandateOutput[]" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ]
+};
+var EIP3009_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ],
+  ReceiveWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ],
+  CancelAuthorization: [
+    { name: "authorizer", type: "address" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function extractDomain(payload) {
+  const domain = {
+    name: payload.domain.name,
+    chainId: BigInt(payload.domain.chainId),
+    verifyingContract: payload.domain.verifyingContract
+  };
+  if (payload.domain.version !== void 0 && payload.domain.version !== null) {
+    domain.version = payload.domain.version;
+  }
+  return domain;
+}
+function getTypesForPayload(payload) {
+  switch (payload.primaryType) {
+    case "PermitBatchWitnessTransferFrom":
+    case "PermitWitnessTransferFrom":
+      return PERMIT2_TYPES;
+    case "TransferWithAuthorization":
+    case "ReceiveWithAuthorization":
+    case "CancelAuthorization":
+      return { [payload.primaryType]: EIP3009_TYPES[payload.primaryType] };
+    default: {
+      if (payload.types) {
+        const filtered = {};
+        for (const [typeName, typeFields] of Object.entries(payload.types)) {
+          if (typeName !== "EIP712Domain") filtered[typeName] = typeFields;
+        }
+        return filtered;
+      }
+      throw new Error(
+        `Unknown primary type: ${payload.primaryType}. Please provide types in payload.`
+      );
+    }
+  }
+}
+async function signPermit2(payload, signer) {
+  const domain = extractDomain(payload);
+  const types = getTypesForPayload(payload);
+  const signature = await signer({
+    domain,
+    types,
+    primaryType: payload.primaryType,
+    message: payload.message
+  });
+  return `0x00${signature.slice(2)}`;
+}
+async function signEip3009(payload, metadata, signer) {
+  const domain = extractDomain(payload);
+  if (domain.version === void 0 || domain.version === null) {
+    domain.version = "1";
+  }
+  const types = getTypesForPayload(payload);
+  const signature = await signer({
+    domain,
+    types,
+    primaryType: payload.primaryType,
+    message: payload.message
+  });
+  const prefixed = `0x01${signature.slice(2)}`;
+  const meta = metadata;
+  const msg = payload.message;
+  const inputs = meta?.inputs ?? msg.inputs ?? [];
+  if (Array.isArray(inputs) && inputs.length > 1) {
+    return (0, import_viem3.encodeAbiParameters)([{ type: "bytes[]" }], [[prefixed]]);
+  }
+  return prefixed;
+}
+async function signQuote(quote, signTypedDataAsync) {
+  const order = quote.order;
+  switch (order.type) {
+    case "oif-escrow-v0":
+      return signPermit2(order.payload, signTypedDataAsync);
+    case "oif-3009-v0":
+      return signEip3009(order.payload, order.metadata, signTypedDataAsync);
+    case "oif-resource-lock-v0":
+    case "oif-generic-v0":
+      throw new Error(
+        `Unsupported order type for wallet signing: ${order.type} (only oif-escrow-v0 and oif-3009-v0 are implemented)`
+      );
+    default:
+      throw new Error(`Unsupported order type: ${order.type}`);
+  }
+}
+
+// src/session.ts
+var ERC20_TRANSFER_ABI = [
+  {
+    name: "transfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var errMessage = (e) => e instanceof Error ? e.message : typeof e === "string" ? e : "Something went wrong.";
+function fmtUnits(amount, decimals) {
+  if (amount === void 0) return "";
+  const human = (0, import_viem4.formatUnits)(typeof amount === "bigint" ? amount : BigInt(amount), decimals);
+  const n = Number(human);
+  return Number.isFinite(n) ? n.toLocaleString("en-US", { maximumFractionDigits: 6 }) : human;
+}
+function isTerminalStatus(status) {
+  if (typeof status === "object") return "failed" in status;
+  return status === "finalized" || status === "refunded";
+}
+function fillTxHash(order) {
+  const f = order?.fillTransaction;
+  if (!f || typeof f !== "object") return null;
+  const rec = f;
+  const h = rec.hash ?? rec.transactionHash ?? rec.txHash;
+  return typeof h === "string" && /^0x[0-9a-fA-F]+$/.test(h) ? h : null;
+}
+var isNativeToken = (token) => !token || /^0x0{40}$/i.test(token) || /^0xe{40}$/i.test(token);
+var INITIAL = {
+  phase: "idle",
+  assetsLoading: true,
+  assetsError: false,
+  ready: false,
+  hint: null,
+  issues: [],
+  resolved: null,
+  route: null,
+  quote: null,
+  preview: null,
+  needsApproval: false,
+  orderId: null,
+  status: null,
+  order: null,
+  explorerUrl: null,
+  error: null,
+  isConnected: false,
+  queueIndex: 0,
+  queueTotal: 0
+};
+function createIntentSession(options = {}) {
+  const api = options.api ?? createApiClient(options);
+  const pollMs = options.pollIntervalMs ?? 2500;
+  let chainsPromise = null;
+  const chains = () => chainsPromise ??= api.getChains().catch((e) => (chainsPromise = null, Promise.reject(e)));
+  const reader = options.chainReader ?? rpcReaders(chains);
+  let wallet = options.wallet ?? null;
+  let hfAccessToken = options.hfAccessToken ?? null;
+  let supported = EMPTY_SUPPORTED;
+  let queue = [];
+  let pollTimer;
+  let destroyed = false;
+  let generation = 0;
+  let state = { ...INITIAL, isConnected: Boolean(wallet) };
+  const listeners = /* @__PURE__ */ new Set();
+  function set(patch) {
+    if (destroyed) return;
+    const next = { ...state, ...patch };
+    next.explorerUrl = buildExplorerUrl(next);
+    state = next;
+    for (const l of listeners) l(state);
+  }
+  function buildExplorerUrl(s) {
+    if (!s.resolved) return null;
+    const base = explorerUrl(s.resolved.dstChainId);
+    if (!base) return null;
+    const hash = s.route === "direct" ? s.orderId : fillTxHash(s.order);
+    return hash ? `${base}/tx/${hash}` : `${base}/address/${s.resolved.recipient}`;
+  }
+  const stopPolling = () => {
+    if (pollTimer) clearTimeout(pollTimer);
+    pollTimer = void 0;
+  };
+  async function refreshAssets() {
+    set({ assetsLoading: true, assetsError: false });
+    try {
+      supported = buildSupportedSet(await api.getSupportedAssets());
+      set({ assetsLoading: false, ready: true });
+    } catch {
+      set({ assetsLoading: false, assetsError: true });
+    }
+  }
+  async function quoteFor(raw, gen) {
+    if (!wallet) return set({ phase: "needsWallet" });
+    try {
+      set({ phase: "quoting", error: null });
+      const resolved = resolveIntent(raw, supported, wallet.address, wallet.solanaAddress);
+      const inAsset = findAsset(supported, resolved.srcChainId, normalizeToken(raw.tokenIn) ?? "");
+      const outSymbol = raw.action === "swap" ? normalizeToken(raw.tokenOut) ?? "" : inAsset?.symbol ?? "";
+      const outAsset = findAsset(supported, resolved.dstChainId, outSymbol);
+      const infos = await chains().catch(() => []);
+      const name = (id) => chainName(id, infos.find((c) => c.chain_id === id));
+      const paySymbol = inAsset?.symbol ?? (outSymbol || "?");
+      if (resolved.action === "send" && resolved.srcChainId === resolved.dstChainId) {
+        if (gen !== generation) return;
+        const amount = fmtUnits(resolved.inputAmount, resolved.inputDecimals);
+        return set({
+          phase: "quoted",
+          resolved,
+          route: "direct",
+          quote: null,
+          needsApproval: false,
+          preview: {
+            action: raw.action,
+            payAmount: amount,
+            paySymbol,
+            srcChainName: name(resolved.srcChainId),
+            receiveAmount: amount,
+            receiveSymbol: paySymbol,
+            dstChainName: name(resolved.dstChainId),
+            recipient: resolved.recipient,
+            etaSeconds: 15,
+            solverCount: 1
+          }
+        });
+      }
+      const res = await api.getQuotes(buildQuoteRequest(resolved));
+      const best = res.quotes?.[0];
+      if (!best) throw new Error("No solver returned a quote for this route yet.");
+      let needsApproval = false;
+      if (best.order.type === "oif-escrow-v0") {
+        const pc = await reader(resolved.srcChainId).catch(() => null);
+        needsApproval = pc ? !await hasPermit2Allowance(pc, resolved.inputToken, resolved.user, resolved.inputAmount).catch(() => false) : true;
+      }
+      if (gen !== generation) return;
+      set({
+        phase: "quoted",
+        resolved,
+        route: "solver",
+        quote: best,
+        needsApproval,
+        preview: {
+          action: raw.action,
+          payAmount: fmtUnits(resolved.inputAmount, resolved.inputDecimals),
+          paySymbol,
+          srcChainName: name(resolved.srcChainId),
+          receiveAmount: fmtUnits(best.preview.outputs?.[0]?.amount, outAsset?.decimals ?? resolved.inputDecimals),
+          receiveSymbol: outAsset?.symbol ?? (outSymbol || inAsset?.symbol || "?"),
+          dstChainName: name(resolved.dstChainId),
+          recipient: raw.action === "send" ? resolved.recipient : void 0,
+          etaSeconds: best.eta,
+          solverCount: res.totalQuotes || res.quotes.length || 1,
+          solversQueried: res.metadata?.solversQueried,
+          raceMs: res.metadata?.totalDurationMs
+        }
+      });
+    } catch (e) {
+      if (gen === generation) set({ phase: "error", error: errMessage(e) });
+    }
+  }
+  function advanceQueue(gen) {
+    const next = state.queueIndex + 1;
+    if (next >= queue.length) return false;
+    set({ queueIndex: next, route: null, quote: null, preview: null, orderId: null, status: null, order: null });
+    void quoteFor(queue[next], gen);
+    return true;
+  }
+  function track(orderId, gen) {
+    stopPolling();
+    const poll = async () => {
+      try {
+        const order = await api.getOrder(orderId);
+        if (gen !== generation) return;
+        set({ status: order.status, order });
+        if (isTerminalStatus(order.status)) {
+          if (!advanceQueue(gen)) set({ phase: "done" });
+          return;
+        }
+      } catch {
+      }
+      if (gen === generation && !destroyed) pollTimer = setTimeout(poll, pollMs);
+    };
+    void poll();
+  }
+  async function confirm() {
+    const { resolved, route } = state;
+    const w = wallet;
+    if (!resolved || !route || !w) return;
+    const gen = generation;
+    try {
+      set({ error: null });
+      if (SOLANA_CHAIN_IDS.has(resolved.srcChainId)) {
+        throw new Error("Swaps from Solana are not supported yet.");
+      }
+      if (await w.getChainId() !== resolved.srcChainId) {
+        set({ phase: "switchingChain" });
+        await w.switchChain(resolved.srcChainId);
+      }
+      if (route === "direct") {
+        set({ phase: "signing" });
+        const hash = isNativeToken(resolved.inputToken) ? await w.sendTransaction({ chainId: resolved.srcChainId, to: resolved.recipient, value: resolved.inputAmount }) : await w.writeContract({
+          chainId: resolved.srcChainId,
+          address: resolved.inputToken,
+          abi: ERC20_TRANSFER_ABI,
+          functionName: "transfer",
+          args: [resolved.recipient, resolved.inputAmount]
+        });
+        if (gen !== generation) return;
+        set({ orderId: hash, status: "finalized", order: null });
+        if (!advanceQueue(gen)) set({ phase: "done" });
+        return;
+      }
+      if (state.quote?.order.type === "oif-escrow-v0") {
+        const pc = await reader(resolved.srcChainId).catch(() => null);
+        const stillNeeds = pc ? !await hasPermit2Allowance(pc, resolved.inputToken, resolved.user, resolved.inputAmount) : state.needsApproval;
+        if (stillNeeds) {
+          set({ phase: "approving" });
+          const approve = buildPermit2ApproveRequest(resolved.inputToken);
+          const hash = await w.writeContract({ chainId: resolved.srcChainId, ...approve, abi: approve.abi });
+          if (pc) await pc.waitForTransactionReceipt({ hash });
+          set({ needsApproval: false });
+        }
+      }
+      set({ phase: "signing" });
+      const fresh = (await api.getQuotes(buildQuoteRequest(resolved))).quotes?.[0];
+      if (!fresh) throw new Error("The quote expired and no fresh quote is available \u2014 try again.");
+      const signature = await signQuote(fresh, w.signTypedData);
+      set({ phase: "submitting" });
+      const order = await api.submitOrder(buildOrderRequest(fresh, signature));
+      if (gen !== generation) return;
+      set({ phase: "tracking", quote: fresh, orderId: order.orderId, status: order.status, order });
+      track(order.orderId, gen);
+    } catch (e) {
+      if (gen === generation) set({ phase: "error", error: errMessage(e) });
+    }
+  }
+  async function run(text) {
+    const gen = ++generation;
+    stopPolling();
+    set({ ...INITIAL, assetsLoading: state.assetsLoading, assetsError: state.assetsError, ready: state.ready, isConnected: Boolean(wallet), phase: "parsing" });
+    const parsed = await parseIntent(text, { hfAccessToken, model: options.hfModel, fetch: api.fetch });
+    if (gen !== generation) return;
+    if (!parsed.ok) return set({ phase: "offTemplate", hint: parsed.message });
+    for (const intent of parsed.intents) {
+      const issues = validateIntent(intent, supported);
+      if (issues.length) return set({ phase: "invalid", issues });
+    }
+    queue = parsed.intents;
+    set({ queueIndex: 0, queueTotal: queue.length });
+    await quoteFor(queue[0], gen);
+  }
+  function reset() {
+    generation++;
+    stopPolling();
+    queue = [];
+    set({ ...INITIAL, assetsLoading: state.assetsLoading, assetsError: state.assetsError, ready: state.ready, isConnected: Boolean(wallet) });
+  }
+  function setWallet(next) {
+    const changedAccount = wallet?.address !== next?.address;
+    wallet = next;
+    set({ isConnected: Boolean(next) });
+    if (next && (state.phase === "needsWallet" || changedAccount && state.phase === "quoted") && queue.length) {
+      void quoteFor(queue[state.queueIndex], generation);
+    }
+  }
+  void refreshAssets();
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    run,
+    confirm,
+    reset,
+    setWallet,
+    refreshAssets,
+    setHfAccessToken(token) {
+      hfAccessToken = token;
+    },
+    destroy() {
+      generation++;
+      stopPolling();
+      destroyed = true;
+      listeners.clear();
+    }
+  };
+}
+
+// src/wallet.ts
+function viemWallet(client) {
+  const account = client.account;
+  if (!account) throw new Error("viemWallet: the WalletClient has no account attached");
+  return {
+    address: account.address,
+    getChainId: () => client.getChainId(),
+    switchChain: (id) => client.switchChain({ id }),
+    signTypedData: (args) => client.signTypedData({
+      account,
+      domain: args.domain,
+      types: stripDomainType(args.types),
+      primaryType: args.primaryType,
+      message: args.message
+    }),
+    writeContract: (req) => client.writeContract({
+      account,
+      chain: null,
+      address: req.address,
+      abi: req.abi,
+      functionName: req.functionName,
+      args: req.args
+    }),
+    sendTransaction: (req) => client.sendTransaction({ account, chain: null, to: req.to, value: req.value })
+  };
+}
+function stripDomainType(types) {
+  const out = {};
+  for (const [name, fields] of Object.entries(types)) if (name !== "EIP712Domain") out[name] = fields;
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  CHAIN_ALIASES,
+  DEFAULT_API_URL,
+  DEFAULT_INTENT_MODEL,
+  EMPTY_SUPPORTED,
+  HF_ROUTER_URL,
+  MAX_UINT256,
+  PERMIT2_ADDRESS,
+  SOLANA_CHAIN_IDS,
+  TEMPLATE_HINT,
+  TOKEN_ALIASES,
+  buildOrderRequest,
+  buildPermit2ApproveRequest,
+  buildQuoteRequest,
+  buildSupportedSet,
+  chainName,
+  createApiClient,
+  createIntentSession,
+  explorerUrl,
+  extractIntents,
+  findAsset,
+  getPermit2Allowance,
+  hasPermit2Allowance,
+  interopAddress,
+  isTerminalStatus,
+  normalizeChain,
+  normalizeToken,
+  parseIntent,
+  resolveIntent,
+  rpcReaders,
+  signQuote,
+  stripDomainType,
+  validateIntent,
+  viemWallet
+});