@manifoldxyz/dropkit 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/react/useMint.ts
 import { useCallback, useEffect, useReducer, useRef, useState } from "react";
-import { BaseError as BaseError3, ExecutionRevertedError, publicActions } from "viem";
+import { BaseError as BaseError3, ExecutionRevertedError, publicActions as publicActions2 } from "viem";
 
 // src/core/rpc/index.ts
 import { createPublicClient, http } from "viem";
-import { apeChain, base, mainnet, optimism, sepolia, shape } from "viem/chains";
+import { apeChain, base, baseSepolia, mainnet, optimism, sepolia, shape } from "viem/chains";
 
 // src/core/errors.ts
 var UNSUPPORTED_REASONS = [
@@ -22,7 +22,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 = [
@@ -35,11 +40,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) {
@@ -61,8 +69,22 @@ var CHAINS = {
   [base.id]: base,
   [optimism.id]: optimism,
   [shape.id]: shape,
-  [apeChain.id]: apeChain
+  [apeChain.id]: apeChain,
+  // Relay pay chain for Sepolia drops only: never a drop chain, no Manifold bridge.
+  [baseSepolia.id]: 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];
@@ -133,7 +155,7 @@ function createReadClient(opts) {
 }
 
 // src/core/wallet/index.ts
-import { createWalletClient, custom, getAddress } from "viem";
+import { createWalletClient, custom, getAddress, publicActions } from "viem";
 var CONNECT_WIDGET_VERSION = "6.4.0";
 var CONNECT_BASE_URL = `https://connect.manifoldxyz.dev/${CONNECT_WIDGET_VERSION}`;
 var CONNECT_ID = "mint-button";
@@ -300,6 +322,37 @@ function getWalletClient(chainId) {
   const request = ((args) => provider.request(args));
   return createWalletClient({ chain: getChain(chainId), transport: custom({ request }) });
 }
+async function waitForDeposit(chainId, hash, timeoutMs = 12e4) {
+  try {
+    const receipt = await getWalletClient(chainId).extend(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);
@@ -331,17 +384,244 @@ async function switchToChain(chainId) {
   }
 }
 
+// src/core/relay/client.ts
+import { formatUnits, getAddress as getAddress2, isHex, keccak256, zeroAddress } from "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, 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: 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" || !isHex(d.data)) throw unknownStep();
+    return { chainId, to: getAddress2(d.to), data: d.data, value: big(d.value), gas: d.gas === void 0 ? null : big(d.gas) };
+  });
+  const requestId = isHex(step2.requestId) ? step2.requestId : 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 !== 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: zeroAddress,
+    destinationCurrency: 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) => 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
 import {
   BaseError,
   ContractFunctionRevertedError,
   decodeErrorResult,
   encodeFunctionData,
-  formatUnits,
-  getAddress as getAddress2,
+  formatUnits as formatUnits2,
+  getAddress as getAddress3,
   isAddress,
-  isHex,
-  zeroAddress,
+  isHex as isHex2,
+  zeroAddress as zeroAddress2,
   zeroHash
 } from "viem";
 
@@ -412,13 +692,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;
 }
@@ -468,8 +748,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();
 }
 
@@ -534,12 +814,12 @@ async function rpc(fn) {
 function revertData(e) {
   const hit = e.walk((x) => {
     const d2 = x.data;
-    return isHex(d2) && d2.length >= 10 || typeof d2 === "object" && d2 !== null && isHex(d2.data);
+    return isHex2(d2) && d2.length >= 10 || typeof d2 === "object" && d2 !== null && isHex2(d2.data);
   });
   const d = hit?.data;
-  if (isHex(d)) return d;
+  if (isHex2(d)) return d;
   const inner = d?.data;
-  return isHex(inner) ? inner : void 0;
+  return isHex2(inner) ? inner : void 0;
 }
 function decodeRevert(e) {
   if (!(e instanceof BaseError)) return null;
@@ -557,7 +837,7 @@ function decodeRevert(e) {
   const named = e.walk((x) => ["ExecutionRevertedError", "InsufficientFundsError"].includes(x.name));
   return named instanceof BaseError ? named.shortMessage : null;
 }
-var money = (value, decimals, symbol) => ({ value, decimals, symbol, formatted: formatUnits(value, decimals) });
+var money = (value, decimals, symbol) => ({ value, decimals, symbol, formatted: formatUnits2(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`);
@@ -574,14 +854,14 @@ function parseConfig(config) {
     throw new MintError("INVALID_CONFIG", "instanceId must be a non-negative integer string.", { field: "instanceId" });
   }
   return {
-    creator: getAddress2(config.creatorContract),
+    creator: getAddress3(config.creatorContract),
     instanceId: BigInt(config.instanceId),
-    extension: config.extension === void 0 ? void 0 : getAddress2(config.extension)
+    extension: config.extension === void 0 ? void 0 : getAddress3(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 = getAddress2(entry.address);
+  const address = getAddress3(entry.address);
   const args = [creator, instanceId];
   try {
     switch (entry.abi) {
@@ -620,7 +900,7 @@ function base2(c) {
   };
 }
 async function hasCode(client, address) {
-  const code2 = await rpc(() => client.getCode({ address: getAddress2(address) }));
+  const code2 = await rpc(() => client.getCode({ address: getAddress3(address) }));
   return code2 !== void 0 && code2 !== "0x";
 }
 var unknownExtension = (address, why) => new MintError("UNKNOWN_EXTENSION", `Extension ${address} ${why}.`);
@@ -664,21 +944,21 @@ async function resolveExtension(ctx, config) {
 }
 async function loadDrop(ctx, config) {
   const { entry, claim } = await resolveExtension(ctx, config);
-  if (claim.signingAddress !== null && claim.signingAddress !== zeroAddress) {
+  if (claim.signingAddress !== null && claim.signingAddress !== zeroAddress2) {
     throw new MintError("SIGNATURE_CLAIM", "This claim mints with a signature (redemption code), which this button does not support.");
   }
   const { client } = ctx;
-  const extension = getAddress2(entry.address);
+  const extension = getAddress3(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 === zeroAddress) {
+  if (claim.erc20 === zeroAddress2) {
     unitPrice = money(claim.cost, native.decimals, native.symbol);
   } else {
-    paymentToken = getAddress2(claim.erc20);
+    paymentToken = getAddress3(claim.erc20);
     const token = paymentToken;
     const [symbol, decimals] = await rpc(
       () => Promise.all([
@@ -709,9 +989,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 = getAddress2(entry.address);
-  const payer = getAddress2(args.payer);
-  const recipient = getAddress2(args.recipient);
+  const extension = getAddress3(entry.address);
+  const payer = getAddress3(args.payer);
+  const recipient = getAddress3(args.recipient);
   let walletMinted = null;
   let walletMax = null;
   let allowlistRemaining = null;
@@ -747,7 +1027,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 === zeroAddress ? null : getAddress2(claim.erc20);
+  const token = claim.erc20 === zeroAddress2 ? null : getAddress3(claim.erc20);
   const [native, erc20, gasPrice] = await rpc(
     () => Promise.all([
       client.getBalance({ address: payer }),
@@ -775,8 +1055,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 = getAddress2(attempt.recipient);
-  const payer = getAddress2(attempt.payer);
+  const recipient = getAddress3(attempt.recipient);
+  const payer = getAddress3(attempt.payer);
   let data = wallet.data;
   if (!isWalletData(data) || !sameClaim(data.config, config) || data.recipient !== recipient) {
     const drop = (await loadDrop(ctx, config)).drop;
@@ -784,7 +1064,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 = getAddress2(entry.address);
+  const extension = getAddress3(entry.address);
   let mintIndices = [];
   let merkleProofs = [];
   if (isAllowlist(claim)) {
@@ -796,7 +1076,7 @@ async function buildPlan(ctx, attempt, wallet) {
     merkleProofs = picked.map((p) => p.proof);
   }
   const qty = BigInt(quantity);
-  const erc20 = claim.erc20 === zeroAddress ? null : getAddress2(claim.erc20);
+  const erc20 = claim.erc20 === zeroAddress2 ? null : getAddress3(claim.erc20);
   const cost = claim.cost * qty;
   const value = fee * qty + (erc20 ? 0n : cost);
   let approve = null;
@@ -825,13 +1105,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: getAddress2(attempt.payer), to: plan.mint.to, data: plan.mint.data, value: plan.mint.value });
+      await ctx.client.call({ account: getAddress3(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);
@@ -848,15 +1133,15 @@ import {
   InsufficientFundsError,
   decodeErrorResult as decodeErrorResult2,
   encodeFunctionData as encodeFunctionData2,
-  formatUnits as formatUnits3,
-  getAddress as getAddress3,
+  formatUnits as formatUnits4,
+  getAddress as getAddress4,
   isAddress as isAddress2,
   parseAbi as parseAbi2,
   parseUnits
 } from "viem";
 
 // src/core/machine.ts
-import { formatUnits as formatUnits2 } from "viem";
+import { formatUnits as formatUnits3 } from "viem";
 var MINT_STATES = [
   "loading",
   "unsupported",
@@ -893,9 +1178,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));
@@ -920,11 +1211,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.` };
@@ -953,7 +1250,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": {
@@ -971,16 +1268,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":
@@ -994,7 +1297,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":
@@ -1036,6 +1341,7 @@ function reducer(state, event) {
       const next = {
         ...state,
         readGen: event.gen,
+        ...NO_ROUTE,
         walletRead: null,
         blocked: null,
         walletGen: state.walletGen + 1,
@@ -1081,7 +1387,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: formatUnits2(value, like.decimals) };
+  return { value, decimals: like.decimals, symbol: like.symbol, formatted: formatUnits3(value, like.decimals) };
 }
 function canAct(state) {
   return state.attempt === null && CLICKABLE_STATES.includes(state.name);
@@ -1318,7 +1624,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" ? getAddress3(v) : v;
+  return typeof v === "string" ? getAddress4(v) : v;
 }
 function fill(t, p, vars) {
   const arr = ARRAY_TYPE.exec(p.type);
@@ -1407,7 +1713,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 : getAddress3(config.price.currency.address);
+var erc20Of = (config) => config.price.currency === "native" ? null : getAddress4(config.price.currency.address);
 async function currencyMeta(ctx, config) {
   const token = erc20Of(config);
   if (!token) return { token, ...nativeMeta(ctx) };
@@ -1439,7 +1745,7 @@ var money3 = (value, decimals, symbol) => ({
   value,
   decimals,
   symbol,
-  formatted: formatUnits3(value, decimals)
+  formatted: formatUnits4(value, decimals)
 });
 function revertData2(e) {
   for (let cur = e, depth = 0; cur && depth < 12; depth++) {
@@ -1552,7 +1858,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: getAddress3(config.address), data: encodeMint(config, vars), value: mintValue(config, null, totalPrice) };
+    const call = { payer, to: getAddress4(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) => {
@@ -1583,7 +1889,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 = getAddress3(config.address);
+  const to = getAddress4(config.address);
   const token = erc20Of(config);
   const mint = {
     to,
@@ -1605,7 +1911,7 @@ async function buildPlan2(ctx, attempt, wallet) {
       };
     }
   }
-  return { approve, mint, tokenContract: getAddress3(attempt.tokenContract) };
+  return { approve, mint, tokenContract: getAddress4(attempt.tokenContract) };
 }
 async function simulate(ctx, attempt, plan) {
   throwIfAborted(ctx);
@@ -1614,28 +1920,28 @@ async function simulate(ctx, attempt, plan) {
 var contractAdapter = { readDrop, readWallet, buildPlan: buildPlan2, simulate };
 
 // src/core/adapters/receipt.ts
-import { decodeAbiParameters, getAddress as getAddress4, zeroAddress as zeroAddress2 } from "viem";
+import { decodeAbiParameters, getAddress as getAddress5, zeroAddress as zeroAddress3 } from "viem";
 var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
 var TRANSFER_SINGLE_TOPIC = "0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62";
 var TRANSFER_BATCH_TOPIC = "0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb";
-var topicAddress = (t) => t && t.length === 66 ? getAddress4(`0x${t.slice(26)}`) : null;
+var topicAddress = (t) => t && t.length === 66 ? getAddress5(`0x${t.slice(26)}`) : null;
 function parseMintReceipt(logs, { tokenContract, recipient }) {
-  const contract = getAddress4(tokenContract);
-  const to = getAddress4(recipient);
+  const contract = getAddress5(tokenContract);
+  const to = getAddress5(recipient);
   const out = /* @__PURE__ */ new Map();
   const add = (id, amount) => out.set(id, (out.get(id) ?? 0n) + amount);
   for (const log of logs) {
-    if (getAddress4(log.address) !== contract) continue;
+    if (getAddress5(log.address) !== contract) continue;
     const [t0, t1, t2, t3] = log.topics;
     if (t0 === TRANSFER_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t1) !== zeroAddress2 || topicAddress(t2) !== to || !t3) continue;
+      if (topicAddress(t1) !== zeroAddress3 || topicAddress(t2) !== to || !t3) continue;
       add(BigInt(t3), 1n);
     } else if (t0 === TRANSFER_SINGLE_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t2) !== zeroAddress2 || topicAddress(t3) !== to) continue;
+      if (topicAddress(t2) !== zeroAddress3 || topicAddress(t3) !== to) continue;
       const [id, value] = decodeAbiParameters([{ type: "uint256" }, { type: "uint256" }], log.data);
       add(id, value);
     } else if (t0 === TRANSFER_BATCH_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t2) !== zeroAddress2 || topicAddress(t3) !== to) continue;
+      if (topicAddress(t2) !== zeroAddress3 || topicAddress(t3) !== to) continue;
       const [ids, values] = decodeAbiParameters([{ type: "uint256[]" }, { type: "uint256[]" }], log.data);
       if (ids.length !== values.length) continue;
       ids.forEach((id, i) => add(id, values[i]));
@@ -1683,6 +1989,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);
@@ -1744,6 +2051,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;
 }
@@ -1801,6 +2127,8 @@ function useMint(options) {
   const widgetFailRef = useRef(null);
   const widgetLoadRef = useRef(null);
   const pushAccountRef = useRef(null);
+  const autoResumedRef = useRef(/* @__PURE__ */ new Set());
+  const [crossChainInfo, setCrossChainInfo] = useState(null);
   useEffect(() => {
     stateRef.current = machine;
     propsRef.current = options;
@@ -1816,6 +2144,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,
@@ -1823,6 +2152,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 {
@@ -1942,7 +2273,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(publicActions).waitForTransactionReceipt(params);
+          receipt2 = await walletFor().extend(publicActions2).waitForTransactionReceipt(params);
         }
         assertActive();
         if (cancelled) throw new MintError("USER_REJECTED", "The transaction was cancelled or replaced with a different transaction.");
@@ -2022,6 +2353,156 @@ function useMint(options) {
     },
     [clientFor, ctxFor, dispatch, emit]
   );
+  const finishRelay = 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 = 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 = 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 = useCallback(async () => {
     if (!mounted.current) return;
     if (attemptRef.current !== null) return;
@@ -2058,6 +2539,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;
@@ -2073,6 +2560,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),
@@ -2080,13 +2568,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);
@@ -2095,7 +2585,7 @@ function useMint(options) {
     } finally {
       attemptRef.current = null;
     }
-  }, [dispatch, emit, readDrop2, executeAttempt, refreshNow]);
+  }, [dispatch, emit, readDrop2, executeAttempt, executeRelayAttempt, resumeOutstanding, refreshNow]);
   const mint = useCallback(() => {
     void runMint();
   }, [runMint]);
@@ -2130,9 +2620,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(",");
   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(
       () => {
@@ -2147,7 +2638,7 @@ function useMint(options) {
     return () => {
       alive = false;
     };
-  }, [config.chainId, projectId, widgetRetry]);
+  }, [widgetChains, projectId, widgetRetry]);
   useEffect(() => {
     if (!mounted.current) return;
     if (isBusy()) return;
@@ -2164,6 +2655,22 @@ function useMint(options) {
       void refreshNow();
     }
   });
+  const resumeKey = machine.account ? outstandingKey(config, machine.account.address) : null;
+  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 = useRef(routeOptionsKey);
+  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 = useRef(machine.quantity);
   useEffect(() => {
     if (previousQuantity.current === machine.quantity || isBusy()) return;
@@ -2196,7 +2703,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) });
@@ -2296,12 +2857,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/PayWithPicker.ts
+import { createElement, useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
+import { formatUnits as formatUnits5 } from "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: formatUnits5(value, c.decimals) };
+};
+function usePayOptions(mint, onSelect) {
+  const info = mint.crossChain;
+  const current = mint.wallet?.chainId ?? null;
+  const [quotes, setQuotes] = useState2({});
+  const [balance, setBalance] = useState2(null);
+  const [tick, setTick] = useState2(0);
+  useEffect2(() => {
+    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] = useState2(key);
+  if (quotedKey !== key) {
+    setQuotedKey(key);
+    setQuotes({});
+  }
+  useEffect2(() => {
+    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]);
+  useEffect2(() => {
+    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 = useCallback2(
+    (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 createElement(
+    "div",
+    { className: props.className, role: "group", "aria-label": "Pay with", "data-open": open ? "true" : "false" },
+    rows.map(
+      (row) => 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
-import { createElement } from "react";
+import { createElement as createElement2 } from "react";
 function defaultLabel(m) {
   const symbol = m.total?.erc20?.symbol ?? m.total?.native.symbol ?? m.drop?.unitPrice.symbol ?? "";
   switch (m.state) {
@@ -2322,6 +3008,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];
@@ -2353,7 +3043,7 @@ function MintButton(props) {
   const m = useMint(options);
   if (typeof children === "function") return children(m);
   const label = labels?.[m.state] ?? defaultLabel(m);
-  return createElement(
+  return createElement2(
     "button",
     {
       type: "button",
@@ -2369,16 +3059,18 @@ function MintButton(props) {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 export {
   CLICKABLE_STATES,
   MAX_QUANTITY,
   MINT_STATES,
   MintButton,
   MintError,
+  PayWithPicker,
   REASON_CODES,
   VERSION,
   isMintError,
-  useMint
+  useMint,
+  usePayOptions
 };
 //# sourceMappingURL=index.js.map