@manifoldxyz/dropkit 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -1,430 +1,40 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  CLICKABLE_STATES: () => CLICKABLE_STATES,
-  MAX_QUANTITY: () => MAX_QUANTITY,
-  MINT_STATES: () => MINT_STATES,
-  MintButton: () => MintButton,
-  MintError: () => MintError,
-  PayWithPicker: () => PayWithPicker,
-  REASON_CODES: () => REASON_CODES,
-  VERSION: () => VERSION,
-  isMintError: () => isMintError,
-  useMint: () => useMint,
-  usePayOptions: () => usePayOptions
-});
-module.exports = __toCommonJS(index_exports);
+
+
+
+
+
+var _chunkGO4TR3HBcjs = require('./chunk-GO4TR3HB.cjs');
 
 // src/react/useMint.ts
-var import_react = require("react");
-var import_viem9 = require("viem");
-
-// src/core/rpc/index.ts
-var import_viem = require("viem");
-var import_chains = require("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",
-  // Relay cross-chain mint (spec relay-cross-chain-mint #execute-click).
-  "BRIDGE_UNAVAILABLE",
-  "BRIDGE_REFUNDED",
-  "BRIDGE_FAILED",
-  "BRIDGE_TIMEOUT"
-];
-var FUNDS_REASONS = ["INSUFFICIENT_FUNDS"];
-var REASON_CODES = [
-  ...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;
-  /** 'relay': the message is Relay's decoded destination revert, shown as-is. */
-  domain;
-  constructor(reason, message, opts) {
-    super(message, opts?.cause === void 0 ? void 0 : { cause: opts.cause });
-    this.name = "MintError";
-    this.reason = reason;
-    if (opts?.field !== void 0) this.field = opts.field;
-    if (opts?.domain !== void 0) this.domain = opts.domain;
-  }
-};
-function isMintError(e) {
-  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 = {
-  [import_chains.mainnet.id]: import_chains.mainnet,
-  [import_chains.sepolia.id]: import_chains.sepolia,
-  [import_chains.base.id]: import_chains.base,
-  [import_chains.optimism.id]: import_chains.optimism,
-  [import_chains.shape.id]: import_chains.shape,
-  [import_chains.apeChain.id]: import_chains.apeChain,
-  // Relay pay chain for Sepolia drops only: never a drop chain, no Manifold bridge.
-  [import_chains.baseSepolia.id]: import_chains.baseSepolia
-};
-var CHAIN_NAMES = {
-  1: "Ethereum",
-  8453: "Base",
-  10: "Optimism",
-  360: "Shape",
-  33139: "ApeChain",
-  11155111: "Sepolia",
-  84532: "Base Sepolia"
-};
-function chainName(chainId) {
-  return CHAIN_NAMES[chainId] ?? CHAINS[chainId]?.name ?? `chain ${String(chainId)}`;
-}
-var TRANSPORT_TIMEOUT_MS = 8e3;
-function getChain(chainId) {
-  const chain = CHAINS[chainId];
-  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) => (0, import_viem.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 (0, import_viem.createPublicClient)({ chain, transport });
-}
-
-// src/core/wallet/index.ts
-var import_viem2 = require("viem");
-var CONNECT_WIDGET_VERSION = "6.5.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 DEFAULT_WALLETCONNECT_PROJECT_ID = "a03ac1695f309dc8d756e7b4006e5e7d";
-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 " + CONNECT_WIDGET_VERSION + ".";
-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;
-  const projectId = state.projectId ?? state.div.dataset.walletConnectProjectId ?? DEFAULT_WALLETCONNECT_PROJECT_ID;
-  if (state.div.dataset.walletConnectProjectId !== projectId) state.div.dataset.walletConnectProjectId = 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) ?? [],
-        // The default id is a placeholder, not a choice: a caller's real id may still replace it.
-        projectId: div?.dataset.walletConnectProjectId === DEFAULT_WALLETCONNECT_PROJECT_ID ? void 0 : 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: (0, import_viem2.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 (0, import_viem2.createWalletClient)({ chain: getChain(chainId), transport: (0, import_viem2.custom)({ request }) });
-}
-async function waitForDeposit(chainId, hash, timeoutMs = 12e4) {
-  try {
-    const receipt = await getWalletClient(chainId).extend(import_viem2.publicActions).waitForTransactionReceipt({ hash, confirmations: 1, timeout: timeoutMs });
-    return receipt.status === "reverted" ? "reverted" : "mined";
-  } catch {
-    return "unknown";
-  }
-}
-var WALLET_READ_TIMEOUT = { ms: 1e4 };
-async function getConnectedBalance(address, chainId) {
-  const provider = eip1193();
-  let timer;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new MintError("RPC_ERROR", "The wallet did not report a balance in time.")), WALLET_READ_TIMEOUT.ms);
-  });
-  try {
-    return await Promise.race([
-      (async () => {
-        const current = Number(await provider.request({ method: "eth_chainId" }));
-        if (current !== chainId) {
-          throw new MintError("CHAIN_SWITCH_FAILED", `The wallet is on chain ${String(current)}, not ${String(chainId)}.`);
-        }
-        const hex = await provider.request({ method: "eth_getBalance", params: [address, "latest"] });
-        return BigInt(hex);
-      })(),
-      timeout
-    ]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-var code = (e) => e?.code;
-async function switchToChain(chainId) {
-  const chain = getChain(chainId);
-  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 });
-  }
-}
+var _react = require('react');
+var _viem = require('viem');
 
 // src/core/relay/client.ts
-var import_viem3 = require("viem");
+
 var RELAY_API = { mainnet: "https://api.relay.link", testnet: "https://api.testnets.relay.link" };
 var MAINNET_PAY_CHAINS = [1, 8453, 10, 360, 33139];
 var MAINNET_DROP_CHAINS = [1, 8453, 10, 360];
@@ -438,7 +48,7 @@ function payChainsFor(dropChainId) {
 }
 var CACHE_MS = 3e4;
 var cache = /* @__PURE__ */ new Map();
-var cacheKey = (a) => [a.testnet, a.originChainId, a.destinationChainId, a.tx.to.toLowerCase(), a.tx.value, (0, import_viem3.keccak256)(a.tx.data), a.payer.toLowerCase(), a.recipient.toLowerCase()].join(":");
+var cacheKey = (a) => [a.testnet, a.originChainId, a.destinationChainId, a.tx.to.toLowerCase(), a.tx.value, _viem.keccak256.call(void 0, a.tx.data), a.payer.toLowerCase(), a.recipient.toLowerCase()].join(":");
 var big = (v) => {
   if (typeof v === "string" && /^\d+$/.test(v)) return BigInt(v);
   if (typeof v === "number" && Number.isSafeInteger(v) && v >= 0) return BigInt(v);
@@ -450,42 +60,42 @@ function moneyOf(amount, currency) {
   const decimals = typeof c.decimals === "number" ? c.decimals : 18;
   const symbol = typeof c.symbol === "string" ? c.symbol : "ETH";
   const value = big(amount);
-  return { value, decimals, symbol, formatted: (0, import_viem3.formatUnits)(value, decimals) };
+  return { value, decimals, symbol, formatted: _viem.formatUnits.call(void 0, value, decimals) };
 }
 function revertReason(errorData) {
   if (typeof errorData !== "string") return "";
-  const text2 = errorData.replace(/^execution reverted:?\s*/i, "").trim();
-  return text2 === "execution reverted" ? "" : text2;
+  const text = errorData.replace(/^execution reverted:?\s*/i, "").trim();
+  return text === "execution reverted" ? "" : text;
 }
 function parseQuote(body, originChainId) {
   const b = obj(body);
   const steps = Array.isArray(b.steps) ? b.steps.map(obj) : [];
-  const unknownStep = () => new MintError("BRIDGE_UNAVAILABLE", "Relay returned a route this button cannot execute.");
+  const unknownStep = () => new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_UNAVAILABLE", "Relay returned a route this button cannot execute.");
   if (steps.length !== 1 || steps[0].kind !== "transaction") throw unknownStep();
-  const step2 = steps[0];
-  const rawItems = Array.isArray(step2.items) ? step2.items.map(obj) : [];
+  const step = steps[0];
+  const rawItems = Array.isArray(step.items) ? step.items.map(obj) : [];
   if (rawItems.length !== 1) throw unknownStep();
   const items = rawItems.map((item) => {
     const d = obj(item.data);
     const chainId = Number(d.chainId);
-    if (chainId !== originChainId || typeof d.to !== "string" || !(0, import_viem3.isHex)(d.data)) throw unknownStep();
-    return { chainId, to: (0, import_viem3.getAddress)(d.to), data: d.data, value: big(d.value), gas: d.gas === void 0 ? null : big(d.gas) };
+    if (chainId !== originChainId || typeof d.to !== "string" || !_viem.isHex.call(void 0, d.data)) throw unknownStep();
+    return { chainId, to: _viem.getAddress.call(void 0, d.to), data: d.data, value: big(d.value), gas: d.gas === void 0 ? null : big(d.gas) };
   });
-  const requestId = (0, import_viem3.isHex)(step2.requestId) ? step2.requestId : (0, import_viem3.isHex)(b.requestId) ? b.requestId : null;
+  const requestId = _viem.isHex.call(void 0, step.requestId) ? step.requestId : _viem.isHex.call(void 0, b.requestId) ? b.requestId : null;
   if (!requestId) throw unknownStep();
-  const details = obj(b.details);
-  const currencyIn = obj(details.currencyIn);
+  const details2 = obj(b.details);
+  const currencyIn = obj(details2.currencyIn);
   const fees = obj(b.fees);
   const amountIn = moneyOf(currencyIn.amount, currencyIn.currency);
-  if (obj(currencyIn.currency).address !== void 0 && obj(currencyIn.currency).address !== import_viem3.zeroAddress) throw unknownStep();
+  if (obj(currencyIn.currency).address !== void 0 && obj(currencyIn.currency).address !== _viem.zeroAddress) throw unknownStep();
   if (items[0].value !== amountIn.value) throw unknownStep();
   return {
     requestId,
     originChainId,
     items,
     amountIn,
-    relayFee: moneyOf(obj(fees.relayer).amount, obj(fees.relayer).currency ?? currencyIn.currency),
-    originGas: moneyOf(obj(fees.gas).amount, obj(fees.gas).currency ?? currencyIn.currency),
+    relayFee: moneyOf(obj(fees.relayer).amount, _nullishCoalesce(obj(fees.relayer).currency, () => ( currencyIn.currency))),
+    originGas: moneyOf(obj(fees.gas).amount, _nullishCoalesce(obj(fees.gas).currency, () => ( currencyIn.currency))),
     quotedAt: Math.floor(Date.now() / 1e3)
   };
 }
@@ -531,7 +141,7 @@ async function timedFetch(f, url, init, ms) {
   }
 }
 async function requestQuote(a) {
-  const f = a.fetch ?? globalThis.fetch;
+  const f = _nullishCoalesce(a.fetch, () => ( globalThis.fetch));
   const body = {
     user: a.payer,
     recipient: a.recipient,
@@ -539,8 +149,8 @@ async function requestQuote(a) {
     // R11: without refundTo, Relay disables automatic refunds.
     originChainId: a.originChainId,
     destinationChainId: a.destinationChainId,
-    originCurrency: import_viem3.zeroAddress,
-    destinationCurrency: import_viem3.zeroAddress,
+    originCurrency: _viem.zeroAddress,
+    destinationCurrency: _viem.zeroAddress,
     tradeType: "EXACT_OUTPUT",
     amount: a.tx.value.toString(),
     txs: [{ to: a.tx.to, value: a.tx.value.toString(), data: a.tx.data }]
@@ -553,21 +163,21 @@ async function requestQuote(a) {
       body: JSON.stringify(body)
     }, RELAY_TIMEOUTS.quoteMs);
   } catch (e) {
-    throw new MintError("BRIDGE_UNAVAILABLE", "Could not reach Relay for a cross-chain quote.", { cause: e });
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_UNAVAILABLE", "Could not reach Relay for a cross-chain quote.", { cause: e });
   }
   const json = res.json;
   if (res.ok) return parseQuote(json, a.originChainId);
   const j = obj(json);
   if (j.errorCode === "DESTINATION_TX_FAILED") {
     const reason = revertReason(j.errorData);
-    throw new MintError("SIMULATION_REVERTED", reason || "The mint would fail on the drop network.", { cause: json, domain: "relay" });
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", reason || "The mint would fail on the drop network.", { cause: json, domain: "relay" });
   }
   if (res.status === 401 || j.errorCode === "UNAUTHORIZED_QUOTE") {
     console.warn("dropkit: Relay rejected the quote (401 UNAUTHORIZED_QUOTE). Relay gates quotes that carry a referrer or need an API key.");
-    throw new MintError("BRIDGE_UNAVAILABLE", "Relay refused the cross-chain quote.", { cause: json });
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_UNAVAILABLE", "Relay refused the cross-chain quote.", { cause: json });
   }
-  if (res.status === 429) throw new MintError("RATE_LIMITED", "Relay is rate limiting quotes. Try again in a moment.", { cause: json });
-  throw new MintError("BRIDGE_UNAVAILABLE", `Relay could not quote this mint (${String(res.status)}).`, { cause: json });
+  if (res.status === 429) throw new (0, _chunkGO4TR3HBcjs.MintError)("RATE_LIMITED", "Relay is rate limiting quotes. Try again in a moment.", { cause: json });
+  throw new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_UNAVAILABLE", `Relay could not quote this mint (${String(res.status)}).`, { cause: json });
 }
 function getQuote(a) {
   const k = cacheKey(a);
@@ -577,19 +187,19 @@ function getQuote(a) {
   const quote = requestQuote(a);
   cache.set(k, { at: now, quote });
   quote.catch(() => {
-    if (cache.get(k)?.quote === quote) cache.delete(k);
+    if (_optionalChain([cache, 'access', _2 => _2.get, 'call', _3 => _3(k), 'optionalAccess', _4 => _4.quote]) === quote) cache.delete(k);
   });
   return raceSignal(quote, a.signal);
 }
 var realReason = (v) => typeof v === "string" && v !== "" && v !== "N/A" ? v : null;
 async function getStatus(a) {
-  const f = a.fetch ?? globalThis.fetch;
+  const f = _nullishCoalesce(a.fetch, () => ( globalThis.fetch));
   const res = await raceSignal(timedFetch(f, `${a.testnet ? RELAY_API.testnet : RELAY_API.mainnet}/intents/status/v3?requestId=${a.requestId}`, {}, RELAY_TIMEOUTS.statusMs), a.signal);
   if (!res.ok) throw new Error(`Relay status ${String(res.status)}`);
   const j = obj(res.json);
   return {
     status: typeof j.status === "string" ? j.status : "unknown",
-    txHashes: Array.isArray(j.txHashes) ? j.txHashes.filter((h) => (0, import_viem3.isHex)(h)) : [],
+    txHashes: Array.isArray(j.txHashes) ? j.txHashes.filter((h) => _viem.isHex.call(void 0, h)) : [],
     failReason: realReason(j.failReason),
     refundFailReason: realReason(j.refundFailReason)
   };
@@ -604,18 +214,18 @@ var POLL_FAST_FOR_MS = 6e4;
 var POLL_CAP_MS = 10 * 6e4;
 var defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
   const t = setTimeout(resolve, ms);
-  signal?.addEventListener("abort", () => {
+  _optionalChain([signal, 'optionalAccess', _5 => _5.addEventListener, 'call', _6 => _6("abort", () => {
     clearTimeout(t);
     reject(new DOMException("Relay polling cancelled", "AbortError"));
-  }, { once: true });
+  }, { once: true })]);
 });
 async function pollUntilTerminal(a) {
-  const sleep = a.sleep ?? defaultSleep;
-  const now = a.now ?? Date.now;
+  const sleep = _nullishCoalesce(a.sleep, () => ( defaultSleep));
+  const now = _nullishCoalesce(a.now, () => ( Date.now));
   const start = now();
   let warned = false;
   for (; ; ) {
-    a.assertActive?.();
+    _optionalChain([a, 'access', _7 => _7.assertActive, 'optionalCall', _8 => _8()]);
     try {
       const status = await getStatus({ testnet: a.testnet, requestId: a.requestId, ...a.signal ? { signal: a.signal } : {}, ...a.fetch ? { fetch: a.fetch } : {} });
       if (TERMINAL.includes(status.status)) return { kind: "terminal", status };
@@ -624,794 +234,641 @@ async function pollUntilTerminal(a) {
         console.warn(`dropkit: Relay status "${status.status}" for ${a.requestId}; still waiting.`);
       }
     } catch (e) {
-      if (e?.name === "AbortError") throw e;
+      if (_optionalChain([e, 'optionalAccess', _9 => _9.name]) === "AbortError") throw e;
     }
-    a.assertActive?.();
+    _optionalChain([a, 'access', _10 => _10.assertActive, 'optionalCall', _11 => _11()]);
     const elapsed = now() - start;
     if (elapsed >= POLL_CAP_MS) return { kind: "timeout" };
     await sleep(elapsed < POLL_FAST_FOR_MS ? POLL_FAST_MS : POLL_SLOW_MS, a.signal);
   }
 }
 
-// src/core/relay/outstanding.ts
-var memory = /* @__PURE__ */ new Map();
-var claimed = /* @__PURE__ */ new Set();
-function outstandingKey(config, payer) {
-  const target = config.type === "manifold-claim" ? `${config.creatorContract.toLowerCase()}:${config.instanceId}` : config.address.toLowerCase();
-  return `${String(config.chainId)}:${target}:${payer.toLowerCase()}`;
-}
-var getOutstanding = (key) => memory.get(key) ?? null;
-var setOutstanding = (key, out) => void memory.set(key, out);
-var clearOutstanding = (key) => void memory.delete(key);
-function claimDeposit(key) {
-  if (claimed.has(key) || memory.has(key)) return false;
-  claimed.add(key);
-  return true;
-}
-var releaseDeposit = (key) => void claimed.delete(key);
+// src/core/adapters/tl-stacks/index.ts
 
-// src/core/adapters/manifold-claim/index.ts
-var import_viem5 = require("viem");
 
-// src/core/adapters/manifold-claim/abis.ts
-var import_viem4 = require("viem");
-var CLAIM_721_V5_ABI = (0, import_viem4.parseAbi)([
-  "function getClaim(address creatorContractAddress, uint256 instanceId) view returns ((uint32 total, uint32 totalMax, uint32 walletMax, uint48 startDate, uint48 endDate, uint8 storageProtocol, uint8 contractVersion, bool identical, bytes32 merkleRoot, string location, uint256 cost, address paymentReceiver, address erc20) claim)"
-]);
-var CLAIM_1155_V5_ABI = (0, import_viem4.parseAbi)([
-  "function getClaim(address creatorContractAddress, uint256 instanceId) view returns ((uint32 total, uint32 totalMax, uint32 walletMax, uint48 startDate, uint48 endDate, uint8 storageProtocol, bytes32 merkleRoot, string location, uint256 tokenId, uint256 cost, address paymentReceiver, address erc20) claim)"
-]);
-var CLAIM_721_V7_ABI = (0, import_viem4.parseAbi)([
-  "function getClaim(address creatorContractAddress, uint256 instanceId) view returns ((uint32 total, uint32 totalMax, uint32 walletMax, uint48 startDate, uint48 endDate, uint8 storageProtocol, uint8 contractVersion, bool identical, bytes32 merkleRoot, string location, uint256 cost, address paymentReceiver, address erc20, address signingAddress) claim)"
-]);
-var CLAIM_1155_V7_ABI = (0, import_viem4.parseAbi)([
-  "function getClaim(address creatorContractAddress, uint256 instanceId) view returns ((uint32 total, uint32 totalMax, uint32 walletMax, uint48 startDate, uint48 endDate, uint8 storageProtocol, bytes32 merkleRoot, string location, uint256 tokenId, uint256 cost, address paymentReceiver, address erc20, address signingAddress) claim)"
-]);
-var EXTENSION_COMMON_ABI = (0, import_viem4.parseAbi)([
-  "function MINT_FEE() view returns (uint256)",
-  "function MINT_FEE_MERKLE() view returns (uint256)",
-  "function getTotalMints(address minter, address creatorContractAddress, uint256 instanceId) view returns (uint32)",
-  "function checkMintIndices(address creatorContractAddress, uint256 instanceId, uint32[] mintIndices) view returns (bool[] minted)",
-  "function mintProxy(address creatorContractAddress, uint256 instanceId, uint16 mintCount, uint32[] mintIndices, bytes32[][] merkleProofs, address mintFor) payable"
-]);
-var EXTENSION_ERRORS_ABI = (0, import_viem4.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 = (0, import_viem4.parseAbi)(["function getExtensions() view returns (address[])"]);
-var ERC20_ABI = (0, import_viem4.parseAbi)([
-  "function symbol() view returns (string)",
-  "function decimals() view returns (uint8)",
-  "function balanceOf(address owner) view returns (uint256)",
-  "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 });
-  }
+
+
+
+
+
+
+
+
+
+
+// src/core/adapters/tl-stacks/abis.ts
+var DROP_PHASE = { NOT_CONFIGURED: 0, NOT_STARTED: 1, PRESALE: 2, PUBLIC_SALE: 3, ENDED: 4 };
+var SUPPORTED_VERSIONS = ["2.3.0", "2.3.1"];
+var stacksAbi = [
+  { type: "function", name: "VERSION", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] },
+  { type: "function", name: "protocolFee", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "uint256" }] },
+  {
+    type: "function",
+    name: "getDrop",
+    stateMutability: "view",
+    inputs: [{ name: "nftAddress", type: "address" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "dropType", type: "uint8" },
+          { name: "payoutReceiver", type: "address" },
+          { name: "initialSupply", type: "uint256" },
+          { name: "supply", type: "uint256" },
+          { name: "allowance", type: "uint256" },
+          { name: "currencyAddress", type: "address" },
+          { name: "startTime", type: "uint256" },
+          { name: "presaleDuration", type: "uint256" },
+          { name: "presaleCost", type: "uint256" },
+          { name: "presaleMerkleRoot", type: "bytes32" },
+          { name: "publicDuration", type: "uint256" },
+          { name: "publicCost", type: "uint256" },
+          { name: "decayRate", type: "int256" },
+          { name: "baseUri", type: "string" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "getDropPhase",
+    stateMutability: "view",
+    inputs: [{ name: "nftAddress", type: "address" }],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    type: "function",
+    name: "getNumberMinted",
+    stateMutability: "view",
+    inputs: [
+      { name: "nftAddress", type: "address" },
+      { name: "recipient", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "purchase",
+    stateMutability: "payable",
+    inputs: [
+      { name: "nftAddress", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "numberToMint", type: "uint256" },
+      { name: "presaleNumberCanMint", type: "uint256" },
+      { name: "proof", type: "bytes32[]" }
+    ],
+    outputs: [{ name: "refundAmount", type: "uint256" }]
+  },
+  { type: "error", name: "MintZeroTokens", inputs: [] },
+  { type: "error", name: "NotOnAllowlist", inputs: [] },
+  { type: "error", name: "YouShallNotMint", inputs: [] },
+  { type: "error", name: "AlreadyReachedMintAllowance", inputs: [] },
+  { type: "error", name: "InsufficientFunds", inputs: [] },
+  { type: "error", name: "SanctionedAddress", inputs: [] },
+  // OpenZeppelin v5 Pausable: purchase is whenNotPaused.
+  { type: "error", name: "EnforcedPause", inputs: [] }
+];
+
+// src/core/adapters/tl-stacks/allowlist.ts
+
+var HASH = /^0x[0-9a-fA-F]{64}$/;
+var UINT = /^\d+$/;
+var MAX_UINT256 = 2n ** 256n - 1n;
+var unavailable = (message, cause) => new (0, _chunkGO4TR3HBcjs.MintError)("ALLOWLIST_UNAVAILABLE", message, cause === void 0 ? void 0 : { cause });
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var hashWallet = (wallet) => _viem.keccak256.call(void 0, _viem.encodeAbiParameters.call(void 0, [{ type: "address" }], [_viem.getAddress.call(void 0, wallet)]));
+var leafOf = (hashedWallet, allowance) => _viem.keccak256.call(void 0, _viem.concatHex.call(void 0, [_viem.keccak256.call(void 0, _viem.encodeAbiParameters.call(void 0, [{ type: "bytes32" }, { type: "uint256" }], [hashedWallet, allowance]))]));
+var hashPair = (a, b) => BigInt(a) < BigInt(b) ? _viem.keccak256.call(void 0, _viem.concatHex.call(void 0, [a, b])) : _viem.keccak256.call(void 0, _viem.concatHex.call(void 0, [b, a]));
+var processProof = (leaf, proof) => proof.reduce((node, sibling) => hashPair(node, sibling), leaf);
+function parseAllowlist(body) {
+  if (!isRecord(body)) throw unavailable("The allowlist file is not a merkle tree dump.");
+  if (body.format !== "standard-v1") throw unavailable("The allowlist file is in an unsupported format.");
+  const enc = body.leafEncoding;
+  if (!Array.isArray(enc) || enc.length !== 2 || enc[0] !== "bytes32" || enc[1] !== "uint256") {
+    throw unavailable("The allowlist file uses an unsupported leaf encoding.");
+  }
+  const { tree, values } = body;
+  if (!Array.isArray(tree) || tree.length === 0 || !tree.every((n) => typeof n === "string" && HASH.test(n))) {
+    throw unavailable("The allowlist file has no readable merkle tree.");
+  }
+  if (!Array.isArray(values)) throw unavailable("The allowlist file has no wallet values.");
+  const entries = /* @__PURE__ */ new Map();
+  for (const row of values) {
+    const value = isRecord(row) ? row.value : void 0;
+    const treeIndex = isRecord(row) ? row.treeIndex : void 0;
+    if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || !HASH.test(value[0])) {
+      throw unavailable("The allowlist file has an unreadable wallet entry.");
+    }
+    const raw = value[1];
+    const allowanceText = typeof raw === "string" ? raw : typeof raw === "number" && Number.isSafeInteger(raw) ? String(raw) : "";
+    if (!UINT.test(allowanceText) || BigInt(allowanceText) > MAX_UINT256) throw unavailable("The allowlist file has an unreadable allowance.");
+    if (typeof treeIndex !== "number") throw unavailable("The allowlist file has an unreadable tree index.");
+    const key = value[0].toLowerCase();
+    const allowance = BigInt(allowanceText);
+    const prev = entries.get(key);
+    if (!prev || allowance > prev.allowance) entries.set(key, { allowance, treeIndex });
+  }
+  return { root: tree[0].toLowerCase(), tree, entries };
+}
+var findEntry = (list, recipient) => _nullishCoalesce(list.entries.get(hashWallet(recipient).toLowerCase()), () => ( null));
+function assertRoot(list, presaleMerkleRoot) {
+  if (list.root !== presaleMerkleRoot.toLowerCase()) {
+    throw unavailable("The allowlist file does not match this drop. The creator may have updated the allowlist; reload the page.");
+  }
+}
+var buildProof = (list, recipient, entry) => buildProofForHash(list, hashWallet(recipient), entry);
+function buildProofForHash(list, hashedWallet, entry) {
+  const { tree } = list;
+  const { treeIndex } = entry;
+  if (!Number.isInteger(treeIndex) || treeIndex < 1 || treeIndex >= tree.length) {
+    throw unavailable("The allowlist file has a tree index outside the tree.");
+  }
+  const leaf = leafOf(hashedWallet, entry.allowance);
+  if (tree[treeIndex].toLowerCase() !== leaf.toLowerCase()) throw unavailable("The allowlist file entry does not match its merkle leaf.");
+  const proof = [];
+  let i = treeIndex;
+  while (i > 0) {
+    const sibling = i % 2 === 0 ? i - 1 : i + 1;
+    const node = tree[sibling];
+    if (node === void 0) throw unavailable("The allowlist file has a broken merkle tree.");
+    proof.push(node);
+    i = Math.floor((i - 1) / 2);
+  }
+  if (processProof(leaf, proof).toLowerCase() !== list.root) throw unavailable("The allowlist file does not produce a valid proof for this wallet.");
+  return proof;
 }
-var isRecord = (v) => typeof v === "object" && v !== null;
 var scopeCaches = /* @__PURE__ */ new WeakMap();
-function memo(cache2, key, signal, load) {
-  const hit = cache2.get(key);
-  if (hit) return hit;
-  const p = withSignal(load(), signal);
-  cache2.set(key, p);
-  p.catch(() => {
-    if (cache2.get(key) === p) cache2.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 }));
+    const onAbort = () => reject(unavailable("The allowlist request was cancelled.", 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.");
+var ALLOWLIST_TIMEOUT_MS = 3e4;
+var ALLOWLIST_MAX_BYTES = 10 * 1024 * 1024;
+var tooLarge = () => unavailable(`The allowlist file is larger than ${ALLOWLIST_MAX_BYTES / (1024 * 1024)} MB.`);
+async function readCapped(res) {
+  const declared = Number(res.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > ALLOWLIST_MAX_BYTES) throw tooLarge();
+  if (!res.body) return "";
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > ALLOWLIST_MAX_BYTES) {
+      void reader.cancel().catch(() => void 0);
+      throw tooLarge();
     }
-    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 });
+    chunks.push(value);
   }
-  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 bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    bytes.set(c, offset);
+    offset += c.byteLength;
   }
-  const cache2 = scoped;
-  const entries = await memo(cache2.entries, key, cache2.signal, () => loadEntries(fetchFn, args.api, args.instanceId, args.recipient, cache2));
-  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 !== import_viem5.zeroHash;
-function isContractFailure(e) {
-  if (!(e instanceof import_viem5.BaseError)) return false;
-  return e.walk((x) => x instanceof import_viem5.ContractFunctionRevertedError || x.name === "ContractFunctionZeroDataError") !== null;
-}
-function toRpcError(e) {
-  if (e instanceof MintError) return e;
-  const msg = e instanceof import_viem5.BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
-  return new MintError("RPC_ERROR", `RPC request failed: ${msg}`, { cause: e });
-}
-async function rpc(fn) {
+  return new TextDecoder().decode(bytes);
+}
+async function fetchAndParse(fetchFn, url, signal) {
+  let res;
   try {
-    return await fn();
-  } catch (e) {
-    throw toRpcError(e);
+    signal.throwIfAborted();
+    res = await fetchFn(url, { signal });
+  } catch (cause) {
+    throw unavailable("Could not reach the allowlist file.", cause);
+  }
+  if (res.status === 429) throw new (0, _chunkGO4TR3HBcjs.MintError)("RATE_LIMITED", "The allowlist host is rate limiting requests. Try again shortly.");
+  if (!res.ok) throw unavailable(`The allowlist file is not available (HTTP ${res.status}).`);
+  let body;
+  try {
+    const text = await readCapped(res);
+    body = JSON.parse(text);
+  } catch (cause) {
+    if (cause instanceof _chunkGO4TR3HBcjs.MintError) throw cause;
+    throw unavailable("The allowlist file could not be read.", cause);
   }
+  return parseAllowlist(body);
 }
-function revertData(e) {
-  const hit = e.walk((x) => {
-    const d2 = x.data;
-    return (0, import_viem5.isHex)(d2) && d2.length >= 10 || typeof d2 === "object" && d2 !== null && (0, import_viem5.isHex)(d2.data);
+async function download(fetchFn, url, signal) {
+  const controller = new AbortController();
+  let onAbort;
+  const stopped = new Promise((_, reject) => {
+    onAbort = () => {
+      const reason = controller.signal.reason;
+      reject(reason instanceof _chunkGO4TR3HBcjs.MintError ? reason : unavailable("The allowlist request was cancelled.", reason));
+    };
+    controller.signal.addEventListener("abort", onAbort, { once: true });
   });
-  const d = hit?.data;
-  if ((0, import_viem5.isHex)(d)) return d;
-  const inner = d?.data;
-  return (0, import_viem5.isHex)(inner) ? inner : void 0;
-}
-function decodeRevert(e) {
-  if (!(e instanceof import_viem5.BaseError)) return null;
-  const data = revertData(e);
-  if (data) {
-    try {
-      const d = (0, import_viem5.decodeErrorResult)({ abi: EXTENSION_ERRORS_ABI, data });
-      if (d.errorName === "Error" && typeof d.args?.[0] === "string") return d.args[0];
-      if (d.errorName === "Panic") return `Panic(${String(d.args?.[0])})`;
-      return d.errorName;
-    } catch {
-      return `reverted with unknown error ${data.slice(0, 10)}`;
-    }
+  const onLifetimeAbort = () => controller.abort(_optionalChain([signal, 'optionalAccess', _12 => _12.reason]));
+  if (_optionalChain([signal, 'optionalAccess', _13 => _13.aborted])) onLifetimeAbort();
+  else _optionalChain([signal, 'optionalAccess', _14 => _14.addEventListener, 'call', _15 => _15("abort", onLifetimeAbort, { once: true })]);
+  const timer = setTimeout(
+    () => controller.abort(unavailable(`The allowlist file did not load within ${ALLOWLIST_TIMEOUT_MS / 1e3} seconds. Try again.`)),
+    ALLOWLIST_TIMEOUT_MS
+  );
+  try {
+    return await Promise.race([fetchAndParse(fetchFn, url, controller.signal), stopped]);
+  } finally {
+    clearTimeout(timer);
+    if (onAbort) controller.signal.removeEventListener("abort", onAbort);
+    _optionalChain([signal, 'optionalAccess', _16 => _16.removeEventListener, 'call', _17 => _17("abort", onLifetimeAbort)]);
   }
-  const named = e.walk((x) => ["ExecutionRevertedError", "InsufficientFundsError"].includes(x.name));
-  return named instanceof import_viem5.BaseError ? named.shortMessage : null;
 }
-var money = (value, decimals, symbol) => ({ value, decimals, symbol, formatted: (0, import_viem5.formatUnits)(value, decimals) });
-function timestamp(v, field) {
-  if (v === 0n) return null;
-  if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new MintError("RPC_ERROR", `Claim ${field} does not fit a safe integer`);
-  return Number(v);
-}
-function parseConfig(config) {
-  if (!(0, import_viem5.isAddress)(config.creatorContract, { strict: false })) {
-    throw new MintError("INVALID_CONFIG", "creatorContract is not a valid address.", { field: "creatorContract" });
-  }
-  if (config.extension !== void 0 && !(0, import_viem5.isAddress)(config.extension, { strict: false })) {
-    throw new MintError("INVALID_CONFIG", "extension is not a valid address.", { field: "extension" });
+function loadAllowlist(args) {
+  if (!args.url) {
+    return Promise.reject(unavailable("This presale has no allowlist file configured (allowlistUrl). Ask the creator to add it."));
   }
-  if (typeof config.instanceId !== "string" || !/^\d+$/.test(config.instanceId)) {
-    throw new MintError("INVALID_CONFIG", "instanceId must be a non-negative integer string.", { field: "instanceId" });
+  if (_optionalChain([args, 'access', _18 => _18.signal, 'optionalAccess', _19 => _19.aborted])) return Promise.reject(unavailable("The allowlist request was cancelled.", args.signal.reason));
+  const fetchFn = _nullishCoalesce(args.fetch, () => ( ((input, init) => globalThis.fetch(input, init))));
+  let scoped = scopeCaches.get(args.scope);
+  if (!scoped || _optionalChain([scoped, 'access', _20 => _20.signal, 'optionalAccess', _21 => _21.aborted])) {
+    scoped = { signal: args.signal, loads: /* @__PURE__ */ new Map() };
+    scopeCaches.set(args.scope, scoped);
   }
-  return {
-    creator: (0, import_viem5.getAddress)(config.creatorContract),
-    instanceId: BigInt(config.instanceId),
-    extension: config.extension === void 0 ? void 0 : (0, import_viem5.getAddress)(config.extension)
-  };
+  const cache2 = scoped;
+  const hit = cache2.loads.get(args.url);
+  if (hit) return hit;
+  const url = args.url;
+  const p = withSignal(download(fetchFn, url, cache2.signal), cache2.signal);
+  cache2.loads.set(url, p);
+  p.catch(() => {
+    if (cache2.loads.get(url) === p) cache2.loads.delete(url);
+  });
+  return p;
 }
-var notFound = (config) => new MintError("CLAIM_NOT_FOUND", `No Manifold claim ${config.instanceId} found on ${config.creatorContract}.`);
-async function readClaim(client, entry, creator, instanceId, config) {
-  const address = (0, import_viem5.getAddress)(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 };
+
+// src/core/adapters/tl-stacks/index.ts
+var FALLBACK_GAS_BASE = 150000n;
+var FALLBACK_GAS_PER_TOKEN = 150000n;
+var details = /* @__PURE__ */ new WeakMap();
+function bad(field, message) {
+  throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `${field} ${message}`, { field });
+}
+function validateTlStacksConfig(config) {
+  if (!Number.isInteger(config.chainId) || config.chainId <= 0) bad("chainId", "must be a positive integer");
+  if (typeof config.stacks !== "string" || !_viem.isAddress.call(void 0, config.stacks, { strict: false })) bad("stacks", "is not a valid address");
+  if (typeof config.nftContract !== "string" || !_viem.isAddress.call(void 0, config.nftContract, { strict: false })) bad("nftContract", "is not a valid address");
+  if (config.allowlistUrl !== void 0) {
+    const https = (() => {
+      try {
+        return typeof config.allowlistUrl === "string" && new URL(config.allowlistUrl).protocol === "https:";
+      } catch (e2) {
+        return false;
       }
-    }
-  } catch (e) {
-    if (isContractFailure(e)) throw notFound(config);
-    throw toRpcError(e);
+    })();
+    if (!https) bad("allowlistUrl", "must be an https: URL");
   }
 }
-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
-  };
+var abortError = () => new DOMException("The operation was aborted", "AbortError");
+var isAbortError = (e) => _optionalChain([e, 'optionalAccess', _22 => _22.name]) === "AbortError";
+function throwIfAborted(ctx) {
+  if (_optionalChain([ctx, 'access', _23 => _23.signal, 'optionalAccess', _24 => _24.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));
+  });
 }
-async function hasCode(client, address) {
-  const code2 = await rpc(() => client.getCode({ address: (0, import_viem5.getAddress)(address) }));
-  return code2 !== void 0 && code2 !== "0x";
-}
-var unknownExtension = (address, why) => new MintError("UNKNOWN_EXTENSION", `Extension ${address} ${why}.`);
-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;
+var shortMessage = (e) => e instanceof _viem.BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
+function rpcError(e) {
+  if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e) || isAbortError(e)) throw e;
+  throw new (0, _chunkGO4TR3HBcjs.MintError)("RPC_ERROR", `RPC request failed: ${shortMessage(e)}`, { cause: e });
+}
+async function readStacks(ctx, config, functionName, args = []) {
   try {
-    registered = await client.readContract({ address: creator, abi: CREATOR_ABI, functionName: "getExtensions" });
+    return await io(
+      ctx,
+      () => ctx.client.readContract({ address: _viem.getAddress.call(void 0, config.stacks), abi: stacksAbi, functionName, args })
+    );
   } catch (e) {
-    if (isContractFailure(e)) throw notFound(config);
-    throw toRpcError(e);
+    if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e) || isAbortError(e)) throw e;
+    if (e instanceof _viem.BaseError && e.walk((x) => x instanceof _viem.ContractFunctionRevertedError || x instanceof _viem.ContractFunctionZeroDataError)) {
+      throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `stacks ${functionName}() reverted or returned no data. Is ${config.stacks} a TL Stacks 721 contract on chain ${config.chainId}?`, {
+        field: "stacks",
+        cause: e
+      });
+    }
+    return rpcError(e);
+  }
+}
+var versions = /* @__PURE__ */ new WeakMap();
+async function checkVersion(ctx, config) {
+  const load = () => readStacks(ctx, config, "VERSION");
+  let version;
+  if (ctx.cacheScope) {
+    let byStacks = versions.get(ctx.cacheScope);
+    if (!byStacks) versions.set(ctx.cacheScope, byStacks = /* @__PURE__ */ new Map());
+    const key = `${config.chainId}:${config.stacks.toLowerCase()}`;
+    const cache2 = byStacks;
+    let hit = cache2.get(key);
+    if (!hit) {
+      const p = load();
+      cache2.set(key, hit = p);
+      p.catch(() => {
+        if (cache2.get(key) === p) cache2.delete(key);
+      });
+    }
+    version = hit;
+  } else {
+    version = load();
   }
-  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.`
-    );
+  const v = await version;
+  if (!SUPPORTED_VERSIONS.includes(v)) {
+    bad("stacks", `is TL Stacks ${v}. Dropkit supports ${SUPPORTED_VERSIONS.join(" and ")} only.`);
   }
-  return hits[0];
 }
-async function loadDrop(ctx, config) {
-  const { entry, claim } = await resolveExtension(ctx, config);
-  if (claim.signingAddress !== null && claim.signingAddress !== import_viem5.zeroAddress) {
-    throw new MintError("SIGNATURE_CLAIM", "This claim mints with a signature (redemption code), which this button does not support.");
-  }
-  const { client } = ctx;
-  const extension = (0, import_viem5.getAddress)(entry.address);
-  const fee = await rpc(
-    () => client.readContract({ address: extension, abi: EXTENSION_COMMON_ABI, functionName: isAllowlist(claim) ? "MINT_FEE_MERKLE" : "MINT_FEE" })
-  );
-  const native = client.chain?.nativeCurrency ?? { symbol: "ETH", decimals: 18 };
-  let unitPrice;
-  let paymentToken = null;
-  if (claim.erc20 === import_viem5.zeroAddress) {
-    unitPrice = money(claim.cost, native.decimals, native.symbol);
-  } else {
-    paymentToken = (0, import_viem5.getAddress)(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 = {
+var money = (value, decimals, symbol) => ({ value, decimals, symbol, formatted: _viem.formatUnits.call(void 0, value, decimals) });
+function nativeMeta(ctx) {
+  const n = _optionalChain([ctx, 'access', _25 => _25.client, 'access', _26 => _26.chain, 'optionalAccess', _27 => _27.nativeCurrency]);
+  return { decimals: _nullishCoalesce(_optionalChain([n, 'optionalAccess', _28 => _28.decimals]), () => ( 18)), symbol: _nullishCoalesce(_optionalChain([n, 'optionalAccess', _29 => _29.symbol]), () => ( "ETH")) };
+}
+function seconds(v, field) {
+  if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `${field} is too large for a unix timestamp`, { field });
+  return Number(v);
+}
+async function readDrop(ctx, config) {
+  validateTlStacksConfig(config);
+  throwIfAborted(ctx);
+  await checkVersion(ctx, config);
+  const nft = _viem.getAddress.call(void 0, config.nftContract);
+  const [drop, phaseRaw, fee] = await Promise.all([
+    readStacks(ctx, config, "getDrop", [nft]),
+    readStacks(ctx, config, "getDropPhase", [nft]),
+    readStacks(ctx, config, "protocolFee")
+  ]);
+  const phase = Number(phaseRaw);
+  if (phase === DROP_PHASE.NOT_CONFIGURED) {
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("DROP_NOT_FOUND", "No Transient Labs drop is configured for this NFT contract on this chain.");
+  }
+  if (drop.currencyAddress !== _viem.zeroAddress) {
+    bad("nftContract", `is sold for an ERC-20 (${drop.currencyAddress}). Dropkit supports drops priced in the native token only.`);
+  }
+  const hasPresale = drop.presaleDuration > 0n;
+  const presalePrice = phase === DROP_PHASE.PRESALE || phase === DROP_PHASE.NOT_STARTED && hasPresale;
+  const unitPrice = presalePrice ? drop.presaleCost : drop.publicCost;
+  const startTime = seconds(drop.startTime, "startTime");
+  const presaleEnd = seconds(drop.startTime + drop.presaleDuration, "presaleDuration");
+  const soldOut = drop.supply === 0n;
+  const neverMintable = drop.initialSupply === 0n;
+  const native = nativeMeta(ctx);
+  const info = {
     chainId: config.chainId,
-    unitPrice,
+    unitPrice: money(unitPrice, native.decimals, native.symbol),
     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"
+    totalMinted: drop.initialSupply - drop.supply,
+    maxSupply: drop.initialSupply,
+    // A never-mintable drop has no start either, so the hook clock has no boundary ahead to tick towards (review F13).
+    startTime: neverMintable || startTime === 0 ? null : startTime,
+    // At supply 0 the drop is sold out for good: no end time, so it never turns into `ended` (D14).
+    endTime: neverMintable ? 0 : soldOut ? null : seconds(drop.startTime + drop.presaleDuration + drop.publicDuration, "publicDuration"),
+    isAllowlist: phase === DROP_PHASE.PRESALE,
+    paymentToken: null,
+    pricePer: "unit",
+    phaseEndsAt: presalePrice ? presaleEnd : null,
+    walletKey: `${phase}:${drop.presaleMerkleRoot}:${unitPrice}:${fee}`
   };
-  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 = (0, import_viem5.getAddress)(entry.address);
-  const payer = (0, import_viem5.getAddress)(args.payer);
-  const recipient = (0, import_viem5.getAddress)(args.recipient);
-  let walletMinted = null;
-  let walletMax = null;
-  let allowlistRemaining = null;
-  let maxQuantity = null;
+  details.set(info, {
+    phase,
+    presaleMerkleRoot: drop.presaleMerkleRoot,
+    allowance: drop.allowance,
+    presaleDuration: drop.presaleDuration,
+    publicDuration: drop.publicDuration,
+    startTime: drop.startTime
+  });
+  return info;
+}
+async function detailOf(ctx, config, drop) {
+  const hit = details.get(drop);
+  if (hit) return hit;
+  const nft = _viem.getAddress.call(void 0, config.nftContract);
+  const [raw, phase] = await Promise.all([
+    readStacks(ctx, config, "getDrop", [nft]),
+    readStacks(ctx, config, "getDropPhase", [nft])
+  ]);
+  return {
+    phase: Number(phase),
+    presaleMerkleRoot: raw.presaleMerkleRoot,
+    allowance: raw.allowance,
+    presaleDuration: raw.presaleDuration,
+    publicDuration: raw.publicDuration,
+    startTime: raw.startTime
+  };
+}
+var dayTime = (unix) => new Date(unix * 1e3).toLocaleString(void 0, { dateStyle: "medium", timeStyle: "short" });
+function notOnAllowlist(d) {
+  const opens = Number(d.startTime + d.presaleDuration);
+  const message = d.publicDuration > 0n ? `This wallet is not on the allowlist. The public sale opens ${dayTime(opens)}.` : "This wallet is not on the allowlist. This drop is allowlist only.";
+  return { reason: "NOT_ON_ALLOWLIST", message };
+}
+async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
+  validateTlStacksConfig(config);
+  throwIfAborted(ctx);
+  const detail = await detailOf(ctx, config, drop);
+  const nft = _viem.getAddress.call(void 0, config.nftContract);
+  const presale = detail.phase === DROP_PHASE.PRESALE;
+  const [minted, native, gasPrice, list] = await Promise.all([
+    readStacks(ctx, config, "getNumberMinted", [nft, _viem.getAddress.call(void 0, recipient)]),
+    io(ctx, () => ctx.client.getBalance({ address: payer })).catch(rpcError),
+    io(ctx, () => ctx.client.getGasPrice()).catch(rpcError),
+    presale ? loadAllowlist({ scope: _nullishCoalesce(ctx.cacheScope, () => ( drop)), url: config.allowlistUrl, fetch: ctx.fetch, signal: ctx.signal }) : Promise.resolve(null)
+  ]);
+  let walletMax = detail.allowance;
+  let proof = [];
+  let presaleNumberCanMint = 0n;
   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);
+  let allowlistRemaining = null;
+  if (presale && list) {
+    assertRoot(list, detail.presaleMerkleRoot);
+    const entry = findEntry(list, recipient);
+    if (!entry) {
+      walletMax = 0n;
+      ineligible = notOnAllowlist(detail);
+    } else {
+      walletMax = entry.allowance;
+      presaleNumberCanMint = entry.allowance;
+      proof = buildProof(list, recipient, entry);
     }
-    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." };
+  }
+  const remaining = walletMax > minted ? walletMax - minted : 0n;
+  if (presale && ineligible === null) {
+    allowlistRemaining = Number(remaining < BigInt(_chunkGO4TR3HBcjs.MAX_QUANTITY) ? remaining : BigInt(_chunkGO4TR3HBcjs.MAX_QUANTITY));
+    if (remaining === 0n) ineligible = { reason: "ALLOWLIST_USED", message: `This wallet has already minted its allowlist allocation of ${walletMax}.` };
+  } else if (!presale && remaining === 0n) {
+    ineligible = { reason: "WALLET_LIMIT", message: `This wallet has already minted its limit of ${walletMax}.` };
+  }
+  const maxQuantity = Number(remaining < BigInt(_chunkGO4TR3HBcjs.MAX_QUANTITY) ? remaining : BigInt(_chunkGO4TR3HBcjs.MAX_QUANTITY));
+  const data = { presaleNumberCanMint, proof, unitPrice: drop.unitPrice.value, unitFee: drop.unitFee.value };
+  const qty = BigInt(quantity);
+  const value = qty * (data.unitPrice + data.unitFee);
+  let gas = FALLBACK_GAS_BASE + FALLBACK_GAS_PER_TOKEN * qty;
+  const open = detail.phase === DROP_PHASE.PRESALE || detail.phase === DROP_PHASE.PUBLIC_SALE;
+  if (open && ineligible === null && native >= value) {
+    try {
+      const estimated = await io(
+        ctx,
+        () => ctx.client.estimateGas({ account: payer, to: _viem.getAddress.call(void 0, config.stacks), data: encodePurchase(config, recipient, qty, data), value })
+      );
+      gas = estimated;
+    } catch (e) {
+      if (isAbortError(e)) throw e;
     }
-  } 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 === import_viem5.zeroAddress ? null : (0, import_viem5.getAddress)(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,
+    walletMinted: minted,
     walletMax,
     allowlistRemaining,
     maxQuantity,
     ineligible,
-    balances: { native, erc20 },
-    gasReserve: gasPrice * gasUnits,
+    balances: { native, erc20: null },
+    gasReserve: gas * gasPrice,
     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 = (0, import_viem5.getAddress)(attempt.recipient);
-  const payer = (0, import_viem5.getAddress)(attempt.payer);
-  let data = wallet.data;
-  if (!isWalletData(data) || !sameClaim(data.config, config) || data.recipient !== recipient) {
-    const drop = (await loadDrop(ctx, config)).drop;
-    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 = (0, import_viem5.getAddress)(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);
+function encodePurchase(config, recipient, quantity, data) {
+  return _viem.encodeFunctionData.call(void 0, {
+    abi: stacksAbi,
+    functionName: "purchase",
+    args: [_viem.getAddress.call(void 0, config.nftContract), _viem.getAddress.call(void 0, recipient), quantity, data.presaleNumberCanMint, [...data.proof]]
+  });
+}
+function walletData(wallet) {
+  const d = wallet.data;
+  if (!d || typeof d.presaleNumberCanMint !== "bigint" || typeof d.unitPrice !== "bigint" || typeof d.unitFee !== "bigint" || !Array.isArray(d.proof)) {
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("RPC_ERROR", "The wallet read is missing the data this mint needs. Reload and try again.");
   }
-  const qty = BigInt(quantity);
-  const erc20 = claim.erc20 === import_viem5.zeroAddress ? null : (0, import_viem5.getAddress)(claim.erc20);
-  const cost = claim.cost * qty;
-  const value = fee * qty + (erc20 ? 0n : cost);
-  let approve = null;
-  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: (0, import_viem5.encodeFunctionData)({ abi: ERC20_ABI, functionName: "approve", args: [extension, cost] }), value: 0n }
-      };
-    }
+  return d;
+}
+async function buildPlan(ctx, attempt, wallet) {
+  const { config, recipient } = attempt;
+  validateTlStacksConfig(config);
+  throwIfAborted(ctx);
+  if (!Number.isInteger(attempt.quantity) || attempt.quantity < 1) {
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", "Choose at least one token to mint.");
   }
+  const data = walletData(wallet);
+  const qty = BigInt(attempt.quantity);
   return {
-    approve,
+    approve: null,
     mint: {
-      to: extension,
-      data: (0, import_viem5.encodeFunctionData)({
-        abi: EXTENSION_COMMON_ABI,
-        functionName: "mintProxy",
-        args: [creator, instanceId, quantity, mintIndices, merkleProofs.map((p) => [...p]), recipient]
-      }),
-      value
+      to: _viem.getAddress.call(void 0, config.stacks),
+      data: encodePurchase(config, recipient, qty, data),
+      value: qty * (data.unitPrice + data.unitFee)
     },
-    tokenContract: creator
+    tokenContract: _viem.getAddress.call(void 0, config.nftContract)
   };
 }
-var RELAY_VERIFIED = ["V6", "V7"];
-var manifoldClaimAdapter = {
-  supportsRelay: (drop) => {
-    const resolved = dropResolved.get(drop);
-    return resolved !== void 0 && RELAY_VERIFIED.includes(resolved.entry.generation) && drop.paymentToken === null;
-  },
-  readDrop: async (ctx, config) => (await loadDrop(ctx, config)).drop,
-  readWallet: loadWallet,
-  buildPlan,
-  simulate: async (ctx, attempt, plan) => {
-    try {
-      await ctx.client.call({ account: (0, import_viem5.getAddress)(attempt.payer), to: plan.mint.to, data: plan.mint.data, value: plan.mint.value });
-    } catch (e) {
-      const text2 = decodeRevert(e);
-      if (text2 === null) throw toRpcError(e);
-      throw new MintError("SIMULATION_REVERTED", text2, { cause: e });
+var TL_MESSAGES = {
+  NotOnAllowlist: "This wallet is not on the allowlist for the current sale.",
+  YouShallNotMint: "This drop is not open for minting right now.",
+  AlreadyReachedMintAllowance: "This wallet has already minted its limit.",
+  InsufficientFunds: "The price or fee changed since the page loaded, so the payment is too low. Reload the page and try again.",
+  MintZeroTokens: "Choose at least one token to mint.",
+  SanctionedAddress: "This wallet or the recipient is blocked by a sanctions check, so it cannot mint.",
+  EnforcedPause: "Minting is paused by Transient Labs right now. Try again later."
+};
+function revertData(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;
   }
-};
-
-// src/core/adapters/contract/index.ts
-var import_viem7 = require("viem");
-
-// src/core/machine.ts
-var import_viem6 = require("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,
-    crossChain: false,
-    routePending: false,
-    route: null,
-    short: null
-  };
+  return null;
 }
-var NO_ROUTE = { crossChain: false, routePending: false, route: null, short: null };
-var PICK_ANOTHER = "Pick another network to pay from.";
-function toQuantity(q, max) {
-  if (Number.isNaN(q)) return 1;
-  return Math.max(1, Math.min(Math.floor(q), max));
-}
-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 };
-  }
-  if (s.routePending) return named("loading");
-  if (s.route?.kind === "relay") return named("live");
-  if (s.short !== null) {
-    return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${s.short.symbol} on ${s.short.name}. ${PICK_ANOTHER}` };
-  }
-  const total = selectTotal(s);
-  if (total !== null) {
-    const { native, erc20 } = total;
-    if (native.value + walletRead.gasReserve > walletRead.balances.native) {
-      const more = s.crossChain ? ` ${PICK_ANOTHER}` : "";
-      return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${native.symbol} to cover the mint.${more}` };
-    }
-    if (erc20 !== null && walletRead.balances.erc20 !== null && erc20.value > walletRead.balances.erc20) {
-      return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${erc20.symbol} to cover the mint.` };
+function decodeTlRevert(e) {
+  if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e)) return e;
+  if (isAbortError(e)) throw e;
+  if (e instanceof _viem.BaseError && e.walk((x) => x instanceof _viem.InsufficientFundsError)) {
+    return new (0, _chunkGO4TR3HBcjs.MintError)("INSUFFICIENT_FUNDS", `The wallet cannot cover the mint: ${e.shortMessage}`, { cause: e });
+  }
+  const data = revertData(e);
+  if (data) {
+    try {
+      const { errorName, args } = _viem.decodeErrorResult.call(void 0, { abi: stacksAbi, data });
+      const known = TL_MESSAGES[errorName];
+      if (known) return new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", known, { cause: e, domain: "tl-stacks" });
+      const shown = (_nullishCoalesce(args, () => ( []))).map(String).join(", ");
+      return new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", `Transient Labs rejected the mint (${errorName}(${shown})).`, { cause: e, domain: "tl-stacks" });
+    } catch (e3) {
+      return new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", `Transient Labs rejected the mint (unrecognized error ${data.slice(0, 10)}).`, { cause: e, domain: "tl-stacks" });
     }
   }
-  return named("live");
-}
-function settle(s, unsupported = s.name === "unsupported") {
-  if (!isIdle(s)) return s;
-  return { ...s, ...derive(s, unsupported) };
+  const reverted = e instanceof _viem.BaseError && e.walk((x) => x.code === 3 || /execution reverted/i.test(x.message));
+  if (reverted) return new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", shortMessage(e), { cause: e });
+  return new (0, _chunkGO4TR3HBcjs.MintError)("RPC_ERROR", `RPC request failed: ${shortMessage(e)}`, { cause: e });
 }
-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, ...NO_ROUTE, readGen: event.gen, drop: null, walletRead: null, blocked: null, walletGen: state.walletGen + 1 };
-      return inFlight ? { ...next, pendingRefresh: true } : settle(next, false);
-    }
-    case "DROP_LOADED": {
-      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, ...NO_ROUTE, account: event.account, walletRead: null, blocked: null, walletGen: state.walletGen + 1 };
-      if (inFlight) return { ...next, pendingRefresh: true };
-      if (state.name === "connecting") return event.account === null ? next : settle({ ...next, name: "loading" }, false);
-      return settle(next);
-    }
-    case "WALLET_LOADED": {
-      if (event.gen !== state.walletGen) return state;
-      const route = event.routePending ? { routePending: state.route === null && state.short === null, route: state.route, short: state.short } : { routePending: false, route: null, short: null };
-      const next = { ...state, ...route, crossChain: event.crossChain ?? false, walletRead: event.read, blocked: null };
-      return inFlight ? { ...next, pendingRefresh: true } : settle(clampQuantity(next));
-    }
-    case "ROUTE_LOADED": {
-      if (event.gen !== state.walletGen) return state;
-      const next = { ...state, routePending: false, route: event.route, short: event.short };
-      return inFlight ? { ...next, pendingRefresh: true } : settle(next);
-    }
-    case "WALLET_FAILED":
-      return event.gen !== state.walletGen ? state : failed(event.reason, event.message);
-    case "CONNECT_STARTED":
-      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":
-      if (state.attempt !== null) return state;
-      if (event.resume === true) return IN_FLIGHT_STATES.includes(state.name) ? state : { ...state, attempt: event.attempt };
-      return state.name === "live" ? { ...state, attempt: event.attempt } : state;
-    case "SWITCHING_CHAIN":
-      return step(state, event.attemptId, "switching-chain");
-    case "APPROVING":
-      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,
-        ...NO_ROUTE,
-        walletRead: null,
-        blocked: null,
-        walletGen: state.walletGen + 1,
-        result: null,
-        pendingRefresh: false
-      };
-      return settle(clampQuantity({ ...next, name: "loading" }), false);
-    }
+async function simulate(ctx, attempt, plan) {
+  throwIfAborted(ctx);
+  try {
+    await io(ctx, () => ctx.client.call({ account: attempt.payer, to: plan.mint.to, data: plan.mint.data, value: plan.mint.value }));
+  } catch (e) {
+    throw decodeTlRevert(e);
   }
 }
-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)
-    };
+var tlStacksAdapter = { readDrop, readWallet, buildPlan, simulate };
+
+// src/core/relay/outstanding.ts
+var memory = /* @__PURE__ */ new Map();
+var claimed = /* @__PURE__ */ new Set();
+function targetOf(config) {
+  switch (config.type) {
+    case "manifold-claim":
+      return `${config.creatorContract.toLowerCase()}:${config.instanceId}`;
+    case "contract":
+      return config.address.toLowerCase();
+    case "tl-stacks":
+      return `stacks:${config.nftContract.toLowerCase()}`;
+    default: {
+      const unreachable = config;
+      return unreachable;
+    }
   }
-  return { native: money2(priceTotal + fee.value * q, price), erc20: null };
 }
-function money2(value, like) {
-  return { value, decimals: like.decimals, symbol: like.symbol, formatted: (0, import_viem6.formatUnits)(value, like.decimals) };
+function outstandingKey(config, payer) {
+  return `${String(config.chainId)}:${targetOf(config)}:${payer.toLowerCase()}`;
 }
-function canAct(state) {
-  return state.attempt === null && CLICKABLE_STATES.includes(state.name);
+var getOutstanding = (key) => _nullishCoalesce(memory.get(key), () => ( null));
+var setOutstanding = (key, out) => void memory.set(key, out);
+var clearOutstanding = (key) => void memory.delete(key);
+function claimDeposit(key) {
+  if (claimed.has(key) || memory.has(key)) return false;
+  claimed.add(key);
+  return true;
 }
+var releaseDeposit = (key) => void claimed.delete(key);
 
 // src/core/adapters/contract/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
 var PLACEHOLDERS = ["{recipient}", "{payer}", "{quantity}", "{unitPrice}", "{totalPrice}"];
-var ERC20_ABI2 = (0, import_viem7.parseAbi)([
+var ERC20_ABI = _viem.parseAbi.call(void 0, [
   "function symbol() view returns (string)",
   "function decimals() view returns (uint8)",
   "function balanceOf(address) view returns (uint256)",
@@ -1423,32 +880,32 @@ 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 });
+function bad2(field, message) {
+  throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `${field} ${message}`, { field });
 }
-var isHexAddress = (a) => typeof a === "string" && (0, import_viem7.isAddress)(a, { strict: false });
+var isHexAddress = (a) => typeof a === "string" && _viem.isAddress.call(void 0, 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`);
+    for (const token of _nullishCoalesce(t.match(PLACEHOLDER_TOKEN), () => ( []))) {
+      if (!PLACEHOLDERS.includes(token)) bad2(path, `"${t}" is not a known placeholder (${token})`);
+      if (!allowed.includes(token)) bad2(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`);
+    if (!Number.isSafeInteger(t)) bad2(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");
+    bad2(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;
+var hasPlaceholder = (t) => typeof t === "string" && (_nullishCoalesce(t.match(PLACEHOLDER_TOKEN), () => ( []))).length > 0;
 function intBounds(type) {
   const m = INT_TYPE.exec(type);
   if (!m) return null;
@@ -1456,7 +913,7 @@ function intBounds(type) {
   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 ?? [];
+var componentsOf = (p) => _nullishCoalesce(p.components, () => ( []));
 function typeIssue(t, p, path) {
   const no = (message) => ({ path, message });
   const arr = ARRAY_TYPE.exec(p.type);
@@ -1483,7 +940,7 @@ function typeIssue(t, p, path) {
   if (Array.isArray(t)) return no(`must not be an array for ${p.type}`);
   if (p.type === "address") {
     if (isExactPlaceholder(t)) return t === "{recipient}" || t === "{payer}" ? null : no(`${t} is a number, but the abi input is an address`);
-    return typeof t === "string" && !hasPlaceholder(t) && (0, import_viem7.isAddress)(t) ? null : no(`${JSON.stringify(String(t))} is not an address`);
+    return typeof t === "string" && !hasPlaceholder(t) && _viem.isAddress.call(void 0, 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`);
@@ -1507,17 +964,17 @@ function typeIssue(t, p, path) {
 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 c = _nullishCoalesce(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 ?? [];
+  if (named.length === 0) bad2(`${prefix}.functionName`, `"${String(c.functionName)}" is not a function in the abi`);
+  if (c.args !== void 0 && !Array.isArray(c.args)) bad2(`${prefix}.args`, "must be an array");
+  if (kind === "mint" && c.args === void 0) bad2(`${prefix}.args`, "is required");
+  const args = _nullishCoalesce(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}`);
+    bad2(`${prefix}.args`, `has ${args.length} argument(s) but "${String(c.functionName)}" takes ${want}`);
   }
   const checked = sameArity.map((f) => {
     let issue = null;
@@ -1527,75 +984,75 @@ function validateCall(abi, call, prefix, kind, allowed) {
   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}`);
+    if (sameArity.length === 1) bad2(first.path, first.message);
+    bad2(`${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 (kind === "read") bad2(`${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`);
+      bad2(`${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`);
+    bad2(`${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`);
+    bad2(`${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`);
+  if (outs.length === 0) bad2(`${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 members = tuple ? _nullishCoalesce(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})`);
+    if (members.length !== 1) bad2(`${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})`);
+      bad2(`${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})`);
+    if (index < 0) bad2(`${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");
+    return bad2(`${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`);
+    if (output === void 0) bad2(`${path}.functionName`, `"${fn.name}" ${reason}`);
+    bad2(`${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 }");
+  if (typeof src !== "object" || src === null) bad2(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 && hasValue) bad2(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");
+    if (typeof s.read !== "object" || s.read === null) bad2(`${name}.read`, "must be { functionName, args?, output? }");
+    if (s.unit !== void 0) bad2(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");
+    if (s.unit !== void 0) bad2(name, "unit is only valid with a string value");
+    if (s.value < 0n) bad2(`${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"`);
+    if (s.unit !== "display") bad2(name, 'string values need unit: "display"');
+    if (!isPrice) bad2(name, "display units are only valid for price; use a bigint in base units");
+    if (!DISPLAY_AMOUNT.test(s.value)) bad2(`${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: {...} }');
+    bad2(name, 'must be { value: bigint }, { value: string, unit: "display" } (price only) or { read: {...} }');
   }
 }
 function hasNonzeroStaticPrice(price) {
@@ -1605,27 +1062,27 @@ function hasNonzeroStaticPrice(price) {
 }
 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 || typeof c !== "object") bad2("config", "must be an object");
+  if (c.type !== "contract") bad2("type", 'must be "contract"');
+  if (!Number.isSafeInteger(c.chainId) || c.chainId <= 0) bad2("chainId", "must be a positive safe integer");
+  if (!isHexAddress(c.address)) bad2("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`);
+    bad2("tokenContract", `"${String(c.tokenContract)}" is not a valid address`);
   }
-  if (!Array.isArray(c.abi)) bad("abi", "must be an abi array");
+  if (!Array.isArray(c.abi)) bad2("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");
+  if (c.price === void 0 || c.price === null) bad2("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');
+    bad2("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`);
+    bad2("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"');
+  if (per !== void 0 && per !== "unit" && per !== "total") bad2("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);
@@ -1639,8 +1096,8 @@ function validateOptional(abi, name, src, allowed) {
 function varFor(token, vars) {
   const key = token.slice(1, -1);
   const v = vars[key];
-  if (v === void 0) throw new MintError("INVALID_CONFIG", `placeholder ${token} has no value here`);
-  return typeof v === "string" ? (0, import_viem7.getAddress)(v) : v;
+  if (v === void 0) throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `placeholder ${token} has no value here`);
+  return typeof v === "string" ? _viem.getAddress.call(void 0, v) : v;
 }
 function fill(t, p, vars) {
   const arr = ARRAY_TYPE.exec(p.type);
@@ -1653,48 +1110,48 @@ function fill(t, p, 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 fillArgs = (args, inputs, vars) => (_nullishCoalesce(args, () => ( []))).map((a, i) => fill(a, inputs[i], vars));
 var totalFor = (per, price, quantity) => per === "total" ? price : price * quantity;
-function shortMessage(e) {
-  return e instanceof import_viem7.BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
+function shortMessage2(e) {
+  return e instanceof _viem.BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
 }
-var abortError = () => new DOMException("The operation was aborted", "AbortError");
-var isAbortError = (e) => e?.name === "AbortError";
-function throwIfAborted(ctx) {
-  if (ctx.signal?.aborted) throw abortError();
+var abortError2 = () => new DOMException("The operation was aborted", "AbortError");
+var isAbortError2 = (e) => _optionalChain([e, 'optionalAccess', _30 => _30.name]) === "AbortError";
+function throwIfAborted2(ctx) {
+  if (_optionalChain([ctx, 'access', _31 => _31.signal, 'optionalAccess', _32 => _32.aborted])) throw abortError2();
 }
-function io(ctx, start) {
+function io2(ctx, start) {
   const signal = ctx.signal;
   if (!signal) return start();
-  if (signal.aborted) return Promise.reject(abortError());
+  if (signal.aborted) return Promise.reject(abortError2());
   return new Promise((resolve, reject) => {
-    const onAbort = () => reject(abortError());
+    const onAbort = () => reject(abortError2());
     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 rpcError2(e) {
+  if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e) || isAbortError2(e)) throw e;
+  throw new (0, _chunkGO4TR3HBcjs.MintError)("RPC_ERROR", `RPC request failed: ${shortMessage2(e)}`, { cause: e });
 }
 function classifyReadError(e, field) {
-  if (isMintError(e) || isAbortError(e)) throw e;
-  if (e instanceof import_viem7.BaseError && e.walk((x) => x instanceof import_viem7.ContractFunctionRevertedError || x instanceof import_viem7.ContractFunctionZeroDataError)) {
-    throw new MintError("INVALID_CONFIG", `${field} read reverted or returned no data: ${e.shortMessage}`, { field, cause: e });
+  if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e) || isAbortError2(e)) throw e;
+  if (e instanceof _viem.BaseError && e.walk((x) => x instanceof _viem.ContractFunctionRevertedError || x instanceof _viem.ContractFunctionZeroDataError)) {
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `${field} read reverted or returned no data: ${e.shortMessage}`, { field, cause: e });
   }
-  return rpcError(e);
+  return rpcError2(e);
 }
 async function readCall(ctx, params, field) {
   try {
-    return await io(ctx, () => ctx.client.readContract(params));
+    return await io2(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 });
+  if (typeof n !== "bigint") throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `${field} did not return a number`, { field });
+  if (n < 0n) throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `${field} returned a negative number`, { field });
   return n;
 }
 async function readField(ctx, config, name, src, vars) {
@@ -1710,58 +1167,58 @@ async function readField(ctx, config, name, src, vars) {
   }
   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 });
+  throw new (0, _chunkGO4TR3HBcjs.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 comps = _nullishCoalesce(fn.outputs[0].components, () => ( []));
   const out = [];
-  out[index] = res[comps[index]?.name ?? ""];
+  out[index] = res[_nullishCoalesce(_optionalChain([comps, 'access', _33 => _33[index], 'optionalAccess', _34 => _34.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 });
+  if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new (0, _chunkGO4TR3HBcjs.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" };
+function nativeMeta2(ctx) {
+  const n = _optionalChain([ctx, 'access', _35 => _35.client, 'access', _36 => _36.chain, 'optionalAccess', _37 => _37.nativeCurrency]);
+  return { decimals: _nullishCoalesce(_optionalChain([n, 'optionalAccess', _38 => _38.decimals]), () => ( 18)), symbol: _nullishCoalesce(_optionalChain([n, 'optionalAccess', _39 => _39.symbol]), () => ( "ETH")) };
 }
-var erc20Of = (config) => config.price.currency === "native" ? null : (0, import_viem7.getAddress)(config.price.currency.address);
+var erc20Of = (config) => config.price.currency === "native" ? null : _viem.getAddress.call(void 0, config.price.currency.address);
 async function currencyMeta(ctx, config) {
   const token = erc20Of(config);
-  if (!token) return { token, ...nativeMeta(ctx) };
+  if (!token) return { token, ...nativeMeta2(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)
+    readCall(ctx, { address: token, abi: ERC20_ABI, functionName: "symbol" }, field),
+    readCall(ctx, { address: token, abi: ERC20_ABI, 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 });
+    throw new (0, _chunkGO4TR3HBcjs.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] ?? "";
+  const frac = _nullishCoalesce(value.split(".")[1], () => ( ""));
   if (frac.length > decimals) {
-    throw new MintError("INVALID_CONFIG", `price.value "${value}" has more than ${decimals} decimal places`, { field: "price.value" });
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `price.value "${value}" has more than ${decimals} decimal places`, { field: "price.value" });
   }
-  return (0, import_viem7.parseUnits)(value, decimals);
+  return _viem.parseUnits.call(void 0, 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);
+  return parseDisplay(value, (await _asyncNullishCoalesce(meta, async () => ( await currencyMeta(ctx, config)))).decimals);
 }
-var money3 = (value, decimals, symbol) => ({
+var money2 = (value, decimals, symbol) => ({
   value,
   decimals,
   symbol,
-  formatted: (0, import_viem7.formatUnits)(value, decimals)
+  formatted: _viem.formatUnits.call(void 0, value, decimals)
 });
 function revertData2(e) {
   for (let cur = e, depth = 0; cur && depth < 12; depth++) {
@@ -1777,31 +1234,31 @@ function revertData2(e) {
 }
 function describeRevert(abi, data) {
   try {
-    const d = (0, import_viem7.decodeErrorResult)({ abi, data });
-    const args = d.args ?? [];
-    if (d.errorName === "Error") return String(args[0] ?? "execution reverted");
-    const inputs = d.abiItem?.inputs ?? [];
-    const shown = args.map((a, i) => inputs[i]?.name ? `${inputs[i].name}: ${String(a)}` : String(a));
+    const d = _viem.decodeErrorResult.call(void 0, { abi, data });
+    const args = _nullishCoalesce(d.args, () => ( []));
+    if (d.errorName === "Error") return String(_nullishCoalesce(args[0], () => ( "execution reverted")));
+    const inputs = _nullishCoalesce(_optionalChain([d, 'access', _40 => _40.abiItem, 'optionalAccess', _41 => _41.inputs]), () => ( []));
+    const shown = args.map((a, i) => _optionalChain([inputs, 'access', _42 => _42[i], 'optionalAccess', _43 => _43.name]) ? `${inputs[i].name}: ${String(a)}` : String(a));
     return `${d.errorName}(${shown.join(", ")})`;
-  } catch {
+  } catch (e4) {
     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 import_viem7.BaseError && e.walk((x) => x instanceof import_viem7.InsufficientFundsError)) {
-    return new MintError("INSUFFICIENT_FUNDS", `Payer cannot cover the mint: ${e.shortMessage}`, { cause: e });
+  if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e)) return e;
+  if (isAbortError2(e)) throw e;
+  if (e instanceof _viem.BaseError && e.walk((x) => x instanceof _viem.InsufficientFundsError)) {
+    return new (0, _chunkGO4TR3HBcjs.MintError)("INSUFFICIENT_FUNDS", `Payer cannot cover the mint: ${e.shortMessage}`, { cause: e });
   }
   const data = revertData2(e);
-  if (data) return new MintError("SIMULATION_REVERTED", describeRevert(abi, data), { cause: e });
-  const isRevert = e instanceof import_viem7.BaseError && e.walk((x) => x.code === 3 || /execution reverted/i.test(x.message));
-  if (isRevert) return new MintError("SIMULATION_REVERTED", shortMessage(e), { cause: e });
-  return new MintError("RPC_ERROR", `RPC request failed: ${shortMessage(e)}`, { cause: e });
+  if (data) return new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", describeRevert(abi, data), { cause: e });
+  const isRevert = e instanceof _viem.BaseError && e.walk((x) => x.code === 3 || /execution reverted/i.test(x.message));
+  if (isRevert) return new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", shortMessage2(e), { cause: e });
+  return new (0, _chunkGO4TR3HBcjs.MintError)("RPC_ERROR", `RPC request failed: ${shortMessage2(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 }));
+    await io2(ctx, () => ctx.client.call({ account: call.payer, to: call.to, data: call.data, value: call.value }));
   } catch (e) {
     throw toSimulationError(e, config.abi);
   }
@@ -1809,24 +1266,24 @@ async function simulateMint(ctx, config, call) {
 function encodeMint(config, vars) {
   const fn = validateCall(config.abi, config.mint, "mint", "mint", PLACEHOLDERS);
   try {
-    return (0, import_viem7.encodeFunctionData)({ abi: [fn], functionName: fn.name, args: fillArgs(config.mint.args, fn.inputs, vars) });
+    return _viem.encodeFunctionData.call(void 0, { 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 });
+    if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e)) throw e;
+    throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `mint.args cannot be encoded for ${signature(fn)}: ${shortMessage2(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`);
+    if (totalPrice > 0n) bad2("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) {
+async function readDrop2(ctx, config) {
   validateContractConfig(config);
-  throwIfAborted(ctx);
+  throwIfAborted2(ctx);
   const meta = await currencyMeta(ctx, config);
   const none = {};
   const [price, totalMinted, maxSupply, start, end] = await Promise.all([
@@ -1837,23 +1294,23 @@ async function readDrop(ctx, config) {
     optField(ctx, config, "endTime", config.endTime, none)
   ]);
   mintValue(config, meta.token, price);
-  const native = nativeMeta(ctx);
+  const native = nativeMeta2(ctx);
   return {
     chainId: config.chainId,
-    unitPrice: money3(price, meta.decimals, meta.symbol),
-    unitFee: money3(0n, native.decimals, native.symbol),
-    totalMinted: totalMinted ?? 0n,
+    unitPrice: money2(price, meta.decimals, meta.symbol),
+    unitFee: money2(0n, native.decimals, native.symbol),
+    totalMinted: _nullishCoalesce(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"
+    pricePer: _nullishCoalesce(config.price.per, () => ( "unit"))
   };
 }
-async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
+async function readWallet2(ctx, config, { payer, recipient, quantity, drop }) {
   validateContractConfig(config);
-  throwIfAborted(ctx);
+  throwIfAborted2(ctx);
   const qty = BigInt(quantity);
   const unitPrice = drop.unitPrice.value;
   const totalPrice = totalFor(drop.pricePer, unitPrice, qty);
@@ -1861,32 +1318,32 @@ async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
   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(
+    io2(ctx, () => ctx.client.getBalance({ address: payer })).catch(rpcError2),
+    drop.paymentToken ? readCall(ctx, { address: drop.paymentToken, abi: ERC20_ABI, 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));
+  const remaining = walletMax === null ? null : walletMax > (_nullishCoalesce(walletMinted, () => ( 0n))) ? walletMax - (_nullishCoalesce(walletMinted, () => ( 0n))) : 0n;
+  const maxQuantity = remaining === null ? null : Number(remaining < BigInt(_chunkGO4TR3HBcjs.MAX_QUANTITY) ? remaining : BigInt(_chunkGO4TR3HBcjs.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: (0, import_viem7.getAddress)(config.address), data: encodeMint(config, vars), value: mintValue(config, null, totalPrice) };
+    const call = { payer, to: _viem.getAddress.call(void 0, 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) => {
+      gas = await io2(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;
+      if (!_chunkGO4TR3HBcjs.isMintError.call(void 0, 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);
+  const gasPrice = await io2(ctx, () => ctx.client.getGasPrice()).catch(rpcError2);
   return {
     walletMinted,
     walletMax,
@@ -1901,11 +1358,11 @@ async function buildPlan2(ctx, attempt, wallet) {
   void wallet;
   const { config, payer, recipient } = attempt;
   validateContractConfig(config);
-  throwIfAborted(ctx);
+  throwIfAborted2(ctx);
   const qty = BigInt(attempt.quantity);
   const unitPrice = await resolvePrice(ctx, config);
-  const totalPrice = totalFor(config.price.per ?? "unit", unitPrice, qty);
-  const to = (0, import_viem7.getAddress)(config.address);
+  const totalPrice = totalFor(_nullishCoalesce(config.price.per, () => ( "unit")), unitPrice, qty);
+  const to = _viem.getAddress.call(void 0, config.address);
   const token = erc20Of(config);
   const mint = {
     to,
@@ -1915,7 +1372,7 @@ async function buildPlan2(ctx, attempt, wallet) {
   let approve = null;
   if (token) {
     const allowance = toBigInt(
-      await readCall(ctx, { address: token, abi: ERC20_ABI2, functionName: "allowance", args: [payer, to] }, "price.currency.address"),
+      await readCall(ctx, { address: token, abi: ERC20_ABI, functionName: "allowance", args: [payer, to] }, "price.currency.address"),
       "price.currency.address"
     );
     if (allowance < totalPrice) {
@@ -1923,134 +1380,17 @@ async function buildPlan2(ctx, attempt, wallet) {
         token,
         spender: to,
         amount: totalPrice,
-        tx: { to: token, data: (0, import_viem7.encodeFunctionData)({ abi: ERC20_ABI2, functionName: "approve", args: [to, totalPrice] }), value: 0n }
+        tx: { to: token, data: _viem.encodeFunctionData.call(void 0, { abi: ERC20_ABI, functionName: "approve", args: [to, totalPrice] }), value: 0n }
       };
     }
   }
-  return { approve, mint, tokenContract: (0, import_viem7.getAddress)(attempt.tokenContract) };
+  return { approve, mint, tokenContract: _viem.getAddress.call(void 0, attempt.tokenContract) };
 }
-async function simulate(ctx, attempt, plan) {
-  throwIfAborted(ctx);
+async function simulate2(ctx, attempt, plan) {
+  throwIfAborted2(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
-var import_viem8 = require("viem");
-var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
-var TRANSFER_SINGLE_TOPIC = "0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62";
-var TRANSFER_BATCH_TOPIC = "0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb";
-var topicAddress = (t) => t && t.length === 66 ? (0, import_viem8.getAddress)(`0x${t.slice(26)}`) : null;
-function parseMintReceipt(logs, { tokenContract, recipient }) {
-  const contract = (0, import_viem8.getAddress)(tokenContract);
-  const to = (0, import_viem8.getAddress)(recipient);
-  const out = /* @__PURE__ */ new Map();
-  const add = (id, amount) => out.set(id, (out.get(id) ?? 0n) + amount);
-  for (const log of logs) {
-    if ((0, import_viem8.getAddress)(log.address) !== contract) continue;
-    const [t0, t1, t2, t3] = log.topics;
-    if (t0 === TRANSFER_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t1) !== import_viem8.zeroAddress || topicAddress(t2) !== to || !t3) continue;
-      add(BigInt(t3), 1n);
-    } else if (t0 === TRANSFER_SINGLE_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t2) !== import_viem8.zeroAddress || topicAddress(t3) !== to) continue;
-      const [id, value] = (0, import_viem8.decodeAbiParameters)([{ type: "uint256" }, { type: "uint256" }], log.data);
-      add(id, value);
-    } else if (t0 === TRANSFER_BATCH_TOPIC && log.topics.length === 4) {
-      if (topicAddress(t2) !== import_viem8.zeroAddress || topicAddress(t3) !== to) continue;
-      const [ids, values] = (0, import_viem8.decodeAbiParameters)([{ type: "uint256[]" }, { type: "uint256[]" }], log.data);
-      if (ids.length !== values.length) continue;
-      ids.forEach((id, i) => add(id, values[i]));
-    }
-  }
-  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.domain === "relay") return error.message;
-    if (error.reason === "SIMULATION_REVERTED" && (error.message === "The token refused the approval." || error.message === "The drop is no longer available for this quantity.")) return error.message;
-  }
-  const errors = collect(error);
-  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;
-}
+var contractAdapter = { readDrop: readDrop2, readWallet: readWallet2, buildPlan: buildPlan2, simulate: simulate2 };
 
 // src/react/useMint.ts
 var REFRESH_MS = 3e4;
@@ -2064,7 +1404,18 @@ 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;
+  switch (config.type) {
+    case "manifold-claim":
+      return _chunkGO4TR3HBcjs.manifoldClaimAdapter;
+    case "contract":
+      return contractAdapter;
+    case "tl-stacks":
+      return tlStacksAdapter;
+    default: {
+      const unreachable = config;
+      return unreachable;
+    }
+  }
 }
 var bridgeEnabled = (config) => config.type === "manifold-claim";
 function payChainsOf(config, option) {
@@ -2080,87 +1431,93 @@ function routeChainOf(payChains, accountChainId, payChainId) {
 var ROUTE_DEBOUNCE_MS = 500;
 var symbolOf = (chainId) => {
   try {
-    return getChain(chainId).nativeCurrency.symbol;
-  } catch {
+    return _chunkGO4TR3HBcjs.getChain.call(void 0, chainId).nativeCurrency.symbol;
+  } catch (e5) {
     return "ETH";
   }
 };
-var shortOf = (chainId) => ({ chainId, symbol: symbolOf(chainId), name: chainName(chainId) });
+var shortOf = (chainId) => ({ chainId, symbol: symbolOf(chainId), name: _chunkGO4TR3HBcjs.chainName.call(void 0, chainId) });
 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;
+  switch (config.type) {
+    case "manifold-claim":
+      return config.creatorContract;
+    case "contract":
+      return _nullishCoalesce(config.tokenContract, () => ( config.address));
+    case "tl-stacks":
+      return config.nftContract;
+    default: {
+      const unreachable = config;
+      return unreachable;
+    }
   }
-  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;
+function eventAddressOf(config) {
+  switch (config.type) {
+    case "manifold-claim":
+      return config.creatorContract;
+    case "contract":
+      return config.address;
+    case "tl-stacks":
+      return config.nftContract;
+    default: {
+      const unreachable = config;
+      return unreachable;
+    }
   }
-  return { reason: "RPC_ERROR", message: friendlyErrorMessage(e) };
 }
+var isUnsupported = (reason) => _chunkGO4TR3HBcjs.UNSUPPORTED_REASONS.includes(reason);
 function errorReasonOf(e) {
-  const { reason, message } = toReason(e);
+  const { reason, message } = _chunkGO4TR3HBcjs.toReason.call(void 0, 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;
+    const url = _optionalChain([_chunkGO4TR3HBcjs.getChain.call(void 0, chainId), 'access', _44 => _44.blockExplorers, 'optionalAccess', _45 => _45.default, 'access', _46 => _46.url]);
     return url ? `${url.replace(/\/$/, "")}/tx/${hash}` : null;
-  } catch {
+  } catch (e6) {
     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] = (0, import_react.useReducer)(reducer, void 0, () => initialState({ quantity: quantityProp }));
-  const [widgetFail, setWidgetFail] = (0, import_react.useState)(null);
-  const [widgetRetry, setWidgetRetry] = (0, import_react.useState)(0);
+  const [machine, rawDispatch] = _react.useReducer.call(void 0, _chunkGO4TR3HBcjs.reducer, void 0, () => _chunkGO4TR3HBcjs.initialState.call(void 0, { quantity: quantityProp }));
+  const [widgetFail, setWidgetFail] = _react.useState.call(void 0, null);
+  const [widgetRetry, setWidgetRetry] = _react.useState.call(void 0, 0);
   const configKey = configKeyOf(config);
-  const mounted = (0, import_react.useRef)(false);
-  const stateRef = (0, import_react.useRef)(machine);
-  const propsRef = (0, import_react.useRef)(options);
-  const lifeRef = (0, import_react.useRef)(null);
-  const genRef = (0, import_react.useRef)(0);
-  const attemptRef = (0, import_react.useRef)(null);
-  const attemptIdRef = (0, import_react.useRef)(0);
-  const accountKeyRef = (0, import_react.useRef)(null);
-  const connectingRef = (0, import_react.useRef)(false);
-  const pendingRefreshRef = (0, import_react.useRef)(false);
-  const pendingQuantityRef = (0, import_react.useRef)(null);
-  const widgetFailRef = (0, import_react.useRef)(null);
-  const widgetLoadRef = (0, import_react.useRef)(null);
-  const pushAccountRef = (0, import_react.useRef)(null);
-  const autoResumedRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
-  const [crossChainInfo, setCrossChainInfo] = (0, import_react.useState)(null);
-  (0, import_react.useEffect)(() => {
+  const mounted = _react.useRef.call(void 0, false);
+  const stateRef = _react.useRef.call(void 0, machine);
+  const propsRef = _react.useRef.call(void 0, options);
+  const lifeRef = _react.useRef.call(void 0, null);
+  const genRef = _react.useRef.call(void 0, 0);
+  const attemptRef = _react.useRef.call(void 0, null);
+  const attemptIdRef = _react.useRef.call(void 0, 0);
+  const accountKeyRef = _react.useRef.call(void 0, null);
+  const connectingRef = _react.useRef.call(void 0, false);
+  const pendingRefreshRef = _react.useRef.call(void 0, false);
+  const pendingQuantityRef = _react.useRef.call(void 0, null);
+  const widgetFailRef = _react.useRef.call(void 0, null);
+  const widgetLoadRef = _react.useRef.call(void 0, null);
+  const pushAccountRef = _react.useRef.call(void 0, null);
+  const autoResumedRef = _react.useRef.call(void 0, /* @__PURE__ */ new Set());
+  const [crossChainInfo, setCrossChainInfo] = _react.useState.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
     stateRef.current = machine;
     propsRef.current = options;
     widgetFailRef.current = widgetFail;
   });
-  const dispatch = (0, import_react.useCallback)((event) => {
+  const dispatch = _react.useCallback.call(void 0, (event) => {
     if (!mounted.current) return;
-    stateRef.current = reducer(stateRef.current, event);
+    stateRef.current = _chunkGO4TR3HBcjs.reducer.call(void 0, stateRef.current, event);
     rawDispatch(event);
   }, []);
-  const emit = (0, import_react.useCallback)((type, over = {}) => {
+  const emit = _react.useCallback.call(void 0, (type, over = {}) => {
     const handler = propsRef.current.onEvent;
     if (!handler || !mounted.current) return;
-    const cfg = attemptRef.current?.config ?? propsRef.current.config;
+    const cfg = _nullishCoalesce(_optionalChain([attemptRef, 'access', _47 => _47.current, 'optionalAccess', _48 => _48.config]), () => ( propsRef.current.config));
     const s = stateRef.current;
-    const originChainId = attemptRef.current?.originChainId ?? (s.route?.kind === "relay" ? s.route.originChainId : s.short?.chainId ?? cfg.chainId);
+    const originChainId = _nullishCoalesce(_optionalChain([attemptRef, 'access', _49 => _49.current, 'optionalAccess', _50 => _50.originChainId]), () => ( (_optionalChain([s, 'access', _51 => _51.route, 'optionalAccess', _52 => _52.kind]) === "relay" ? s.route.originChainId : _nullishCoalesce(_optionalChain([s, 'access', _53 => _53.short, 'optionalAccess', _54 => _54.chainId]), () => ( cfg.chainId)))));
     const payload = {
       type,
       state: s.name,
@@ -2174,18 +1531,18 @@ function useMint(options) {
     };
     try {
       handler(payload);
-    } catch {
+    } catch (e7) {
     }
   }, []);
-  const clientFor = (0, import_react.useCallback)((life, cfg) => {
-    const rpcUrl = propsRef.current.rpcUrls?.[cfg.chainId];
+  const clientFor = _react.useCallback.call(void 0, (life, cfg) => {
+    const rpcUrl = _optionalChain([propsRef, 'access', _55 => _55.current, 'access', _56 => _56.rpcUrls, 'optionalAccess', _57 => _57[cfg.chainId]]);
     if (!life.client || life.rpcUrl !== rpcUrl) {
       life.rpcUrl = rpcUrl;
-      life.client = createReadClient({ chainId: cfg.chainId, rpcUrls: propsRef.current.rpcUrls, useBridge: bridgeEnabled(cfg) });
+      life.client = _chunkGO4TR3HBcjs.createReadClient.call(void 0, { chainId: cfg.chainId, rpcUrls: propsRef.current.rpcUrls, useBridge: bridgeEnabled(cfg) });
     }
     return life.client;
   }, []);
-  const ctxFor = (0, import_react.useCallback)(
+  const ctxFor = _react.useCallback.call(void 0, 
     (life, cfg) => ({
       client: clientFor(life, cfg),
       cacheScope: life.cacheScope,
@@ -2194,7 +1551,7 @@ function useMint(options) {
     }),
     [clientFor]
   );
-  const readDrop2 = (0, import_react.useCallback)(
+  const readDrop3 = _react.useCallback.call(void 0, 
     async (life, gen, cfg) => {
       const adapter = adapterFor(cfg);
       try {
@@ -2203,27 +1560,27 @@ function useMint(options) {
         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);
+        const { reason, message } = _chunkGO4TR3HBcjs.toReason.call(void 0, e);
         if (isUnsupported(reason)) dispatch({ type: "DROP_UNSUPPORTED", gen, reason, message });
         else dispatch({ type: "READ_FAILED", gen, ...errorReasonOf(e) });
       }
     },
     [ctxFor, dispatch]
   );
-  const startLifetime = (0, import_react.useCallback)(
+  const startLifetime = _react.useCallback.call(void 0, 
     (key, cfg) => {
       const prev = lifeRef.current;
       lifeRef.current = null;
-      prev?.controller.abort();
+      _optionalChain([prev, 'optionalAccess', _58 => _58.controller, 'access', _59 => _59.abort, 'call', _60 => _60()]);
       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);
+      void readDrop3(life, gen, cfg);
     },
-    [dispatch, readDrop2]
+    [dispatch, readDrop3]
   );
-  const refreshNow = (0, import_react.useCallback)(
+  const refreshNow = _react.useCallback.call(void 0, 
     async (kind = "refresh") => {
       const life = lifeRef.current;
       if (!life || !mounted.current) return;
@@ -2234,16 +1591,16 @@ function useMint(options) {
       const gen = ++genRef.current;
       life.gen = gen;
       dispatch({ type: "LOAD", gen, kind });
-      await readDrop2(life, gen, propsRef.current.config);
+      await readDrop3(life, gen, propsRef.current.config);
     },
-    [dispatch, readDrop2]
+    [dispatch, readDrop3]
   );
-  const refresh = (0, import_react.useCallback)(() => refreshNow("refresh"), [refreshNow]);
-  const isBusy = (0, import_react.useCallback)(
-    () => connectingRef.current || attemptRef.current !== null || stateRef.current.attempt !== null || IN_FLIGHT_STATES.includes(stateRef.current.name),
+  const refresh = _react.useCallback.call(void 0, () => refreshNow("refresh"), [refreshNow]);
+  const isBusy = _react.useCallback.call(void 0, 
+    () => connectingRef.current || attemptRef.current !== null || stateRef.current.attempt !== null || _chunkGO4TR3HBcjs.IN_FLIGHT_STATES.includes(stateRef.current.name),
     []
   );
-  const executeAttempt = (0, import_react.useCallback)(
+  const executeAttempt = _react.useCallback.call(void 0, 
     async (attempt, walletRead, life, account2) => {
       const cfg = attempt.config;
       const adapter = adapterFor(cfg);
@@ -2256,20 +1613,20 @@ function useMint(options) {
       };
       const assertPayer = () => {
         assertActive();
-        const live = getAccount();
+        const live = _chunkGO4TR3HBcjs.getAccount.call(void 0, );
         if (!live || live.address.toLowerCase() !== attempt.payer.toLowerCase()) {
-          throw new MintError("USER_REJECTED", "The connected wallet changed before the transaction was sent.");
+          throw new (0, _chunkGO4TR3HBcjs.MintError)("USER_REJECTED", "The connected wallet changed before the transaction was sent.");
         }
       };
       let wallet2 = null;
       const walletFor = () => {
-        if (!wallet2) wallet2 = getWalletClient(attempt.chainId);
+        if (!wallet2) wallet2 = _chunkGO4TR3HBcjs.getWalletClient.call(void 0, 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) });
+        return w.sendTransaction({ account: attempt.payer, to: tx.to, data: tx.data, value: tx.value, chain: _chunkGO4TR3HBcjs.getChain.call(void 0, attempt.chainId) });
       };
       const waitReceipt = async (hash2) => {
         let cancelled = false;
@@ -2286,19 +1643,19 @@ function useMint(options) {
           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 (cancelled) throw new (0, _chunkGO4TR3HBcjs.MintError)("USER_REJECTED", "The transaction was cancelled or replaced with a different transaction.");
           if (await walletFor().getChainId() !== attempt.chainId) throw e;
           assertActive();
-          receipt2 = await walletFor().extend(import_viem9.publicActions).waitForTransactionReceipt(params);
+          receipt2 = await walletFor().extend(_viem.publicActions).waitForTransactionReceipt(params);
         }
         assertActive();
-        if (cancelled) throw new MintError("USER_REJECTED", "The transaction was cancelled or replaced with a different transaction.");
+        if (cancelled) throw new (0, _chunkGO4TR3HBcjs.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);
+        await _chunkGO4TR3HBcjs.switchToChain.call(void 0, attempt.chainId);
       }
       assertPayer();
       let plan = await adapter.buildPlan(ctx, attempt, walletRead);
@@ -2308,13 +1665,13 @@ function useMint(options) {
         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.");
+            throw new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", "The token refused the approval.");
           }
         } catch (e) {
-          if (isMintError(e)) throw e;
-          const reverted = e instanceof import_viem9.BaseError ? e.walk((cause) => cause instanceof import_viem9.ExecutionRevertedError) : null;
-          if (reverted instanceof import_viem9.ExecutionRevertedError) {
-            throw new MintError("SIMULATION_REVERTED", reverted.shortMessage);
+          if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e)) throw e;
+          const reverted = e instanceof _viem.BaseError ? e.walk((cause) => cause instanceof _viem.ExecutionRevertedError) : null;
+          if (reverted instanceof _viem.ExecutionRevertedError) {
+            throw new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", reverted.shortMessage);
           }
           throw e;
         }
@@ -2326,7 +1683,7 @@ function useMint(options) {
         const approveReceipt = await waitReceipt(approveHash);
         assertActive();
         if (!receiptOk(approveReceipt.status)) {
-          throw new MintError("TX_REVERTED", `The approval transaction reverted (${approveHash}).`);
+          throw new (0, _chunkGO4TR3HBcjs.MintError)("TX_REVERTED", `The approval transaction reverted (${approveHash}).`);
         }
         const freshDrop = await adapter.readDrop(ctx, cfg);
         assertActive();
@@ -2337,11 +1694,11 @@ function useMint(options) {
           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.");
+        let checked = _chunkGO4TR3HBcjs.reducer.call(void 0, _chunkGO4TR3HBcjs.initialState.call(void 0, { quantity: attempt.quantity }), { type: "ACCOUNT_CHANGED", account: account2 });
+        checked = _chunkGO4TR3HBcjs.reducer.call(void 0, checked, { type: "DROP_LOADED", gen: checked.readGen, drop: freshDrop, now: nowSec() });
+        checked = _chunkGO4TR3HBcjs.reducer.call(void 0, checked, { type: "WALLET_LOADED", gen: checked.walletGen, read: freshWallet });
+        if (checked.name !== "live" || (_nullishCoalesce(_chunkGO4TR3HBcjs.selectMaxQuantity.call(void 0, checked), () => ( 0))) < attempt.quantity) {
+          throw new (0, _chunkGO4TR3HBcjs.MintError)(_nullishCoalesce(checked.reason, () => ( "SIMULATION_REVERTED")), _nullishCoalesce(checked.message, () => ( "The drop is no longer available for this quantity.")));
         }
         plan = await adapter.buildPlan(ctx, attempt, freshWallet);
         assertPayer();
@@ -2355,21 +1712,21 @@ function useMint(options) {
       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;
+      const confirmedHash = _nullishCoalesce(receipt.transactionHash, () => ( hash));
       if (!receiptOk(receipt.status)) {
-        throw new MintError("TX_REVERTED", `The mint transaction reverted (${confirmedHash}).`);
+        throw new (0, _chunkGO4TR3HBcjs.MintError)("TX_REVERTED", `The mint transaction reverted (${confirmedHash}).`);
       }
-      const tokens = parseMintReceipt(receipt.logs ?? [], {
-        tokenContract: plan.tokenContract ?? attempt.tokenContract,
+      const tokens = _chunkGO4TR3HBcjs.parseMintReceipt.call(void 0, _nullishCoalesce(receipt.logs, () => ( [])), {
+        tokenContract: _nullishCoalesce(plan.tokenContract, () => ( attempt.tokenContract)),
         recipient: attempt.recipient
       });
-      const result = { txHash: confirmedHash, explorerUrl: explorerUrlFor(attempt.chainId, confirmedHash), tokens };
+      const result = { txHash: confirmedHash, explorerUrl: explorerUrlFor(attempt.chainId, confirmedHash), tokens, requested: attempt.quantity };
       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 finishRelay = (0, import_react.useCallback)(
+  const finishRelay = _react.useCallback.call(void 0, 
     async (attempt, out, life) => {
       const cfg = attempt.config;
       const client = clientFor(life, cfg);
@@ -2380,38 +1737,39 @@ function useMint(options) {
       };
       const outcome = await pollUntilTerminal({ testnet: out.testnet, requestId: out.requestId, signal: life.controller.signal, assertActive });
       assertActive();
-      const where = chainName(out.originChainId);
+      const where = _chunkGO4TR3HBcjs.chainName.call(void 0, out.originChainId);
       if (outcome.kind === "timeout") {
-        throw new MintError("BRIDGE_TIMEOUT", "The bridge is still processing. Your mint may still complete.");
+        throw new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_TIMEOUT", "The bridge is still processing. Your mint may still complete.");
       }
       const key = outstandingKey(attempt.config, attempt.payer);
       const { status } = outcome;
       if (status.status !== "success") clearOutstanding(key);
       if (status.status === "refund") {
-        throw new MintError("BRIDGE_REFUNDED", `Relay could not complete the mint and is refunding your payment. Relay request ${out.requestId}.`);
+        throw new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_REFUNDED", `Relay could not complete the mint and is refunding your payment. Relay request ${out.requestId}.`);
       }
       if (status.status === "failure") {
         const why = status.failReason ? ` (${status.failReason})` : "";
         const noRefund = status.refundFailReason ? ` No automatic refund was sent. Contact support with Relay request ${out.requestId}.` : "";
-        throw new MintError("BRIDGE_FAILED", `Relay could not complete the mint paid on ${where}${why}.${noRefund}`);
+        throw new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_FAILED", `Relay could not complete the mint paid on ${where}${why}.${noRefund}`);
       }
-      const fillHash = status.txHashes[0] ?? null;
+      const fillHash = _nullishCoalesce(status.txHashes[0], () => ( null));
       let tokens = [];
       if (fillHash) {
         try {
           const receipt = await client.waitForTransactionReceipt({ hash: fillHash, confirmations: 1, timeout: 6e4 });
           if (receiptOk(receipt.status)) {
-            tokens = parseMintReceipt(receipt.logs ?? [], { tokenContract: attempt.tokenContract, recipient: attempt.recipient });
+            tokens = _chunkGO4TR3HBcjs.parseMintReceipt.call(void 0, _nullishCoalesce(receipt.logs, () => ( [])), { tokenContract: attempt.tokenContract, recipient: attempt.recipient });
           }
-        } catch {
+        } catch (e8) {
         }
         assertActive();
       }
-      const txHash = fillHash ?? out.originTxHash;
+      const txHash = _nullishCoalesce(fillHash, () => ( out.originTxHash));
       const result = {
         txHash,
         explorerUrl: explorerUrlFor(fillHash ? cfg.chainId : out.originChainId, txHash),
         tokens,
+        requested: attempt.quantity,
         relay: { requestId: out.requestId, originTxHash: out.originTxHash, originChainId: out.originChainId }
       };
       clearOutstanding(key);
@@ -2420,7 +1778,7 @@ function useMint(options) {
     },
     [clientFor, dispatch, emit]
   );
-  const executeRelayAttempt = (0, import_react.useCallback)(
+  const executeRelayAttempt = _react.useCallback.call(void 0, 
     async (attempt, walletRead, life, account2) => {
       const cfg = attempt.config;
       const adapter = adapterFor(cfg);
@@ -2431,19 +1789,19 @@ function useMint(options) {
         if (!mounted.current || life.controller.signal.aborted || lifeRef.current !== life || attemptRef.current !== attempt) {
           throw new DOMException("Mint attempt cancelled", "AbortError");
         }
-        const live = getAccount();
+        const live = _chunkGO4TR3HBcjs.getAccount.call(void 0, );
         if (!live || live.address.toLowerCase() !== attempt.payer.toLowerCase()) {
-          throw new MintError("USER_REJECTED", "The connected wallet changed before the transaction was sent.");
+          throw new (0, _chunkGO4TR3HBcjs.MintError)("USER_REJECTED", "The connected wallet changed before the transaction was sent.");
         }
       };
       assertPayer();
       if (account2.chainId !== origin) {
         dispatch({ type: "SWITCHING_CHAIN", attemptId: attempt.attemptId });
-        await switchToChain(origin);
+        await _chunkGO4TR3HBcjs.switchToChain.call(void 0, origin);
       }
       assertPayer();
       const plan = await adapter.buildPlan(ctx, attempt, walletRead);
-      if (plan.approve) throw new MintError("BRIDGE_UNAVAILABLE", "Cross-chain mint supports native-priced drops only.");
+      if (plan.approve) throw new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_UNAVAILABLE", "Cross-chain mint supports native-priced drops only.");
       assertPayer();
       const quote = await getQuote({
         testnet,
@@ -2456,18 +1814,18 @@ function useMint(options) {
         signal: life.controller.signal
       });
       assertPayer();
-      const balance = await getConnectedBalance(attempt.payer, origin);
+      const balance = await _chunkGO4TR3HBcjs.getConnectedBalance.call(void 0, attempt.payer, origin);
       if (balance < quote.amountIn.value + quote.originGas.value) {
         const s = shortOf(origin);
-        throw new MintError("INSUFFICIENT_FUNDS", `Not enough ${s.symbol} on ${s.name}. Pick another network to pay from.`);
+        throw new (0, _chunkGO4TR3HBcjs.MintError)("INSUFFICIENT_FUNDS", `Not enough ${s.symbol} on ${s.name}. Pick another network to pay from.`);
       }
       assertPayer();
       const item = quote.items[0];
       const key = outstandingKey(cfg, attempt.payer);
-      const wallet2 = getWalletClient(origin);
+      const wallet2 = _chunkGO4TR3HBcjs.getWalletClient.call(void 0, origin);
       assertPayer();
       if (!claimDeposit(key)) {
-        throw new MintError("BRIDGE_UNAVAILABLE", "A cross-chain payment for this drop is already in progress. Try again once it finishes.");
+        throw new (0, _chunkGO4TR3HBcjs.MintError)("BRIDGE_UNAVAILABLE", "A cross-chain payment for this drop is already in progress. Try again once it finishes.");
       }
       let out;
       try {
@@ -2479,7 +1837,7 @@ function useMint(options) {
           data: item.data,
           value: item.value,
           ...item.gas !== null && item.gas > 0n ? { gas: item.gas } : {},
-          chain: getChain(origin)
+          chain: _chunkGO4TR3HBcjs.getChain.call(void 0, origin)
         });
         out = { requestId: quote.requestId, testnet, originChainId: origin, originTxHash: originTxHash2, attempt };
         setOutstanding(key, out);
@@ -2490,16 +1848,16 @@ function useMint(options) {
       autoResumedRef.current.add(key);
       dispatch({ type: "TX_SUBMITTED", attemptId: attempt.attemptId });
       emit("tx-submitted", { state: "confirming", reason: null, txHash: originTxHash, quantity: attempt.quantity, chainId: cfg.chainId });
-      const deposit = await waitForDeposit(origin, originTxHash);
+      const deposit = await _chunkGO4TR3HBcjs.waitForDeposit.call(void 0, origin, originTxHash);
       if (deposit === "reverted") {
         clearOutstanding(key);
-        throw new MintError("TX_REVERTED", `The payment transaction reverted (${originTxHash}).`);
+        throw new (0, _chunkGO4TR3HBcjs.MintError)("TX_REVERTED", `The payment transaction reverted (${originTxHash}).`);
       }
       await finishRelay(attempt, out, life);
     },
     [ctxFor, dispatch, emit, finishRelay]
   );
-  const resumeOutstanding = (0, import_react.useCallback)(
+  const resumeOutstanding = _react.useCallback.call(void 0, 
     async (out, life) => {
       const attempt = Object.freeze({ ...out.attempt, attemptId: ++attemptIdRef.current });
       attemptRef.current = attempt;
@@ -2510,7 +1868,7 @@ function useMint(options) {
         await finishRelay(attempt, out, life);
       } catch (e) {
         if (!mounted.current || life.controller.signal.aborted || lifeRef.current !== life) return;
-        const { reason, message } = toReason(e);
+        const { reason, message } = _chunkGO4TR3HBcjs.toReason.call(void 0, e);
         dispatch({ type: "ATTEMPT_FAILED", attemptId: attempt.attemptId, reason, message });
         emit("error", { quantity: attempt.quantity, chainId: attempt.chainId });
       } finally {
@@ -2519,7 +1877,7 @@ function useMint(options) {
     },
     [dispatch, emit, finishRelay]
   );
-  const runMint = (0, import_react.useCallback)(async () => {
+  const runMint = _react.useCallback.call(void 0, async () => {
     if (!mounted.current) return;
     if (attemptRef.current !== null) return;
     if (widgetFailRef.current) {
@@ -2531,31 +1889,31 @@ function useMint(options) {
       return;
     }
     const s = stateRef.current;
-    if (!canAct(s) || s.attempt !== null) return;
+    if (!_chunkGO4TR3HBcjs.canAct.call(void 0, 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;
+      const active = () => mounted.current && lifeRef.current === connectLife && !_optionalChain([connectLife, 'optionalAccess', _61 => _61.controller, 'access', _62 => _62.signal, 'access', _63 => _63.aborted]);
       try {
         await widgetLoadRef.current;
         if (!active()) return;
-        const outcome = await openConnectModal();
+        const outcome = await _chunkGO4TR3HBcjs.openConnectModal.call(void 0, );
         if (!active()) return;
         connectingRef.current = false;
         if (outcome === "connected") {
           accountKeyRef.current = null;
-          pushAccountRef.current?.(getAccount());
+          _optionalChain([pushAccountRef, 'access', _64 => _64.current, 'optionalCall', _65 => _65(_chunkGO4TR3HBcjs.getAccount.call(void 0, ))]);
         } else dispatch({ type: "CONNECT_DISMISSED" });
-      } catch {
+      } catch (e9) {
         if (active()) dispatch({ type: "CONNECT_DISMISSED" });
       } finally {
         connectingRef.current = false;
       }
       return;
     }
-    const payer = s.account?.address;
+    const payer = _optionalChain([s, 'access', _66 => _66.account, 'optionalAccess', _67 => _67.address]);
     const out = payer ? getOutstanding(outstandingKey(propsRef.current.config, payer)) : null;
     if (out && lifeRef.current) {
       await resumeOutstanding(out, lifeRef.current);
@@ -2567,7 +1925,7 @@ function useMint(options) {
       if (life2) life2.gen = gen;
       dispatch({ type: "RESET", gen });
       dispatch({ type: "LOAD", gen, kind: "config" });
-      if (life2) void readDrop2(life2, gen, propsRef.current.config);
+      if (life2) void readDrop3(life2, gen, propsRef.current.config);
       return;
     }
     if (s.name !== "live") return;
@@ -2576,12 +1934,12 @@ function useMint(options) {
     const life = lifeRef.current;
     if (!account2 || !walletRead || !life) return;
     const cfg = propsRef.current.config;
-    const relayRoute = s.route?.kind === "relay" ? s.route : null;
+    const relayRoute = _optionalChain([s, 'access', _68 => _68.route, 'optionalAccess', _69 => _69.kind]) === "relay" ? s.route : null;
     const attempt = Object.freeze({
       attemptId: ++attemptIdRef.current,
       config: structuredClone(cfg),
       payer: account2.address,
-      recipient: propsRef.current.recipient ?? account2.address,
+      recipient: _nullishCoalesce(propsRef.current.recipient, () => ( account2.address)),
       quantity: s.quantity,
       chainId: cfg.chainId,
       tokenContract: tokenContractOf(cfg),
@@ -2595,51 +1953,51 @@ function useMint(options) {
       else await executeAttempt(attempt, walletRead, life, account2);
     } catch (e) {
       if (!mounted.current || life.controller.signal.aborted || lifeRef.current !== life) return;
-      const { reason, message } = toReason(e);
+      const { reason, message } = _chunkGO4TR3HBcjs.toReason.call(void 0, 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, executeRelayAttempt, resumeOutstanding, refreshNow]);
-  const mint = (0, import_react.useCallback)(() => {
+  }, [dispatch, emit, readDrop3, executeAttempt, executeRelayAttempt, resumeOutstanding, refreshNow]);
+  const mint = _react.useCallback.call(void 0, () => {
     void runMint();
   }, [runMint]);
-  (0, import_react.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     mounted.current = true;
     return () => {
       mounted.current = false;
-      lifeRef.current?.controller.abort();
+      _optionalChain([lifeRef, 'access', _70 => _70.current, 'optionalAccess', _71 => _71.controller, 'access', _72 => _72.abort, 'call', _73 => _73()]);
       lifeRef.current = null;
     };
   }, []);
-  (0, import_react.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     const push = (a) => {
-      const key = a ? `${a.address.toLowerCase()}:${a.chainId}:${(propsRef.current.recipient ?? "").toLowerCase()}` : "null";
+      const key = a ? `${a.address.toLowerCase()}:${a.chainId}:${(_nullishCoalesce(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);
+    push(_chunkGO4TR3HBcjs.getAccount.call(void 0, ));
+    const unsubscribe = _chunkGO4TR3HBcjs.subscribeAccount.call(void 0, push);
     return () => {
       unsubscribe();
     };
   }, [dispatch]);
-  const recipientRef = (0, import_react.useRef)(recipient);
-  (0, import_react.useEffect)(() => {
+  const recipientRef = _react.useRef.call(void 0, recipient);
+  _react.useEffect.call(void 0, () => {
     if (isBusy() || recipientRef.current === recipient) return;
     recipientRef.current = recipient;
     accountKeyRef.current = null;
-    pushAccountRef.current?.(getAccount());
+    _optionalChain([pushAccountRef, 'access', _74 => _74.current, 'optionalCall', _75 => _75(_chunkGO4TR3HBcjs.getAccount.call(void 0, ))]);
   }, [recipient, machine.attempt, isBusy]);
-  const projectId = connect?.walletConnectProjectId;
+  const projectId = _optionalChain([connect, 'optionalAccess', _76 => _76.walletConnectProjectId]);
   const widgetChains = [config.chainId, ...payChainsOf(config, options.crossChain).filter((id) => id !== config.chainId)].join(",");
-  (0, import_react.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     let alive = true;
-    const loading = loadConnectWidget({ chainIds: widgetChains.split(",").map(Number), ...projectId ? { walletConnectProjectId: projectId } : {} });
+    const loading = _chunkGO4TR3HBcjs.loadConnectWidget.call(void 0, { chainIds: widgetChains.split(",").map(Number), ...projectId ? { walletConnectProjectId: projectId } : {} });
     widgetLoadRef.current = loading;
     loading.then(
       () => {
@@ -2647,7 +2005,7 @@ function useMint(options) {
       },
       (e) => {
         if (!alive) return;
-        const { reason, message } = toReason(e);
+        const { reason, message } = _chunkGO4TR3HBcjs.toReason.call(void 0, e);
         setWidgetFail({ reason, message });
       }
     );
@@ -2655,7 +2013,7 @@ function useMint(options) {
       alive = false;
     };
   }, [widgetChains, projectId, widgetRetry]);
-  (0, import_react.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     if (!mounted.current) return;
     if (isBusy()) return;
     if (pendingQuantityRef.current !== null) {
@@ -2663,16 +2021,16 @@ function useMint(options) {
       pendingQuantityRef.current = null;
       dispatch({ type: "SET_QUANTITY", quantity });
     }
-    if (lifeRef.current?.key !== configKey) {
+    if (_optionalChain([lifeRef, 'access', _77 => _77.current, 'optionalAccess', _78 => _78.key]) !== configKey) {
       pendingRefreshRef.current = false;
       startLifetime(configKey, config);
-    } else if (pendingRefreshRef.current || lifeRef.current.rpcUrl !== options.rpcUrls?.[config.chainId]) {
+    } else if (pendingRefreshRef.current || lifeRef.current.rpcUrl !== _optionalChain([options, 'access', _79 => _79.rpcUrls, 'optionalAccess', _80 => _80[config.chainId]])) {
       pendingRefreshRef.current = false;
       void refreshNow();
     }
   });
   const resumeKey = machine.account ? outstandingKey(config, machine.account.address) : null;
-  (0, import_react.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     if (!resumeKey || autoResumedRef.current.has(resumeKey) || attemptRef.current !== null || isBusy()) return;
     const out = getOutstanding(resumeKey);
     const life = lifeRef.current;
@@ -2680,15 +2038,15 @@ function useMint(options) {
     autoResumedRef.current.add(resumeKey);
     void resumeOutstanding(out, life);
   }, [resumeKey, machine.attempt, isBusy, resumeOutstanding]);
-  const routeOptionsKey = `${String(options.payChainId ?? "")}|${JSON.stringify(options.crossChain ?? null)}`;
-  const previousRouteOptions = (0, import_react.useRef)(routeOptionsKey);
-  (0, import_react.useEffect)(() => {
+  const routeOptionsKey = `${String(_nullishCoalesce(options.payChainId, () => ( "")))}|${JSON.stringify(_nullishCoalesce(options.crossChain, () => ( null)))}`;
+  const previousRouteOptions = _react.useRef.call(void 0, routeOptionsKey);
+  _react.useEffect.call(void 0, () => {
     if (previousRouteOptions.current === routeOptionsKey || isBusy()) return;
     previousRouteOptions.current = routeOptionsKey;
     if (stateRef.current.account) dispatch({ type: "ACCOUNT_CHANGED", account: stateRef.current.account });
   }, [routeOptionsKey, machine.attempt, dispatch, isBusy]);
-  const previousQuantity = (0, import_react.useRef)(machine.quantity);
-  (0, import_react.useEffect)(() => {
+  const previousQuantity = _react.useRef.call(void 0, machine.quantity);
+  _react.useEffect.call(void 0, () => {
     if (previousQuantity.current === machine.quantity || isBusy()) return;
     previousQuantity.current = machine.quantity;
     if (stateRef.current.walletRead) dispatch({ type: "ACCOUNT_CHANGED", account: stateRef.current.account });
@@ -2696,11 +2054,11 @@ function useMint(options) {
   const loadedDrop = machine.drop;
   const walletGen = machine.walletGen;
   const account = machine.account;
-  const lastWalletRead = (0, import_react.useRef)(null);
-  (0, import_react.useEffect)(() => {
+  const lastWalletRead = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
     if (!account || !loadedDrop || isBusy()) return;
     const previous = lastWalletRead.current;
-    if (stateRef.current.blocked && previous?.drop === loadedDrop && previous.gen === walletGen && previous.quantity === machine.quantity) return;
+    if (stateRef.current.blocked && _optionalChain([previous, 'optionalAccess', _81 => _81.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;
@@ -2713,15 +2071,15 @@ function useMint(options) {
       try {
         const read = await adapter.readWallet(ctxFor(life, cfg), cfg, {
           payer: account.address,
-          recipient: propsRef.current.recipient ?? account.address,
+          recipient: _nullishCoalesce(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;
+        const ineligible = _optionalChain([read, 'access', _82 => _82.ineligible, 'optionalAccess', _83 => _83.reason]) === "SIMULATION_REVERTED" ? { ...read.ineligible, message: _chunkGO4TR3HBcjs.friendlyErrorMessage.call(void 0, new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", read.ineligible.message)) } : read.ineligible;
         const fullRead = { ...read, ineligible };
         const payChains = payChainsOf(cfg, propsRef.current.crossChain);
-        const crossChain = payChains.length > 0 && ineligible === null && (adapter.supportsRelay?.(drop) ?? false);
+        const crossChain = payChains.length > 0 && ineligible === null && (_nullishCoalesce(_optionalChain([adapter, 'access', _84 => _84.supportsRelay, 'optionalCall', _85 => _85(drop)]), () => ( false)));
         const routeChain = routeChainOf(payChains, account.chainId, propsRef.current.payChainId);
         const routePending = crossChain && routeChain !== cfg.chainId && payChains.includes(routeChain);
         dispatch({ type: "WALLET_LOADED", gen: walletGen, read: fullRead, crossChain, routePending });
@@ -2729,7 +2087,7 @@ function useMint(options) {
           setCrossChainInfo(null);
           return;
         }
-        const recipientAddr = propsRef.current.recipient ?? account.address;
+        const recipientAddr = _nullishCoalesce(propsRef.current.recipient, () => ( account.address));
         const draft = {
           attemptId: 0,
           config: cfg,
@@ -2744,7 +2102,7 @@ function useMint(options) {
         let tx;
         try {
           tx = (await adapter.buildPlan(ctxFor(life, cfg), draft, fullRead)).mint;
-        } catch {
+        } catch (e10) {
           if (!alive) return;
           setCrossChainInfo(null);
           if (routePending) dispatch({ type: "ROUTE_LOADED", gen: walletGen, route: { kind: "direct", chainId: cfg.chainId }, short: null });
@@ -2766,11 +2124,11 @@ function useMint(options) {
           if (routeChain !== account.chainId) {
             route = relay;
           } else {
-            const balance = await getConnectedBalance(account.address, routeChain);
+            const balance = await _chunkGO4TR3HBcjs.getConnectedBalance.call(void 0, account.address, routeChain);
             if (balance >= quote.amountIn.value + quote.originGas.value) route = relay;
             else short = shortOf(routeChain);
           }
-        } catch {
+        } catch (e11) {
         }
         if (!alive || life.controller.signal.aborted || lifeRef.current !== life) return;
         dispatch({ type: "ROUTE_LOADED", gen: walletGen, route: short ? null : route, short });
@@ -2783,8 +2141,8 @@ function useMint(options) {
       alive = false;
     };
   }, [account, loadedDrop, walletGen, machine.quantity, machine.attempt, ctxFor, dispatch, isBusy]);
-  const prevQuantityProp = (0, import_react.useRef)(quantityProp);
-  (0, import_react.useEffect)(() => {
+  const prevQuantityProp = _react.useRef.call(void 0, quantityProp);
+  _react.useEffect.call(void 0, () => {
     if (isBusy()) return;
     const propChanged = prevQuantityProp.current !== quantityProp;
     prevQuantityProp.current = quantityProp;
@@ -2792,11 +2150,11 @@ function useMint(options) {
     const state = stateRef.current;
     if (!propChanged && state.account && !state.walletRead) return;
     const event = { type: "SET_QUANTITY", quantity: quantityProp };
-    const clamped = reducer(state, event).quantity;
+    const clamped = _chunkGO4TR3HBcjs.reducer.call(void 0, state, event).quantity;
     if (clamped !== state.quantity) dispatch(event);
-    if (clamped !== quantityProp) propsRef.current.onQuantityChange?.(clamped);
+    if (clamped !== quantityProp) _optionalChain([propsRef, 'access', _86 => _86.current, 'access', _87 => _87.onQuantityChange, 'optionalCall', _88 => _88(clamped)]);
   }, [quantityProp, machine.quantity, machine.drop, machine.walletRead, machine.attempt, dispatch, isBusy]);
-  (0, import_react.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     const timer = setInterval(() => {
       if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
       void refreshNow("refresh");
@@ -2810,29 +2168,29 @@ function useMint(options) {
       document.removeEventListener("visibilitychange", onVisible);
     };
   }, [refreshNow]);
-  const boundary = machine.drop ? [machine.drop.startTime, machine.drop.endTime].some((t) => t !== null && t > machine.now) : false;
-  (0, import_react.useEffect)(() => {
+  const boundary = machine.drop ? [machine.drop.startTime, machine.drop.endTime, _nullishCoalesce(machine.drop.phaseEndsAt, () => ( null))].some((t) => t !== null && t > machine.now) : false;
+  _react.useEffect.call(void 0, () => {
     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);
+      const crossed = s.drop && [s.drop.startTime, s.drop.endTime, _nullishCoalesce(s.drop.phaseEndsAt, () => ( null))].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 = (0, import_react.useRef)(null);
-  (0, import_react.useEffect)(() => {
+  const prevName = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
     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 });
+    emit("state", { state: name, reason: _nullishCoalesce(_optionalChain([widgetFail, 'optionalAccess', _89 => _89.reason]), () => ( machine.reason)) });
   }, [machine.name, machine.reason, widgetFail, emit]);
-  const setQuantity = (0, import_react.useCallback)(
+  const setQuantity = _react.useCallback.call(void 0, 
     (next) => {
       const s = stateRef.current;
-      const max = selectMaxQuantity(s) ?? 65535;
+      const max = _nullishCoalesce(_chunkGO4TR3HBcjs.selectMaxQuantity.call(void 0, s), () => ( 65535));
       const clamped = Math.max(1, Math.min(Math.floor(Number.isNaN(next) ? 1 : next), max));
       const handler = propsRef.current.onQuantityChange;
       if (handler) {
@@ -2854,7 +2212,7 @@ function useMint(options) {
   const wallet = machine.account && machine.walletRead ? {
     address: machine.account.address,
     chainId: machine.account.chainId,
-    recipient: recipient ?? machine.account.address,
+    recipient: _nullishCoalesce(recipient, () => ( machine.account.address)),
     walletMinted: machine.walletRead.walletMinted,
     walletMax: machine.walletRead.walletMax,
     allowlistRemaining: machine.walletRead.allowlistRemaining
@@ -2867,46 +2225,46 @@ function useMint(options) {
     wallet,
     quantity: machine.quantity,
     setQuantity,
-    maxQuantity: selectMaxQuantity(machine),
-    total: selectTotal(machine),
+    maxQuantity: _chunkGO4TR3HBcjs.selectMaxQuantity.call(void 0, machine),
+    total: _chunkGO4TR3HBcjs.selectTotal.call(void 0, 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,
+    canAct: _chunkGO4TR3HBcjs.canAct.call(void 0, { ...machine, name: effective.name }) && machine.attempt === null,
     // Short on the wallet chain is neither route: nothing can be paid until the collector picks another chain.
-    route: machine.route ?? (machine.walletRead && machine.drop && !machine.routePending && machine.short === null ? { kind: "direct", chainId: machine.drop.chainId } : null),
-    crossChain: machine.crossChain && machine.account && crossChainInfo?.gen === machine.walletGen ? crossChainInfo.info : null
+    route: _nullishCoalesce(machine.route, () => ( (machine.walletRead && machine.drop && !machine.routePending && machine.short === null ? { kind: "direct", chainId: machine.drop.chainId } : null))),
+    crossChain: machine.crossChain && machine.account && _optionalChain([crossChainInfo, 'optionalAccess', _90 => _90.gen]) === machine.walletGen ? crossChainInfo.info : null
   };
 }
 
 // src/react/PayWithPicker.ts
-var import_react2 = require("react");
-var import_viem10 = require("viem");
+
+
 var PICKER_REFRESH_MS = 2e4;
 var PICKER_DEBOUNCE_MS = 500;
 var RELAY_REASONS = /* @__PURE__ */ new Set(["BRIDGE_UNAVAILABLE", "BRIDGE_TIMEOUT", "BRIDGE_REFUNDED", "BRIDGE_FAILED"]);
-var money4 = (value, chainId) => {
-  const c = getChain(chainId).nativeCurrency;
-  return { value, decimals: c.decimals, symbol: c.symbol, formatted: (0, import_viem10.formatUnits)(value, c.decimals) };
+var money3 = (value, chainId) => {
+  const c = _chunkGO4TR3HBcjs.getChain.call(void 0, chainId).nativeCurrency;
+  return { value, decimals: c.decimals, symbol: c.symbol, formatted: _viem.formatUnits.call(void 0, value, c.decimals) };
 };
 function usePayOptions(mint, onSelect) {
   const info = mint.crossChain;
-  const current = mint.wallet?.chainId ?? null;
-  const [quotes, setQuotes] = (0, import_react2.useState)({});
-  const [balance, setBalance] = (0, import_react2.useState)(null);
-  const [tick, setTick] = (0, import_react2.useState)(0);
-  (0, import_react2.useEffect)(() => {
+  const current = _nullishCoalesce(_optionalChain([mint, 'access', _91 => _91.wallet, 'optionalAccess', _92 => _92.chainId]), () => ( null));
+  const [quotes, setQuotes] = _react.useState.call(void 0, {});
+  const [balance, setBalance] = _react.useState.call(void 0, null);
+  const [tick, setTick] = _react.useState.call(void 0, 0);
+  _react.useEffect.call(void 0, () => {
     const t = setInterval(() => setTick((n) => n + 1), PICKER_REFRESH_MS);
     return () => clearInterval(t);
   }, []);
   const key = info ? `${info.tx.to}:${info.tx.value}:${info.tx.data}:${info.payer}:${info.recipient}:${info.payChains.join()}` : "";
-  const [quotedKey, setQuotedKey] = (0, import_react2.useState)(key);
+  const [quotedKey, setQuotedKey] = _react.useState.call(void 0, key);
   if (quotedKey !== key) {
     setQuotedKey(key);
     setQuotes({});
   }
-  (0, import_react2.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     if (!info) return;
     const controller = new AbortController();
     const timer = setTimeout(() => {
@@ -2917,7 +2275,7 @@ function usePayOptions(mint, onSelect) {
             if (!controller.signal.aborted) setQuotes((prev) => ({ ...prev, [chainId]: { relayFee: q.relayFee, amountIn: q.amountIn } }));
           },
           (e) => {
-            if (controller.signal.aborted || e?.reason === "RATE_LIMITED") return;
+            if (controller.signal.aborted || _optionalChain([e, 'optionalAccess', _93 => _93.reason]) === "RATE_LIMITED") return;
             setQuotes((prev) => ({ ...prev, [chainId]: "failed" }));
           }
         );
@@ -2928,10 +2286,10 @@ function usePayOptions(mint, onSelect) {
       controller.abort();
     };
   }, [key, tick]);
-  (0, import_react2.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     if (!info || current === null || !mint.wallet) return;
     let alive = true;
-    getConnectedBalance(mint.wallet.address, current).then(
+    _chunkGO4TR3HBcjs.getConnectedBalance.call(void 0, mint.wallet.address, current).then(
       (value) => {
         if (alive) setBalance({ chainId: current, value });
       },
@@ -2942,12 +2300,12 @@ function usePayOptions(mint, onSelect) {
     return () => {
       alive = false;
     };
-  }, [current, mint.wallet?.address, key, tick]);
-  const select = (0, import_react2.useCallback)(
+  }, [current, _optionalChain([mint, 'access', _94 => _94.wallet, 'optionalAccess', _95 => _95.address]), key, tick]);
+  const select = _react.useCallback.call(void 0, 
     (chainId) => {
-      switchToChain(chainId).then(
-        () => onSelect?.(chainId, null),
-        (e) => onSelect?.(chainId, e)
+      _chunkGO4TR3HBcjs.switchToChain.call(void 0, chainId).then(
+        () => _optionalChain([onSelect, 'optionalCall', _96 => _96(chainId, null)]),
+        (e) => _optionalChain([onSelect, 'optionalCall', _97 => _97(chainId, e)])
       );
     },
     [onSelect]
@@ -2959,12 +2317,12 @@ function usePayOptions(mint, onSelect) {
     const quoted = q && q !== "failed" ? q : null;
     return {
       chainId,
-      name: chainName(chainId),
+      name: _chunkGO4TR3HBcjs.chainName.call(void 0, chainId),
       selected: chainId === current,
       isDropChain,
-      relayFee: isDropChain ? null : quoted?.relayFee ?? null,
-      amountIn: isDropChain ? null : quoted?.amountIn ?? null,
-      balance: balance && balance.chainId === chainId && chainId === current ? money4(balance.value, chainId) : null,
+      relayFee: isDropChain ? null : _nullishCoalesce(_optionalChain([quoted, 'optionalAccess', _98 => _98.relayFee]), () => ( null)),
+      amountIn: isDropChain ? null : _nullishCoalesce(_optionalChain([quoted, 'optionalAccess', _99 => _99.amountIn]), () => ( null)),
+      balance: balance && balance.chainId === chainId && chainId === current ? money3(balance.value, chainId) : null,
       loading: !isDropChain && q === void 0,
       select: () => select(chainId)
     };
@@ -2979,11 +2337,11 @@ function PayWithPicker(props) {
   const rows = usePayOptions(props.mint, props.onSelect);
   if (rows.length === 0) return null;
   const open = props.mint.state === "insufficient-funds" || props.mint.reason !== null && RELAY_REASONS.has(props.mint.reason);
-  return (0, import_react2.createElement)(
+  return _react.createElement.call(void 0, 
     "div",
     { className: props.className, role: "group", "aria-label": "Pay with", "data-open": open ? "true" : "false" },
     rows.map(
-      (row) => (0, import_react2.createElement)(
+      (row) => _react.createElement.call(void 0, 
         "button",
         {
           key: row.chainId,
@@ -3003,16 +2361,16 @@ function PayWithPicker(props) {
 }
 
 // src/react/MintButton.ts
-var import_react3 = require("react");
+
 function defaultLabel(m) {
-  const symbol = m.total?.erc20?.symbol ?? m.total?.native.symbol ?? m.drop?.unitPrice.symbol ?? "";
+  const symbol = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([m, 'access', _100 => _100.total, 'optionalAccess', _101 => _101.erc20, 'optionalAccess', _102 => _102.symbol]), () => ( _optionalChain([m, 'access', _103 => _103.total, 'optionalAccess', _104 => _104.native, 'access', _105 => _105.symbol]))), () => ( _optionalChain([m, 'access', _106 => _106.drop, 'optionalAccess', _107 => _107.unitPrice, 'access', _108 => _108.symbol]))), () => ( ""));
   switch (m.state) {
     case "loading":
       return "Loading\u2026";
     case "unsupported":
       return "Unavailable";
     case "upcoming": {
-      const t = m.drop?.startTime;
+      const t = _optionalChain([m, 'access', _109 => _109.drop, 'optionalAccess', _110 => _110.startTime]);
       return `Starts ${t ? new Date(t * 1e3).toLocaleString() : "soon"}`;
     }
     case "ended":
@@ -3025,8 +2383,8 @@ function defaultLabel(m) {
       return "Connecting\u2026";
     case "live": {
       const route = m.route;
-      if (route?.kind === "relay") {
-        return `Mint \xB7 ${route.amountIn.formatted} ${route.amountIn.symbol} on ${chainName(route.originChainId)}`;
+      if (_optionalChain([route, 'optionalAccess', _111 => _111.kind]) === "relay") {
+        return `Mint \xB7 ${route.amountIn.formatted} ${route.amountIn.symbol} on ${_chunkGO4TR3HBcjs.chainName.call(void 0, route.originChainId)}`;
       }
       const total = m.total;
       if (!total) return "Mint";
@@ -3036,8 +2394,8 @@ function defaultLabel(m) {
     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;
+      const erc20 = _optionalChain([m, 'access', _112 => _112.total, 'optionalAccess', _113 => _113.erc20]);
+      const shortage = erc20 && m.message === `Not enough ${erc20.symbol} to cover the mint.` ? erc20.symbol : _nullishCoalesce(_optionalChain([m, 'access', _114 => _114.total, 'optionalAccess', _115 => _115.native, 'access', _116 => _116.symbol]), () => ( symbol));
       return `Insufficient ${shortage}`.trimEnd();
     }
     case "switching-chain":
@@ -3058,8 +2416,8 @@ 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 (0, import_react3.createElement)(
+  const label = _nullishCoalesce(_optionalChain([labels, 'optionalAccess', _117 => _117[m.state]]), () => ( defaultLabel(m)));
+  return _react.createElement.call(void 0, 
     "button",
     {
       type: "button",
@@ -3070,24 +2428,23 @@ function MintButton(props) {
       disabled: !m.canAct,
       onClick: m.mint
     },
-    children ?? label
+    _nullishCoalesce(children, () => ( label))
   );
 }
 
 // src/index.ts
-var VERSION = "0.2.1";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CLICKABLE_STATES,
-  MAX_QUANTITY,
-  MINT_STATES,
-  MintButton,
-  MintError,
-  PayWithPicker,
-  REASON_CODES,
-  VERSION,
-  isMintError,
-  useMint,
-  usePayOptions
-});
+var VERSION = "0.4.0";
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CLICKABLE_STATES = _chunkGO4TR3HBcjs.CLICKABLE_STATES; exports.MAX_QUANTITY = _chunkGO4TR3HBcjs.MAX_QUANTITY; exports.MINT_STATES = _chunkGO4TR3HBcjs.MINT_STATES; exports.MintButton = MintButton; exports.MintError = _chunkGO4TR3HBcjs.MintError; exports.PayWithPicker = PayWithPicker; exports.REASON_CODES = _chunkGO4TR3HBcjs.REASON_CODES; exports.VERSION = VERSION; exports.isMintError = _chunkGO4TR3HBcjs.isMintError; exports.useMint = useMint; exports.usePayOptions = usePayOptions;
 //# sourceMappingURL=index.cjs.map