@wafermapxyz/cli 0.0.0-stage → 0.4.1

package/dist/index.js

@@ -0,0 +1,719 @@
+// src/core.ts
+import { createPublicClient, createWalletClient, erc20Abi as erc20Abi2, formatUnits as formatUnits2, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { arbitrum, base, polygon, robinhood } from "viem/chains";
+
+// shared/swap.ts
+import { decodeFunctionData, erc20Abi, formatUnits, getAddress, isAddress, parseAbi, parseUnits } from "viem";
+var NATIVE = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var TOKENS = {
+  robinhood: [
+    { symbol: "ETH", name: "Ether", address: NATIVE, decimals: 18, kind: "native" },
+    { symbol: "WETH", name: "Wrapped Ether", address: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73", decimals: 18, kind: "wrapped" },
+    { symbol: "USDG", name: "Global Dollar", address: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", decimals: 6, kind: "stable" }
+  ],
+  base: [
+    { symbol: "ETH", name: "Ether", address: NATIVE, decimals: 18, kind: "native" },
+    { symbol: "WETH", name: "Wrapped Ether", address: "0x4200000000000000000000000000000000000006", decimals: 18, kind: "wrapped" },
+    { symbol: "USDC", name: "USD Coin", address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", decimals: 6, kind: "stable" }
+  ]
+};
+var KYBER_ROUTER = {
+  robinhood: "0x6131B5fae19EA4f9D964eAc0408E4408b66337b5",
+  base: "0x6131B5fae19EA4f9D964eAc0408E4408b66337b5"
+};
+function checkRouter(net, router) {
+  const r = typeof router === "string" && isAddress(router) ? getAddress(router) : null;
+  if (r !== KYBER_ROUTER[net]) throw new SwapError("unexpected_router", `The swap API named router ${String(router)}, not KyberSwap's router ${KYBER_ROUTER[net]} on ${net}. Nothing was approved or sent.`);
+  return r;
+}
+var KYBER = (net) => `https://aggregator-api.kyberswap.com/${net}/api/v1`;
+var HEADERS = { "x-client-id": "wafermap", accept: "application/json" };
+var SwapError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+async function resolveToken(net, ref, client, lookup) {
+  const r = ref.trim();
+  let t = null;
+  if (isAddress(r)) t = TOKENS[net].find((x) => x.address.toLowerCase() === r.toLowerCase()) ?? { symbol: "?", name: "", address: getAddress(r), decimals: null };
+  else t = TOKENS[net].find((x) => x.symbol.toLowerCase() === r.toLowerCase()) ?? (lookup ? await lookup(net, r) : null);
+  if (!t) throw new SwapError("unknown_token", `Unknown token "${r}" on ${net}. Use a symbol (ETH, ${net === "base" ? "USDC" : "USDG, TSLA"}) or a 0x address.`);
+  if (t.decimals === null || t.symbol === "?") {
+    const [dec, sym] = await client.multicall({ contracts: [{ address: t.address, abi: erc20Abi, functionName: "decimals" }, { address: t.address, abi: erc20Abi, functionName: "symbol" }], allowFailure: true });
+    if (dec.status !== "success") throw new SwapError("not_a_token", `${t.address} is not an ERC-20 token on ${net}.`);
+    t = { ...t, decimals: Number(dec.result), symbol: t.symbol === "?" && sym.status === "success" ? String(sym.result) : t.symbol };
+  }
+  return t;
+}
+async function quoteSwap(o) {
+  const f = o.fetch ?? fetch;
+  if (o.tokenIn.address.toLowerCase() === o.tokenOut.address.toLowerCase()) throw new SwapError("same_token", "Pick two different tokens.");
+  let units;
+  try {
+    units = parseUnits(o.amount, o.tokenIn.decimals ?? 18);
+  } catch {
+    throw new SwapError("invalid_amount", `"${o.amount}" is not an amount.`);
+  }
+  if (units <= 0n) throw new SwapError("invalid_amount", "Amount must be above zero.");
+  const q = new URLSearchParams({ tokenIn: o.tokenIn.address, tokenOut: o.tokenOut.address, amountIn: units.toString(), gasInclude: "true" });
+  const res = await f(`${KYBER(o.network)}/routes?${q}`, { headers: HEADERS }).catch(() => null);
+  const j = await res?.json().catch(() => null);
+  const s = j?.data?.routeSummary;
+  if (!res?.ok || !s) throw new SwapError("no_route", j?.message && j.message !== "successfully" ? `No route: ${j.message}` : "No swap route found for that pair and size.");
+  const inUsd = Number(s.amountInUsd);
+  const outUsd = Number(s.amountOutUsd);
+  return {
+    network: o.network,
+    tokenIn: o.tokenIn,
+    tokenOut: o.tokenOut,
+    amountIn: o.amount,
+    amountOut: formatUnits(BigInt(s.amountOut), o.tokenOut.decimals ?? 18),
+    amountInUsd: Number.isFinite(inUsd) && inUsd > 0 ? inUsd : null,
+    amountOutUsd: Number.isFinite(outUsd) && outUsd > 0 ? outUsd : null,
+    gasUsd: Number(s.gasUsd) || null,
+    impactPct: inUsd > 0 && outUsd > 0 ? Math.round((1 - outUsd / inUsd) * 1e4) / 100 : null,
+    routerAddress: checkRouter(o.network, j.data.routerAddress),
+    route: s,
+    at: Date.now()
+  };
+}
+var SWAP_DESC = "(address srcToken, address dstToken, address[] srcReceivers, uint256[] srcAmounts, address[] feeReceivers, uint256[] feeAmounts, address dstReceiver, uint256 amount, uint256 minReturnAmount, uint256 flags, bytes permit)";
+var ROUTER_ABI = parseAbi([
+  `function swap((address callTarget, address approveTarget, bytes targetData, ${SWAP_DESC} desc, bytes clientData) execution) payable returns (uint256, uint256)`,
+  `function swapSimpleMode(address caller, ${SWAP_DESC} desc, bytes executorData, bytes clientData) returns (uint256, uint256)`
+]);
+function decodeSwap(data) {
+  let d;
+  try {
+    d = decodeFunctionData({ abi: ROUTER_ABI, data });
+  } catch {
+    throw new SwapError("unexpected_calldata", "The swap API returned a call this wallet does not recognise. Nothing was sent.");
+  }
+  const desc = d.functionName === "swap" ? d.args[0].desc : d.args[1];
+  return { fn: d.functionName, srcToken: getAddress(desc.srcToken), dstToken: getAddress(desc.dstToken), receiver: getAddress(desc.dstReceiver), amount: desc.amount, minReturn: desc.minReturnAmount, feeReceivers: desc.feeReceivers, feeAmounts: desc.feeAmounts };
+}
+async function executeSwap(o) {
+  const f = o.fetch ?? fetch;
+  const { quote } = o;
+  const account = o.wallet.account;
+  if (!account) throw new SwapError("no_account", "No wallet account to swap from.");
+  if (Date.now() - quote.at > 9e4) throw new SwapError("stale_quote", "The quote is older than 90 seconds. Get a fresh one.");
+  checkRouter(quote.network, quote.routerAddress);
+  const from = account.address;
+  const amountIn = parseUnits(quote.amountIn, quote.tokenIn.decimals ?? 18);
+  const slippageBps = o.slippageBps ?? 100;
+  if (!(slippageBps > 0 && slippageBps <= 500)) throw new SwapError("invalid_slippage", "Slippage must be above 0 and at most 5%.");
+  const native = quote.tokenIn.address.toLowerCase() === NATIVE.toLowerCase();
+  const eth = await o.client.getBalance({ address: from });
+  if (eth === 0n) throw new SwapError("no_gas", `The wallet has no ETH on ${quote.network} to pay gas. Send a little ETH first.`);
+  if (native ? eth < amountIn : await o.client.readContract({ address: quote.tokenIn.address, abi: erc20Abi, functionName: "balanceOf", args: [from] }) < amountIn)
+    throw new SwapError("insufficient_balance", `Not enough ${quote.tokenIn.symbol} in ${from.slice(0, 6)}\u2026${from.slice(-4)}.`);
+  o.step?.("building");
+  const res = await f(`${KYBER(quote.network)}/route/build`, {
+    method: "POST",
+    headers: { ...HEADERS, "content-type": "application/json" },
+    body: JSON.stringify({ routeSummary: quote.route, sender: from, recipient: from, slippageTolerance: slippageBps, deadline: Math.floor(Date.now() / 1e3) + 1200, source: "wafermap" })
+  }).catch(() => null);
+  const j = await res?.json().catch(() => null);
+  if (!res?.ok || !j?.data?.data) throw new SwapError("build_failed", j?.message ? `Route build failed: ${j.message}` : "Could not build the swap. Get a fresh quote.");
+  const b = j.data;
+  const to = checkRouter(quote.network, b.routerAddress);
+  const big = (v) => (typeof v === "string" || typeof v === "number") && /^\d+$/.test(String(v)) ? BigInt(v) : null;
+  const value = big(b.transactionValue ?? "0");
+  const builtOut = big(b.amountOut);
+  const quotedOut = parseUnits(quote.amountOut, quote.tokenOut.decimals ?? 18);
+  const call = decodeSwap(b.data);
+  const mismatch = (what) => {
+    throw new SwapError("build_mismatch", `The built swap ${what}. Nothing was approved or sent.`);
+  };
+  if (call.srcToken !== getAddress(quote.tokenIn.address) || call.dstToken !== getAddress(quote.tokenOut.address)) mismatch("trades other tokens than the quote");
+  if (call.amount !== amountIn) mismatch("spends a different amount than the quote");
+  if (call.receiver !== getAddress(from)) mismatch(`sends the output to ${call.receiver}, not to this wallet`);
+  if (call.feeAmounts.some((x) => x > 0n)) mismatch("takes a fee");
+  if (value === null || value !== (native ? amountIn : 0n)) mismatch("sends a different amount of ETH than the quote");
+  if (builtOut === null || builtOut * 10000n < quotedOut * BigInt(1e4 - slippageBps)) throw new SwapError("price_moved", "The price moved past your slippage since the quote. Nothing was sent; get a fresh quote.");
+  if (call.minReturn < builtOut * BigInt(1e4 - slippageBps) / 10000n) mismatch("accepts less output than your slippage allows");
+  let approveTx;
+  if (!native) {
+    const allowance = await o.client.readContract({ address: quote.tokenIn.address, abi: erc20Abi, functionName: "allowance", args: [from, to] });
+    if (allowance < amountIn) {
+      o.step?.("approving");
+      approveTx = await o.wallet.writeContract({ address: quote.tokenIn.address, abi: erc20Abi, functionName: "approve", args: [to, amountIn], account, chain: o.wallet.chain });
+      const r = await o.client.waitForTransactionReceipt({ hash: approveTx });
+      if (r.status !== "success") throw new SwapError("approve_failed", "The approval transaction failed.");
+    }
+  }
+  o.step?.("swapping");
+  const tx = await o.wallet.sendTransaction({ to, data: b.data, value, account, chain: o.wallet.chain });
+  const receipt = await o.client.waitForTransactionReceipt({ hash: tx });
+  if (receipt.status !== "success") throw new SwapError("swap_reverted", "The swap reverted on-chain (price moved past your slippage). Nothing was swapped; gas was spent.");
+  return { approveTx, tx, amountOutMin: formatUnits(call.minReturn, quote.tokenOut.decimals ?? 18) };
+}
+
+// shared/solana.ts
+import { ed25519 } from "@noble/curves/ed25519";
+import { hmac } from "@noble/hashes/hmac";
+import { sha256 } from "@noble/hashes/sha2";
+import { base58, base64 } from "@scure/base";
+var SOLANA_CAIP = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var SOLANA_USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var USDC_DECIMALS = 6;
+var TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var ATA_PROGRAM = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+var COMPUTE_BUDGET = "ComputeBudget111111111111111111111111111111";
+var MEMO_PROGRAM = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+var CU_LIMIT = 2e4;
+var CU_PRICE_MICROLAMPORTS = 1n;
+var MAX_MEMO_BYTES = 256;
+var utf8 = (s) => new TextEncoder().encode(s);
+var concat = (...parts) => {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let o = 0;
+  for (const p of parts) out.set(p, o), o += p.length;
+  return out;
+};
+var hexBytes = (h) => {
+  const s = h.replace(/^0x/, "");
+  if (!/^[0-9a-fA-F]{64}$/.test(s)) throw new Error("Expected a 32-byte hex private key.");
+  return Uint8Array.from(s.match(/../g), (b) => parseInt(b, 16));
+};
+var le = (v, bytes) => Uint8Array.from({ length: bytes }, (_, i) => Number(v >> BigInt(8 * i) & 0xffn));
+var shortvec = (n) => {
+  const out = [];
+  for (let v = n; ; ) {
+    const b = v & 127;
+    v >>= 7;
+    if (!v) return Uint8Array.from([...out, b]);
+    out.push(b | 128);
+  }
+};
+function isSolanaAddress(v) {
+  try {
+    return base58.decode(v).length === 32;
+  } catch {
+    return false;
+  }
+}
+function solanaKeyFromEvm(privateKey) {
+  const seed = hmac(sha256, hexBytes(privateKey), utf8("wafermap/solana/v1"));
+  const pub = ed25519.getPublicKey(seed);
+  return {
+    address: base58.encode(pub),
+    /** seed ‖ public key, base58: the format Phantom and Solflare import. */
+    secretKey: base58.encode(concat(seed, pub)),
+    sign: (message) => ed25519.sign(message, seed)
+  };
+}
+var onCurve = (b) => {
+  try {
+    ed25519.ExtendedPoint.fromHex(b);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function ataOf(owner, mint = SOLANA_USDC) {
+  const seeds = concat(base58.decode(owner), base58.decode(TOKEN_PROGRAM), base58.decode(mint));
+  const tail = concat(base58.decode(ATA_PROGRAM), utf8("ProgramDerivedAddress"));
+  for (let bump = 255; bump >= 0; bump--) {
+    const h = sha256(concat(seeds, Uint8Array.of(bump), tail));
+    if (!onCurve(h)) return base58.encode(h);
+  }
+  throw new Error("No associated token account address.");
+}
+async function solanaPayment(payer, q) {
+  if (q.asset !== SOLANA_USDC) throw new Error("Only USDC is paid on Solana.");
+  if (!isSolanaAddress(q.feePayer) || !isSolanaAddress(q.payTo)) throw new Error("The quote has no valid Solana fee payer or recipient.");
+  if (q.feePayer === payer.address) throw new Error("The fee payer cannot be the paying wallet.");
+  const memo = utf8(q.memo ?? [...crypto.getRandomValues(new Uint8Array(16))].map((b) => b.toString(16).padStart(2, "0")).join(""));
+  if (memo.length > MAX_MEMO_BYTES) throw new Error("The seller's memo is too long.");
+  const source = ataOf(payer.address, q.asset);
+  const dest = ataOf(q.payTo, q.asset);
+  const keys = [q.feePayer, payer.address, source, dest, q.asset, TOKEN_PROGRAM, COMPUTE_BUDGET, MEMO_PROGRAM];
+  if (new Set(keys).size !== keys.length) throw new Error("The quote reuses an account it should not.");
+  const at = (k) => keys.indexOf(k);
+  const ixs = [
+    { program: COMPUTE_BUDGET, accounts: [], data: concat(Uint8Array.of(2), le(BigInt(CU_LIMIT), 4)) },
+    { program: COMPUTE_BUDGET, accounts: [], data: concat(Uint8Array.of(3), le(CU_PRICE_MICROLAMPORTS, 8)) },
+    { program: TOKEN_PROGRAM, accounts: [source, q.asset, dest, payer.address], data: concat(Uint8Array.of(12), le(BigInt(q.amount), 8), Uint8Array.of(USDC_DECIMALS)) },
+    { program: MEMO_PROGRAM, accounts: [], data: memo }
+  ];
+  const message = concat(
+    Uint8Array.of(128, 2, 1, 4),
+    // v0; 2 signatures, 1 of them readonly; 4 readonly non-signers
+    shortvec(keys.length),
+    ...keys.map((k) => base58.decode(k)),
+    base58.decode(await payer.blockhash()),
+    shortvec(ixs.length),
+    ...ixs.map((ix) => concat(Uint8Array.of(at(ix.program)), shortvec(ix.accounts.length), Uint8Array.from(ix.accounts.map(at)), shortvec(ix.data.length), ix.data)),
+    shortvec(0)
+    // no address lookup tables
+  );
+  const signature = await payer.sign(message);
+  return base64.encode(concat(shortvec(2), new Uint8Array(64), signature, message));
+}
+async function solanaRpc(url, method, params, f = fetch) {
+  const r = await f(url, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }) });
+  const j = await r.json().catch(() => null);
+  if (!j) throw new Error(`Solana RPC answered ${r.status}.`);
+  if (j.error) throw new Error(j.error.message ?? "Solana RPC error.");
+  return j.result;
+}
+var latestBlockhash = async (url, f) => (await solanaRpc(url, "getLatestBlockhash", [{ commitment: "confirmed" }], f)).value.blockhash;
+async function solanaBalances(url, owner, f) {
+  const [usdc, lamports] = await Promise.all([
+    solanaRpc(url, "getAccountInfo", [ataOf(owner), { commitment: "confirmed", encoding: "jsonParsed" }], f).then((r) => String(r.value?.data?.parsed?.info?.tokenAmount?.uiAmountString ?? "0")),
+    solanaRpc(url, "getBalance", [owner, { commitment: "confirmed" }], f).then((r) => Number(r.value ?? 0))
+  ]);
+  return { usdc, sol: String(lamports / 1e9) };
+}
+
+// shared/x402client.ts
+var USDC_DOMAIN = { name: "USD Coin", version: "2" };
+var PAY_CHAINS = [
+  { key: "robinhood", vm: "evm", id: 4663, caip: "eip155:4663", v1: "robinhood", stable: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", symbol: "USDG", name: "Robinhood Chain", domain: { name: "Global Dollar", version: "1" } },
+  { key: "solana", vm: "svm", id: 0, caip: SOLANA_CAIP, v1: "solana", stable: SOLANA_USDC, symbol: "USDC", name: "Solana" },
+  { key: "base", vm: "evm", id: 8453, caip: "eip155:8453", v1: "base", stable: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", symbol: "USDC", name: "Base", domain: USDC_DOMAIN },
+  { key: "arbitrum", vm: "evm", id: 42161, caip: "eip155:42161", v1: "arbitrum", stable: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", symbol: "USDC", name: "Arbitrum", domain: USDC_DOMAIN },
+  { key: "polygon", vm: "evm", id: 137, caip: "eip155:137", v1: "polygon", stable: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", symbol: "USDC", name: "Polygon", domain: USDC_DOMAIN }
+];
+var EVM_CHAINS = PAY_CHAINS.filter((c) => c.vm === "evm");
+var CHAIN_KEYS = PAY_CHAINS.map((c) => c.key);
+var X402Error = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var b64encode = (s) => {
+  const bytes = new TextEncoder().encode(s);
+  let bin = "";
+  for (let i = 0; i < bytes.length; i += 32768) bin += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(bin);
+};
+var b64decode = (s) => new TextDecoder().decode(Uint8Array.from(atob(s), (c) => c.charCodeAt(0)));
+function chainOf(network) {
+  const n = String(network ?? "").toLowerCase();
+  return PAY_CHAINS.find((c) => c.caip.toLowerCase() === n || c.v1 === n || c.id > 0 && String(c.id) === n);
+}
+async function readQuote(res) {
+  let body = null;
+  const header = res.headers.get("payment-required");
+  if (header) {
+    try {
+      body = JSON.parse(b64decode(header));
+    } catch {
+    }
+  }
+  if (!body) body = await res.json().catch(() => null);
+  if (!body || !Array.isArray(body.accepts)) throw new X402Error("not_x402", "The service answered 402 without x402 payment details.");
+  const version = Number(body.x402Version) === 1 ? 1 : 2;
+  const accepts = [];
+  const offered = [];
+  for (const r of body.accepts) {
+    offered.push(`${r.scheme ?? "?"}/${r.network ?? "?"}`);
+    const chain = chainOf(r.network);
+    if (!chain || r.scheme !== "exact") continue;
+    if (chain.vm === "evm" ? String(r.asset ?? "").toLowerCase() !== chain.stable.toLowerCase() : r.asset !== chain.stable) continue;
+    const amount = String(version === 1 ? r.maxAmountRequired : r.amount);
+    if (!/^\d+$/.test(amount)) continue;
+    let extra;
+    if (chain.vm === "svm") {
+      if (typeof r.extra?.feePayer !== "string") continue;
+      extra = { feePayer: r.extra.feePayer, ...typeof r.extra.memo === "string" ? { memo: r.extra.memo } : {} };
+    } else extra = r.extra?.name && r.extra?.version ? { name: String(r.extra.name), version: String(r.extra.version) } : chain.domain;
+    accepts.push({ version, chain, amount, usd: Number(amount) / 1e6, payTo: r.payTo, asset: r.asset, maxTimeoutSeconds: Number(r.maxTimeoutSeconds) || 120, extra, raw: r });
+  }
+  const inputError = body.inputError?.message ? { code: String(body.inputError.code ?? "invalid_input"), message: String(body.inputError.message) } : void 0;
+  return { version, resource: body.resource ?? null, accepts, offered, inputError };
+}
+function choose(q, prefer = CHAIN_KEYS) {
+  for (const k of prefer) {
+    const r = q.accepts.find((a) => a.chain.key === k);
+    if (r) return r;
+  }
+  throw new X402Error("no_supported_payment", q.offered.length ? `This service only accepts ${[...new Set(q.offered)].join(", ")}. Wafermap pays USDG on Robinhood Chain or USDC on Solana, Base, Arbitrum or Polygon.` : "The service offered no payment option.");
+}
+var 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" }
+  ]
+};
+var MAX_VALIDITY_SECONDS = 90;
+var randomNonce = () => "0x" + [...crypto.getRandomValues(new Uint8Array(32))].map((b) => b.toString(16).padStart(2, "0")).join("");
+async function signPayment(signer, req, resource, solana) {
+  if (req.chain.vm === "svm") {
+    if (!solana) throw new X402Error("no_solana_wallet", "This payment is on Solana and no Solana wallet was given.");
+    let transaction;
+    try {
+      transaction = await solanaPayment(solana, { amount: req.amount, payTo: req.payTo, asset: req.asset, feePayer: req.extra.feePayer, memo: req.extra.memo });
+    } catch (e) {
+      if (e?.name === "TimeoutError" || e?.cause?.name === "TimeoutError") throw e;
+      throw new X402Error("sign_failed", e?.message ?? "Could not build the Solana payment.");
+    }
+    if (req.version === 1) return { name: "X-PAYMENT", value: b64encode(JSON.stringify({ x402Version: 1, scheme: "exact", network: req.raw.network, payload: { transaction } })) };
+    return { name: "PAYMENT-SIGNATURE", value: b64encode(JSON.stringify({ x402Version: 2, resource, accepted: req.raw, payload: { transaction } })) };
+  }
+  const nonce = randomNonce();
+  const validBefore = BigInt(Math.floor(Date.now() / 1e3) + Math.min(req.maxTimeoutSeconds, MAX_VALIDITY_SECONDS));
+  const message = { from: signer.address, to: req.payTo, value: BigInt(req.amount), validAfter: 0n, validBefore, nonce };
+  let signature;
+  try {
+    signature = await signer.signTypedData({ domain: { name: req.extra.name, version: req.extra.version, chainId: req.chain.id, verifyingContract: req.asset }, types: TYPES, primaryType: "TransferWithAuthorization", message });
+  } catch (e) {
+    throw new X402Error("sign_rejected", e?.shortMessage ?? e?.message ?? "Signature rejected.");
+  }
+  const authorization = { from: signer.address, to: req.payTo, value: req.amount, validAfter: "0", validBefore: validBefore.toString(), nonce };
+  const auth = { nonce, validBefore: Number(validBefore) };
+  if (req.version === 1) return { name: "X-PAYMENT", value: b64encode(JSON.stringify({ x402Version: 1, scheme: "exact", network: req.raw.network, payload: { signature, authorization } })), auth };
+  return { name: "PAYMENT-SIGNATURE", value: b64encode(JSON.stringify({ x402Version: 2, resource, accepted: req.raw, payload: { signature, authorization } })), auth };
+}
+function readSettlement(res) {
+  const h = res.headers.get("payment-response") ?? res.headers.get("x-payment-response");
+  if (!h) return null;
+  try {
+    const j = JSON.parse(b64decode(h));
+    return { tx: j.transaction ?? j.txHash ?? j.tx, network: j.network, success: j.success };
+  } catch {
+    return null;
+  }
+}
+async function x402fetch(url, init, opts) {
+  const f = opts.fetch ?? fetch;
+  const first = await f(url, init);
+  if (first.status !== 402) return { res: first, paid: null };
+  const quote = await readQuote(first);
+  if (quote.inputError) throw new X402Error(quote.inputError.code, quote.inputError.message);
+  const req = choose(quote, (opts.prefer ?? CHAIN_KEYS).filter((k) => k !== "solana" || opts.solana));
+  if (opts.approve) await opts.approve(req);
+  const svm = req.chain.vm === "svm";
+  const signer = svm ? null : typeof opts.signer === "function" ? await opts.signer() : opts.signer;
+  const header = await signPayment(signer, req, quote.resource, opts.solana);
+  const signed = { req, from: svm ? opts.solana.address : signer.address, ...header.auth ? { auth: header.auth } : {} };
+  opts.onSigned?.(signed);
+  const headers = new Headers(init.headers);
+  headers.set(header.name, header.value);
+  const res = await f(url, { ...init, headers });
+  return { res, paid: { ...signed, tx: readSettlement(res)?.tx ?? null } };
+}
+
+// src/core.ts
+var NETS = CHAIN_KEYS;
+var isSwapNet = (v) => v === "robinhood" || v === "base";
+var WafermapError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var CHAINS = { robinhood, base, arbitrum, polygon };
+var AUTH_STATE_ABI = [{ type: "function", name: "authorizationState", stateMutability: "view", inputs: [{ name: "authorizer", type: "address" }, { name: "nonce", type: "bytes32" }], outputs: [{ type: "bool" }] }];
+function mergeLog(entries) {
+  const outcomes = new Map(entries.filter((e) => e.of).map((e) => [e.of, e]));
+  return entries.filter((e) => !e.of).map((e) => {
+    const o = e.id ? outcomes.get(e.id) : void 0;
+    if (!o) return e;
+    return { ...e, status: o.status, tx: o.tx ?? e.tx, reported: o.reported ?? null, ...o.status === "aborted" ? { usd: 0 } : {} };
+  });
+}
+async function checkPayment(e, rpc) {
+  if (e.network === "solana" || !e.nonce || !(e.network in CHAINS)) return "unknown";
+  const chain = PAY_CHAINS.find((c) => c.key === e.network);
+  try {
+    const client = createPublicClient({ chain: CHAINS[e.network], transport: http(rpc) });
+    const used = await client.readContract({ address: chain.stable, abi: AUTH_STATE_ABI, functionName: "authorizationState", args: [e.payer, e.nonce] });
+    if (used) return "used";
+    return e.validBefore && Date.now() / 1e3 > e.validBefore ? "unused" : "pending";
+  } catch {
+    return "error";
+  }
+}
+var DEFAULT_LIMITS = { perPayment: 0.1, perDay: 1, perSwap: 25 };
+var DEFAULT_TIMEOUT_MS = 6e4;
+var timedOut = (e) => e?.name === "TimeoutError" || e?.cause?.name === "TimeoutError";
+var Wafermap = class {
+  account;
+  baseUrl;
+  network;
+  limits;
+  ledger;
+  approveFn;
+  rpc;
+  clients = {};
+  solana;
+  solanaAddress;
+  timeoutMs;
+  /** fetch with this wallet's time limit: a server that never answers cannot hold a call forever. */
+  fetch;
+  constructor(o) {
+    const account = o.account ?? (o.privateKey ? privateKeyToAccount(o.privateKey) : null);
+    if (!account) throw new WafermapError("no_account", "Pass privateKey or account.");
+    this.account = account;
+    this.baseUrl = (o.baseUrl ?? "https://wafermap.xyz").replace(/\/$/, "");
+    this.network = o.network ?? "robinhood";
+    this.limits = { ...DEFAULT_LIMITS, ...o.limits };
+    const mem = [];
+    this.ledger = o.ledger ?? { entries: () => mem, record: (e) => void mem.push(e) };
+    this.approveFn = o.approve;
+    this.rpc = o.rpc ?? {};
+    this.timeoutMs = o.timeoutMs && o.timeoutMs > 0 ? o.timeoutMs : DEFAULT_TIMEOUT_MS;
+    this.fetch = (input, init) => fetch(input, { ...init, signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs) });
+    const sol = o.solana ?? (o.privateKey ? solanaKeyFromEvm(o.privateKey) : null);
+    const solRpc = this.rpc.solana ?? `${this.baseUrl}/api/solana`;
+    this.solana = sol ? { address: sol.address, sign: sol.sign, blockhash: () => latestBlockhash(solRpc, this.fetch) } : null;
+    this.solanaAddress = sol?.address ?? o.solanaAddress ?? null;
+  }
+  get address() {
+    return this.account.address;
+  }
+  client(n) {
+    return this.clients[n] ??= createPublicClient({ chain: CHAINS[n], transport: http(this.rpc[n]) });
+  }
+  /** USD signed today (local midnight) on payments, not counting swaps. Every signed payment
+   *  counts at its full amount, whatever the server answered, because a signed payment can be
+   *  executed until it expires. `checkPayment` shows on-chain which ones were never used. */
+  spentToday() {
+    const start = /* @__PURE__ */ new Date();
+    start.setHours(0, 0, 0, 0);
+    return this.ledger.entries().filter((e) => e.kind !== "swap" && e.at >= start.getTime() && (e.payer.toLowerCase() === this.address.toLowerCase() || e.payer === this.solanaAddress)).reduce((a, e) => a + e.usd, 0);
+  }
+  async gate(a) {
+    if (a.kind === "swap") {
+      if (a.usd > this.limits.perSwap) throw new WafermapError("over_swap_cap", `$${a.usd.toFixed(2)} is above the per-swap cap of $${this.limits.perSwap}.`);
+    } else {
+      if (a.usd > this.limits.perPayment) throw new WafermapError("over_payment_cap", `$${a.usd} is above the per-payment cap of $${this.limits.perPayment}.`);
+      if (this.spentToday() + a.usd > this.limits.perDay + 1e-9) throw new WafermapError("over_daily_cap", `This would pass the daily cap of $${this.limits.perDay} ($${this.spentToday().toFixed(4)} spent today).`);
+    }
+    if (this.approveFn && !await this.approveFn(a)) throw new WafermapError("declined", "Declined.");
+  }
+  prefer(n) {
+    const first = n ?? this.network;
+    return [first, ...NETS.filter((x) => x !== first)];
+  }
+  /** A second 402 means the payment itself was refused (usually: not enough balance). */
+  rejected(res, body, paid) {
+    if (!paid || res.status !== 402) return null;
+    const reason = typeof body?.error === "string" ? body.error : body?.error?.message ?? "rejected";
+    return new WafermapError("payment_rejected", `Payment refused (${reason}). Check that ${paid.req.chain.vm === "svm" ? this.solanaAddress : this.address} holds at least $${paid.req.usd} ${paid.req.chain.symbol} on ${paid.req.chain.name}.`);
+  }
+  /** Write the signed payment to the ledger before it leaves the machine. */
+  booked(kind, what, s) {
+    const id = crypto.randomUUID();
+    this.ledger.record({ at: Date.now(), kind, what, usd: s.req.usd, network: s.req.chain.key, tx: null, payer: s.from, id, status: "signed", ...s.auth ? { nonce: s.auth.nonce, validBefore: s.auth.validBefore } : {} });
+    return id;
+  }
+  /** The outcome line for a booked payment. It adds nothing to the daily total. */
+  outcome(id, kind, what, s, status, tx, reported = null) {
+    this.ledger.record({ at: Date.now(), kind, what, usd: 0, network: s.req.chain.key, tx, payer: s.from, of: id, status, reported });
+  }
+  /** The timeout error for `host`, saying whether a payment was signed and until when it can be executed. */
+  timeoutError(host, signed) {
+    const after = signed ? ` A payment had been signed and sent. It stays counted${signed.validBefore ? ` and can only be executed until ${new Date(signed.validBefore * 1e3).toLocaleTimeString()}` : ""}; check with \`wafermap history --verify\`.` : " Nothing was paid.";
+    return new WafermapError("timeout", `${host} did not answer within ${Math.round(this.timeoutMs / 1e3)} s.${after}`);
+  }
+  /** Read a JSON body; a time-out while reading is reported, anything else gives `fallback`. */
+  async body(res, read, fallback, host, signed) {
+    try {
+      return await read();
+    } catch (e) {
+      if (timedOut(e)) throw this.timeoutError(host, signed);
+      return fallback;
+    }
+  }
+  // Check-sign-book runs one payment at a time in this process, so two calls started together
+  // cannot both pass the daily cap on the same remaining budget. Across processes, see onSigned.
+  queue = Promise.resolve();
+  acquire() {
+    let release;
+    const held = new Promise((r) => release = r);
+    const prev = this.queue;
+    this.queue = prev.then(() => held);
+    return prev.then(() => release);
+  }
+  async paidFetch(kind, what, url, init, network) {
+    let id = null;
+    let release = null;
+    const unlock = () => {
+      release?.();
+      release = null;
+    };
+    try {
+      const r = await x402fetch(url, init, {
+        signer: this.account,
+        solana: this.solana ?? void 0,
+        prefer: this.prefer(network),
+        fetch: this.fetch,
+        approve: async (req) => {
+          release = await this.acquire();
+          await this.gate({ kind, what, usd: req.usd, network: req.chain.key, detail: `${req.chain.symbol} to ${req.payTo}` });
+        },
+        onSigned: (s) => {
+          id = this.booked(kind, what, s);
+          unlock();
+          if (this.spentToday() > this.limits.perDay + 1e-9) {
+            this.ledger.record({ at: Date.now(), kind, what, usd: -s.req.usd, network: s.req.chain.key, tx: null, payer: s.from, of: id, status: "aborted" });
+            id = null;
+            throw new WafermapError("over_daily_cap", `Another payment from this wallet used the daily cap of $${this.limits.perDay} at the same time. Nothing was sent.`);
+          }
+        }
+      });
+      return { ...r, id };
+    } catch (e) {
+      if (e instanceof WafermapError) throw e;
+      if (e instanceof X402Error) throw new WafermapError(e.code, e.message);
+      if (timedOut(e)) throw this.timeoutError(new URL(url).host, id ? this.ledger.entries().find((x) => x.id === id) ?? {} : null);
+      throw new WafermapError("network_error", `${new URL(url).host}: ${e?.cause?.message ?? e?.message ?? "request failed"}`);
+    } finally {
+      unlock();
+    }
+  }
+  // ---- Wafermap resources ----
+  async resources() {
+    const host = new URL(this.baseUrl).host;
+    const r = await this.fetch(`${this.baseUrl}/v1/resources`).catch((e) => {
+      throw timedOut(e) ? this.timeoutError(host) : new WafermapError("network_error", `${host}: ${e?.message ?? "request failed"}`);
+    });
+    const j = await this.body(r, () => r.json(), null, host);
+    return j?.data ?? [];
+  }
+  async call(id, input = {}, o = {}) {
+    const go = () => this.paidFetch("resource", id, `${this.baseUrl}/v1/${id}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(input) }, o.network);
+    const settle = (r2, out2) => {
+      if (!r2.paid || !r2.id) return;
+      const status = r2.res.status === 402 ? "refused" : r2.res.ok ? "ok" : "failed";
+      this.outcome(r2.id, "resource", id, r2.paid, status, out2?.receipt?.tx ?? r2.paid.tx, typeof out2?.receipt?.amountUsd === "number" ? out2.receipt.amountUsd : null);
+    };
+    const host = new URL(this.baseUrl).host;
+    const read = (r2) => this.body(r2.res, () => r2.res.json(), {}, host, r2.paid?.auth ?? (r2.paid ? {} : null));
+    let r = await go();
+    let out = await read(r);
+    settle(r, out);
+    if (r.paid?.req.chain.vm === "svm" && r.res.status === 402 && /fee_payer/i.test(JSON.stringify(out))) {
+      r = await go().catch((e) => {
+        if (e?.code === "over_daily_cap") throw new WafermapError("over_daily_cap", `The facilitator refused the first Solana payment (its fee payer rotated). That signed payment still counts until it expires, and a second one would pass the daily cap of $${this.limits.perDay}. Try again in a few minutes or pay on another network.`);
+        throw e;
+      });
+      out = await read(r);
+      settle(r, out);
+    }
+    const { res, paid } = r;
+    const refused = this.rejected(res, out, paid);
+    if (refused) throw refused;
+    if (!res.ok) throw new WafermapError(out?.error?.code ?? "http_error", out?.error?.message ?? (typeof out?.error === "string" ? out.error : `HTTP ${res.status}`));
+    return out;
+  }
+  // ---- Third-party x402 services ----
+  async discover(query, limit = 10) {
+    const host = new URL(this.baseUrl).host;
+    const r = await this.fetch(`${this.baseUrl}/api/discover?q=${encodeURIComponent(query)}&limit=${limit}`).catch((e) => {
+      throw timedOut(e) ? this.timeoutError(host) : new WafermapError("network_error", `${host}: ${e?.message ?? "request failed"}`);
+    });
+    const j = await this.body(r, () => r.json(), null, host);
+    if (!r.ok || !Array.isArray(j?.services)) throw new WafermapError(j?.error?.code ?? "discovery_failed", j?.error?.message ?? "Discovery is unavailable.");
+    return j.services;
+  }
+  /** Call any x402 URL and pay it if it asks. GET sends `input` as the query string, POST as JSON. */
+  async pay(url, o = {}) {
+    const method = o.method ?? "GET";
+    const qs = method === "GET" && o.input && Object.keys(o.input).length ? new URLSearchParams(Object.entries(o.input).map(([k, v]) => [k, String(v)])).toString() : "";
+    const target = qs ? `${url}${url.includes("?") ? "&" : "?"}${qs}` : url;
+    const init = method === "GET" ? { method } : { method, headers: { "content-type": "application/json" }, body: JSON.stringify(o.input ?? {}) };
+    const u = new URL(url);
+    const what = `${u.host}${u.pathname}`;
+    const { res, paid, id } = await this.paidFetch("service", what, target, init, o.network);
+    if (paid && id) this.outcome(id, "service", what, paid, res.status === 402 ? "refused" : res.ok ? "ok" : "failed", paid.tx);
+    const type = res.headers.get("content-type") ?? "";
+    const signed = paid?.auth ?? (paid ? {} : null);
+    const result = /json/.test(type) ? await this.body(res, () => res.json(), null, u.host, signed) : /^(image|audio|video)\//.test(type) ? { bytes: (await this.body(res, () => res.arrayBuffer(), new ArrayBuffer(0), u.host, signed)).byteLength, contentType: type } : await this.body(res, () => res.text(), "", u.host, signed);
+    const refused = this.rejected(res, result, paid);
+    if (refused) throw refused;
+    if (!res.ok) throw new WafermapError(paid ? "payment_failed" : "http_error", `${u.host} answered ${res.status}: ${JSON.stringify(result).slice(0, 300)}`);
+    return { status: res.status, result, paid: paid ? { usd: paid.req.usd, network: paid.req.chain.key, tx: paid.tx } : null };
+  }
+  // ---- Wallet ----
+  async balances() {
+    const out = Object.fromEntries(NETS.map((n) => [n, null]));
+    const sol = this.solanaAddress;
+    await Promise.all([
+      sol ? solanaBalances(this.rpc.solana ?? `${this.baseUrl}/api/solana`, sol, this.fetch).then(
+        (b) => void (out.solana = { eth: b.sol, gas: "SOL", stable: b.usdc, symbol: "USDC" }),
+        () => {
+        }
+      ) : null,
+      ...NETS.filter((n) => n !== "solana").map(async (n) => {
+        try {
+          const c = this.client(n);
+          const chain = PAY_CHAINS.find((x) => x.key === n);
+          const [eth, usd] = await Promise.all([c.getBalance({ address: this.address }), c.readContract({ address: chain.stable, abi: erc20Abi2, functionName: "balanceOf", args: [this.address] })]);
+          out[n] = { eth: formatUnits2(eth, 18), gas: CHAINS[n].nativeCurrency.symbol, stable: formatUnits2(usd, 6), symbol: chain.symbol };
+        } catch {
+          out[n] = null;
+        }
+      })
+    ]);
+    return out;
+  }
+  // ---- Swaps ----
+  tokenCache = {};
+  async lookup(n, symbol) {
+    if (!this.tokenCache[n]) {
+      const j = await this.fetch(`${this.baseUrl}/api/tokens?network=${n}`).then((r) => r.json()).catch(() => null);
+      this.tokenCache[n] = j?.tokens ?? TOKENS[n];
+    }
+    return this.tokenCache[n].find((t) => t.symbol.toLowerCase() === symbol.toLowerCase()) ?? null;
+  }
+  async swapQuote(from, to, amount, network) {
+    const n = network ?? (isSwapNet(this.network) ? this.network : "robinhood");
+    if (!isSwapNet(n)) throw new WafermapError("unsupported_network", "Swaps run on Robinhood Chain or Base. Use --network robinhood or base.");
+    const c = this.client(n);
+    try {
+      const [tokenIn, tokenOut] = await Promise.all([resolveToken(n, from, c, (net, s) => this.lookup(net, s)), resolveToken(n, to, c, (net, s) => this.lookup(net, s))]);
+      return await quoteSwap({ network: n, tokenIn, tokenOut, amount, fetch: this.fetch });
+    } catch (e) {
+      throw new WafermapError(e?.code ?? "quote_failed", e?.shortMessage ?? e?.message ?? "No quote.");
+    }
+  }
+  async swap(quote, o = {}) {
+    if (!quote.amountInUsd) throw new WafermapError("no_usd_value", "This swap has no USD value, so the per-swap cap cannot be checked. Not sent.");
+    await this.gate({ kind: "swap", what: `${quote.amountIn} ${quote.tokenIn.symbol} \u2192 ${quote.tokenOut.symbol}`, usd: quote.amountInUsd, network: quote.network, detail: `about ${quote.amountOut} ${quote.tokenOut.symbol}` });
+    const wallet = createWalletClient({ account: this.account, chain: CHAINS[quote.network], transport: http(this.rpc[quote.network]) });
+    try {
+      const r = await executeSwap({ quote, wallet, client: this.client(quote.network), slippageBps: o.slippageBps, step: o.step, fetch: this.fetch });
+      this.ledger.record({ at: Date.now(), kind: "swap", what: `${quote.amountIn} ${quote.tokenIn.symbol} \u2192 ${quote.tokenOut.symbol}`, usd: 0, network: quote.network, tx: r.tx, payer: this.address });
+      return r;
+    } catch (e) {
+      throw new WafermapError(e?.code ?? "swap_failed", e?.shortMessage ?? e?.message ?? "Swap failed.");
+    }
+  }
+};
+export {
+  DEFAULT_LIMITS,
+  DEFAULT_TIMEOUT_MS,
+  KYBER_ROUTER,
+  MAX_VALIDITY_SECONDS,
+  PAY_CHAINS,
+  SwapError,
+  Wafermap,
+  WafermapError,
+  X402Error,
+  checkPayment,
+  choose,
+  decodeSwap,
+  executeSwap,
+  mergeLog,
+  quoteSwap,
+  readQuote,
+  signPayment,
+  x402fetch
+};