@manifoldxyz/dropkit 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -25,16 +25,18 @@ __export(index_exports, {
   MINT_STATES: () => MINT_STATES,
   MintButton: () => MintButton,
   MintError: () => MintError,
+  PayWithPicker: () => PayWithPicker,
   REASON_CODES: () => REASON_CODES,
   VERSION: () => VERSION,
   isMintError: () => isMintError,
-  useMint: () => useMint
+  useMint: () => useMint,
+  usePayOptions: () => usePayOptions
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/react/useMint.ts
 var import_react = require("react");
-var import_viem8 = require("viem");
+var import_viem9 = require("viem");
 
 // src/core/rpc/index.ts
 var import_viem = require("viem");
@@ -56,7 +58,12 @@ var ERROR_REASONS = [
   "RATE_LIMITED",
   "RPC_ERROR",
   "CHAIN_SWITCH_FAILED",
-  "ALLOWLIST_UNAVAILABLE"
+  "ALLOWLIST_UNAVAILABLE",
+  // Relay cross-chain mint (spec relay-cross-chain-mint #execute-click).
+  "BRIDGE_UNAVAILABLE",
+  "BRIDGE_REFUNDED",
+  "BRIDGE_FAILED",
+  "BRIDGE_TIMEOUT"
 ];
 var FUNDS_REASONS = ["INSUFFICIENT_FUNDS"];
 var REASON_CODES = [
@@ -69,11 +76,14 @@ var MintError = class extends Error {
   reason;
   /** INVALID_CONFIG only: dotted path of the bad field, e.g. "mint.args[1]" or "price". */
   field;
+  /** 'relay': the message is Relay's decoded destination revert, shown as-is. */
+  domain;
   constructor(reason, message, opts) {
     super(message, opts?.cause === void 0 ? void 0 : { cause: opts.cause });
     this.name = "MintError";
     this.reason = reason;
     if (opts?.field !== void 0) this.field = opts.field;
+    if (opts?.domain !== void 0) this.domain = opts.domain;
   }
 };
 function isMintError(e) {
@@ -95,8 +105,22 @@ var CHAINS = {
   [import_chains.base.id]: import_chains.base,
   [import_chains.optimism.id]: import_chains.optimism,
   [import_chains.shape.id]: import_chains.shape,
-  [import_chains.apeChain.id]: import_chains.apeChain
+  [import_chains.apeChain.id]: import_chains.apeChain,
+  // Relay pay chain for Sepolia drops only: never a drop chain, no Manifold bridge.
+  [import_chains.baseSepolia.id]: import_chains.baseSepolia
+};
+var CHAIN_NAMES = {
+  1: "Ethereum",
+  8453: "Base",
+  10: "Optimism",
+  360: "Shape",
+  33139: "ApeChain",
+  11155111: "Sepolia",
+  84532: "Base Sepolia"
 };
+function chainName(chainId) {
+  return CHAIN_NAMES[chainId] ?? CHAINS[chainId]?.name ?? `chain ${String(chainId)}`;
+}
 var TRANSPORT_TIMEOUT_MS = 8e3;
 function getChain(chainId) {
   const chain = CHAINS[chainId];
@@ -334,6 +358,37 @@ function getWalletClient(chainId) {
   const request = ((args) => provider.request(args));
   return (0, import_viem2.createWalletClient)({ chain: getChain(chainId), transport: (0, import_viem2.custom)({ request }) });
 }
+async function waitForDeposit(chainId, hash, timeoutMs = 12e4) {
+  try {
+    const receipt = await getWalletClient(chainId).extend(import_viem2.publicActions).waitForTransactionReceipt({ hash, confirmations: 1, timeout: timeoutMs });
+    return receipt.status === "reverted" ? "reverted" : "mined";
+  } catch {
+    return "unknown";
+  }
+}
+var WALLET_READ_TIMEOUT = { ms: 1e4 };
+async function getConnectedBalance(address, chainId) {
+  const provider = eip1193();
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new MintError("RPC_ERROR", "The wallet did not report a balance in time.")), WALLET_READ_TIMEOUT.ms);
+  });
+  try {
+    return await Promise.race([
+      (async () => {
+        const current = Number(await provider.request({ method: "eth_chainId" }));
+        if (current !== chainId) {
+          throw new MintError("CHAIN_SWITCH_FAILED", `The wallet is on chain ${String(current)}, not ${String(chainId)}.`);
+        }
+        const hex = await provider.request({ method: "eth_getBalance", params: [address, "latest"] });
+        return BigInt(hex);
+      })(),
+      timeout
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 var code = (e) => e?.code;
 async function switchToChain(chainId) {
   const chain = getChain(chainId);
@@ -365,31 +420,258 @@ async function switchToChain(chainId) {
   }
 }
 
+// src/core/relay/client.ts
+var import_viem3 = require("viem");
+var RELAY_API = { mainnet: "https://api.relay.link", testnet: "https://api.testnets.relay.link" };
+var MAINNET_PAY_CHAINS = [1, 8453, 10, 360, 33139];
+var MAINNET_DROP_CHAINS = [1, 8453, 10, 360];
+var SEPOLIA = 11155111;
+var BASE_SEPOLIA = 84532;
+var isRelayTestnet = (dropChainId) => dropChainId === SEPOLIA;
+function payChainsFor(dropChainId) {
+  if (MAINNET_DROP_CHAINS.includes(dropChainId)) return [...MAINNET_PAY_CHAINS];
+  if (dropChainId === SEPOLIA) return [SEPOLIA, BASE_SEPOLIA];
+  return [];
+}
+var CACHE_MS = 3e4;
+var cache = /* @__PURE__ */ new Map();
+var cacheKey = (a) => [a.testnet, a.originChainId, a.destinationChainId, a.tx.to.toLowerCase(), a.tx.value, (0, import_viem3.keccak256)(a.tx.data), a.payer.toLowerCase(), a.recipient.toLowerCase()].join(":");
+var big = (v) => {
+  if (typeof v === "string" && /^\d+$/.test(v)) return BigInt(v);
+  if (typeof v === "number" && Number.isSafeInteger(v) && v >= 0) return BigInt(v);
+  return 0n;
+};
+var obj = (v) => v !== null && typeof v === "object" ? v : {};
+function moneyOf(amount, currency) {
+  const c = obj(currency);
+  const decimals = typeof c.decimals === "number" ? c.decimals : 18;
+  const symbol = typeof c.symbol === "string" ? c.symbol : "ETH";
+  const value = big(amount);
+  return { value, decimals, symbol, formatted: (0, import_viem3.formatUnits)(value, decimals) };
+}
+function revertReason(errorData) {
+  if (typeof errorData !== "string") return "";
+  const text2 = errorData.replace(/^execution reverted:?\s*/i, "").trim();
+  return text2 === "execution reverted" ? "" : text2;
+}
+function parseQuote(body, originChainId) {
+  const b = obj(body);
+  const steps = Array.isArray(b.steps) ? b.steps.map(obj) : [];
+  const unknownStep = () => new MintError("BRIDGE_UNAVAILABLE", "Relay returned a route this button cannot execute.");
+  if (steps.length !== 1 || steps[0].kind !== "transaction") throw unknownStep();
+  const step2 = steps[0];
+  const rawItems = Array.isArray(step2.items) ? step2.items.map(obj) : [];
+  if (rawItems.length !== 1) throw unknownStep();
+  const items = rawItems.map((item) => {
+    const d = obj(item.data);
+    const chainId = Number(d.chainId);
+    if (chainId !== originChainId || typeof d.to !== "string" || !(0, import_viem3.isHex)(d.data)) throw unknownStep();
+    return { chainId, to: (0, import_viem3.getAddress)(d.to), data: d.data, value: big(d.value), gas: d.gas === void 0 ? null : big(d.gas) };
+  });
+  const requestId = (0, import_viem3.isHex)(step2.requestId) ? step2.requestId : (0, import_viem3.isHex)(b.requestId) ? b.requestId : null;
+  if (!requestId) throw unknownStep();
+  const details = obj(b.details);
+  const currencyIn = obj(details.currencyIn);
+  const fees = obj(b.fees);
+  const amountIn = moneyOf(currencyIn.amount, currencyIn.currency);
+  if (obj(currencyIn.currency).address !== void 0 && obj(currencyIn.currency).address !== import_viem3.zeroAddress) throw unknownStep();
+  if (items[0].value !== amountIn.value) throw unknownStep();
+  return {
+    requestId,
+    originChainId,
+    items,
+    amountIn,
+    relayFee: moneyOf(obj(fees.relayer).amount, obj(fees.relayer).currency ?? currencyIn.currency),
+    originGas: moneyOf(obj(fees.gas).amount, obj(fees.gas).currency ?? currencyIn.currency),
+    quotedAt: Math.floor(Date.now() / 1e3)
+  };
+}
+var RELAY_TIMEOUTS = { quoteMs: 1e4, statusMs: 1e4 };
+function raceSignal(p, signal) {
+  if (!signal) return p;
+  if (signal.aborted) return Promise.reject(new DOMException("Relay quote cancelled", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new DOMException("Relay quote cancelled", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    p.then(
+      (v) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(v);
+      },
+      (e) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    );
+  });
+}
+async function timedFetch(f, url, init, ms) {
+  const controller = new AbortController();
+  let t;
+  const timeout = new Promise((_, reject) => {
+    t = setTimeout(() => {
+      controller.abort();
+      reject(new DOMException("Relay request timed out", "TimeoutError"));
+    }, ms);
+  });
+  try {
+    return await Promise.race([
+      (async () => {
+        const res = await f(url, { ...init, signal: controller.signal });
+        const json = await res.json().catch(() => null);
+        return { ok: res.ok, status: res.status, json };
+      })(),
+      timeout
+    ]);
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function requestQuote(a) {
+  const f = a.fetch ?? globalThis.fetch;
+  const body = {
+    user: a.payer,
+    recipient: a.recipient,
+    refundTo: a.payer,
+    // R11: without refundTo, Relay disables automatic refunds.
+    originChainId: a.originChainId,
+    destinationChainId: a.destinationChainId,
+    originCurrency: import_viem3.zeroAddress,
+    destinationCurrency: import_viem3.zeroAddress,
+    tradeType: "EXACT_OUTPUT",
+    amount: a.tx.value.toString(),
+    txs: [{ to: a.tx.to, value: a.tx.value.toString(), data: a.tx.data }]
+  };
+  let res;
+  try {
+    res = await timedFetch(f, `${a.testnet ? RELAY_API.testnet : RELAY_API.mainnet}/quote`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }, RELAY_TIMEOUTS.quoteMs);
+  } catch (e) {
+    throw new MintError("BRIDGE_UNAVAILABLE", "Could not reach Relay for a cross-chain quote.", { cause: e });
+  }
+  const json = res.json;
+  if (res.ok) return parseQuote(json, a.originChainId);
+  const j = obj(json);
+  if (j.errorCode === "DESTINATION_TX_FAILED") {
+    const reason = revertReason(j.errorData);
+    throw new MintError("SIMULATION_REVERTED", reason || "The mint would fail on the drop network.", { cause: json, domain: "relay" });
+  }
+  if (res.status === 401 || j.errorCode === "UNAUTHORIZED_QUOTE") {
+    console.warn("dropkit: Relay rejected the quote (401 UNAUTHORIZED_QUOTE). Relay gates quotes that carry a referrer or need an API key.");
+    throw new MintError("BRIDGE_UNAVAILABLE", "Relay refused the cross-chain quote.", { cause: json });
+  }
+  if (res.status === 429) throw new MintError("RATE_LIMITED", "Relay is rate limiting quotes. Try again in a moment.", { cause: json });
+  throw new MintError("BRIDGE_UNAVAILABLE", `Relay could not quote this mint (${String(res.status)}).`, { cause: json });
+}
+function getQuote(a) {
+  const k = cacheKey(a);
+  const now = Date.now();
+  const hit = cache.get(k);
+  if (!a.fresh && hit && now - hit.at < CACHE_MS) return raceSignal(hit.quote, a.signal);
+  const quote = requestQuote(a);
+  cache.set(k, { at: now, quote });
+  quote.catch(() => {
+    if (cache.get(k)?.quote === quote) cache.delete(k);
+  });
+  return raceSignal(quote, a.signal);
+}
+var realReason = (v) => typeof v === "string" && v !== "" && v !== "N/A" ? v : null;
+async function getStatus(a) {
+  const f = a.fetch ?? globalThis.fetch;
+  const res = await raceSignal(timedFetch(f, `${a.testnet ? RELAY_API.testnet : RELAY_API.mainnet}/intents/status/v3?requestId=${a.requestId}`, {}, RELAY_TIMEOUTS.statusMs), a.signal);
+  if (!res.ok) throw new Error(`Relay status ${String(res.status)}`);
+  const j = obj(res.json);
+  return {
+    status: typeof j.status === "string" ? j.status : "unknown",
+    txHashes: Array.isArray(j.txHashes) ? j.txHashes.filter((h) => (0, import_viem3.isHex)(h)) : [],
+    failReason: realReason(j.failReason),
+    refundFailReason: realReason(j.refundFailReason)
+  };
+}
+var KEEP_POLLING = ["waiting", "depositing", "pending", "submitted", "delayed"];
+var TERMINAL = ["success", "refund", "failure"];
+
+// src/core/relay/status.ts
+var POLL_FAST_MS = 2e3;
+var POLL_SLOW_MS = 5e3;
+var POLL_FAST_FOR_MS = 6e4;
+var POLL_CAP_MS = 10 * 6e4;
+var defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
+  const t = setTimeout(resolve, ms);
+  signal?.addEventListener("abort", () => {
+    clearTimeout(t);
+    reject(new DOMException("Relay polling cancelled", "AbortError"));
+  }, { once: true });
+});
+async function pollUntilTerminal(a) {
+  const sleep = a.sleep ?? defaultSleep;
+  const now = a.now ?? Date.now;
+  const start = now();
+  let warned = false;
+  for (; ; ) {
+    a.assertActive?.();
+    try {
+      const status = await getStatus({ testnet: a.testnet, requestId: a.requestId, ...a.signal ? { signal: a.signal } : {}, ...a.fetch ? { fetch: a.fetch } : {} });
+      if (TERMINAL.includes(status.status)) return { kind: "terminal", status };
+      if (!KEEP_POLLING.includes(status.status) && !warned) {
+        warned = true;
+        console.warn(`dropkit: Relay status "${status.status}" for ${a.requestId}; still waiting.`);
+      }
+    } catch (e) {
+      if (e?.name === "AbortError") throw e;
+    }
+    a.assertActive?.();
+    const elapsed = now() - start;
+    if (elapsed >= POLL_CAP_MS) return { kind: "timeout" };
+    await sleep(elapsed < POLL_FAST_FOR_MS ? POLL_FAST_MS : POLL_SLOW_MS, a.signal);
+  }
+}
+
+// src/core/relay/outstanding.ts
+var memory = /* @__PURE__ */ new Map();
+var claimed = /* @__PURE__ */ new Set();
+function outstandingKey(config, payer) {
+  const target = config.type === "manifold-claim" ? `${config.creatorContract.toLowerCase()}:${config.instanceId}` : config.address.toLowerCase();
+  return `${String(config.chainId)}:${target}:${payer.toLowerCase()}`;
+}
+var getOutstanding = (key) => memory.get(key) ?? null;
+var setOutstanding = (key, out) => void memory.set(key, out);
+var clearOutstanding = (key) => void memory.delete(key);
+function claimDeposit(key) {
+  if (claimed.has(key) || memory.has(key)) return false;
+  claimed.add(key);
+  return true;
+}
+var releaseDeposit = (key) => void claimed.delete(key);
+
 // src/core/adapters/manifold-claim/index.ts
-var import_viem4 = require("viem");
+var import_viem5 = require("viem");
 
 // src/core/adapters/manifold-claim/abis.ts
-var import_viem3 = require("viem");
-var CLAIM_721_V5_ABI = (0, import_viem3.parseAbi)([
+var import_viem4 = require("viem");
+var CLAIM_721_V5_ABI = (0, import_viem4.parseAbi)([
   "function getClaim(address creatorContractAddress, uint256 instanceId) view returns ((uint32 total, uint32 totalMax, uint32 walletMax, uint48 startDate, uint48 endDate, uint8 storageProtocol, uint8 contractVersion, bool identical, bytes32 merkleRoot, string location, uint256 cost, address paymentReceiver, address erc20) claim)"
 ]);
-var CLAIM_1155_V5_ABI = (0, import_viem3.parseAbi)([
+var CLAIM_1155_V5_ABI = (0, import_viem4.parseAbi)([
   "function getClaim(address creatorContractAddress, uint256 instanceId) view returns ((uint32 total, uint32 totalMax, uint32 walletMax, uint48 startDate, uint48 endDate, uint8 storageProtocol, bytes32 merkleRoot, string location, uint256 tokenId, uint256 cost, address paymentReceiver, address erc20) claim)"
 ]);
-var CLAIM_721_V7_ABI = (0, import_viem3.parseAbi)([
+var CLAIM_721_V7_ABI = (0, import_viem4.parseAbi)([
   "function getClaim(address creatorContractAddress, uint256 instanceId) view returns ((uint32 total, uint32 totalMax, uint32 walletMax, uint48 startDate, uint48 endDate, uint8 storageProtocol, uint8 contractVersion, bool identical, bytes32 merkleRoot, string location, uint256 cost, address paymentReceiver, address erc20, address signingAddress) claim)"
 ]);
-var CLAIM_1155_V7_ABI = (0, import_viem3.parseAbi)([
+var CLAIM_1155_V7_ABI = (0, import_viem4.parseAbi)([
   "function getClaim(address creatorContractAddress, uint256 instanceId) view returns ((uint32 total, uint32 totalMax, uint32 walletMax, uint48 startDate, uint48 endDate, uint8 storageProtocol, bytes32 merkleRoot, string location, uint256 tokenId, uint256 cost, address paymentReceiver, address erc20, address signingAddress) claim)"
 ]);
-var EXTENSION_COMMON_ABI = (0, import_viem3.parseAbi)([
+var EXTENSION_COMMON_ABI = (0, import_viem4.parseAbi)([
   "function MINT_FEE() view returns (uint256)",
   "function MINT_FEE_MERKLE() view returns (uint256)",
   "function getTotalMints(address minter, address creatorContractAddress, uint256 instanceId) view returns (uint32)",
   "function checkMintIndices(address creatorContractAddress, uint256 instanceId, uint32[] mintIndices) view returns (bool[] minted)",
   "function mintProxy(address creatorContractAddress, uint256 instanceId, uint16 mintCount, uint32[] mintIndices, bytes32[][] merkleProofs, address mintFor) payable"
 ]);
-var EXTENSION_ERRORS_ABI = (0, import_viem3.parseAbi)([
+var EXTENSION_ERRORS_ABI = (0, import_viem4.parseAbi)([
   "error Error(string message)",
   "error Panic(uint256 code)",
   "error ClaimInactive()",
@@ -406,8 +688,8 @@ var EXTENSION_ERRORS_ABI = (0, import_viem3.parseAbi)([
   "error TokenDNE()",
   "error TooManyRequested()"
 ]);
-var CREATOR_ABI = (0, import_viem3.parseAbi)(["function getExtensions() view returns (address[])"]);
-var ERC20_ABI = (0, import_viem3.parseAbi)([
+var CREATOR_ABI = (0, import_viem4.parseAbi)(["function getExtensions() view returns (address[])"]);
+var ERC20_ABI = (0, import_viem4.parseAbi)([
   "function symbol() view returns (string)",
   "function decimals() view returns (uint8)",
   "function balanceOf(address owner) view returns (uint256)",
@@ -435,13 +717,13 @@ async function getJson(fetchFn, url, signal, what) {
 }
 var isRecord = (v) => typeof v === "object" && v !== null;
 var scopeCaches = /* @__PURE__ */ new WeakMap();
-function memo(cache, key, signal, load) {
-  const hit = cache.get(key);
+function memo(cache2, key, signal, load) {
+  const hit = cache2.get(key);
   if (hit) return hit;
   const p = withSignal(load(), signal);
-  cache.set(key, p);
+  cache2.set(key, p);
   p.catch(() => {
-    if (cache.get(key) === p) cache.delete(key);
+    if (cache2.get(key) === p) cache2.delete(key);
   });
   return p;
 }
@@ -491,8 +773,8 @@ async function fetchMerkleEntries(args) {
     scoped = { signal: args.signal, instances: /* @__PURE__ */ new Map(), entries: /* @__PURE__ */ new Map() };
     scopeCaches.set(args.scope, scoped);
   }
-  const cache = scoped;
-  const entries = await memo(cache.entries, key, cache.signal, () => loadEntries(fetchFn, args.api, args.instanceId, args.recipient, cache));
+  const cache2 = scoped;
+  const entries = await memo(cache2.entries, key, cache2.signal, () => loadEntries(fetchFn, args.api, args.instanceId, args.recipient, cache2));
   return entries.slice();
 }
 
@@ -537,14 +819,14 @@ var GAS_UNITS_APPROVE = 60000n;
 var dropResolved = /* @__PURE__ */ new WeakMap();
 var WALLET_DATA_BRAND = /* @__PURE__ */ Symbol("manifold-claim-wallet-data");
 var isWalletData = (d) => typeof d === "object" && d !== null && d.brand === WALLET_DATA_BRAND;
-var isAllowlist = (claim) => claim.merkleRoot !== import_viem4.zeroHash;
+var isAllowlist = (claim) => claim.merkleRoot !== import_viem5.zeroHash;
 function isContractFailure(e) {
-  if (!(e instanceof import_viem4.BaseError)) return false;
-  return e.walk((x) => x instanceof import_viem4.ContractFunctionRevertedError || x.name === "ContractFunctionZeroDataError") !== null;
+  if (!(e instanceof import_viem5.BaseError)) return false;
+  return e.walk((x) => x instanceof import_viem5.ContractFunctionRevertedError || x.name === "ContractFunctionZeroDataError") !== null;
 }
 function toRpcError(e) {
   if (e instanceof MintError) return e;
-  const msg = e instanceof import_viem4.BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
+  const msg = e instanceof import_viem5.BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
   return new MintError("RPC_ERROR", `RPC request failed: ${msg}`, { cause: e });
 }
 async function rpc(fn) {
@@ -557,19 +839,19 @@ async function rpc(fn) {
 function revertData(e) {
   const hit = e.walk((x) => {
     const d2 = x.data;
-    return (0, import_viem4.isHex)(d2) && d2.length >= 10 || typeof d2 === "object" && d2 !== null && (0, import_viem4.isHex)(d2.data);
+    return (0, import_viem5.isHex)(d2) && d2.length >= 10 || typeof d2 === "object" && d2 !== null && (0, import_viem5.isHex)(d2.data);
   });
   const d = hit?.data;
-  if ((0, import_viem4.isHex)(d)) return d;
+  if ((0, import_viem5.isHex)(d)) return d;
   const inner = d?.data;
-  return (0, import_viem4.isHex)(inner) ? inner : void 0;
+  return (0, import_viem5.isHex)(inner) ? inner : void 0;
 }
 function decodeRevert(e) {
-  if (!(e instanceof import_viem4.BaseError)) return null;
+  if (!(e instanceof import_viem5.BaseError)) return null;
   const data = revertData(e);
   if (data) {
     try {
-      const d = (0, import_viem4.decodeErrorResult)({ abi: EXTENSION_ERRORS_ABI, data });
+      const d = (0, import_viem5.decodeErrorResult)({ abi: EXTENSION_ERRORS_ABI, data });
       if (d.errorName === "Error" && typeof d.args?.[0] === "string") return d.args[0];
       if (d.errorName === "Panic") return `Panic(${String(d.args?.[0])})`;
       return d.errorName;
@@ -578,33 +860,33 @@ function decodeRevert(e) {
     }
   }
   const named = e.walk((x) => ["ExecutionRevertedError", "InsufficientFundsError"].includes(x.name));
-  return named instanceof import_viem4.BaseError ? named.shortMessage : null;
+  return named instanceof import_viem5.BaseError ? named.shortMessage : null;
 }
-var money = (value, decimals, symbol) => ({ value, decimals, symbol, formatted: (0, import_viem4.formatUnits)(value, decimals) });
+var money = (value, decimals, symbol) => ({ value, decimals, symbol, formatted: (0, import_viem5.formatUnits)(value, decimals) });
 function timestamp(v, field) {
   if (v === 0n) return null;
   if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new MintError("RPC_ERROR", `Claim ${field} does not fit a safe integer`);
   return Number(v);
 }
 function parseConfig(config) {
-  if (!(0, import_viem4.isAddress)(config.creatorContract, { strict: false })) {
+  if (!(0, import_viem5.isAddress)(config.creatorContract, { strict: false })) {
     throw new MintError("INVALID_CONFIG", "creatorContract is not a valid address.", { field: "creatorContract" });
   }
-  if (config.extension !== void 0 && !(0, import_viem4.isAddress)(config.extension, { strict: false })) {
+  if (config.extension !== void 0 && !(0, import_viem5.isAddress)(config.extension, { strict: false })) {
     throw new MintError("INVALID_CONFIG", "extension is not a valid address.", { field: "extension" });
   }
   if (typeof config.instanceId !== "string" || !/^\d+$/.test(config.instanceId)) {
     throw new MintError("INVALID_CONFIG", "instanceId must be a non-negative integer string.", { field: "instanceId" });
   }
   return {
-    creator: (0, import_viem4.getAddress)(config.creatorContract),
+    creator: (0, import_viem5.getAddress)(config.creatorContract),
     instanceId: BigInt(config.instanceId),
-    extension: config.extension === void 0 ? void 0 : (0, import_viem4.getAddress)(config.extension)
+    extension: config.extension === void 0 ? void 0 : (0, import_viem5.getAddress)(config.extension)
   };
 }
 var notFound = (config) => new MintError("CLAIM_NOT_FOUND", `No Manifold claim ${config.instanceId} found on ${config.creatorContract}.`);
 async function readClaim(client, entry, creator, instanceId, config) {
-  const address = (0, import_viem4.getAddress)(entry.address);
+  const address = (0, import_viem5.getAddress)(entry.address);
   const args = [creator, instanceId];
   try {
     switch (entry.abi) {
@@ -643,7 +925,7 @@ function base2(c) {
   };
 }
 async function hasCode(client, address) {
-  const code2 = await rpc(() => client.getCode({ address: (0, import_viem4.getAddress)(address) }));
+  const code2 = await rpc(() => client.getCode({ address: (0, import_viem5.getAddress)(address) }));
   return code2 !== void 0 && code2 !== "0x";
 }
 var unknownExtension = (address, why) => new MintError("UNKNOWN_EXTENSION", `Extension ${address} ${why}.`);
@@ -687,21 +969,21 @@ async function resolveExtension(ctx, config) {
 }
 async function loadDrop(ctx, config) {
   const { entry, claim } = await resolveExtension(ctx, config);
-  if (claim.signingAddress !== null && claim.signingAddress !== import_viem4.zeroAddress) {
+  if (claim.signingAddress !== null && claim.signingAddress !== import_viem5.zeroAddress) {
     throw new MintError("SIGNATURE_CLAIM", "This claim mints with a signature (redemption code), which this button does not support.");
   }
   const { client } = ctx;
-  const extension = (0, import_viem4.getAddress)(entry.address);
+  const extension = (0, import_viem5.getAddress)(entry.address);
   const fee = await rpc(
     () => client.readContract({ address: extension, abi: EXTENSION_COMMON_ABI, functionName: isAllowlist(claim) ? "MINT_FEE_MERKLE" : "MINT_FEE" })
   );
   const native = client.chain?.nativeCurrency ?? { symbol: "ETH", decimals: 18 };
   let unitPrice;
   let paymentToken = null;
-  if (claim.erc20 === import_viem4.zeroAddress) {
+  if (claim.erc20 === import_viem5.zeroAddress) {
     unitPrice = money(claim.cost, native.decimals, native.symbol);
   } else {
-    paymentToken = (0, import_viem4.getAddress)(claim.erc20);
+    paymentToken = (0, import_viem5.getAddress)(claim.erc20);
     const token = paymentToken;
     const [symbol, decimals] = await rpc(
       () => Promise.all([
@@ -732,9 +1014,9 @@ async function loadWallet(ctx, config, args) {
   const { client } = ctx;
   const resolved = dropResolved.get(args.drop) ?? (await loadDrop(ctx, config)).resolved;
   const { entry, claim } = resolved;
-  const extension = (0, import_viem4.getAddress)(entry.address);
-  const payer = (0, import_viem4.getAddress)(args.payer);
-  const recipient = (0, import_viem4.getAddress)(args.recipient);
+  const extension = (0, import_viem5.getAddress)(entry.address);
+  const payer = (0, import_viem5.getAddress)(args.payer);
+  const recipient = (0, import_viem5.getAddress)(args.recipient);
   let walletMinted = null;
   let walletMax = null;
   let allowlistRemaining = null;
@@ -770,7 +1052,7 @@ async function loadWallet(ctx, config, args) {
     maxQuantity = Number(left);
     if (left === 0n) ineligible = { reason: "WALLET_LIMIT", message: `This wallet has already minted its limit of ${walletMax}.` };
   }
-  const token = claim.erc20 === import_viem4.zeroAddress ? null : (0, import_viem4.getAddress)(claim.erc20);
+  const token = claim.erc20 === import_viem5.zeroAddress ? null : (0, import_viem5.getAddress)(claim.erc20);
   const [native, erc20, gasPrice] = await rpc(
     () => Promise.all([
       client.getBalance({ address: payer }),
@@ -798,8 +1080,8 @@ async function buildPlan(ctx, attempt, wallet) {
     throw new MintError("INVALID_CONFIG", `quantity must be an integer from 1 to ${MAX_MINT_COUNT}.`, { field: "quantity" });
   }
   const { creator, instanceId } = parseConfig(config);
-  const recipient = (0, import_viem4.getAddress)(attempt.recipient);
-  const payer = (0, import_viem4.getAddress)(attempt.payer);
+  const recipient = (0, import_viem5.getAddress)(attempt.recipient);
+  const payer = (0, import_viem5.getAddress)(attempt.payer);
   let data = wallet.data;
   if (!isWalletData(data) || !sameClaim(data.config, config) || data.recipient !== recipient) {
     const drop = (await loadDrop(ctx, config)).drop;
@@ -807,7 +1089,7 @@ async function buildPlan(ctx, attempt, wallet) {
   }
   if (!isWalletData(data)) throw new MintError("RPC_ERROR", "Wallet read produced no plan data.");
   const { entry, claim, fee } = data.resolved;
-  const extension = (0, import_viem4.getAddress)(entry.address);
+  const extension = (0, import_viem5.getAddress)(entry.address);
   let mintIndices = [];
   let merkleProofs = [];
   if (isAllowlist(claim)) {
@@ -819,7 +1101,7 @@ async function buildPlan(ctx, attempt, wallet) {
     merkleProofs = picked.map((p) => p.proof);
   }
   const qty = BigInt(quantity);
-  const erc20 = claim.erc20 === import_viem4.zeroAddress ? null : (0, import_viem4.getAddress)(claim.erc20);
+  const erc20 = claim.erc20 === import_viem5.zeroAddress ? null : (0, import_viem5.getAddress)(claim.erc20);
   const cost = claim.cost * qty;
   const value = fee * qty + (erc20 ? 0n : cost);
   let approve = null;
@@ -830,7 +1112,7 @@ async function buildPlan(ctx, attempt, wallet) {
         token: erc20,
         spender: extension,
         amount: cost,
-        tx: { to: erc20, data: (0, import_viem4.encodeFunctionData)({ abi: ERC20_ABI, functionName: "approve", args: [extension, cost] }), value: 0n }
+        tx: { to: erc20, data: (0, import_viem5.encodeFunctionData)({ abi: ERC20_ABI, functionName: "approve", args: [extension, cost] }), value: 0n }
       };
     }
   }
@@ -838,7 +1120,7 @@ async function buildPlan(ctx, attempt, wallet) {
     approve,
     mint: {
       to: extension,
-      data: (0, import_viem4.encodeFunctionData)({
+      data: (0, import_viem5.encodeFunctionData)({
         abi: EXTENSION_COMMON_ABI,
         functionName: "mintProxy",
         args: [creator, instanceId, quantity, mintIndices, merkleProofs.map((p) => [...p]), recipient]
@@ -848,13 +1130,18 @@ async function buildPlan(ctx, attempt, wallet) {
     tokenContract: creator
   };
 }
+var RELAY_VERIFIED = ["V6", "V7"];
 var manifoldClaimAdapter = {
+  supportsRelay: (drop) => {
+    const resolved = dropResolved.get(drop);
+    return resolved !== void 0 && RELAY_VERIFIED.includes(resolved.entry.generation) && drop.paymentToken === null;
+  },
   readDrop: async (ctx, config) => (await loadDrop(ctx, config)).drop,
   readWallet: loadWallet,
   buildPlan,
   simulate: async (ctx, attempt, plan) => {
     try {
-      await ctx.client.call({ account: (0, import_viem4.getAddress)(attempt.payer), to: plan.mint.to, data: plan.mint.data, value: plan.mint.value });
+      await ctx.client.call({ account: (0, import_viem5.getAddress)(attempt.payer), to: plan.mint.to, data: plan.mint.data, value: plan.mint.value });
     } catch (e) {
       const text2 = decodeRevert(e);
       if (text2 === null) throw toRpcError(e);
@@ -864,10 +1151,10 @@ var manifoldClaimAdapter = {
 };
 
 // src/core/adapters/contract/index.ts
-var import_viem6 = require("viem");
+var import_viem7 = require("viem");
 
 // src/core/machine.ts
-var import_viem5 = require("viem");
+var import_viem6 = require("viem");
 var MINT_STATES = [
   "loading",
   "unsupported",
@@ -904,9 +1191,15 @@ function initialState(opts) {
     attempt: null,
     result: null,
     pendingRefresh: false,
-    now: 0
+    now: 0,
+    crossChain: false,
+    routePending: false,
+    route: null,
+    short: null
   };
 }
+var NO_ROUTE = { crossChain: false, routePending: false, route: null, short: null };
+var PICK_ANOTHER = "Pick another network to pay from.";
 function toQuantity(q, max) {
   if (Number.isNaN(q)) return 1;
   return Math.max(1, Math.min(Math.floor(q), max));
@@ -931,11 +1224,17 @@ function derive(s, unsupported) {
   if (walletRead.ineligible !== null) {
     return { name: "ineligible", reason: walletRead.ineligible.reason, message: walletRead.ineligible.message };
   }
+  if (s.routePending) return named("loading");
+  if (s.route?.kind === "relay") return named("live");
+  if (s.short !== null) {
+    return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${s.short.symbol} on ${s.short.name}. ${PICK_ANOTHER}` };
+  }
   const total = selectTotal(s);
   if (total !== null) {
     const { native, erc20 } = total;
     if (native.value + walletRead.gasReserve > walletRead.balances.native) {
-      return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${native.symbol} to cover the mint.` };
+      const more = s.crossChain ? ` ${PICK_ANOTHER}` : "";
+      return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${native.symbol} to cover the mint.${more}` };
     }
     if (erc20 !== null && walletRead.balances.erc20 !== null && erc20.value > walletRead.balances.erc20) {
       return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${erc20.symbol} to cover the mint.` };
@@ -964,7 +1263,7 @@ function reducer(state, event) {
         const next2 = { ...state, readGen: event.gen };
         return inFlight ? { ...next2, pendingRefresh: true } : settle(next2);
       }
-      const next = { ...state, readGen: event.gen, drop: null, walletRead: null, blocked: null, walletGen: state.walletGen + 1 };
+      const next = { ...state, ...NO_ROUTE, readGen: event.gen, drop: null, walletRead: null, blocked: null, walletGen: state.walletGen + 1 };
       return inFlight ? { ...next, pendingRefresh: true } : settle(next, false);
     }
     case "DROP_LOADED": {
@@ -982,16 +1281,22 @@ function reducer(state, event) {
     case "READ_FAILED":
       return event.gen !== state.readGen ? state : failed(event.reason, event.message);
     case "ACCOUNT_CHANGED": {
-      const next = { ...state, account: event.account, walletRead: null, blocked: null, walletGen: state.walletGen + 1 };
+      const next = { ...state, ...NO_ROUTE, account: event.account, walletRead: null, blocked: null, walletGen: state.walletGen + 1 };
       if (inFlight) return { ...next, pendingRefresh: true };
       if (state.name === "connecting") return event.account === null ? next : settle({ ...next, name: "loading" }, false);
       return settle(next);
     }
     case "WALLET_LOADED": {
       if (event.gen !== state.walletGen) return state;
-      const next = { ...state, walletRead: event.read, blocked: null };
+      const route = event.routePending ? { routePending: state.route === null && state.short === null, route: state.route, short: state.short } : { routePending: false, route: null, short: null };
+      const next = { ...state, ...route, crossChain: event.crossChain ?? false, walletRead: event.read, blocked: null };
       return inFlight ? { ...next, pendingRefresh: true } : settle(clampQuantity(next));
     }
+    case "ROUTE_LOADED": {
+      if (event.gen !== state.walletGen) return state;
+      const next = { ...state, routePending: false, route: event.route, short: event.short };
+      return inFlight ? { ...next, pendingRefresh: true } : settle(next);
+    }
     case "WALLET_FAILED":
       return event.gen !== state.walletGen ? state : failed(event.reason, event.message);
     case "CONNECT_STARTED":
@@ -1005,7 +1310,9 @@ function reducer(state, event) {
       return inFlight ? { ...next, pendingRefresh: true } : settle(next);
     }
     case "ATTEMPT_STARTED":
-      return state.name === "live" && state.attempt === null ? { ...state, attempt: event.attempt } : state;
+      if (state.attempt !== null) return state;
+      if (event.resume === true) return IN_FLIGHT_STATES.includes(state.name) ? state : { ...state, attempt: event.attempt };
+      return state.name === "live" ? { ...state, attempt: event.attempt } : state;
     case "SWITCHING_CHAIN":
       return step(state, event.attemptId, "switching-chain");
     case "APPROVING":
@@ -1047,6 +1354,7 @@ function reducer(state, event) {
       const next = {
         ...state,
         readGen: event.gen,
+        ...NO_ROUTE,
         walletRead: null,
         blocked: null,
         walletGen: state.walletGen + 1,
@@ -1092,7 +1400,7 @@ function selectTotal(state) {
   return { native: money2(priceTotal + fee.value * q, price), erc20: null };
 }
 function money2(value, like) {
-  return { value, decimals: like.decimals, symbol: like.symbol, formatted: (0, import_viem5.formatUnits)(value, like.decimals) };
+  return { value, decimals: like.decimals, symbol: like.symbol, formatted: (0, import_viem6.formatUnits)(value, like.decimals) };
 }
 function canAct(state) {
   return state.attempt === null && CLICKABLE_STATES.includes(state.name);
@@ -1100,7 +1408,7 @@ function canAct(state) {
 
 // src/core/adapters/contract/index.ts
 var PLACEHOLDERS = ["{recipient}", "{payer}", "{quantity}", "{unitPrice}", "{totalPrice}"];
-var ERC20_ABI2 = (0, import_viem6.parseAbi)([
+var ERC20_ABI2 = (0, import_viem7.parseAbi)([
   "function symbol() view returns (string)",
   "function decimals() view returns (uint8)",
   "function balanceOf(address) view returns (uint256)",
@@ -1115,7 +1423,7 @@ var NUMERIC_TYPE = /^u?int\d*$/;
 function bad(field, message) {
   throw new MintError("INVALID_CONFIG", `${field} ${message}`, { field });
 }
-var isHexAddress = (a) => typeof a === "string" && (0, import_viem6.isAddress)(a, { strict: false });
+var isHexAddress = (a) => typeof a === "string" && (0, import_viem7.isAddress)(a, { strict: false });
 function functionsNamed(abi, name) {
   return abi.filter((i) => i.type === "function" && i.name === name);
 }
@@ -1172,7 +1480,7 @@ function typeIssue(t, p, path) {
   if (Array.isArray(t)) return no(`must not be an array for ${p.type}`);
   if (p.type === "address") {
     if (isExactPlaceholder(t)) return t === "{recipient}" || t === "{payer}" ? null : no(`${t} is a number, but the abi input is an address`);
-    return typeof t === "string" && !hasPlaceholder(t) && (0, import_viem6.isAddress)(t) ? null : no(`${JSON.stringify(String(t))} is not an address`);
+    return typeof t === "string" && !hasPlaceholder(t) && (0, import_viem7.isAddress)(t) ? null : no(`${JSON.stringify(String(t))} is not an address`);
   }
   if (p.type === "bool") return typeof t === "boolean" ? null : no(`${JSON.stringify(String(t))} is not a boolean`);
   if (p.type === "string") return typeof t === "string" ? null : no(`${JSON.stringify(String(t))} is not a string`);
@@ -1329,7 +1637,7 @@ function varFor(token, vars) {
   const key = token.slice(1, -1);
   const v = vars[key];
   if (v === void 0) throw new MintError("INVALID_CONFIG", `placeholder ${token} has no value here`);
-  return typeof v === "string" ? (0, import_viem6.getAddress)(v) : v;
+  return typeof v === "string" ? (0, import_viem7.getAddress)(v) : v;
 }
 function fill(t, p, vars) {
   const arr = ARRAY_TYPE.exec(p.type);
@@ -1345,7 +1653,7 @@ function fill(t, p, vars) {
 var fillArgs = (args, inputs, vars) => (args ?? []).map((a, i) => fill(a, inputs[i], vars));
 var totalFor = (per, price, quantity) => per === "total" ? price : price * quantity;
 function shortMessage(e) {
-  return e instanceof import_viem6.BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
+  return e instanceof import_viem7.BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
 }
 var abortError = () => new DOMException("The operation was aborted", "AbortError");
 var isAbortError = (e) => e?.name === "AbortError";
@@ -1368,7 +1676,7 @@ function rpcError(e) {
 }
 function classifyReadError(e, field) {
   if (isMintError(e) || isAbortError(e)) throw e;
-  if (e instanceof import_viem6.BaseError && e.walk((x) => x instanceof import_viem6.ContractFunctionRevertedError || x instanceof import_viem6.ContractFunctionZeroDataError)) {
+  if (e instanceof import_viem7.BaseError && e.walk((x) => x instanceof import_viem7.ContractFunctionRevertedError || x instanceof import_viem7.ContractFunctionZeroDataError)) {
     throw new MintError("INVALID_CONFIG", `${field} read reverted or returned no data: ${e.shortMessage}`, { field, cause: e });
   }
   return rpcError(e);
@@ -1418,7 +1726,7 @@ function nativeMeta(ctx) {
   const n = ctx.client.chain?.nativeCurrency;
   return { decimals: n?.decimals ?? 18, symbol: n?.symbol ?? "ETH" };
 }
-var erc20Of = (config) => config.price.currency === "native" ? null : (0, import_viem6.getAddress)(config.price.currency.address);
+var erc20Of = (config) => config.price.currency === "native" ? null : (0, import_viem7.getAddress)(config.price.currency.address);
 async function currencyMeta(ctx, config) {
   const token = erc20Of(config);
   if (!token) return { token, ...nativeMeta(ctx) };
@@ -1437,7 +1745,7 @@ function parseDisplay(value, decimals) {
   if (frac.length > decimals) {
     throw new MintError("INVALID_CONFIG", `price.value "${value}" has more than ${decimals} decimal places`, { field: "price.value" });
   }
-  return (0, import_viem6.parseUnits)(value, decimals);
+  return (0, import_viem7.parseUnits)(value, decimals);
 }
 async function resolvePrice(ctx, config, meta) {
   const price = config.price;
@@ -1450,7 +1758,7 @@ var money3 = (value, decimals, symbol) => ({
   value,
   decimals,
   symbol,
-  formatted: (0, import_viem6.formatUnits)(value, decimals)
+  formatted: (0, import_viem7.formatUnits)(value, decimals)
 });
 function revertData2(e) {
   for (let cur = e, depth = 0; cur && depth < 12; depth++) {
@@ -1466,7 +1774,7 @@ function revertData2(e) {
 }
 function describeRevert(abi, data) {
   try {
-    const d = (0, import_viem6.decodeErrorResult)({ abi, data });
+    const d = (0, import_viem7.decodeErrorResult)({ abi, data });
     const args = d.args ?? [];
     if (d.errorName === "Error") return String(args[0] ?? "execution reverted");
     const inputs = d.abiItem?.inputs ?? [];
@@ -1479,12 +1787,12 @@ function describeRevert(abi, data) {
 function toSimulationError(e, abi) {
   if (isMintError(e)) return e;
   if (isAbortError(e)) throw e;
-  if (e instanceof import_viem6.BaseError && e.walk((x) => x instanceof import_viem6.InsufficientFundsError)) {
+  if (e instanceof import_viem7.BaseError && e.walk((x) => x instanceof import_viem7.InsufficientFundsError)) {
     return new MintError("INSUFFICIENT_FUNDS", `Payer cannot cover the mint: ${e.shortMessage}`, { cause: e });
   }
   const data = revertData2(e);
   if (data) return new MintError("SIMULATION_REVERTED", describeRevert(abi, data), { cause: e });
-  const isRevert = e instanceof import_viem6.BaseError && e.walk((x) => x.code === 3 || /execution reverted/i.test(x.message));
+  const isRevert = e instanceof import_viem7.BaseError && e.walk((x) => x.code === 3 || /execution reverted/i.test(x.message));
   if (isRevert) return new MintError("SIMULATION_REVERTED", shortMessage(e), { cause: e });
   return new MintError("RPC_ERROR", `RPC request failed: ${shortMessage(e)}`, { cause: e });
 }
@@ -1498,7 +1806,7 @@ async function simulateMint(ctx, config, call) {
 function encodeMint(config, vars) {
   const fn = validateCall(config.abi, config.mint, "mint", "mint", PLACEHOLDERS);
   try {
-    return (0, import_viem6.encodeFunctionData)({ abi: [fn], functionName: fn.name, args: fillArgs(config.mint.args, fn.inputs, vars) });
+    return (0, import_viem7.encodeFunctionData)({ abi: [fn], functionName: fn.name, args: fillArgs(config.mint.args, fn.inputs, vars) });
   } catch (e) {
     if (isMintError(e)) throw e;
     throw new MintError("INVALID_CONFIG", `mint.args cannot be encoded for ${signature(fn)}: ${shortMessage(e)}`, { field: "mint.args", cause: e });
@@ -1563,7 +1871,7 @@ async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
   if (remaining === 0n) {
     ineligible = { reason: "WALLET_LIMIT", message: `This wallet has already minted its limit of ${walletMax}.` };
   } else if (drop.paymentToken === null && native >= totalPrice) {
-    const call = { payer, to: (0, import_viem6.getAddress)(config.address), data: encodeMint(config, vars), value: mintValue(config, null, totalPrice) };
+    const call = { payer, to: (0, import_viem7.getAddress)(config.address), data: encodeMint(config, vars), value: mintValue(config, null, totalPrice) };
     try {
       await simulateMint(ctx, config, call);
       gas = await io(ctx, () => ctx.client.estimateGas({ account: payer, to: call.to, data: call.data, value: call.value })).catch((e) => {
@@ -1594,7 +1902,7 @@ async function buildPlan2(ctx, attempt, wallet) {
   const qty = BigInt(attempt.quantity);
   const unitPrice = await resolvePrice(ctx, config);
   const totalPrice = totalFor(config.price.per ?? "unit", unitPrice, qty);
-  const to = (0, import_viem6.getAddress)(config.address);
+  const to = (0, import_viem7.getAddress)(config.address);
   const token = erc20Of(config);
   const mint = {
     to,
@@ -1612,11 +1920,11 @@ async function buildPlan2(ctx, attempt, wallet) {
         token,
         spender: to,
         amount: totalPrice,
-        tx: { to: token, data: (0, import_viem6.encodeFunctionData)({ abi: ERC20_ABI2, functionName: "approve", args: [to, totalPrice] }), value: 0n }
+        tx: { to: token, data: (0, import_viem7.encodeFunctionData)({ abi: ERC20_ABI2, functionName: "approve", args: [to, totalPrice] }), value: 0n }
       };
     }
   }
-  return { approve, mint, tokenContract: (0, import_viem6.getAddress)(attempt.tokenContract) };
+  return { approve, mint, tokenContract: (0, import_viem7.getAddress)(attempt.tokenContract) };
 }
 async function simulate(ctx, attempt, plan) {
   throwIfAborted(ctx);
@@ -1625,29 +1933,29 @@ async function simulate(ctx, attempt, plan) {
 var contractAdapter = { readDrop, readWallet, buildPlan: buildPlan2, simulate };
 
 // src/core/adapters/receipt.ts
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
 var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
 var TRANSFER_SINGLE_TOPIC = "0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62";
 var TRANSFER_BATCH_TOPIC = "0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb";
-var topicAddress = (t) => t && t.length === 66 ? (0, import_viem7.getAddress)(`0x${t.slice(26)}`) : null;
+var topicAddress = (t) => t && t.length === 66 ? (0, import_viem8.getAddress)(`0x${t.slice(26)}`) : null;
 function parseMintReceipt(logs, { tokenContract, recipient }) {
-  const contract = (0, import_viem7.getAddress)(tokenContract);
-  const to = (0, import_viem7.getAddress)(recipient);
+  const contract = (0, import_viem8.getAddress)(tokenContract);
+  const to = (0, import_viem8.getAddress)(recipient);
   const out = /* @__PURE__ */ new Map();
   const add = (id, amount) => out.set(id, (out.get(id) ?? 0n) + amount);
   for (const log of logs) {
-    if ((0, import_viem7.getAddress)(log.address) !== contract) continue;
+    if ((0, import_viem8.getAddress)(log.address) !== contract) continue;
     const [t0, t1, t2, t3] = log.topics;
     if (t0 === TRANSFER_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t1) !== import_viem7.zeroAddress || topicAddress(t2) !== to || !t3) continue;
+      if (topicAddress(t1) !== import_viem8.zeroAddress || topicAddress(t2) !== to || !t3) continue;
       add(BigInt(t3), 1n);
     } else if (t0 === TRANSFER_SINGLE_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t2) !== import_viem7.zeroAddress || topicAddress(t3) !== to) continue;
-      const [id, value] = (0, import_viem7.decodeAbiParameters)([{ type: "uint256" }, { type: "uint256" }], log.data);
+      if (topicAddress(t2) !== import_viem8.zeroAddress || topicAddress(t3) !== to) continue;
+      const [id, value] = (0, import_viem8.decodeAbiParameters)([{ type: "uint256" }, { type: "uint256" }], log.data);
       add(id, value);
     } else if (t0 === TRANSFER_BATCH_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t2) !== import_viem7.zeroAddress || topicAddress(t3) !== to) continue;
-      const [ids, values] = (0, import_viem7.decodeAbiParameters)([{ type: "uint256[]" }, { type: "uint256[]" }], log.data);
+      if (topicAddress(t2) !== import_viem8.zeroAddress || topicAddress(t3) !== to) continue;
+      const [ids, values] = (0, import_viem8.decodeAbiParameters)([{ type: "uint256[]" }, { type: "uint256[]" }], log.data);
       if (ids.length !== values.length) continue;
       ids.forEach((id, i) => add(id, values[i]));
     }
@@ -1694,6 +2002,7 @@ function friendlyErrorMessage(error) {
   if (isMintError(error)) {
     if (error.reason === "INSUFFICIENT_FUNDS") return fundsMessage(collect(error.cause)) ?? error.message;
     if (error.reason !== "RPC_ERROR" && error.reason !== "SIMULATION_REVERTED") return error.message;
+    if (error.reason === "SIMULATION_REVERTED" && error.domain === "relay") return error.message;
     if (error.reason === "SIMULATION_REVERTED" && (error.message === "The token refused the approval." || error.message === "The drop is no longer available for this quantity.")) return error.message;
   }
   const errors = collect(error);
@@ -1755,6 +2064,25 @@ function adapterFor(config) {
   return config.type === "manifold-claim" ? manifoldClaimAdapter : contractAdapter;
 }
 var bridgeEnabled = (config) => config.type === "manifold-claim";
+function payChainsOf(config, option) {
+  if (config.type !== "manifold-claim" || option === false) return [];
+  const all = payChainsFor(config.chainId);
+  const narrowed = typeof option === "object" && option.chains ? all.filter((id) => id === config.chainId || option.chains.includes(id)) : all;
+  return narrowed.length > 1 ? narrowed : [];
+}
+function routeChainOf(payChains, accountChainId, payChainId) {
+  if (payChainId !== void 0 && payChains.includes(payChainId)) return payChainId;
+  return accountChainId;
+}
+var ROUTE_DEBOUNCE_MS = 500;
+var symbolOf = (chainId) => {
+  try {
+    return getChain(chainId).nativeCurrency.symbol;
+  } catch {
+    return "ETH";
+  }
+};
+var shortOf = (chainId) => ({ chainId, symbol: symbolOf(chainId), name: chainName(chainId) });
 function tokenContractOf(config) {
   return config.type === "manifold-claim" ? config.creatorContract : config.tokenContract ?? config.address;
 }
@@ -1812,6 +2140,8 @@ function useMint(options) {
   const widgetFailRef = (0, import_react.useRef)(null);
   const widgetLoadRef = (0, import_react.useRef)(null);
   const pushAccountRef = (0, import_react.useRef)(null);
+  const autoResumedRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+  const [crossChainInfo, setCrossChainInfo] = (0, import_react.useState)(null);
   (0, import_react.useEffect)(() => {
     stateRef.current = machine;
     propsRef.current = options;
@@ -1827,6 +2157,7 @@ function useMint(options) {
     if (!handler || !mounted.current) return;
     const cfg = attemptRef.current?.config ?? propsRef.current.config;
     const s = stateRef.current;
+    const originChainId = attemptRef.current?.originChainId ?? (s.route?.kind === "relay" ? s.route.originChainId : s.short?.chainId ?? cfg.chainId);
     const payload = {
       type,
       state: s.name,
@@ -1834,6 +2165,8 @@ function useMint(options) {
       chainId: cfg.chainId,
       quantity: s.quantity,
       config: { type: cfg.type, chainId: cfg.chainId, address: eventAddressOf(cfg) },
+      route: originChainId === cfg.chainId ? "direct" : "relay",
+      originChainId,
       ...over
     };
     try {
@@ -1953,7 +2286,7 @@ function useMint(options) {
           if (cancelled) throw new MintError("USER_REJECTED", "The transaction was cancelled or replaced with a different transaction.");
           if (await walletFor().getChainId() !== attempt.chainId) throw e;
           assertActive();
-          receipt2 = await walletFor().extend(import_viem8.publicActions).waitForTransactionReceipt(params);
+          receipt2 = await walletFor().extend(import_viem9.publicActions).waitForTransactionReceipt(params);
         }
         assertActive();
         if (cancelled) throw new MintError("USER_REJECTED", "The transaction was cancelled or replaced with a different transaction.");
@@ -1976,8 +2309,8 @@ function useMint(options) {
           }
         } catch (e) {
           if (isMintError(e)) throw e;
-          const reverted = e instanceof import_viem8.BaseError ? e.walk((cause) => cause instanceof import_viem8.ExecutionRevertedError) : null;
-          if (reverted instanceof import_viem8.ExecutionRevertedError) {
+          const reverted = e instanceof import_viem9.BaseError ? e.walk((cause) => cause instanceof import_viem9.ExecutionRevertedError) : null;
+          if (reverted instanceof import_viem9.ExecutionRevertedError) {
             throw new MintError("SIMULATION_REVERTED", reverted.shortMessage);
           }
           throw e;
@@ -2033,6 +2366,156 @@ function useMint(options) {
     },
     [clientFor, ctxFor, dispatch, emit]
   );
+  const finishRelay = (0, import_react.useCallback)(
+    async (attempt, out, life) => {
+      const cfg = attempt.config;
+      const client = clientFor(life, cfg);
+      const assertActive = () => {
+        if (!mounted.current || life.controller.signal.aborted || lifeRef.current !== life || attemptRef.current !== attempt) {
+          throw new DOMException("Mint attempt cancelled", "AbortError");
+        }
+      };
+      const outcome = await pollUntilTerminal({ testnet: out.testnet, requestId: out.requestId, signal: life.controller.signal, assertActive });
+      assertActive();
+      const where = chainName(out.originChainId);
+      if (outcome.kind === "timeout") {
+        throw new MintError("BRIDGE_TIMEOUT", "The bridge is still processing. Your mint may still complete.");
+      }
+      const key = outstandingKey(attempt.config, attempt.payer);
+      const { status } = outcome;
+      if (status.status !== "success") clearOutstanding(key);
+      if (status.status === "refund") {
+        throw new MintError("BRIDGE_REFUNDED", `Relay could not complete the mint and is refunding your payment. Relay request ${out.requestId}.`);
+      }
+      if (status.status === "failure") {
+        const why = status.failReason ? ` (${status.failReason})` : "";
+        const noRefund = status.refundFailReason ? ` No automatic refund was sent. Contact support with Relay request ${out.requestId}.` : "";
+        throw new MintError("BRIDGE_FAILED", `Relay could not complete the mint paid on ${where}${why}.${noRefund}`);
+      }
+      const fillHash = status.txHashes[0] ?? null;
+      let tokens = [];
+      if (fillHash) {
+        try {
+          const receipt = await client.waitForTransactionReceipt({ hash: fillHash, confirmations: 1, timeout: 6e4 });
+          if (receiptOk(receipt.status)) {
+            tokens = parseMintReceipt(receipt.logs ?? [], { tokenContract: attempt.tokenContract, recipient: attempt.recipient });
+          }
+        } catch {
+        }
+        assertActive();
+      }
+      const txHash = fillHash ?? out.originTxHash;
+      const result = {
+        txHash,
+        explorerUrl: explorerUrlFor(fillHash ? cfg.chainId : out.originChainId, txHash),
+        tokens,
+        relay: { requestId: out.requestId, originTxHash: out.originTxHash, originChainId: out.originChainId }
+      };
+      clearOutstanding(key);
+      dispatch({ type: "ATTEMPT_SUCCEEDED", attemptId: attempt.attemptId, result });
+      emit("success", { state: "success", reason: null, txHash, quantity: attempt.quantity, chainId: cfg.chainId });
+    },
+    [clientFor, dispatch, emit]
+  );
+  const executeRelayAttempt = (0, import_react.useCallback)(
+    async (attempt, walletRead, life, account2) => {
+      const cfg = attempt.config;
+      const adapter = adapterFor(cfg);
+      const ctx = ctxFor(life, cfg);
+      const testnet = isRelayTestnet(cfg.chainId);
+      const origin = attempt.originChainId;
+      const assertPayer = () => {
+        if (!mounted.current || life.controller.signal.aborted || lifeRef.current !== life || attemptRef.current !== attempt) {
+          throw new DOMException("Mint attempt cancelled", "AbortError");
+        }
+        const live = getAccount();
+        if (!live || live.address.toLowerCase() !== attempt.payer.toLowerCase()) {
+          throw new MintError("USER_REJECTED", "The connected wallet changed before the transaction was sent.");
+        }
+      };
+      assertPayer();
+      if (account2.chainId !== origin) {
+        dispatch({ type: "SWITCHING_CHAIN", attemptId: attempt.attemptId });
+        await switchToChain(origin);
+      }
+      assertPayer();
+      const plan = await adapter.buildPlan(ctx, attempt, walletRead);
+      if (plan.approve) throw new MintError("BRIDGE_UNAVAILABLE", "Cross-chain mint supports native-priced drops only.");
+      assertPayer();
+      const quote = await getQuote({
+        testnet,
+        payer: attempt.payer,
+        recipient: attempt.recipient,
+        originChainId: origin,
+        destinationChainId: cfg.chainId,
+        tx: plan.mint,
+        fresh: true,
+        signal: life.controller.signal
+      });
+      assertPayer();
+      const balance = await getConnectedBalance(attempt.payer, origin);
+      if (balance < quote.amountIn.value + quote.originGas.value) {
+        const s = shortOf(origin);
+        throw new MintError("INSUFFICIENT_FUNDS", `Not enough ${s.symbol} on ${s.name}. Pick another network to pay from.`);
+      }
+      assertPayer();
+      const item = quote.items[0];
+      const key = outstandingKey(cfg, attempt.payer);
+      const wallet2 = getWalletClient(origin);
+      assertPayer();
+      if (!claimDeposit(key)) {
+        throw new MintError("BRIDGE_UNAVAILABLE", "A cross-chain payment for this drop is already in progress. Try again once it finishes.");
+      }
+      let out;
+      try {
+        dispatch({ type: "MINT_PROMPTED", attemptId: attempt.attemptId });
+        const send = wallet2;
+        const originTxHash2 = await send.sendTransaction({
+          account: attempt.payer,
+          to: item.to,
+          data: item.data,
+          value: item.value,
+          ...item.gas !== null && item.gas > 0n ? { gas: item.gas } : {},
+          chain: getChain(origin)
+        });
+        out = { requestId: quote.requestId, testnet, originChainId: origin, originTxHash: originTxHash2, attempt };
+        setOutstanding(key, out);
+      } finally {
+        releaseDeposit(key);
+      }
+      const { originTxHash } = out;
+      autoResumedRef.current.add(key);
+      dispatch({ type: "TX_SUBMITTED", attemptId: attempt.attemptId });
+      emit("tx-submitted", { state: "confirming", reason: null, txHash: originTxHash, quantity: attempt.quantity, chainId: cfg.chainId });
+      const deposit = await waitForDeposit(origin, originTxHash);
+      if (deposit === "reverted") {
+        clearOutstanding(key);
+        throw new MintError("TX_REVERTED", `The payment transaction reverted (${originTxHash}).`);
+      }
+      await finishRelay(attempt, out, life);
+    },
+    [ctxFor, dispatch, emit, finishRelay]
+  );
+  const resumeOutstanding = (0, import_react.useCallback)(
+    async (out, life) => {
+      const attempt = Object.freeze({ ...out.attempt, attemptId: ++attemptIdRef.current });
+      attemptRef.current = attempt;
+      dispatch({ type: "ATTEMPT_STARTED", attempt, resume: true });
+      dispatch({ type: "TX_SUBMITTED", attemptId: attempt.attemptId });
+      emit("attempt", { state: "confirming", reason: null, quantity: attempt.quantity, chainId: attempt.chainId });
+      try {
+        await finishRelay(attempt, out, life);
+      } catch (e) {
+        if (!mounted.current || life.controller.signal.aborted || lifeRef.current !== life) return;
+        const { reason, message } = toReason(e);
+        dispatch({ type: "ATTEMPT_FAILED", attemptId: attempt.attemptId, reason, message });
+        emit("error", { quantity: attempt.quantity, chainId: attempt.chainId });
+      } finally {
+        attemptRef.current = null;
+      }
+    },
+    [dispatch, emit, finishRelay]
+  );
   const runMint = (0, import_react.useCallback)(async () => {
     if (!mounted.current) return;
     if (attemptRef.current !== null) return;
@@ -2069,6 +2552,12 @@ function useMint(options) {
       }
       return;
     }
+    const payer = s.account?.address;
+    const out = payer ? getOutstanding(outstandingKey(propsRef.current.config, payer)) : null;
+    if (out && lifeRef.current) {
+      await resumeOutstanding(out, lifeRef.current);
+      return;
+    }
     if (s.name === "success" || s.name === "error") {
       const life2 = lifeRef.current;
       const gen = ++genRef.current;
@@ -2084,6 +2573,7 @@ function useMint(options) {
     const life = lifeRef.current;
     if (!account2 || !walletRead || !life) return;
     const cfg = propsRef.current.config;
+    const relayRoute = s.route?.kind === "relay" ? s.route : null;
     const attempt = Object.freeze({
       attemptId: ++attemptIdRef.current,
       config: structuredClone(cfg),
@@ -2091,13 +2581,15 @@ function useMint(options) {
       recipient: propsRef.current.recipient ?? account2.address,
       quantity: s.quantity,
       chainId: cfg.chainId,
-      tokenContract: tokenContractOf(cfg)
+      tokenContract: tokenContractOf(cfg),
+      originChainId: relayRoute ? relayRoute.originChainId : cfg.chainId
     });
     attemptRef.current = attempt;
     dispatch({ type: "ATTEMPT_STARTED", attempt });
     emit("attempt", { state: "live", reason: null, quantity: attempt.quantity, chainId: attempt.chainId });
     try {
-      await executeAttempt(attempt, walletRead, life, account2);
+      if (relayRoute) await executeRelayAttempt(attempt, walletRead, life, account2);
+      else await executeAttempt(attempt, walletRead, life, account2);
     } catch (e) {
       if (!mounted.current || life.controller.signal.aborted || lifeRef.current !== life) return;
       const { reason, message } = toReason(e);
@@ -2106,7 +2598,7 @@ function useMint(options) {
     } finally {
       attemptRef.current = null;
     }
-  }, [dispatch, emit, readDrop2, executeAttempt, refreshNow]);
+  }, [dispatch, emit, readDrop2, executeAttempt, executeRelayAttempt, resumeOutstanding, refreshNow]);
   const mint = (0, import_react.useCallback)(() => {
     void runMint();
   }, [runMint]);
@@ -2141,9 +2633,10 @@ function useMint(options) {
     pushAccountRef.current?.(getAccount());
   }, [recipient, machine.attempt, isBusy]);
   const projectId = connect?.walletConnectProjectId;
+  const widgetChains = [config.chainId, ...payChainsOf(config, options.crossChain).filter((id) => id !== config.chainId)].join(",");
   (0, import_react.useEffect)(() => {
     let alive = true;
-    const loading = loadConnectWidget({ chainIds: [config.chainId], ...projectId ? { walletConnectProjectId: projectId } : {} });
+    const loading = loadConnectWidget({ chainIds: widgetChains.split(",").map(Number), ...projectId ? { walletConnectProjectId: projectId } : {} });
     widgetLoadRef.current = loading;
     loading.then(
       () => {
@@ -2158,7 +2651,7 @@ function useMint(options) {
     return () => {
       alive = false;
     };
-  }, [config.chainId, projectId, widgetRetry]);
+  }, [widgetChains, projectId, widgetRetry]);
   (0, import_react.useEffect)(() => {
     if (!mounted.current) return;
     if (isBusy()) return;
@@ -2175,6 +2668,22 @@ function useMint(options) {
       void refreshNow();
     }
   });
+  const resumeKey = machine.account ? outstandingKey(config, machine.account.address) : null;
+  (0, import_react.useEffect)(() => {
+    if (!resumeKey || autoResumedRef.current.has(resumeKey) || attemptRef.current !== null || isBusy()) return;
+    const out = getOutstanding(resumeKey);
+    const life = lifeRef.current;
+    if (!out || !life) return;
+    autoResumedRef.current.add(resumeKey);
+    void resumeOutstanding(out, life);
+  }, [resumeKey, machine.attempt, isBusy, resumeOutstanding]);
+  const routeOptionsKey = `${String(options.payChainId ?? "")}|${JSON.stringify(options.crossChain ?? null)}`;
+  const previousRouteOptions = (0, import_react.useRef)(routeOptionsKey);
+  (0, import_react.useEffect)(() => {
+    if (previousRouteOptions.current === routeOptionsKey || isBusy()) return;
+    previousRouteOptions.current = routeOptionsKey;
+    if (stateRef.current.account) dispatch({ type: "ACCOUNT_CHANGED", account: stateRef.current.account });
+  }, [routeOptionsKey, machine.attempt, dispatch, isBusy]);
   const previousQuantity = (0, import_react.useRef)(machine.quantity);
   (0, import_react.useEffect)(() => {
     if (previousQuantity.current === machine.quantity || isBusy()) return;
@@ -2207,7 +2716,61 @@ function useMint(options) {
         });
         if (!alive || life.controller.signal.aborted || lifeRef.current !== life || life.gen !== readGen) return;
         const ineligible = read.ineligible?.reason === "SIMULATION_REVERTED" ? { ...read.ineligible, message: friendlyErrorMessage(new MintError("SIMULATION_REVERTED", read.ineligible.message)) } : read.ineligible;
-        dispatch({ type: "WALLET_LOADED", gen: walletGen, read: { ...read, ineligible } });
+        const fullRead = { ...read, ineligible };
+        const payChains = payChainsOf(cfg, propsRef.current.crossChain);
+        const crossChain = payChains.length > 0 && ineligible === null && (adapter.supportsRelay?.(drop) ?? false);
+        const routeChain = routeChainOf(payChains, account.chainId, propsRef.current.payChainId);
+        const routePending = crossChain && routeChain !== cfg.chainId && payChains.includes(routeChain);
+        dispatch({ type: "WALLET_LOADED", gen: walletGen, read: fullRead, crossChain, routePending });
+        if (!crossChain) {
+          setCrossChainInfo(null);
+          return;
+        }
+        const recipientAddr = propsRef.current.recipient ?? account.address;
+        const draft = {
+          attemptId: 0,
+          config: cfg,
+          payer: account.address,
+          recipient: recipientAddr,
+          quantity: stateRef.current.quantity,
+          chainId: cfg.chainId,
+          tokenContract: tokenContractOf(cfg),
+          originChainId: routeChain
+        };
+        const testnet = isRelayTestnet(cfg.chainId);
+        let tx;
+        try {
+          tx = (await adapter.buildPlan(ctxFor(life, cfg), draft, fullRead)).mint;
+        } catch {
+          if (!alive) return;
+          setCrossChainInfo(null);
+          if (routePending) dispatch({ type: "ROUTE_LOADED", gen: walletGen, route: { kind: "direct", chainId: cfg.chainId }, short: null });
+          return;
+        }
+        if (!alive || life.controller.signal.aborted || lifeRef.current !== life) return;
+        setCrossChainInfo((prev) => {
+          const same = prev && prev.info.dropChainId === cfg.chainId && prev.info.testnet === testnet && prev.info.tx.to === tx.to && prev.info.tx.data === tx.data && prev.info.tx.value === tx.value && prev.info.payer === account.address && prev.info.recipient === recipientAddr && prev.info.payChains.join() === payChains.join();
+          return { gen: walletGen, info: same ? prev.info : { dropChainId: cfg.chainId, payChains, tx, payer: account.address, recipient: recipientAddr, testnet } };
+        });
+        if (!routePending) return;
+        await new Promise((r) => setTimeout(r, ROUTE_DEBOUNCE_MS));
+        if (!alive || life.controller.signal.aborted || lifeRef.current !== life) return;
+        let route = { kind: "direct", chainId: cfg.chainId };
+        let short = null;
+        try {
+          const quote = await getQuote({ testnet, payer: account.address, recipient: recipientAddr, originChainId: routeChain, destinationChainId: cfg.chainId, tx, signal: life.controller.signal });
+          const relay = { kind: "relay", originChainId: routeChain, amountIn: quote.amountIn, relayFee: quote.relayFee, originGas: quote.originGas, quotedAt: quote.quotedAt };
+          if (routeChain !== account.chainId) {
+            route = relay;
+          } else {
+            const balance = await getConnectedBalance(account.address, routeChain);
+            if (balance >= quote.amountIn.value + quote.originGas.value) route = relay;
+            else short = shortOf(routeChain);
+          }
+        } catch {
+        }
+        if (!alive || life.controller.signal.aborted || lifeRef.current !== life) return;
+        dispatch({ type: "ROUTE_LOADED", gen: walletGen, route: short ? null : route, short });
       } catch (e) {
         if (!alive || life.controller.signal.aborted || lifeRef.current !== life || life.gen !== readGen) return;
         dispatch({ type: "WALLET_FAILED", gen: walletGen, ...errorReasonOf(e) });
@@ -2307,12 +2870,137 @@ function useMint(options) {
     result: machine.result,
     refresh,
     // An attempt claimed by a click is not clickable, even while the reducer still reads 'live'.
-    canAct: canAct({ ...machine, name: effective.name }) && machine.attempt === null
+    canAct: canAct({ ...machine, name: effective.name }) && machine.attempt === null,
+    // Short on the wallet chain is neither route: nothing can be paid until the collector picks another chain.
+    route: machine.route ?? (machine.walletRead && machine.drop && !machine.routePending && machine.short === null ? { kind: "direct", chainId: machine.drop.chainId } : null),
+    crossChain: machine.crossChain && machine.account && crossChainInfo?.gen === machine.walletGen ? crossChainInfo.info : null
   };
 }
 
-// src/react/MintButton.ts
+// src/react/PayWithPicker.ts
 var import_react2 = require("react");
+var import_viem10 = require("viem");
+var PICKER_REFRESH_MS = 2e4;
+var PICKER_DEBOUNCE_MS = 500;
+var RELAY_REASONS = /* @__PURE__ */ new Set(["BRIDGE_UNAVAILABLE", "BRIDGE_TIMEOUT", "BRIDGE_REFUNDED", "BRIDGE_FAILED"]);
+var money4 = (value, chainId) => {
+  const c = getChain(chainId).nativeCurrency;
+  return { value, decimals: c.decimals, symbol: c.symbol, formatted: (0, import_viem10.formatUnits)(value, c.decimals) };
+};
+function usePayOptions(mint, onSelect) {
+  const info = mint.crossChain;
+  const current = mint.wallet?.chainId ?? null;
+  const [quotes, setQuotes] = (0, import_react2.useState)({});
+  const [balance, setBalance] = (0, import_react2.useState)(null);
+  const [tick, setTick] = (0, import_react2.useState)(0);
+  (0, import_react2.useEffect)(() => {
+    const t = setInterval(() => setTick((n) => n + 1), PICKER_REFRESH_MS);
+    return () => clearInterval(t);
+  }, []);
+  const key = info ? `${info.tx.to}:${info.tx.value}:${info.tx.data}:${info.payer}:${info.recipient}:${info.payChains.join()}` : "";
+  const [quotedKey, setQuotedKey] = (0, import_react2.useState)(key);
+  if (quotedKey !== key) {
+    setQuotedKey(key);
+    setQuotes({});
+  }
+  (0, import_react2.useEffect)(() => {
+    if (!info) return;
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+      for (const chainId of info.payChains) {
+        if (chainId === info.dropChainId) continue;
+        getQuote({ testnet: info.testnet, payer: info.payer, recipient: info.recipient, originChainId: chainId, destinationChainId: info.dropChainId, tx: info.tx, signal: controller.signal }).then(
+          (q) => {
+            if (!controller.signal.aborted) setQuotes((prev) => ({ ...prev, [chainId]: { relayFee: q.relayFee, amountIn: q.amountIn } }));
+          },
+          (e) => {
+            if (controller.signal.aborted || e?.reason === "RATE_LIMITED") return;
+            setQuotes((prev) => ({ ...prev, [chainId]: "failed" }));
+          }
+        );
+      }
+    }, PICKER_DEBOUNCE_MS);
+    return () => {
+      clearTimeout(timer);
+      controller.abort();
+    };
+  }, [key, tick]);
+  (0, import_react2.useEffect)(() => {
+    if (!info || current === null || !mint.wallet) return;
+    let alive = true;
+    getConnectedBalance(mint.wallet.address, current).then(
+      (value) => {
+        if (alive) setBalance({ chainId: current, value });
+      },
+      () => {
+        if (alive) setBalance(null);
+      }
+    );
+    return () => {
+      alive = false;
+    };
+  }, [current, mint.wallet?.address, key, tick]);
+  const select = (0, import_react2.useCallback)(
+    (chainId) => {
+      switchToChain(chainId).then(
+        () => onSelect?.(chainId, null),
+        (e) => onSelect?.(chainId, e)
+      );
+    },
+    [onSelect]
+  );
+  if (!info) return [];
+  return info.payChains.filter((chainId) => chainId === info.dropChainId || quotes[chainId] !== "failed").map((chainId) => {
+    const q = quotes[chainId];
+    const isDropChain = chainId === info.dropChainId;
+    const quoted = q && q !== "failed" ? q : null;
+    return {
+      chainId,
+      name: chainName(chainId),
+      selected: chainId === current,
+      isDropChain,
+      relayFee: isDropChain ? null : quoted?.relayFee ?? null,
+      amountIn: isDropChain ? null : quoted?.amountIn ?? null,
+      balance: balance && balance.chainId === chainId && chainId === current ? money4(balance.value, chainId) : null,
+      loading: !isDropChain && q === void 0,
+      select: () => select(chainId)
+    };
+  });
+}
+function defaultRow(row) {
+  const fee = row.isDropChain ? "None" : row.loading ? "\u2026" : row.relayFee ? `${row.relayFee.formatted} ${row.relayFee.symbol}` : "--";
+  const balance = row.balance ? ` \xB7 ${row.balance.formatted} ${row.balance.symbol}` : "";
+  return `${row.name}${balance} \xB7 fee ${fee}`;
+}
+function PayWithPicker(props) {
+  const rows = usePayOptions(props.mint, props.onSelect);
+  if (rows.length === 0) return null;
+  const open = props.mint.state === "insufficient-funds" || props.mint.reason !== null && RELAY_REASONS.has(props.mint.reason);
+  return (0, import_react2.createElement)(
+    "div",
+    { className: props.className, role: "group", "aria-label": "Pay with", "data-open": open ? "true" : "false" },
+    rows.map(
+      (row) => (0, import_react2.createElement)(
+        "button",
+        {
+          key: row.chainId,
+          type: "button",
+          "data-chain": String(row.chainId),
+          "data-selected": row.selected ? "true" : "false",
+          "data-loading": row.loading ? "true" : "false",
+          "aria-pressed": row.selected,
+          // Only an idle button may change chains: a click in progress already chose its pay chain.
+          disabled: row.selected || !(props.mint.canAct || props.mint.state === "insufficient-funds" || props.mint.state === "loading"),
+          onClick: row.select
+        },
+        props.renderRow ? props.renderRow(row) : defaultRow(row)
+      )
+    )
+  );
+}
+
+// src/react/MintButton.ts
+var import_react3 = require("react");
 function defaultLabel(m) {
   const symbol = m.total?.erc20?.symbol ?? m.total?.native.symbol ?? m.drop?.unitPrice.symbol ?? "";
   switch (m.state) {
@@ -2333,6 +3021,10 @@ function defaultLabel(m) {
     case "connecting":
       return "Connecting\u2026";
     case "live": {
+      const route = m.route;
+      if (route?.kind === "relay") {
+        return `Mint \xB7 ${route.amountIn.formatted} ${route.amountIn.symbol} on ${chainName(route.originChainId)}`;
+      }
       const total = m.total;
       if (!total) return "Mint";
       const legs = total.erc20 ? [total.erc20, ...total.native.value > 0n ? [total.native] : []] : [total.native];
@@ -2364,7 +3056,7 @@ function MintButton(props) {
   const m = useMint(options);
   if (typeof children === "function") return children(m);
   const label = labels?.[m.state] ?? defaultLabel(m);
-  return (0, import_react2.createElement)(
+  return (0, import_react3.createElement)(
     "button",
     {
       type: "button",
@@ -2380,7 +3072,7 @@ function MintButton(props) {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CLICKABLE_STATES,
@@ -2388,9 +3080,11 @@ var VERSION = "0.1.0";
   MINT_STATES,
   MintButton,
   MintError,
+  PayWithPicker,
   REASON_CODES,
   VERSION,
   isMintError,
-  useMint
+  useMint,
+  usePayOptions
 });
 //# sourceMappingURL=index.cjs.map