@manifoldxyz/dropkit 0.1.0

package/dist/index.js

@@ -0,0 +1,2384 @@
+// src/react/useMint.ts
+import { useCallback, useEffect, useReducer, useRef, useState } from "react";
+import { BaseError as BaseError3, ExecutionRevertedError, publicActions } from "viem";
+
+// src/core/rpc/index.ts
+import { createPublicClient, http } from "viem";
+import { apeChain, base, mainnet, optimism, sepolia, shape } from "viem/chains";
+
+// src/core/errors.ts
+var UNSUPPORTED_REASONS = [
+  "UNKNOWN_EXTENSION",
+  "AMBIGUOUS_EXTENSION",
+  "CLAIM_NOT_FOUND",
+  "SIGNATURE_CLAIM",
+  "INVALID_CONFIG",
+  "CONNECT_WIDGET_TOO_OLD"
+];
+var INELIGIBLE_REASONS = ["NOT_ON_ALLOWLIST", "ALLOWLIST_USED", "WALLET_LIMIT", "SIMULATION_REVERTED"];
+var ERROR_REASONS = [
+  "USER_REJECTED",
+  "TX_REVERTED",
+  "RATE_LIMITED",
+  "RPC_ERROR",
+  "CHAIN_SWITCH_FAILED",
+  "ALLOWLIST_UNAVAILABLE"
+];
+var FUNDS_REASONS = ["INSUFFICIENT_FUNDS"];
+var REASON_CODES = [
+  ...UNSUPPORTED_REASONS,
+  ...INELIGIBLE_REASONS,
+  ...ERROR_REASONS,
+  ...FUNDS_REASONS
+];
+var MintError = class extends Error {
+  reason;
+  /** INVALID_CONFIG only: dotted path of the bad field, e.g. "mint.args[1]" or "price". */
+  field;
+  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;
+  }
+};
+function isMintError(e) {
+  return e instanceof MintError;
+}
+
+// src/core/rpc/index.ts
+var BRIDGE_URLS = {
+  1: "https://bridge.manifoldxyz.dev/rpc",
+  11155111: "https://sepolia.bridge.manifoldxyz.dev/rpc",
+  8453: "https://base.bridge.manifoldxyz.dev/rpc",
+  10: "https://optimism.bridge.manifoldxyz.dev/rpc",
+  360: "https://shape.bridge.manifoldxyz.dev/rpc",
+  33139: "https://apechain.bridge.manifoldxyz.dev/rpc"
+};
+var CHAINS = {
+  [mainnet.id]: mainnet,
+  [sepolia.id]: sepolia,
+  [base.id]: base,
+  [optimism.id]: optimism,
+  [shape.id]: shape,
+  [apeChain.id]: apeChain
+};
+var TRANSPORT_TIMEOUT_MS = 8e3;
+function getChain(chainId) {
+  const chain = CHAINS[chainId];
+  if (!chain) {
+    throw new MintError("INVALID_CONFIG", `chainId ${String(chainId)} is not supported`, { field: "chainId" });
+  }
+  return chain;
+}
+var TERMINAL_CODES = /* @__PURE__ */ new Set([3, -32602, -32003, 4001, 4100, 4200, 4900, 4901, 4902]);
+var FALLBACK_CODES = /* @__PURE__ */ new Set([-32700, -32600, -32601, -32001, -32002, -32004, -32005, 429]);
+var EXECUTION_WORDING = /execution reverted|execution error|\breverted?\b|out of gas|invalid opcode|insufficient funds|nonce too low|gas required exceeds/i;
+var UPSTREAM_WORDING = /\btimeout\b|\btimed out\b|\btoo many requests\b|\brate limit\b|\brequest limit reached\b|\b(?:exceeded.*capacity|capacity.*exceeded)\b|\bheader not found\b|\binternal (?:json-rpc )?(?:server )?error\b|\bnon-200 status code:\s*['"]?503\b/i;
+var TRANSPORT_ERROR_NAMES = /* @__PURE__ */ new Set(["HttpRequestError", "TimeoutError", "SocketClosedError", "WebSocketRequestError"]);
+function carriesExecutionEvidence(value, seen = /* @__PURE__ */ new Set()) {
+  if (typeof value === "string") return /^(?:Reverted\s+)?0x(?:[a-f\d]{2})*$/i.test(value) || EXECUTION_WORDING.test(value);
+  if (!value || typeof value !== "object" || seen.has(value)) return false;
+  seen.add(value);
+  const e = value;
+  if (typeof e.code === "number" && TERMINAL_CODES.has(e.code)) return true;
+  if (typeof e.message === "string" && EXECUTION_WORDING.test(e.message)) return true;
+  return ["data", "error", "originalError", "cause", "result"].some((key) => carriesExecutionEvidence(e[key], seen));
+}
+function shouldFallback(err) {
+  let retry = false;
+  const seen = /* @__PURE__ */ new Set();
+  for (let e = err; e && typeof e === "object" && !seen.has(e); ) {
+    seen.add(e);
+    const error = e;
+    const message = typeof error.details === "string" ? error.details : typeof error.shortMessage !== "string" ? error.message : "";
+    if (typeof message === "string" && EXECUTION_WORDING.test(message)) return false;
+    if (carriesExecutionEvidence(error.data)) return false;
+    if (typeof error.code === "number" && TERMINAL_CODES.has(error.code)) return false;
+    if (error.name === "ContractFunctionRevertedError" || error.name === "ExecutionRevertedError") return false;
+    if (typeof error.name === "string" && TRANSPORT_ERROR_NAMES.has(error.name)) retry = true;
+    if (typeof error.code === "number" && FALLBACK_CODES.has(error.code)) retry = true;
+    if (typeof message === "string" && UPSTREAM_WORDING.test(message)) retry = true;
+    e = error.cause;
+  }
+  return retry;
+}
+function createReadClient(opts) {
+  const chain = getChain(opts.chainId);
+  const urls = [opts.rpcUrls?.[opts.chainId], opts.useBridge ? BRIDGE_URLS[opts.chainId] : void 0, chain.rpcUrls.default.http[0]].filter(
+    (u, i, all) => !!u && all.indexOf(u) === i
+  );
+  const transport = ({ chain: c, pollingInterval }) => {
+    const transports = urls.map((url) => http(url, { timeout: TRANSPORT_TIMEOUT_MS, retryCount: 0 })({ chain: c, pollingInterval, retryCount: 0, timeout: TRANSPORT_TIMEOUT_MS }));
+    const request = (async (args) => {
+      let last;
+      for (const t of transports) {
+        try {
+          return await t.request(args);
+        } catch (err) {
+          if (!shouldFallback(err)) throw err;
+          last = err;
+        }
+      }
+      console.warn(`dropkit: all RPC endpoints failed for chain ${String(opts.chainId)}; pass rpcUrls={{ ${String(opts.chainId)}: '<your RPC url>' }} to <MintButton>.`);
+      throw new MintError("RPC_ERROR", `All RPC endpoints failed for chain ${String(opts.chainId)}`, { cause: last });
+    });
+    return {
+      config: { key: "dropkit-fallback", name: "Dropkit fallback", request, retryCount: 0, retryDelay: 0, timeout: TRANSPORT_TIMEOUT_MS, type: "fallback" },
+      request,
+      value: {}
+    };
+  };
+  return createPublicClient({ chain, transport });
+}
+
+// src/core/wallet/index.ts
+import { createWalletClient, custom, getAddress } 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";
+var ADDRESS_CHANGED = "ethereum-address-changed";
+var CHAIN_CHANGED = "frontend-provider-chain-changed";
+var LOADER_KEY = "__manifoldMintConnectLoader";
+var STATE_KEY = "__manifoldMintConnectStateV1";
+var win = () => window;
+var pageState = () => win()[STATE_KEY] ??= {};
+var TOO_OLD = "A Manifold connect widget older than 6.4.0 is already on this page; update it or remove it so dropkit can load 6.4.0.";
+var MANIFOLD_HOST = /(^|\.)(manifoldxyz\.dev|manifold\.xyz)$/;
+function isManifoldConnectScript(src) {
+  try {
+    const url = new URL(src, document.baseURI);
+    return url.hostname === "connect.manifoldxyz.dev" || MANIFOLD_HOST.test(url.hostname) && /\/connect\.umd[^/]*\.js$/.test(url.pathname);
+  } catch {
+    return false;
+  }
+}
+function applyState(state) {
+  if (!state.div) return;
+  const network = state.networks.join(",");
+  if (state.div.dataset.network !== network) state.div.dataset.network = network;
+  if (state.projectId && state.div.dataset.walletConnectProjectId !== state.projectId) state.div.dataset.walletConnectProjectId = state.projectId;
+}
+function register(state, opts) {
+  for (const id2 of opts.chainIds) if (!state.networks.includes(id2)) state.networks.push(id2);
+  const id = opts.walletConnectProjectId;
+  if (id) {
+    if (!state.projectId) state.projectId = id;
+    else if (state.projectId !== id) {
+      console.warn(`dropkit: walletConnectProjectId "${id}" ignored; this page already uses "${state.projectId}" for the shared connect widget.`);
+    }
+  }
+  applyState(state);
+}
+function startLoad(state) {
+  const connect = win().ManifoldConnect;
+  if (connect?.capabilities?.includes("open")) return Promise.resolve(connect.ready).then(() => void 0);
+  const hasScript = Array.from(document.querySelectorAll("script[src]")).some((s) => isManifoldConnectScript(s.src));
+  if (hasScript || document.querySelector('[data-widget="m-connect"]')) {
+    return Promise.reject(new MintError("CONNECT_WIDGET_TOO_OLD", TOO_OLD));
+  }
+  return new Promise((resolve, reject) => {
+    const css = document.createElement("link");
+    css.rel = "stylesheet";
+    css.href = `${CONNECT_BASE_URL}/connect.css`;
+    document.head.appendChild(css);
+    state.nodes.push(css);
+    const div = document.createElement("div");
+    div.hidden = true;
+    div.style.display = "none";
+    div.dataset.widget = "m-connect";
+    div.dataset.connectId = CONNECT_ID;
+    div.dataset.autoReconnect = "true";
+    div.dataset.enableNetworkSwitching = "true";
+    state.div = div;
+    applyState(state);
+    document.body.appendChild(div);
+    state.nodes.push(div);
+    const script = document.createElement("script");
+    script.src = `${CONNECT_BASE_URL}/connect.umd.min.js`;
+    script.async = true;
+    script.addEventListener("load", () => {
+      const ready = win().ManifoldConnect?.ready;
+      if (!ready) return reject(new MintError("CONNECT_WIDGET_TOO_OLD", TOO_OLD));
+      Promise.resolve(ready).then(() => resolve(), reject);
+    });
+    script.addEventListener("error", () => reject(new MintError("RPC_ERROR", `Could not load the Manifold connect widget from ${CONNECT_BASE_URL}`)));
+    document.head.appendChild(script);
+    state.nodes.push(script);
+  });
+}
+function loadConnectWidget(opts) {
+  const w = win();
+  const page = pageState();
+  const existing = w[LOADER_KEY];
+  if (existing) {
+    if (page.load?.promise !== existing) {
+      const div = document.querySelector(`[data-widget="m-connect"][data-connect-id="${CONNECT_ID}"]`) ?? void 0;
+      page.load = {
+        promise: existing,
+        networks: div?.dataset.network?.split(",").filter(Boolean).map(Number) ?? [],
+        projectId: div?.dataset.walletConnectProjectId,
+        div,
+        nodes: []
+      };
+    }
+    register(page.load, opts);
+    return existing;
+  }
+  let resolve;
+  let reject;
+  const p = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  const state = { promise: p, networks: [], nodes: [] };
+  page.load = state;
+  w[LOADER_KEY] = p;
+  p.catch(() => {
+    if (w[LOADER_KEY] === p) delete w[LOADER_KEY];
+    if (page.load === state) page.load = void 0;
+    for (const node of state.nodes) node.parentNode?.removeChild(node);
+    state.nodes.length = 0;
+    state.div = void 0;
+  });
+  register(state, opts);
+  try {
+    startLoad(state).then(resolve, reject);
+  } catch (error) {
+    reject(error);
+  }
+  return p;
+}
+function openConnectModal() {
+  const page = pageState();
+  if (page.pendingModal) return page.pendingModal;
+  const p = new Promise((resolve) => {
+    const onClosed = (e) => {
+      const detail = e.detail ?? {};
+      if (detail.connectId !== void 0 && detail.connectId !== CONNECT_ID) return;
+      window.removeEventListener("m-connect:closed", onClosed);
+      page.pendingModal = void 0;
+      resolve(detail.reason === "connected" ? "connected" : "dismissed");
+    };
+    window.addEventListener("m-connect:closed", onClosed);
+  });
+  page.pendingModal = p;
+  window.dispatchEvent(new CustomEvent("m-connect:open", { detail: { connectId: CONNECT_ID } }));
+  return p;
+}
+function getAccount() {
+  const p = win().ManifoldEthereumProvider;
+  const address = p?.selectedAddress?.();
+  let chainId = p?.chainId?.();
+  if (chainId === void 0 || chainId === null) {
+    try {
+      chainId = p?.browserChainId?.();
+    } catch {
+      chainId = void 0;
+    }
+  }
+  if (!address || chainId === void 0 || chainId === null) return null;
+  return { address: getAddress(address), chainId: Number(chainId) };
+}
+function subscribeAccount(cb) {
+  const handler = () => cb(getAccount());
+  window.addEventListener(ADDRESS_CHANGED, handler);
+  window.addEventListener(CHAIN_CHANGED, handler);
+  return () => {
+    window.removeEventListener(ADDRESS_CHANGED, handler);
+    window.removeEventListener(CHAIN_CHANGED, handler);
+  };
+}
+function eip1193() {
+  const p = win().ManifoldEthereumProvider;
+  const provider = (p?.provider?.(true) ?? p?.browserProvider?.())?.provider;
+  if (!provider) throw new MintError("CHAIN_SWITCH_FAILED", "No wallet is connected.");
+  return provider;
+}
+function getWalletClient(chainId) {
+  const provider = eip1193();
+  const request = ((args) => provider.request(args));
+  return createWalletClient({ chain: getChain(chainId), transport: custom({ request }) });
+}
+var code = (e) => e?.code;
+async function switchToChain(chainId) {
+  const chain = getChain(chainId);
+  const provider = eip1193();
+  const hexId = `0x${chainId.toString(16)}`;
+  const switchChain = () => provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: hexId }] });
+  try {
+    try {
+      await switchChain();
+    } catch (e) {
+      if (code(e) !== 4902) throw e;
+      await provider.request({
+        method: "wallet_addEthereumChain",
+        params: [
+          {
+            chainId: hexId,
+            chainName: chain.name,
+            nativeCurrency: chain.nativeCurrency,
+            rpcUrls: [...chain.rpcUrls.default.http],
+            ...chain.blockExplorers ? { blockExplorerUrls: [chain.blockExplorers.default.url] } : {}
+          }
+        ]
+      });
+      await switchChain();
+    }
+  } catch (e) {
+    if (code(e) === 4001) throw new MintError("USER_REJECTED", "You rejected the network switch.", { cause: e });
+    throw new MintError("CHAIN_SWITCH_FAILED", `Could not switch the wallet to chain ${String(chainId)}.`, { cause: e });
+  }
+}
+
+// src/core/adapters/manifold-claim/index.ts
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  decodeErrorResult,
+  encodeFunctionData,
+  formatUnits,
+  getAddress as getAddress2,
+  isAddress,
+  isHex,
+  zeroAddress,
+  zeroHash
+} from "viem";
+
+// src/core/adapters/manifold-claim/abis.ts
+import { parseAbi } from "viem";
+var CLAIM_721_V5_ABI = 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 = 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 = 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 = 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 = 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 = parseAbi([
+  "error Error(string message)",
+  "error Panic(uint256 code)",
+  "error ClaimInactive()",
+  "error ClaimNotInitialized()",
+  "error ExpiredSignature()",
+  "error FailedToTransfer()",
+  "error InvalidAirdrop()",
+  "error InvalidInput()",
+  "error InvalidInstance()",
+  "error InvalidSignature()",
+  "error InvalidStartDate()",
+  "error InvalidStorageProtocol()",
+  "error MustUseSignatureMinting()",
+  "error TokenDNE()",
+  "error TooManyRequested()"
+]);
+var CREATOR_ABI = parseAbi(["function getExtensions() view returns (address[])"]);
+var ERC20_ABI = parseAbi([
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)",
+  "function balanceOf(address owner) view returns (uint256)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)"
+]);
+
+// src/core/adapters/manifold-claim/merkle.ts
+var UINT32_MAX = 4294967295;
+async function getJson(fetchFn, url, signal, what) {
+  let res;
+  try {
+    signal?.throwIfAborted();
+    res = await fetchFn(url, signal ? { signal } : void 0);
+  } catch (cause) {
+    throw new MintError("ALLOWLIST_UNAVAILABLE", `Could not reach the allowlist service (${what}).`, { cause });
+  }
+  if (res.status === 429) throw new MintError("RATE_LIMITED", "The allowlist service is rate limiting requests. Try again shortly.");
+  if (!res.ok) throw new MintError("ALLOWLIST_UNAVAILABLE", `The allowlist service has no data for this claim (${what}: HTTP ${res.status}).`);
+  try {
+    return await res.json();
+  } catch (cause) {
+    throw new MintError("ALLOWLIST_UNAVAILABLE", `The allowlist service returned an unreadable response (${what}).`, { cause });
+  }
+}
+var isRecord = (v) => typeof v === "object" && v !== null;
+var scopeCaches = /* @__PURE__ */ new WeakMap();
+function memo(cache, key, signal, load) {
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const p = withSignal(load(), signal);
+  cache.set(key, p);
+  p.catch(() => {
+    if (cache.get(key) === p) cache.delete(key);
+  });
+  return p;
+}
+function withSignal(p, signal) {
+  if (!signal) return p;
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new MintError("ALLOWLIST_UNAVAILABLE", "The allowlist request was cancelled.", { cause: signal.reason }));
+    p.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+    if (signal.aborted) return onAbort();
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function loadInstance(fetchFn, api, instanceId, signal) {
+  const instance = await getJson(fetchFn, `${api}/public/instance/data?id=${instanceId}`, signal, "instance data");
+  const publicData = isRecord(instance) ? instance.publicData : void 0;
+  const allowlist = isRecord(publicData) ? publicData.instanceAllowlist : void 0;
+  const merkleTreeId = isRecord(allowlist) ? allowlist.merkleTreeId : void 0;
+  const appId = isRecord(instance) ? instance.appId : void 0;
+  if (typeof merkleTreeId !== "number" && typeof merkleTreeId !== "string" || typeof appId !== "number" && typeof appId !== "string") {
+    throw new MintError("ALLOWLIST_UNAVAILABLE", "The allowlist for this claim is not published yet.");
+  }
+  return { merkleTreeId, appId };
+}
+async function loadEntries(fetchFn, api, instanceId, recipient, scoped) {
+  const { signal } = scoped;
+  const { merkleTreeId, appId } = await memo(scoped.instances, `${api}|${instanceId}`, signal, () => loadInstance(fetchFn, api, instanceId, signal));
+  const url = `${api}/public/merkleTree/${encodeURIComponent(String(merkleTreeId))}/merkleInfo?address=${recipient}&appId=${encodeURIComponent(String(appId))}`;
+  const body = await getJson(fetchFn, url, signal, "merkle info");
+  if (!Array.isArray(body)) throw new MintError("ALLOWLIST_UNAVAILABLE", "The allowlist service returned an unexpected response.");
+  return body.map((row) => {
+    const proof = isRecord(row) ? row.merkleProof : void 0;
+    const value = isRecord(row) ? row.value : void 0;
+    if (!Array.isArray(proof) || !proof.every((p) => typeof p === "string" && /^0x[0-9a-fA-F]{64}$/.test(p)) || typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > UINT32_MAX) {
+      throw new MintError("ALLOWLIST_UNAVAILABLE", "The allowlist service returned an unexpected response.");
+    }
+    return { mintIndex: value, proof };
+  });
+}
+async function fetchMerkleEntries(args) {
+  if (args.signal?.aborted) {
+    throw new MintError("ALLOWLIST_UNAVAILABLE", "The allowlist request was cancelled.", { cause: args.signal.reason });
+  }
+  const fetchFn = args.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  const key = `${args.api}|${args.instanceId}|${args.recipient.toLowerCase()}`;
+  let scoped = scopeCaches.get(args.scope);
+  if (!scoped || scoped.signal?.aborted) {
+    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));
+  return entries.slice();
+}
+
+// src/core/adapters/manifold-claim/index.ts
+var V6_721 = "0x1eb73fee2090fb1c20105d5ba887e3c3ba14a17e";
+var V6_1155 = "0x04ba6cf3c5aa6d4946f5b7f7adf111012a9fac65";
+var V7_721 = "0x23aa05a271debffaa3d75739af5581f744b326e4";
+var V7_1155 = "0x26bbea7803dcac346d5f5f135b57cf2c752a02be";
+var V8_721 = "0x5889e848b2423344f7969bc158100c07595c0137";
+var V8_1155 = "0x88438f4d4b8516e758a319ad16924da60e1e56cc";
+var v6 = (chainId) => [
+  { chainId, address: V6_721, generation: "V6", spec: "721", abi: "Claim721V5Optimization" },
+  { chainId, address: V6_1155, generation: "V6", spec: "1155", abi: "Claim1155V5Optimization" }
+];
+var v7 = (chainId) => [
+  { chainId, address: V7_721, generation: "V7", spec: "721", abi: "Claim721V7" },
+  { chainId, address: V7_1155, generation: "V7", spec: "1155", abi: "Claim1155V7" }
+];
+var EXTENSIONS = [
+  ...v6(1),
+  ...v7(1),
+  ...v6(8453),
+  ...v7(8453),
+  ...v6(10),
+  ...v7(10),
+  ...v7(360),
+  { chainId: 360, address: V8_1155, generation: "V8", spec: "1155", abi: "Claim1155V7" },
+  ...v6(11155111),
+  ...v7(11155111),
+  { chainId: 11155111, address: V8_721, generation: "V8", spec: "721", abi: "Claim721V7" },
+  { chainId: 11155111, address: V8_1155, generation: "V8", spec: "1155", abi: "Claim1155V7" }
+];
+function findExtension(chainId, address) {
+  const a = address.toLowerCase();
+  return EXTENSIONS.find((e) => e.chainId === chainId && e.address === a);
+}
+var MERKLE_API = "https://apps.api.manifoldxyz.dev";
+var MAX_MINT_COUNT = 65535;
+var GAS_UNITS_BASE = 100000n;
+var GAS_UNITS_PER_TOKEN = 150000n;
+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 !== zeroHash;
+function isContractFailure(e) {
+  if (!(e instanceof BaseError)) return false;
+  return e.walk((x) => x instanceof ContractFunctionRevertedError || x.name === "ContractFunctionZeroDataError") !== null;
+}
+function toRpcError(e) {
+  if (e instanceof MintError) return e;
+  const msg = e instanceof 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) {
+  try {
+    return await fn();
+  } catch (e) {
+    throw toRpcError(e);
+  }
+}
+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);
+  });
+  const d = hit?.data;
+  if (isHex(d)) return d;
+  const inner = d?.data;
+  return isHex(inner) ? inner : void 0;
+}
+function decodeRevert(e) {
+  if (!(e instanceof BaseError)) return null;
+  const data = revertData(e);
+  if (data) {
+    try {
+      const d = 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;
+    } catch {
+      return `reverted with unknown error ${data.slice(0, 10)}`;
+    }
+  }
+  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) });
+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 (!isAddress(config.creatorContract, { strict: false })) {
+    throw new MintError("INVALID_CONFIG", "creatorContract is not a valid address.", { field: "creatorContract" });
+  }
+  if (config.extension !== void 0 && !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: getAddress2(config.creatorContract),
+    instanceId: BigInt(config.instanceId),
+    extension: config.extension === void 0 ? void 0 : getAddress2(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 args = [creator, instanceId];
+  try {
+    switch (entry.abi) {
+      case "Claim721V5Optimization": {
+        const c = await client.readContract({ address, abi: CLAIM_721_V5_ABI, functionName: "getClaim", args });
+        return { ...base2(c), signingAddress: null };
+      }
+      case "Claim1155V5Optimization": {
+        const c = await client.readContract({ address, abi: CLAIM_1155_V5_ABI, functionName: "getClaim", args });
+        return { ...base2(c), signingAddress: null };
+      }
+      case "Claim721V7": {
+        const c = await client.readContract({ address, abi: CLAIM_721_V7_ABI, functionName: "getClaim", args });
+        return { ...base2(c), signingAddress: c.signingAddress };
+      }
+      case "Claim1155V7": {
+        const c = await client.readContract({ address, abi: CLAIM_1155_V7_ABI, functionName: "getClaim", args });
+        return { ...base2(c), signingAddress: c.signingAddress };
+      }
+    }
+  } catch (e) {
+    if (isContractFailure(e)) throw notFound(config);
+    throw toRpcError(e);
+  }
+}
+function base2(c) {
+  return {
+    total: BigInt(c.total),
+    totalMax: BigInt(c.totalMax),
+    walletMax: BigInt(c.walletMax),
+    startDate: BigInt(c.startDate),
+    endDate: BigInt(c.endDate),
+    merkleRoot: c.merkleRoot,
+    cost: c.cost,
+    erc20: c.erc20
+  };
+}
+async function hasCode(client, address) {
+  const code2 = await rpc(() => client.getCode({ address: getAddress2(address) }));
+  return code2 !== void 0 && code2 !== "0x";
+}
+var unknownExtension = (address, why) => new MintError("UNKNOWN_EXTENSION", `Extension ${address} ${why}.`);
+async function resolveExtension(ctx, config) {
+  const { creator, instanceId, extension } = parseConfig(config);
+  const { client } = ctx;
+  if (extension) {
+    const entry = findExtension(config.chainId, extension);
+    if (!entry) throw unknownExtension(extension, `is not a supported Manifold claim extension on chain ${config.chainId}`);
+    if (!await hasCode(client, extension)) throw unknownExtension(extension, "has no contract code on this chain");
+    return { entry, claim: await readClaim(client, entry, creator, instanceId, config) };
+  }
+  let registered;
+  try {
+    registered = await client.readContract({ address: creator, abi: CREATOR_ABI, functionName: "getExtensions" });
+  } catch (e) {
+    if (isContractFailure(e)) throw notFound(config);
+    throw toRpcError(e);
+  }
+  const candidates = [...new Set(registered.map((a) => a.toLowerCase()))].map((a) => findExtension(config.chainId, a)).filter((e) => e !== void 0);
+  const found = await Promise.all(
+    candidates.map(async (entry) => {
+      if (!await hasCode(client, entry.address)) return null;
+      try {
+        return { entry, claim: await readClaim(client, entry, creator, instanceId, config) };
+      } catch (e) {
+        if (e instanceof MintError && e.reason === "CLAIM_NOT_FOUND") return null;
+        throw e;
+      }
+    })
+  );
+  const hits = found.filter((f) => f !== null);
+  if (hits.length === 0) throw notFound(config);
+  if (hits.length > 1) {
+    throw new MintError(
+      "AMBIGUOUS_EXTENSION",
+      `Claim ${config.instanceId} exists on ${hits.length} extensions (${hits.map((h) => h.entry.address).join(", ")}). Set config.extension.`
+    );
+  }
+  return hits[0];
+}
+async function loadDrop(ctx, config) {
+  const { entry, claim } = await resolveExtension(ctx, config);
+  if (claim.signingAddress !== null && claim.signingAddress !== 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 = getAddress2(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) {
+    unitPrice = money(claim.cost, native.decimals, native.symbol);
+  } else {
+    paymentToken = getAddress2(claim.erc20);
+    const token = paymentToken;
+    const [symbol, decimals] = await rpc(
+      () => Promise.all([
+        client.readContract({ address: token, abi: ERC20_ABI, functionName: "symbol" }),
+        client.readContract({ address: token, abi: ERC20_ABI, functionName: "decimals" })
+      ])
+    );
+    unitPrice = money(claim.cost, decimals, symbol);
+  }
+  const drop = {
+    chainId: config.chainId,
+    unitPrice,
+    unitFee: money(fee, native.decimals, native.symbol),
+    totalMinted: claim.total,
+    maxSupply: claim.totalMax === 0n ? null : claim.totalMax,
+    startTime: timestamp(claim.startDate, "startDate"),
+    endTime: timestamp(claim.endDate, "endDate"),
+    isAllowlist: isAllowlist(claim),
+    paymentToken,
+    pricePer: "unit"
+  };
+  const resolved = { entry, claim, fee };
+  dropResolved.set(drop, resolved);
+  return { drop, resolved };
+}
+async function loadWallet(ctx, config, args) {
+  const { creator, instanceId } = parseConfig(config);
+  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);
+  let walletMinted = null;
+  let walletMax = null;
+  let allowlistRemaining = null;
+  let maxQuantity = null;
+  let ineligible = null;
+  let unused = [];
+  if (isAllowlist(claim)) {
+    const entries = await fetchMerkleEntries({ scope: ctx.cacheScope ?? args.drop, api: MERKLE_API, instanceId: config.instanceId, recipient, fetch: ctx.fetch, signal: ctx.signal });
+    if (entries.length > 0) {
+      const minted = await rpc(
+        () => client.readContract({
+          address: extension,
+          abi: EXTENSION_COMMON_ABI,
+          functionName: "checkMintIndices",
+          args: [creator, instanceId, entries.map((e) => e.mintIndex)]
+        })
+      );
+      unused = entries.filter((_, i) => minted[i] === false);
+    }
+    allowlistRemaining = unused.length;
+    maxQuantity = unused.length;
+    if (entries.length === 0) {
+      ineligible = { reason: "NOT_ON_ALLOWLIST", message: "This wallet is not on the allowlist." };
+    } else if (unused.length === 0) {
+      ineligible = { reason: "ALLOWLIST_USED", message: "This wallet has already used all its allowlist spots." };
+    }
+  } else if (claim.walletMax > 0n) {
+    walletMax = claim.walletMax;
+    walletMinted = BigInt(
+      await rpc(() => client.readContract({ address: extension, abi: EXTENSION_COMMON_ABI, functionName: "getTotalMints", args: [recipient, creator, instanceId] }))
+    );
+    const left = walletMax > walletMinted ? walletMax - walletMinted : 0n;
+    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 [native, erc20, gasPrice] = await rpc(
+    () => Promise.all([
+      client.getBalance({ address: payer }),
+      token ? client.readContract({ address: token, abi: ERC20_ABI, functionName: "balanceOf", args: [payer] }) : Promise.resolve(null),
+      client.getGasPrice()
+    ])
+  );
+  const gasUnits = GAS_UNITS_BASE + GAS_UNITS_PER_TOKEN * BigInt(Math.max(1, args.quantity)) + (token ? GAS_UNITS_APPROVE : 0n);
+  const data = { brand: WALLET_DATA_BRAND, resolved, config, recipient, unused };
+  return {
+    walletMinted,
+    walletMax,
+    allowlistRemaining,
+    maxQuantity,
+    ineligible,
+    balances: { native, erc20 },
+    gasReserve: gasPrice * gasUnits,
+    data
+  };
+}
+var sameClaim = (a, b) => a.chainId === b.chainId && a.creatorContract.toLowerCase() === b.creatorContract.toLowerCase() && a.instanceId === b.instanceId && a.extension?.toLowerCase() === b.extension?.toLowerCase();
+async function buildPlan(ctx, attempt, wallet) {
+  const { config, quantity } = attempt;
+  if (!Number.isInteger(quantity) || quantity < 1 || quantity > MAX_MINT_COUNT) {
+    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);
+  let data = wallet.data;
+  if (!isWalletData(data) || !sameClaim(data.config, config) || data.recipient !== recipient) {
+    const drop = (await loadDrop(ctx, config)).drop;
+    data = (await loadWallet(ctx, config, { payer, recipient, quantity, drop })).data;
+  }
+  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);
+  let mintIndices = [];
+  let merkleProofs = [];
+  if (isAllowlist(claim)) {
+    if (quantity > data.unused.length) {
+      throw new MintError("WALLET_LIMIT", `Only ${data.unused.length} allowlist spot(s) left for this wallet.`);
+    }
+    const picked = data.unused.slice(0, quantity);
+    mintIndices = picked.map((p) => p.mintIndex);
+    merkleProofs = picked.map((p) => p.proof);
+  }
+  const qty = BigInt(quantity);
+  const erc20 = claim.erc20 === zeroAddress ? null : getAddress2(claim.erc20);
+  const cost = claim.cost * qty;
+  const value = fee * qty + (erc20 ? 0n : cost);
+  let approve = null;
+  if (erc20 && cost > 0n) {
+    const allowance = await rpc(() => ctx.client.readContract({ address: erc20, abi: ERC20_ABI, functionName: "allowance", args: [payer, extension] }));
+    if (allowance < cost) {
+      approve = {
+        token: erc20,
+        spender: extension,
+        amount: cost,
+        tx: { to: erc20, data: encodeFunctionData({ abi: ERC20_ABI, functionName: "approve", args: [extension, cost] }), value: 0n }
+      };
+    }
+  }
+  return {
+    approve,
+    mint: {
+      to: extension,
+      data: encodeFunctionData({
+        abi: EXTENSION_COMMON_ABI,
+        functionName: "mintProxy",
+        args: [creator, instanceId, quantity, mintIndices, merkleProofs.map((p) => [...p]), recipient]
+      }),
+      value
+    },
+    tokenContract: creator
+  };
+}
+var manifoldClaimAdapter = {
+  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 });
+    } catch (e) {
+      const text2 = decodeRevert(e);
+      if (text2 === null) throw toRpcError(e);
+      throw new MintError("SIMULATION_REVERTED", text2, { cause: e });
+    }
+  }
+};
+
+// src/core/adapters/contract/index.ts
+import {
+  BaseError as BaseError2,
+  ContractFunctionRevertedError as ContractFunctionRevertedError2,
+  ContractFunctionZeroDataError,
+  InsufficientFundsError,
+  decodeErrorResult as decodeErrorResult2,
+  encodeFunctionData as encodeFunctionData2,
+  formatUnits as formatUnits3,
+  getAddress as getAddress3,
+  isAddress as isAddress2,
+  parseAbi as parseAbi2,
+  parseUnits
+} from "viem";
+
+// src/core/machine.ts
+import { formatUnits as formatUnits2 } from "viem";
+var MINT_STATES = [
+  "loading",
+  "unsupported",
+  "upcoming",
+  "ended",
+  "sold-out",
+  "disconnected",
+  "connecting",
+  "live",
+  "ineligible",
+  "insufficient-funds",
+  "switching-chain",
+  "approving",
+  "minting",
+  "confirming",
+  "success",
+  "error"
+];
+var CLICKABLE_STATES = ["disconnected", "live", "success", "error"];
+var IN_FLIGHT_STATES = ["switching-chain", "approving", "minting", "confirming"];
+var MAX_QUANTITY = 65535;
+function initialState(opts) {
+  return {
+    name: "loading",
+    reason: null,
+    message: null,
+    readGen: 0,
+    walletGen: 0,
+    drop: null,
+    account: null,
+    walletRead: null,
+    blocked: null,
+    quantity: toQuantity(opts?.quantity ?? 1, MAX_QUANTITY),
+    attempt: null,
+    result: null,
+    pendingRefresh: false,
+    now: 0
+  };
+}
+function toQuantity(q, max) {
+  if (Number.isNaN(q)) return 1;
+  return Math.max(1, Math.min(Math.floor(q), max));
+}
+function isInFlight(s) {
+  return s.attempt !== null || IN_FLIGHT_STATES.includes(s.name);
+}
+function isIdle(s) {
+  return !isInFlight(s) && s.name !== "connecting" && s.name !== "success" && s.name !== "error";
+}
+function derive(s, unsupported) {
+  const named = (name) => ({ name, reason: null, message: null });
+  const { drop, walletRead } = s;
+  if (unsupported) return { name: "unsupported", reason: s.reason, message: s.message };
+  if (drop === null) return named("loading");
+  if (drop.endTime !== null && drop.endTime <= s.now) return named("ended");
+  if (drop.maxSupply !== null && drop.maxSupply > 0n && drop.totalMinted >= drop.maxSupply) return named("sold-out");
+  if (drop.startTime !== null && drop.startTime > s.now) return named("upcoming");
+  if (s.account === null) return named("disconnected");
+  if (walletRead === null) return named("loading");
+  if (s.blocked !== null) return s.blocked;
+  if (walletRead.ineligible !== null) {
+    return { name: "ineligible", reason: walletRead.ineligible.reason, message: walletRead.ineligible.message };
+  }
+  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.` };
+    }
+    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.` };
+    }
+  }
+  return named("live");
+}
+function settle(s, unsupported = s.name === "unsupported") {
+  if (!isIdle(s)) return s;
+  return { ...s, ...derive(s, unsupported) };
+}
+function clampQuantity(s) {
+  const quantity = toQuantity(s.quantity, selectMaxQuantity(s) ?? MAX_QUANTITY);
+  return quantity === s.quantity ? s : { ...s, quantity };
+}
+function reducer(state, event) {
+  const inFlight = isInFlight(state);
+  const failed = (reason, message) => {
+    if (inFlight) return { ...state, pendingRefresh: true };
+    if (state.name === "success" || state.name === "error") return state;
+    return { ...state, name: "error", reason, message };
+  };
+  switch (event.type) {
+    case "LOAD": {
+      if (event.kind === "refresh") {
+        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 };
+      return inFlight ? { ...next, pendingRefresh: true } : settle(next, false);
+    }
+    case "DROP_LOADED": {
+      if (event.gen !== state.readGen) return state;
+      const next = { ...state, drop: event.drop, now: Math.max(state.now, event.now) };
+      if (inFlight) return { ...next, pendingRefresh: true };
+      return isIdle(next) ? settle(clampQuantity(next), false) : clampQuantity(next);
+    }
+    case "DROP_UNSUPPORTED": {
+      if (event.gen !== state.readGen) return state;
+      if (inFlight) return { ...state, pendingRefresh: true };
+      if (state.name === "success" || state.name === "error") return state;
+      return { ...state, name: "unsupported", reason: event.reason, message: event.message };
+    }
+    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 };
+      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 };
+      return inFlight ? { ...next, pendingRefresh: true } : settle(clampQuantity(next));
+    }
+    case "WALLET_FAILED":
+      return event.gen !== state.walletGen ? state : failed(event.reason, event.message);
+    case "CONNECT_STARTED":
+      return state.name === "disconnected" && state.attempt === null ? { ...state, name: "connecting", reason: null, message: null } : state;
+    case "CONNECT_DISMISSED":
+      return state.name === "connecting" ? settle({ ...state, name: "disconnected" }, false) : state;
+    case "TICK":
+      return settle({ ...state, now: Math.max(state.now, event.now) });
+    case "SET_QUANTITY": {
+      const next = { ...state, quantity: toQuantity(event.quantity, selectMaxQuantity(state) ?? MAX_QUANTITY) };
+      return inFlight ? { ...next, pendingRefresh: true } : settle(next);
+    }
+    case "ATTEMPT_STARTED":
+      return state.name === "live" && state.attempt === null ? { ...state, attempt: event.attempt } : state;
+    case "SWITCHING_CHAIN":
+      return step(state, event.attemptId, "switching-chain");
+    case "APPROVING":
+      return step(state, event.attemptId, "approving");
+    case "MINT_PROMPTED":
+      return step(state, event.attemptId, "minting");
+    case "TX_SUBMITTED":
+      return step(state, event.attemptId, "confirming");
+    case "ATTEMPT_SUCCEEDED":
+      return state.attempt?.attemptId === event.attemptId ? {
+        ...state,
+        name: "success",
+        reason: null,
+        message: null,
+        attempt: null,
+        result: event.result,
+        drop: null,
+        readGen: state.readGen + 1
+      } : state;
+    case "ATTEMPT_FAILED": {
+      if (state.attempt?.attemptId !== event.attemptId) return state;
+      const { reason, message } = event;
+      const done = { ...state, reason, message, attempt: null, result: null };
+      if (INELIGIBLE_REASONS.includes(reason)) {
+        return { ...done, name: "ineligible", blocked: { name: "ineligible", reason, message } };
+      }
+      if (reason === "INSUFFICIENT_FUNDS") {
+        return { ...done, name: "insufficient-funds", blocked: { name: "insufficient-funds", reason, message } };
+      }
+      return {
+        ...done,
+        name: "error",
+        drop: state.name === "confirming" ? null : state.drop,
+        readGen: state.name === "confirming" ? state.readGen + 1 : state.readGen
+      };
+    }
+    case "RESET": {
+      if (state.name !== "success" && state.name !== "error") return state;
+      const next = {
+        ...state,
+        readGen: event.gen,
+        walletRead: null,
+        blocked: null,
+        walletGen: state.walletGen + 1,
+        result: null,
+        pendingRefresh: false
+      };
+      return settle(clampQuantity({ ...next, name: "loading" }), false);
+    }
+  }
+}
+var STEP_ORDER = ["switching-chain", "approving", "minting", "confirming"];
+function step(state, attemptId, name) {
+  if (state.attempt?.attemptId !== attemptId) return state;
+  if (STEP_ORDER.indexOf(name) <= STEP_ORDER.indexOf(state.name)) return state;
+  return { ...state, name, reason: null, message: null };
+}
+function selectMaxQuantity(state) {
+  const { drop, walletRead } = state;
+  if (drop === null) return null;
+  let max = MAX_QUANTITY;
+  if (drop.maxSupply !== null && drop.maxSupply > 0n) {
+    const remaining = drop.maxSupply - drop.totalMinted;
+    if (remaining < BigInt(max)) max = remaining > 0n ? Number(remaining) : 0;
+  }
+  if (walletRead !== null && walletRead.maxQuantity !== null) {
+    max = Math.min(max, Math.max(0, Math.floor(walletRead.maxQuantity)));
+  }
+  return max;
+}
+function selectTotal(state) {
+  const { drop } = state;
+  if (drop === null) return null;
+  const q = BigInt(state.quantity);
+  const price = drop.unitPrice;
+  const fee = drop.unitFee;
+  const priceTotal = drop.pricePer === "total" ? price.value : price.value * q;
+  if (drop.paymentToken !== null) {
+    return {
+      native: money2(fee.value * q, fee),
+      erc20: money2(priceTotal, price)
+    };
+  }
+  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) };
+}
+function canAct(state) {
+  return state.attempt === null && CLICKABLE_STATES.includes(state.name);
+}
+
+// src/core/adapters/contract/index.ts
+var PLACEHOLDERS = ["{recipient}", "{payer}", "{quantity}", "{unitPrice}", "{totalPrice}"];
+var ERC20_ABI2 = parseAbi2([
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)",
+  "function balanceOf(address) view returns (uint256)",
+  "function allowance(address,address) view returns (uint256)",
+  "function approve(address,uint256) returns (bool)"
+]);
+var FALLBACK_MINT_GAS = 300000n;
+var APPROVE_GAS = 65000n;
+var PLACEHOLDER_TOKEN = /\{[A-Za-z_]\w*\}/g;
+var DISPLAY_AMOUNT = /^\d+(\.\d+)?$/;
+var NUMERIC_TYPE = /^u?int\d*$/;
+function bad(field, message) {
+  throw new MintError("INVALID_CONFIG", `${field} ${message}`, { field });
+}
+var isHexAddress = (a) => typeof a === "string" && isAddress2(a, { strict: false });
+function functionsNamed(abi, name) {
+  return abi.filter((i) => i.type === "function" && i.name === name);
+}
+function validateTemplate(t, path, allowed) {
+  if (typeof t === "string") {
+    for (const token of t.match(PLACEHOLDER_TOKEN) ?? []) {
+      if (!PLACEHOLDERS.includes(token)) bad(path, `"${t}" is not a known placeholder (${token})`);
+      if (!allowed.includes(token)) bad(path, `"${t}" uses ${token}, which is not available in this field`);
+    }
+  } else if (Array.isArray(t)) {
+    t.forEach((x, i) => validateTemplate(x, `${path}[${i}]`, allowed));
+  } else if (typeof t === "number") {
+    if (!Number.isSafeInteger(t)) bad(path, `${t} is not a safe integer; pass larger or fractional values as a bigint or decimal string`);
+  } else if (typeof t !== "bigint" && typeof t !== "boolean") {
+    bad(path, "must be a string, number, bigint, boolean or array");
+  }
+}
+var ARRAY_TYPE = /^(.*)\[(\d*)\]$/;
+var BYTES_TYPE = /^bytes(\d*)$/;
+var INT_TYPE = /^(u?)int(\d*)$/;
+var isExactPlaceholder = (t) => typeof t === "string" && PLACEHOLDERS.includes(t);
+var hasPlaceholder = (t) => typeof t === "string" && (t.match(PLACEHOLDER_TOKEN) ?? []).length > 0;
+function intBounds(type) {
+  const m = INT_TYPE.exec(type);
+  if (!m) return null;
+  const bits = BigInt(m[2] ? Number(m[2]) : 256);
+  return m[1] ? { min: 0n, max: 2n ** bits - 1n } : { min: -(2n ** (bits - 1n)), max: 2n ** (bits - 1n) - 1n };
+}
+var elementParam = (p, type) => ({ ...p, type });
+var componentsOf = (p) => p.components ?? [];
+function typeIssue(t, p, path) {
+  const no = (message) => ({ path, message });
+  const arr = ARRAY_TYPE.exec(p.type);
+  if (arr) {
+    if (!Array.isArray(t)) return no(`must be an array for ${p.type}`);
+    if (arr[2] !== "" && t.length !== Number(arr[2])) return no(`has ${t.length} item(s) but ${p.type} takes ${arr[2]}`);
+    const el = elementParam(p, arr[1]);
+    for (let i = 0; i < t.length; i++) {
+      const issue = typeIssue(t[i], el, `${path}[${i}]`);
+      if (issue) return issue;
+    }
+    return null;
+  }
+  if (p.type === "tuple") {
+    const comps = componentsOf(p);
+    if (!Array.isArray(t)) return no("must be an array for a tuple");
+    if (t.length !== comps.length) return no(`has ${t.length} item(s) but the tuple takes ${comps.length}`);
+    for (let i = 0; i < comps.length; i++) {
+      const issue = typeIssue(t[i], comps[i], `${path}[${i}]`);
+      if (issue) return issue;
+    }
+    return null;
+  }
+  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) && isAddress2(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`);
+  const bytes = BYTES_TYPE.exec(p.type);
+  if (bytes) {
+    const ok = typeof t === "string" && !hasPlaceholder(t) && /^0x([0-9a-fA-F]{2})*$/.test(t) && (!bytes[1] || t.length === 2 + 2 * Number(bytes[1]));
+    return ok ? null : no(`${JSON.stringify(String(t))} is not ${bytes[1] ? `${bytes[1]} bytes of` : ""} hex data`);
+  }
+  const bounds = intBounds(p.type);
+  if (bounds) {
+    let n;
+    if (isExactPlaceholder(t)) return t === "{recipient}" || t === "{payer}" ? no(`${t} is an address, but the abi input is ${p.type}`) : null;
+    if (typeof t === "bigint") n = t;
+    else if (typeof t === "number") n = BigInt(t);
+    else if (typeof t === "string" && !hasPlaceholder(t) && /^-?\d+$/.test(t)) n = BigInt(t);
+    else return no(`${JSON.stringify(String(t))} is not an integer for ${p.type}`);
+    return n >= bounds.min && n <= bounds.max ? null : no(`${n} is out of range for ${p.type}`);
+  }
+  return no(`abi type ${p.type} is not supported in an argument template`);
+}
+var signature = (f) => `${f.name}(${f.inputs.map((i) => i.type).join(",")})`;
+var NO_PLACEHOLDERS = [];
+function validateCall(abi, call, prefix, kind, allowed) {
+  const c = call ?? {};
+  const named = typeof c.functionName === "string" ? functionsNamed(abi, c.functionName) : [];
+  if (named.length === 0) bad(`${prefix}.functionName`, `"${String(c.functionName)}" is not a function in the abi`);
+  if (c.args !== void 0 && !Array.isArray(c.args)) bad(`${prefix}.args`, "must be an array");
+  if (kind === "mint" && c.args === void 0) bad(`${prefix}.args`, "is required");
+  const args = c.args ?? [];
+  args.forEach((a, i) => validateTemplate(a, `${prefix}.args[${i}]`, allowed));
+  const sameArity = named.filter((f) => f.inputs.length === args.length);
+  if (sameArity.length === 0) {
+    const want = [...new Set(named.map((f) => f.inputs.length))].join(" or ");
+    bad(`${prefix}.args`, `has ${args.length} argument(s) but "${String(c.functionName)}" takes ${want}`);
+  }
+  const checked = sameArity.map((f) => {
+    let issue = null;
+    for (let i = 0; i < args.length && !issue; i++) issue = typeIssue(args[i], f.inputs[i], `${prefix}.args[${i}]`);
+    return { f, issue };
+  });
+  const fits = checked.filter((x) => !x.issue);
+  if (fits.length === 0) {
+    const first = checked[0].issue;
+    if (sameArity.length === 1) bad(first.path, first.message);
+    bad(`${prefix}.args`, `fit none of the overloads ${sameArity.map(signature).join(", ")}: ${first.path} ${first.message}`);
+  }
+  const roleFits = fits.filter(
+    ({ f }) => kind === "read" ? f.stateMutability === "view" || f.stateMutability === "pure" : f.stateMutability === "payable" || f.stateMutability === "nonpayable"
+  );
+  if (roleFits.length === 0) {
+    const name = fits[0].f.name;
+    if (kind === "read") bad(`${prefix}.functionName`, `"${name}" is not a view or pure function`);
+    if (fits.some(({ f }) => f.stateMutability !== "view" && f.stateMutability !== "pure")) {
+      bad(`${prefix}.functionName`, `"${name}" has missing or invalid stateMutability; mint requires payable or nonpayable`);
+    }
+    bad(`${prefix}.functionName`, `"${name}" is a view or pure function and cannot mint`);
+  }
+  if (roleFits.length > 1) {
+    bad(`${prefix}.functionName`, `"${String(c.functionName)}" is ambiguous: ${roleFits.map((x) => signature(x.f)).join(" and ")} both accept these arguments`);
+  }
+  return roleFits[0].f;
+}
+function resolveOutput(fn, output, path) {
+  const outs = fn.outputs;
+  if (outs.length === 0) bad(`${path}.functionName`, `"${fn.name}" returns nothing`);
+  const first = outs[0];
+  const tuple = outs.length === 1 && first.type === "tuple";
+  const members = tuple ? first.components ?? [] : outs;
+  const memberNames = members.map((m, i) => m.name || String(i)).join(", ");
+  let index;
+  if (output === void 0) {
+    if (members.length !== 1) bad(`${path}.output`, `is required: "${fn.name}" returns several values (${memberNames})`);
+    index = 0;
+  } else if (typeof output === "number") {
+    if (!Number.isInteger(output) || output < 0 || output >= members.length) {
+      bad(`${path}.output`, `${output} is not in the abi outputs of "${fn.name}" (${memberNames})`);
+    }
+    index = output;
+  } else if (typeof output === "string") {
+    index = members.findIndex((m) => m.name === output);
+    if (index < 0) bad(`${path}.output`, `"${output}" is not in the abi outputs of "${fn.name}" (${memberNames})`);
+  } else {
+    return bad(`${path}.output`, "must be an index or a name");
+  }
+  const type = members[index].type;
+  if (!NUMERIC_TYPE.test(type)) {
+    const reason = `returns ${type}, not a number`;
+    if (output === void 0) bad(`${path}.functionName`, `"${fn.name}" ${reason}`);
+    bad(`${path}.output`, `selects a value that is ${type}, not a number`);
+  }
+  return { tuple, index, type };
+}
+function validateField(abi, name, src, allowed, isPrice) {
+  if (typeof src !== "object" || src === null) bad(name, "is required and must be { value } or { read }");
+  const s = src;
+  const hasRead = Object.hasOwn(s, "read");
+  const hasValue = Object.hasOwn(s, "value");
+  if (hasRead && hasValue) bad(name, "must be exactly one of { value } or { read }, not both");
+  if (hasRead) {
+    if (typeof s.read !== "object" || s.read === null) bad(`${name}.read`, "must be { functionName, args?, output? }");
+    if (s.unit !== void 0) bad(name, "unit is only valid with a string value");
+    const fn = validateCall(abi, s.read, `${name}.read`, "read", allowed);
+    resolveOutput(fn, s.read.output, `${name}.read`);
+  } else if (typeof s.value === "bigint") {
+    if (s.unit !== void 0) bad(name, "unit is only valid with a string value");
+    if (s.value < 0n) bad(`${name}.value`, "must not be negative");
+  } else if (typeof s.value === "string") {
+    if (s.unit !== "display") bad(name, 'string values need unit: "display"');
+    if (!isPrice) bad(name, "display units are only valid for price; use a bigint in base units");
+    if (!DISPLAY_AMOUNT.test(s.value)) bad(`${name}.value`, `"${s.value}" is not a decimal number like "0.01"`);
+  } else {
+    bad(name, 'must be { value: bigint }, { value: string, unit: "display" } (price only) or { read: {...} }');
+  }
+}
+function hasNonzeroStaticPrice(price) {
+  if (typeof price !== "object" || price === null || !Object.hasOwn(price, "value")) return false;
+  const v = price.value;
+  return typeof v === "bigint" ? v > 0n : typeof v === "string" && /[1-9]/.test(v);
+}
+function validateContractConfig(config) {
+  const c = config;
+  if (!c || typeof c !== "object") bad("config", "must be an object");
+  if (c.type !== "contract") bad("type", 'must be "contract"');
+  if (!Number.isSafeInteger(c.chainId) || c.chainId <= 0) bad("chainId", "must be a positive safe integer");
+  if (!isHexAddress(c.address)) bad("address", `"${String(c.address)}" is not a valid address`);
+  if (c.tokenContract !== void 0 && !isHexAddress(c.tokenContract)) {
+    bad("tokenContract", `"${String(c.tokenContract)}" is not a valid address`);
+  }
+  if (!Array.isArray(c.abi)) bad("abi", "must be an abi array");
+  const abi = c.abi;
+  const mintFn = validateCall(abi, c.mint, "mint", "mint", PLACEHOLDERS);
+  if (c.price === void 0 || c.price === null) bad("price", "is required");
+  validateField(abi, "price", c.price, NO_PLACEHOLDERS, true);
+  const cur = c.price.currency;
+  if (cur !== "native" && !(typeof cur === "object" && cur !== null && isHexAddress(cur.address))) {
+    bad("price.currency", 'must be "native" or { address } with a valid ERC20 address');
+  }
+  if (cur === "native" && mintFn.stateMutability === "nonpayable" && hasNonzeroStaticPrice(c.price)) {
+    bad("price", `is a native price, but "${mintFn.name}" is nonpayable and cannot take value`);
+  }
+  const per = c.price.per;
+  if (per !== void 0 && per !== "unit" && per !== "total") bad("price.per", 'must be "unit" or "total"');
+  validateOptional(abi, "totalMinted", c.totalMinted, NO_PLACEHOLDERS);
+  validateOptional(abi, "maxSupply", c.maxSupply, NO_PLACEHOLDERS);
+  validateOptional(abi, "startTime", c.startTime, NO_PLACEHOLDERS);
+  validateOptional(abi, "endTime", c.endTime, NO_PLACEHOLDERS);
+  validateOptional(abi, "walletMinted", c.walletMinted, PLACEHOLDERS);
+  validateOptional(abi, "walletMax", c.walletMax, PLACEHOLDERS);
+}
+function validateOptional(abi, name, src, allowed) {
+  if (src !== void 0) validateField(abi, name, src, allowed, false);
+}
+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;
+}
+function fill(t, p, vars) {
+  const arr = ARRAY_TYPE.exec(p.type);
+  if (arr && Array.isArray(t)) return t.map((x) => fill(x, elementParam(p, arr[1]), vars));
+  if (p.type === "tuple" && Array.isArray(t)) return t.map((x, i) => fill(x, componentsOf(p)[i], vars));
+  if (typeof t === "number") return BigInt(t);
+  if (typeof t !== "string") return t;
+  if (p.type === "string") return t.replace(PLACEHOLDER_TOKEN, (token) => String(varFor(token, vars)));
+  if (isExactPlaceholder(t)) return varFor(t, vars);
+  if (intBounds(p.type)) return BigInt(t);
+  return t;
+}
+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 BaseError2 ? e.shortMessage : e instanceof Error ? e.message : String(e);
+}
+var abortError = () => new DOMException("The operation was aborted", "AbortError");
+var isAbortError = (e) => e?.name === "AbortError";
+function throwIfAborted(ctx) {
+  if (ctx.signal?.aborted) throw abortError();
+}
+function io(ctx, start) {
+  const signal = ctx.signal;
+  if (!signal) return start();
+  if (signal.aborted) return Promise.reject(abortError());
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    start().then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function rpcError(e) {
+  if (isMintError(e) || isAbortError(e)) throw e;
+  throw new MintError("RPC_ERROR", `RPC request failed: ${shortMessage(e)}`, { cause: e });
+}
+function classifyReadError(e, field) {
+  if (isMintError(e) || isAbortError(e)) throw e;
+  if (e instanceof BaseError2 && e.walk((x) => x instanceof ContractFunctionRevertedError2 || x instanceof ContractFunctionZeroDataError)) {
+    throw new MintError("INVALID_CONFIG", `${field} read reverted or returned no data: ${e.shortMessage}`, { field, cause: e });
+  }
+  return rpcError(e);
+}
+async function readCall(ctx, params, field) {
+  try {
+    return await io(ctx, () => ctx.client.readContract(params));
+  } catch (e) {
+    return classifyReadError(e, field);
+  }
+}
+function toBigInt(v, field) {
+  const n = typeof v === "number" ? BigInt(v) : v;
+  if (typeof n !== "bigint") throw new MintError("INVALID_CONFIG", `${field} did not return a number`, { field });
+  if (n < 0n) throw new MintError("INVALID_CONFIG", `${field} returned a negative number`, { field });
+  return n;
+}
+async function readField(ctx, config, name, src, vars) {
+  if (Object.hasOwn(src, "read") && src.read != null) {
+    const read = src.read;
+    const path = `${name}.read`;
+    const fn = validateCall(config.abi, read, path, "read", PLACEHOLDERS);
+    const args = fillArgs(read.args, fn.inputs, vars);
+    const ref = resolveOutput(fn, read.output, path);
+    const res = await readCall(ctx, { address: config.address, abi: [fn], functionName: fn.name, args }, `${path}.functionName`);
+    const members = fn.outputs.length === 1 && !ref.tuple ? [res] : ref.tuple ? tupleMembers(res, fn, ref.index) : res;
+    return toBigInt(members[ref.index], path);
+  }
+  const value = src.value;
+  if (typeof value === "bigint") return value;
+  throw new MintError("INVALID_CONFIG", `${name} display units are only valid for price`, { field: name });
+}
+function tupleMembers(res, fn, index) {
+  if (Array.isArray(res)) return res;
+  const comps = fn.outputs[0].components ?? [];
+  const out = [];
+  out[index] = res[comps[index]?.name ?? ""];
+  return out;
+}
+var optField = (ctx, config, name, src, vars) => src ? readField(ctx, config, name, src, vars) : Promise.resolve(null);
+function toSeconds(v, field) {
+  if (v === null || v === 0n) return null;
+  if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new MintError("INVALID_CONFIG", `${field} is too large for a unix timestamp`, { field });
+  return Number(v);
+}
+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);
+async function currencyMeta(ctx, config) {
+  const token = erc20Of(config);
+  if (!token) return { token, ...nativeMeta(ctx) };
+  const field = "price.currency.address";
+  const [symbol, decimals] = await Promise.all([
+    readCall(ctx, { address: token, abi: ERC20_ABI2, functionName: "symbol" }, field),
+    readCall(ctx, { address: token, abi: ERC20_ABI2, functionName: "decimals" }, field)
+  ]);
+  if (typeof symbol !== "string" || typeof decimals !== "number") {
+    throw new MintError("INVALID_CONFIG", `${field} ${token} is not an ERC20 (symbol/decimals unreadable)`, { field });
+  }
+  return { token, decimals, symbol };
+}
+function parseDisplay(value, decimals) {
+  const frac = value.split(".")[1] ?? "";
+  if (frac.length > decimals) {
+    throw new MintError("INVALID_CONFIG", `price.value "${value}" has more than ${decimals} decimal places`, { field: "price.value" });
+  }
+  return parseUnits(value, decimals);
+}
+async function resolvePrice(ctx, config, meta) {
+  const price = config.price;
+  if (Object.hasOwn(price, "read")) return readField(ctx, config, "price", price, {});
+  const value = price.value;
+  if (typeof value === "bigint") return value;
+  return parseDisplay(value, (meta ?? await currencyMeta(ctx, config)).decimals);
+}
+var money3 = (value, decimals, symbol) => ({
+  value,
+  decimals,
+  symbol,
+  formatted: formatUnits3(value, decimals)
+});
+function revertData2(e) {
+  for (let cur = e, depth = 0; cur && depth < 12; depth++) {
+    const d = cur.data;
+    if (typeof d === "string" && d.startsWith("0x") && d.length >= 10) return d;
+    if (d && typeof d === "object" && typeof d.data === "string") {
+      const inner = d.data;
+      if (inner.startsWith("0x") && inner.length >= 10) return inner;
+    }
+    cur = cur.cause;
+  }
+  return null;
+}
+function describeRevert(abi, data) {
+  try {
+    const d = decodeErrorResult2({ abi, data });
+    const args = d.args ?? [];
+    if (d.errorName === "Error") return String(args[0] ?? "execution reverted");
+    const inputs = d.abiItem?.inputs ?? [];
+    const shown = args.map((a, i) => inputs[i]?.name ? `${inputs[i].name}: ${String(a)}` : String(a));
+    return `${d.errorName}(${shown.join(", ")})`;
+  } catch {
+    return `reverted with unrecognized error ${data.slice(0, 10)}`;
+  }
+}
+function toSimulationError(e, abi) {
+  if (isMintError(e)) return e;
+  if (isAbortError(e)) throw e;
+  if (e instanceof BaseError2 && e.walk((x) => x instanceof 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 BaseError2 && 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 });
+}
+async function simulateMint(ctx, config, call) {
+  try {
+    await io(ctx, () => ctx.client.call({ account: call.payer, to: call.to, data: call.data, value: call.value }));
+  } catch (e) {
+    throw toSimulationError(e, config.abi);
+  }
+}
+function encodeMint(config, vars) {
+  const fn = validateCall(config.abi, config.mint, "mint", "mint", PLACEHOLDERS);
+  try {
+    return encodeFunctionData2({ 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 });
+  }
+}
+function mintValue(config, token, totalPrice) {
+  if (token) return 0n;
+  const fn = validateCall(config.abi, config.mint, "mint", "mint", PLACEHOLDERS);
+  if (fn.stateMutability === "nonpayable") {
+    if (totalPrice > 0n) bad("price", `is ${totalPrice} wei in native currency, but "${fn.name}" is nonpayable and cannot take value`);
+    return 0n;
+  }
+  return totalPrice;
+}
+async function readDrop(ctx, config) {
+  validateContractConfig(config);
+  throwIfAborted(ctx);
+  const meta = await currencyMeta(ctx, config);
+  const none = {};
+  const [price, totalMinted, maxSupply, start, end] = await Promise.all([
+    resolvePrice(ctx, config, meta),
+    optField(ctx, config, "totalMinted", config.totalMinted, none),
+    optField(ctx, config, "maxSupply", config.maxSupply, none),
+    optField(ctx, config, "startTime", config.startTime, none),
+    optField(ctx, config, "endTime", config.endTime, none)
+  ]);
+  mintValue(config, meta.token, price);
+  const native = nativeMeta(ctx);
+  return {
+    chainId: config.chainId,
+    unitPrice: money3(price, meta.decimals, meta.symbol),
+    unitFee: money3(0n, native.decimals, native.symbol),
+    totalMinted: totalMinted ?? 0n,
+    maxSupply: maxSupply === null || maxSupply === 0n ? null : maxSupply,
+    startTime: toSeconds(start, "startTime"),
+    endTime: toSeconds(end, "endTime"),
+    isAllowlist: false,
+    paymentToken: meta.token,
+    pricePer: config.price.per ?? "unit"
+  };
+}
+async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
+  validateContractConfig(config);
+  throwIfAborted(ctx);
+  const qty = BigInt(quantity);
+  const unitPrice = drop.unitPrice.value;
+  const totalPrice = totalFor(drop.pricePer, unitPrice, qty);
+  const vars = { payer, recipient, quantity: qty, unitPrice, totalPrice };
+  const [walletMinted, rawMax, native, erc20] = await Promise.all([
+    optField(ctx, config, "walletMinted", config.walletMinted, vars),
+    optField(ctx, config, "walletMax", config.walletMax, vars),
+    io(ctx, () => ctx.client.getBalance({ address: payer })).catch(rpcError),
+    drop.paymentToken ? readCall(ctx, { address: drop.paymentToken, abi: ERC20_ABI2, functionName: "balanceOf", args: [payer] }, "price.currency.address").then(
+      (v) => toBigInt(v, "price.currency.address")
+    ) : Promise.resolve(null)
+  ]);
+  const walletMax = rawMax === null || rawMax === 0n ? null : rawMax;
+  const remaining = walletMax === null ? null : walletMax > (walletMinted ?? 0n) ? walletMax - (walletMinted ?? 0n) : 0n;
+  const maxQuantity = remaining === null ? null : Number(remaining < BigInt(MAX_QUANTITY) ? remaining : BigInt(MAX_QUANTITY));
+  let ineligible = null;
+  let gas = FALLBACK_MINT_GAS;
+  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) };
+    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) => {
+        throw toSimulationError(e, config.abi);
+      });
+    } catch (e) {
+      if (!isMintError(e) || e.reason !== "SIMULATION_REVERTED") throw e;
+      ineligible = { reason: "SIMULATION_REVERTED", message: e.message };
+    }
+  }
+  if (drop.paymentToken) gas += APPROVE_GAS;
+  const gasPrice = await io(ctx, () => ctx.client.getGasPrice()).catch(rpcError);
+  return {
+    walletMinted,
+    walletMax,
+    allowlistRemaining: null,
+    maxQuantity,
+    ineligible,
+    balances: { native, erc20 },
+    gasReserve: gas * gasPrice
+  };
+}
+async function buildPlan2(ctx, attempt, wallet) {
+  void wallet;
+  const { config, payer, recipient } = attempt;
+  validateContractConfig(config);
+  throwIfAborted(ctx);
+  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 token = erc20Of(config);
+  const mint = {
+    to,
+    data: encodeMint(config, { payer, recipient, quantity: qty, unitPrice, totalPrice }),
+    value: mintValue(config, token, totalPrice)
+  };
+  let approve = null;
+  if (token) {
+    const allowance = toBigInt(
+      await readCall(ctx, { address: token, abi: ERC20_ABI2, functionName: "allowance", args: [payer, to] }, "price.currency.address"),
+      "price.currency.address"
+    );
+    if (allowance < totalPrice) {
+      approve = {
+        token,
+        spender: to,
+        amount: totalPrice,
+        tx: { to: token, data: encodeFunctionData2({ abi: ERC20_ABI2, functionName: "approve", args: [to, totalPrice] }), value: 0n }
+      };
+    }
+  }
+  return { approve, mint, tokenContract: getAddress3(attempt.tokenContract) };
+}
+async function simulate(ctx, attempt, plan) {
+  throwIfAborted(ctx);
+  await simulateMint(ctx, attempt.config, { payer: attempt.payer, to: plan.mint.to, data: plan.mint.data, value: plan.mint.value });
+}
+var contractAdapter = { readDrop, readWallet, buildPlan: buildPlan2, simulate };
+
+// src/core/adapters/receipt.ts
+import { decodeAbiParameters, getAddress as getAddress4, zeroAddress as zeroAddress2 } 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;
+function parseMintReceipt(logs, { tokenContract, recipient }) {
+  const contract = getAddress4(tokenContract);
+  const to = getAddress4(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;
+    const [t0, t1, t2, t3] = log.topics;
+    if (t0 === TRANSFER_TOPIC && log.topics.length === 4) {
+      if (topicAddress(t1) !== zeroAddress2 || 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;
+      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;
+      const [ids, values] = decodeAbiParameters([{ type: "uint256[]" }, { type: "uint256[]" }], log.data);
+      if (ids.length !== values.length) continue;
+      ids.forEach((id, i) => add(id, values[i]));
+    }
+  }
+  return [...out].map(([tokenId, amount]) => ({ contract, tokenId, amount }));
+}
+
+// src/core/friendly-errors.ts
+var GENERIC = "Transaction failed. Please try again. If it fails again, please contact support.";
+var REVERTED = "Transaction reverted";
+var record = (value) => value !== null && typeof value === "object" ? value : void 0;
+var text = (value) => typeof value === "string" ? value.toLowerCase() : "";
+function collect(error) {
+  const pending = [error];
+  const seen = /* @__PURE__ */ new Set();
+  const errors = [];
+  while (pending.length) {
+    const e = record(pending.pop());
+    if (!e || seen.has(e)) continue;
+    seen.add(e);
+    const data = record(e.data);
+    errors.push({
+      name: e.name,
+      code: e.code,
+      cancelled: e.cancelled,
+      replacement: e.replacement,
+      message: [e.message, e.shortMessage, isMintError(e) ? void 0 : e.reason, data?.message].map(text).join("\n")
+    });
+    pending.push(e.cause, data?.originalError);
+  }
+  return errors;
+}
+function fundsMessage(errors) {
+  const hasText = (phrase) => errors.some((e) => e.message.includes(phrase));
+  if (hasText("insufficient funds for gas")) {
+    return "Your wallet does not have enough funds to pay for gas fees. Please try again with a different wallet or add more funds to your wallet.";
+  }
+  if (errors.some((e) => e.name === "InsufficientFundsError" || e.code === "INSUFFICIENT_FUNDS") || hasText("insufficient funds") || hasText("balance too low to proceed")) {
+    return "Your wallet does not have enough funds to complete this transaction. Please try again with a different wallet or add more funds to your wallet.";
+  }
+  return null;
+}
+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.message === "The token refused the approval." || error.message === "The drop is no longer available for this quantity.")) return error.message;
+  }
+  const errors = collect(error);
+  const hasText = (phrase) => errors.some((e) => e.message.includes(phrase));
+  const hasName = (name) => errors.some((e) => e.name === name);
+  const hasCode2 = (code2) => errors.some((e) => e.code === code2);
+  if (hasName("UserRejectedRequestError") || hasCode2("ACTION_REJECTED") || hasCode2(4001) || hasText("user denied transaction signature") || hasText("userrefusedondevice") || hasText("rejected transaction") || hasText("user rejected") || errors.some((e) => e.message.includes("cancelled") && !e.cancelled)) {
+    return "Transaction Rejected";
+  }
+  if (hasCode2(4902)) return "Network not available in wallet";
+  const replaced = errors.find((e) => e.name === "TransactionReplacedError" || e.code === "TRANSACTION_REPLACED");
+  if (replaced?.cancelled) return "Transaction was cancelled";
+  if (replaced?.replacement) return "Transaction was replaced with a new transaction (usually due to speed up)";
+  if (hasText("ledger")) return "Error with Ledger device. Please ensure device is connected and unlocked";
+  if (errors.some((e) => e.code === -32002 && e.message.includes("pending"))) {
+    return "Transaction already pending in wallet. Please check your wallet";
+  }
+  if (hasText("invalid amount")) return "Price calculation is incorrect, contact support!";
+  const funds = fundsMessage(errors);
+  if (funds) return funds;
+  if (hasName("NonceTooLowError") || hasName("NonceExhaustedError") || hasText("nonce too low")) {
+    return "Transaction nonce is too low. Please try again";
+  }
+  if (hasName("FeeCapTooLowError") || hasText("max fee per gas less than block base fee")) {
+    return "Gas price too low for current network conditions. Please try again";
+  }
+  if (hasName("TimeoutError") || hasCode2("TIMEOUT") || hasText("timeout")) {
+    return "Transaction timed out. Your wallet connection is having issues. Disconnect and reconnect your wallet, then please try again";
+  }
+  if (hasText("network disconnected")) return "Network connection lost. Please check your internet connection and try again";
+  if (hasName("ChainMismatchError") || hasText("wrong network")) return "Wrong network selected. Please switch to the correct network";
+  if (hasText("erc20: transfer amount exceeds balance")) {
+    return "You do not have the required amount of ERC20 tokens to complete this transaction.";
+  }
+  if (hasName("EstimateGasExecutionError") || hasCode2("UNPREDICTABLE_GAS_LIMIT") || hasText("cannot estimate gas")) {
+    return "Unable to estimate gas for transaction. The transaction may fail. Please try again.";
+  }
+  if (hasName("ContractFunctionExecutionError") || hasCode2("CALL_EXCEPTION")) {
+    return "Transaction failed due to contract execution error";
+  }
+  if (hasName("ContractFunctionRevertedError") || hasName("ExecutionRevertedError") || hasText("revert")) return REVERTED;
+  if (hasName("TransactionExecutionError")) return "Transaction execution failed";
+  if (hasCode2("NETWORK_ERROR") || hasName("HttpRequestError") || hasText("network")) return "Network error occurred";
+  return isMintError(error) && error.reason === "SIMULATION_REVERTED" ? REVERTED : GENERIC;
+}
+
+// src/react/useMint.ts
+var REFRESH_MS = 3e4;
+var TICK_MS = 1e3;
+var ASYNC_STATES = ["loading", "connecting", "switching-chain", "approving", "minting", "confirming"];
+function isAsyncState(name) {
+  return ASYNC_STATES.includes(name);
+}
+var nowSec = () => Math.floor(Date.now() / 1e3);
+function configKeyOf(config) {
+  return JSON.stringify(config, (_k, v) => typeof v === "bigint" ? { __dropkitBigInt: v.toString() } : v);
+}
+function adapterFor(config) {
+  return config.type === "manifold-claim" ? manifoldClaimAdapter : contractAdapter;
+}
+var bridgeEnabled = (config) => config.type === "manifold-claim";
+function tokenContractOf(config) {
+  return config.type === "manifold-claim" ? config.creatorContract : config.tokenContract ?? config.address;
+}
+function eventAddressOf(config) {
+  return config.type === "manifold-claim" ? config.creatorContract : config.address;
+}
+var isUnsupported = (reason) => UNSUPPORTED_REASONS.includes(reason);
+function isRejection(error) {
+  for (let e = error, depth = 0; e && depth < 8; depth++) {
+    if (e.code === 4001) return true;
+    e = e.cause;
+  }
+  return false;
+}
+function toReason(e) {
+  if (isMintError(e)) return { reason: e.reason, message: friendlyErrorMessage(e) };
+  if (isRejection(e)) return { reason: "USER_REJECTED", message: "You rejected the request." };
+  for (let cause = e, depth = 0; cause && depth < 8; depth++) {
+    if (cause.name === "ChainMismatchError") return { reason: "CHAIN_SWITCH_FAILED", message: "The wallet network changed before the transaction was sent." };
+    cause = cause.cause;
+  }
+  return { reason: "RPC_ERROR", message: friendlyErrorMessage(e) };
+}
+function errorReasonOf(e) {
+  const { reason, message } = toReason(e);
+  const ok = ["USER_REJECTED", "TX_REVERTED", "RATE_LIMITED", "RPC_ERROR", "CHAIN_SWITCH_FAILED", "ALLOWLIST_UNAVAILABLE"];
+  return { reason: ok.includes(reason) ? reason : "RPC_ERROR", message };
+}
+function explorerUrlFor(chainId, hash) {
+  try {
+    const url = getChain(chainId).blockExplorers?.default.url;
+    return url ? `${url.replace(/\/$/, "")}/tx/${hash}` : null;
+  } catch {
+    return null;
+  }
+}
+var receiptOk = (status) => status === "success" || status === 1 || status === 1n || status === "0x1";
+function useMint(options) {
+  const { config, recipient, quantity: quantityProp, connect } = options;
+  const [machine, rawDispatch] = useReducer(reducer, void 0, () => initialState({ quantity: quantityProp }));
+  const [widgetFail, setWidgetFail] = useState(null);
+  const [widgetRetry, setWidgetRetry] = useState(0);
+  const configKey = configKeyOf(config);
+  const mounted = useRef(false);
+  const stateRef = useRef(machine);
+  const propsRef = useRef(options);
+  const lifeRef = useRef(null);
+  const genRef = useRef(0);
+  const attemptRef = useRef(null);
+  const attemptIdRef = useRef(0);
+  const accountKeyRef = useRef(null);
+  const connectingRef = useRef(false);
+  const pendingRefreshRef = useRef(false);
+  const pendingQuantityRef = useRef(null);
+  const widgetFailRef = useRef(null);
+  const widgetLoadRef = useRef(null);
+  const pushAccountRef = useRef(null);
+  useEffect(() => {
+    stateRef.current = machine;
+    propsRef.current = options;
+    widgetFailRef.current = widgetFail;
+  });
+  const dispatch = useCallback((event) => {
+    if (!mounted.current) return;
+    stateRef.current = reducer(stateRef.current, event);
+    rawDispatch(event);
+  }, []);
+  const emit = useCallback((type, over = {}) => {
+    const handler = propsRef.current.onEvent;
+    if (!handler || !mounted.current) return;
+    const cfg = attemptRef.current?.config ?? propsRef.current.config;
+    const s = stateRef.current;
+    const payload = {
+      type,
+      state: s.name,
+      reason: s.reason,
+      chainId: cfg.chainId,
+      quantity: s.quantity,
+      config: { type: cfg.type, chainId: cfg.chainId, address: eventAddressOf(cfg) },
+      ...over
+    };
+    try {
+      handler(payload);
+    } catch {
+    }
+  }, []);
+  const clientFor = useCallback((life, cfg) => {
+    const rpcUrl = propsRef.current.rpcUrls?.[cfg.chainId];
+    if (!life.client || life.rpcUrl !== rpcUrl) {
+      life.rpcUrl = rpcUrl;
+      life.client = createReadClient({ chainId: cfg.chainId, rpcUrls: propsRef.current.rpcUrls, useBridge: bridgeEnabled(cfg) });
+    }
+    return life.client;
+  }, []);
+  const ctxFor = useCallback(
+    (life, cfg) => ({
+      client: clientFor(life, cfg),
+      cacheScope: life.cacheScope,
+      // The lifetime signal: a config change or unmount cancels every adapter call, including shared merkle fetches.
+      signal: life.controller.signal
+    }),
+    [clientFor]
+  );
+  const readDrop2 = useCallback(
+    async (life, gen, cfg) => {
+      const adapter = adapterFor(cfg);
+      try {
+        const drop = await adapter.readDrop(ctxFor(life, cfg), cfg);
+        if (life.controller.signal.aborted || life.gen !== gen || lifeRef.current !== life) return;
+        dispatch({ type: "DROP_LOADED", gen, drop, now: Math.max(stateRef.current.now, nowSec()) });
+      } catch (e) {
+        if (life.controller.signal.aborted || life.gen !== gen || lifeRef.current !== life) return;
+        const { reason, message } = toReason(e);
+        if (isUnsupported(reason)) dispatch({ type: "DROP_UNSUPPORTED", gen, reason, message });
+        else dispatch({ type: "READ_FAILED", gen, ...errorReasonOf(e) });
+      }
+    },
+    [ctxFor, dispatch]
+  );
+  const startLifetime = useCallback(
+    (key, cfg) => {
+      const prev = lifeRef.current;
+      lifeRef.current = null;
+      prev?.controller.abort();
+      const gen = ++genRef.current;
+      const life = { key, controller: new AbortController(), cacheScope: {}, gen };
+      lifeRef.current = life;
+      dispatch({ type: "LOAD", gen, kind: "config" });
+      void readDrop2(life, gen, cfg);
+    },
+    [dispatch, readDrop2]
+  );
+  const refreshNow = useCallback(
+    async (kind = "refresh") => {
+      const life = lifeRef.current;
+      if (!life || !mounted.current) return;
+      if (connectingRef.current || attemptRef.current || stateRef.current.attempt) {
+        pendingRefreshRef.current = true;
+        return;
+      }
+      const gen = ++genRef.current;
+      life.gen = gen;
+      dispatch({ type: "LOAD", gen, kind });
+      await readDrop2(life, gen, propsRef.current.config);
+    },
+    [dispatch, readDrop2]
+  );
+  const refresh = useCallback(() => refreshNow("refresh"), [refreshNow]);
+  const isBusy = useCallback(
+    () => connectingRef.current || attemptRef.current !== null || stateRef.current.attempt !== null || IN_FLIGHT_STATES.includes(stateRef.current.name),
+    []
+  );
+  const executeAttempt = useCallback(
+    async (attempt, walletRead, life, account2) => {
+      const cfg = attempt.config;
+      const adapter = adapterFor(cfg);
+      const ctx = ctxFor(life, cfg);
+      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 assertPayer = () => {
+        assertActive();
+        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.");
+        }
+      };
+      let wallet2 = null;
+      const walletFor = () => {
+        if (!wallet2) wallet2 = getWalletClient(attempt.chainId);
+        return wallet2;
+      };
+      const submit = async (tx) => {
+        assertPayer();
+        const w = walletFor();
+        return w.sendTransaction({ account: attempt.payer, to: tx.to, data: tx.data, value: tx.value, chain: getChain(attempt.chainId) });
+      };
+      const waitReceipt = async (hash2) => {
+        let cancelled = false;
+        const params = {
+          hash: hash2,
+          confirmations: 1,
+          timeout: 12e4,
+          onReplaced: ({ reason }) => {
+            if (reason !== "repriced") cancelled = true;
+          }
+        };
+        let receipt2;
+        try {
+          receipt2 = await client.waitForTransactionReceipt(params);
+        } catch (e) {
+          assertActive();
+          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);
+        }
+        assertActive();
+        if (cancelled) throw new MintError("USER_REJECTED", "The transaction was cancelled or replaced with a different transaction.");
+        return receipt2;
+      };
+      assertPayer();
+      if (account2.chainId !== attempt.chainId) {
+        dispatch({ type: "SWITCHING_CHAIN", attemptId: attempt.attemptId });
+        await switchToChain(attempt.chainId);
+      }
+      assertPayer();
+      let plan = await adapter.buildPlan(ctx, attempt, walletRead);
+      assertPayer();
+      if (plan.approve) {
+        const a = plan.approve;
+        try {
+          const simulated = await client.call({ account: attempt.payer, to: a.tx.to, data: a.tx.data, value: a.tx.value });
+          if (simulated.data && simulated.data !== "0x" && BigInt(simulated.data) === 0n) {
+            throw new MintError("SIMULATION_REVERTED", "The token refused the approval.");
+          }
+        } catch (e) {
+          if (isMintError(e)) throw e;
+          const reverted = e instanceof BaseError3 ? e.walk((cause) => cause instanceof ExecutionRevertedError) : null;
+          if (reverted instanceof ExecutionRevertedError) {
+            throw new MintError("SIMULATION_REVERTED", reverted.shortMessage);
+          }
+          throw e;
+        }
+        assertPayer();
+        dispatch({ type: "APPROVING", attemptId: attempt.attemptId });
+        const approveHash = await submit(a.tx);
+        assertActive();
+        emit("approve-submitted", { state: "approving", reason: null, txHash: approveHash, quantity: attempt.quantity, chainId: attempt.chainId });
+        const approveReceipt = await waitReceipt(approveHash);
+        assertActive();
+        if (!receiptOk(approveReceipt.status)) {
+          throw new MintError("TX_REVERTED", `The approval transaction reverted (${approveHash}).`);
+        }
+        const freshDrop = await adapter.readDrop(ctx, cfg);
+        assertActive();
+        const freshWallet = await adapter.readWallet(ctx, cfg, {
+          payer: attempt.payer,
+          recipient: attempt.recipient,
+          quantity: attempt.quantity,
+          drop: freshDrop
+        });
+        assertPayer();
+        let checked = reducer(initialState({ quantity: attempt.quantity }), { type: "ACCOUNT_CHANGED", account: account2 });
+        checked = reducer(checked, { type: "DROP_LOADED", gen: checked.readGen, drop: freshDrop, now: nowSec() });
+        checked = reducer(checked, { type: "WALLET_LOADED", gen: checked.walletGen, read: freshWallet });
+        if (checked.name !== "live" || (selectMaxQuantity(checked) ?? 0) < attempt.quantity) {
+          throw new MintError(checked.reason ?? "SIMULATION_REVERTED", checked.message ?? "The drop is no longer available for this quantity.");
+        }
+        plan = await adapter.buildPlan(ctx, attempt, freshWallet);
+        assertPayer();
+      }
+      await adapter.simulate(ctx, attempt, plan);
+      assertPayer();
+      dispatch({ type: "MINT_PROMPTED", attemptId: attempt.attemptId });
+      const hash = await submit(plan.mint);
+      assertActive();
+      dispatch({ type: "TX_SUBMITTED", attemptId: attempt.attemptId });
+      emit("tx-submitted", { state: "confirming", reason: null, txHash: hash, quantity: attempt.quantity, chainId: attempt.chainId });
+      const receipt = await waitReceipt(hash);
+      assertActive();
+      const confirmedHash = receipt.transactionHash ?? hash;
+      if (!receiptOk(receipt.status)) {
+        throw new MintError("TX_REVERTED", `The mint transaction reverted (${confirmedHash}).`);
+      }
+      const tokens = parseMintReceipt(receipt.logs ?? [], {
+        tokenContract: plan.tokenContract ?? attempt.tokenContract,
+        recipient: attempt.recipient
+      });
+      const result = { txHash: confirmedHash, explorerUrl: explorerUrlFor(attempt.chainId, confirmedHash), tokens };
+      dispatch({ type: "ATTEMPT_SUCCEEDED", attemptId: attempt.attemptId, result });
+      emit("success", { state: "success", reason: null, txHash: confirmedHash, quantity: attempt.quantity, chainId: attempt.chainId });
+    },
+    [clientFor, ctxFor, dispatch, emit]
+  );
+  const runMint = useCallback(async () => {
+    if (!mounted.current) return;
+    if (attemptRef.current !== null) return;
+    if (widgetFailRef.current) {
+      if (isUnsupported(widgetFailRef.current.reason)) return;
+      widgetFailRef.current = null;
+      setWidgetFail(null);
+      setWidgetRetry((n) => n + 1);
+      void refreshNow("config");
+      return;
+    }
+    const s = stateRef.current;
+    if (!canAct(s) || s.attempt !== null) return;
+    if (s.name === "disconnected") {
+      if (connectingRef.current) return;
+      connectingRef.current = true;
+      dispatch({ type: "CONNECT_STARTED" });
+      const connectLife = lifeRef.current;
+      const active = () => mounted.current && lifeRef.current === connectLife && !connectLife?.controller.signal.aborted;
+      try {
+        await widgetLoadRef.current;
+        if (!active()) return;
+        const outcome = await openConnectModal();
+        if (!active()) return;
+        connectingRef.current = false;
+        if (outcome === "connected") {
+          accountKeyRef.current = null;
+          pushAccountRef.current?.(getAccount());
+        } else dispatch({ type: "CONNECT_DISMISSED" });
+      } catch {
+        if (active()) dispatch({ type: "CONNECT_DISMISSED" });
+      } finally {
+        connectingRef.current = false;
+      }
+      return;
+    }
+    if (s.name === "success" || s.name === "error") {
+      const life2 = lifeRef.current;
+      const gen = ++genRef.current;
+      if (life2) life2.gen = gen;
+      dispatch({ type: "RESET", gen });
+      dispatch({ type: "LOAD", gen, kind: "config" });
+      if (life2) void readDrop2(life2, gen, propsRef.current.config);
+      return;
+    }
+    if (s.name !== "live") return;
+    const account2 = s.account;
+    const walletRead = s.walletRead;
+    const life = lifeRef.current;
+    if (!account2 || !walletRead || !life) return;
+    const cfg = propsRef.current.config;
+    const attempt = Object.freeze({
+      attemptId: ++attemptIdRef.current,
+      config: structuredClone(cfg),
+      payer: account2.address,
+      recipient: propsRef.current.recipient ?? account2.address,
+      quantity: s.quantity,
+      chainId: cfg.chainId,
+      tokenContract: tokenContractOf(cfg)
+    });
+    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);
+    } 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, readDrop2, executeAttempt, refreshNow]);
+  const mint = useCallback(() => {
+    void runMint();
+  }, [runMint]);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      lifeRef.current?.controller.abort();
+      lifeRef.current = null;
+    };
+  }, []);
+  useEffect(() => {
+    const push = (a) => {
+      const key = a ? `${a.address.toLowerCase()}:${a.chainId}:${(propsRef.current.recipient ?? "").toLowerCase()}` : "null";
+      if (key === accountKeyRef.current) return;
+      accountKeyRef.current = key;
+      if (attemptRef.current || stateRef.current.attempt) pendingRefreshRef.current = true;
+      dispatch({ type: "ACCOUNT_CHANGED", account: a });
+    };
+    pushAccountRef.current = push;
+    push(getAccount());
+    const unsubscribe = subscribeAccount(push);
+    return () => {
+      unsubscribe();
+    };
+  }, [dispatch]);
+  const recipientRef = useRef(recipient);
+  useEffect(() => {
+    if (isBusy() || recipientRef.current === recipient) return;
+    recipientRef.current = recipient;
+    accountKeyRef.current = null;
+    pushAccountRef.current?.(getAccount());
+  }, [recipient, machine.attempt, isBusy]);
+  const projectId = connect?.walletConnectProjectId;
+  useEffect(() => {
+    let alive = true;
+    const loading = loadConnectWidget({ chainIds: [config.chainId], ...projectId ? { walletConnectProjectId: projectId } : {} });
+    widgetLoadRef.current = loading;
+    loading.then(
+      () => {
+        if (alive) setWidgetFail(null);
+      },
+      (e) => {
+        if (!alive) return;
+        const { reason, message } = toReason(e);
+        setWidgetFail({ reason, message });
+      }
+    );
+    return () => {
+      alive = false;
+    };
+  }, [config.chainId, projectId, widgetRetry]);
+  useEffect(() => {
+    if (!mounted.current) return;
+    if (isBusy()) return;
+    if (pendingQuantityRef.current !== null) {
+      const quantity = pendingQuantityRef.current;
+      pendingQuantityRef.current = null;
+      dispatch({ type: "SET_QUANTITY", quantity });
+    }
+    if (lifeRef.current?.key !== configKey) {
+      pendingRefreshRef.current = false;
+      startLifetime(configKey, config);
+    } else if (pendingRefreshRef.current || lifeRef.current.rpcUrl !== options.rpcUrls?.[config.chainId]) {
+      pendingRefreshRef.current = false;
+      void refreshNow();
+    }
+  });
+  const previousQuantity = useRef(machine.quantity);
+  useEffect(() => {
+    if (previousQuantity.current === machine.quantity || isBusy()) return;
+    previousQuantity.current = machine.quantity;
+    if (stateRef.current.walletRead) dispatch({ type: "ACCOUNT_CHANGED", account: stateRef.current.account });
+  }, [machine.quantity, machine.attempt, dispatch, isBusy]);
+  const loadedDrop = machine.drop;
+  const walletGen = machine.walletGen;
+  const account = machine.account;
+  const lastWalletRead = useRef(null);
+  useEffect(() => {
+    if (!account || !loadedDrop || isBusy()) return;
+    const previous = lastWalletRead.current;
+    if (stateRef.current.blocked && previous?.drop === loadedDrop && previous.gen === walletGen && previous.quantity === machine.quantity) return;
+    lastWalletRead.current = { drop: loadedDrop, gen: walletGen, quantity: machine.quantity };
+    const life = lifeRef.current;
+    const drop = stateRef.current.drop;
+    if (!life || !drop || life.key !== configKeyOf(propsRef.current.config)) return;
+    const readGen = life.gen;
+    const cfg = propsRef.current.config;
+    const adapter = adapterFor(cfg);
+    let alive = true;
+    void (async () => {
+      try {
+        const read = await adapter.readWallet(ctxFor(life, cfg), cfg, {
+          payer: account.address,
+          recipient: propsRef.current.recipient ?? account.address,
+          quantity: stateRef.current.quantity,
+          drop
+        });
+        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 } });
+      } catch (e) {
+        if (!alive || life.controller.signal.aborted || lifeRef.current !== life || life.gen !== readGen) return;
+        dispatch({ type: "WALLET_FAILED", gen: walletGen, ...errorReasonOf(e) });
+      }
+    })();
+    return () => {
+      alive = false;
+    };
+  }, [account, loadedDrop, walletGen, machine.quantity, machine.attempt, ctxFor, dispatch, isBusy]);
+  const prevQuantityProp = useRef(quantityProp);
+  useEffect(() => {
+    if (isBusy()) return;
+    const propChanged = prevQuantityProp.current !== quantityProp;
+    prevQuantityProp.current = quantityProp;
+    if (quantityProp === void 0 || !propChanged && !propsRef.current.onQuantityChange) return;
+    const state = stateRef.current;
+    if (!propChanged && state.account && !state.walletRead) return;
+    const event = { type: "SET_QUANTITY", quantity: quantityProp };
+    const clamped = reducer(state, event).quantity;
+    if (clamped !== state.quantity) dispatch(event);
+    if (clamped !== quantityProp) propsRef.current.onQuantityChange?.(clamped);
+  }, [quantityProp, machine.quantity, machine.drop, machine.walletRead, machine.attempt, dispatch, isBusy]);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
+      void refreshNow("refresh");
+    }, REFRESH_MS);
+    const onVisible = () => {
+      if (document.visibilityState === "visible") void refreshNow("refresh");
+    };
+    document.addEventListener("visibilitychange", onVisible);
+    return () => {
+      clearInterval(timer);
+      document.removeEventListener("visibilitychange", onVisible);
+    };
+  }, [refreshNow]);
+  const boundary = machine.drop ? [machine.drop.startTime, machine.drop.endTime].some((t) => t !== null && t > machine.now) : false;
+  useEffect(() => {
+    if (!boundary) return;
+    const timer = setInterval(() => {
+      const s = stateRef.current;
+      const now = nowSec();
+      const crossed = s.drop && [s.drop.startTime, s.drop.endTime].some((t) => t !== null && t > s.now && t <= now);
+      dispatch({ type: "TICK", now });
+      if (crossed) void refreshNow();
+    }, TICK_MS);
+    return () => clearInterval(timer);
+  }, [boundary, dispatch, refreshNow]);
+  const prevName = useRef(null);
+  useEffect(() => {
+    const name = widgetFail ? isUnsupported(widgetFail.reason) ? "unsupported" : "error" : machine.name;
+    if (prevName.current === name) return;
+    prevName.current = name;
+    emit("state", { state: name, reason: widgetFail?.reason ?? machine.reason });
+  }, [machine.name, machine.reason, widgetFail, emit]);
+  const setQuantity = useCallback(
+    (next) => {
+      const s = stateRef.current;
+      const max = selectMaxQuantity(s) ?? 65535;
+      const clamped = Math.max(1, Math.min(Math.floor(Number.isNaN(next) ? 1 : next), max));
+      const handler = propsRef.current.onQuantityChange;
+      if (handler) {
+        handler(clamped);
+        return;
+      }
+      if (attemptRef.current) {
+        pendingQuantityRef.current = clamped;
+        return;
+      }
+      dispatch({ type: "SET_QUANTITY", quantity: clamped });
+      if (s.quantity !== stateRef.current.quantity) {
+        dispatch({ type: "ACCOUNT_CHANGED", account: stateRef.current.account });
+      }
+    },
+    [dispatch]
+  );
+  const effective = widgetFail ? { name: isUnsupported(widgetFail.reason) ? "unsupported" : "error", reason: widgetFail.reason, message: widgetFail.message } : { name: machine.name, reason: machine.reason, message: machine.message };
+  const wallet = machine.account && machine.walletRead ? {
+    address: machine.account.address,
+    chainId: machine.account.chainId,
+    recipient: recipient ?? machine.account.address,
+    walletMinted: machine.walletRead.walletMinted,
+    walletMax: machine.walletRead.walletMax,
+    allowlistRemaining: machine.walletRead.allowlistRemaining
+  } : null;
+  return {
+    state: effective.name,
+    reason: effective.reason,
+    message: effective.message,
+    drop: machine.drop,
+    wallet,
+    quantity: machine.quantity,
+    setQuantity,
+    maxQuantity: selectMaxQuantity(machine),
+    total: selectTotal(machine),
+    mint,
+    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
+  };
+}
+
+// src/react/MintButton.ts
+import { createElement } from "react";
+function defaultLabel(m) {
+  const symbol = m.total?.erc20?.symbol ?? m.total?.native.symbol ?? m.drop?.unitPrice.symbol ?? "";
+  switch (m.state) {
+    case "loading":
+      return "Loading\u2026";
+    case "unsupported":
+      return "Unavailable";
+    case "upcoming": {
+      const t = m.drop?.startTime;
+      return `Starts ${t ? new Date(t * 1e3).toLocaleString() : "soon"}`;
+    }
+    case "ended":
+      return "Ended";
+    case "sold-out":
+      return "Sold out";
+    case "disconnected":
+      return "Connect wallet";
+    case "connecting":
+      return "Connecting\u2026";
+    case "live": {
+      const total = m.total;
+      if (!total) return "Mint";
+      const legs = total.erc20 ? [total.erc20, ...total.native.value > 0n ? [total.native] : []] : [total.native];
+      return `Mint \xB7 ${legs.map((leg) => `${leg.formatted} ${leg.symbol}`).join(" + ")}`.trimEnd();
+    }
+    case "ineligible":
+      return "Not eligible";
+    case "insufficient-funds": {
+      const erc20 = m.total?.erc20;
+      const shortage = erc20 && m.message === `Not enough ${erc20.symbol} to cover the mint.` ? erc20.symbol : m.total?.native.symbol ?? symbol;
+      return `Insufficient ${shortage}`.trimEnd();
+    }
+    case "switching-chain":
+      return "Switching network\u2026";
+    case "approving":
+      return `Approving ${symbol}\u2026`.replace(" \u2026", "\u2026");
+    case "minting":
+      return "Confirm in wallet\u2026";
+    case "confirming":
+      return "Minting\u2026";
+    case "success":
+      return "Minted";
+    case "error":
+      return "Try again";
+  }
+}
+function MintButton(props) {
+  const { className, labels, children, ...options } = props;
+  const m = useMint(options);
+  if (typeof children === "function") return children(m);
+  const label = labels?.[m.state] ?? defaultLabel(m);
+  return createElement(
+    "button",
+    {
+      type: "button",
+      className,
+      "data-state": m.state,
+      ...m.reason ? { "data-reason": m.reason } : {},
+      ...isAsyncState(m.state) ? { "aria-busy": "true" } : {},
+      disabled: !m.canAct,
+      onClick: m.mint
+    },
+    children ?? label
+  );
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  CLICKABLE_STATES,
+  MAX_QUANTITY,
+  MINT_STATES,
+  MintButton,
+  MintError,
+  REASON_CODES,
+  VERSION,
+  isMintError,
+  useMint
+};
+//# sourceMappingURL=index.js.map