@manifoldxyz/dropkit 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -27,7 +27,7 @@
 
 
 
-var _chunkOO6QQT3Mcjs = require('./chunk-OO6QQT3M.cjs');
+var _chunkGO4TR3HBcjs = require('./chunk-GO4TR3HB.cjs');
 
 // src/react/useMint.ts
 var _react = require('react');
@@ -70,7 +70,7 @@ function revertReason(errorData) {
 function parseQuote(body, originChainId) {
   const b = obj(body);
   const steps = Array.isArray(b.steps) ? b.steps.map(obj) : [];
-  const unknownStep = () => new (0, _chunkOO6QQT3Mcjs.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 step = steps[0];
   const rawItems = Array.isArray(step.items) ? step.items.map(obj) : [];
@@ -83,8 +83,8 @@ function parseQuote(body, originChainId) {
   });
   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 !== _viem.zeroAddress) throw unknownStep();
@@ -163,21 +163,21 @@ async function requestQuote(a) {
       body: JSON.stringify(body)
     }, RELAY_TIMEOUTS.quoteMs);
   } catch (e) {
-    throw new (0, _chunkOO6QQT3Mcjs.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 (0, _chunkOO6QQT3Mcjs.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 (0, _chunkOO6QQT3Mcjs.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 (0, _chunkOO6QQT3Mcjs.MintError)("RATE_LIMITED", "Relay is rate limiting quotes. Try again in a moment.", { cause: json });
-  throw new (0, _chunkOO6QQT3Mcjs.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);
@@ -243,12 +243,605 @@ async function pollUntilTerminal(a) {
   }
 }
 
+// src/core/adapters/tl-stacks/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+// 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 scopeCaches = /* @__PURE__ */ new WeakMap();
+function withSignal(p, signal) {
+  if (!signal) return p;
+  return new Promise((resolve, reject) => {
+    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 });
+  });
+}
+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();
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    bytes.set(c, offset);
+    offset += c.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+async function fetchAndParse(fetchFn, url, signal) {
+  let res;
+  try {
+    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);
+}
+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 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)]);
+  }
+}
+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 (_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);
+  }
+  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;
+}
+
+// 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;
+      }
+    })();
+    if (!https) bad("allowlistUrl", "must be an https: URL");
+  }
+}
+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));
+  });
+}
+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 {
+    return await io(
+      ctx,
+      () => ctx.client.readContract({ address: _viem.getAddress.call(void 0, config.stacks), abi: stacksAbi, functionName, args })
+    );
+  } catch (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 v = await version;
+  if (!SUPPORTED_VERSIONS.includes(v)) {
+    bad("stacks", `is TL Stacks ${v}. Dropkit supports ${SUPPORTED_VERSIONS.join(" and ")} only.`);
+  }
+}
+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: money(unitPrice, native.decimals, native.symbol),
+    unitFee: money(fee, native.decimals, native.symbol),
+    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}`
+  };
+  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 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);
+    }
+  }
+  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;
+    }
+  }
+  return {
+    walletMinted: minted,
+    walletMax,
+    allowlistRemaining,
+    maxQuantity,
+    ineligible,
+    balances: { native, erc20: null },
+    gasReserve: gas * gasPrice,
+    data
+  };
+}
+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.");
+  }
+  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: null,
+    mint: {
+      to: _viem.getAddress.call(void 0, config.stacks),
+      data: encodePurchase(config, recipient, qty, data),
+      value: qty * (data.unitPrice + data.unitFee)
+    },
+    tokenContract: _viem.getAddress.call(void 0, config.nftContract)
+  };
+}
+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;
+  }
+  return null;
+}
+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" });
+    }
+  }
+  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 });
+}
+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 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;
+    }
+  }
+}
 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()}`;
+  return `${String(config.chainId)}:${targetOf(config)}:${payer.toLowerCase()}`;
 }
 var getOutstanding = (key) => _nullishCoalesce(memory.get(key), () => ( null));
 var setOutstanding = (key, out) => void memory.set(key, out);
@@ -287,8 +880,8 @@ 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 (0, _chunkOO6QQT3Mcjs.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" && _viem.isAddress.call(void 0, a, { strict: false });
 function functionsNamed(abi, name) {
@@ -297,15 +890,15 @@ function functionsNamed(abi, name) {
 function validateTemplate(t, path, allowed) {
   if (typeof t === "string") {
     for (const token of _nullishCoalesce(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`);
+      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*)\]$/;
@@ -373,15 +966,15 @@ var NO_PLACEHOLDERS = [];
 function validateCall(abi, call, prefix, kind, allowed) {
   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");
+  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;
@@ -391,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 ? _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) {
@@ -469,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);
@@ -503,7 +1096,7 @@ 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 (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", `placeholder ${token} has no value here`);
+  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) {
@@ -519,46 +1112,46 @@ function fill(t, p, 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) {
+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) => _optionalChain([e, 'optionalAccess', _12 => _12.name]) === "AbortError";
-function throwIfAborted(ctx) {
-  if (_optionalChain([ctx, 'access', _13 => _13.signal, 'optionalAccess', _14 => _14.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 (_chunkOO6QQT3Mcjs.isMintError.call(void 0, e) || isAbortError(e)) throw e;
-  throw new (0, _chunkOO6QQT3Mcjs.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 (_chunkOO6QQT3Mcjs.isMintError.call(void 0, e) || isAbortError(e)) throw 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, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", `${field} read reverted or returned no data: ${e.shortMessage}`, { field, cause: e });
+    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 (0, _chunkOO6QQT3Mcjs.MintError)("INVALID_CONFIG", `${field} did not return a number`, { field });
-  if (n < 0n) throw new (0, _chunkOO6QQT3Mcjs.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) {
@@ -574,43 +1167,43 @@ async function readField(ctx, config, name, src, vars) {
   }
   const value = src.value;
   if (typeof value === "bigint") return value;
-  throw new (0, _chunkOO6QQT3Mcjs.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 = _nullishCoalesce(fn.outputs[0].components, () => ( []));
   const out = [];
-  out[index] = res[_nullishCoalesce(_optionalChain([comps, 'access', _15 => _15[index], 'optionalAccess', _16 => _16.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 (0, _chunkOO6QQT3Mcjs.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 = _optionalChain([ctx, 'access', _17 => _17.client, 'access', _18 => _18.chain, 'optionalAccess', _19 => _19.nativeCurrency]);
-  return { decimals: _nullishCoalesce(_optionalChain([n, 'optionalAccess', _20 => _20.decimals]), () => ( 18)), symbol: _nullishCoalesce(_optionalChain([n, 'optionalAccess', _21 => _21.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 : _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_ABI, functionName: "symbol" }, field),
     readCall(ctx, { address: token, abi: ERC20_ABI, functionName: "decimals" }, field)
   ]);
   if (typeof symbol !== "string" || typeof decimals !== "number") {
-    throw new (0, _chunkOO6QQT3Mcjs.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 = _nullishCoalesce(value.split(".")[1], () => ( ""));
   if (frac.length > decimals) {
-    throw new (0, _chunkOO6QQT3Mcjs.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 _viem.parseUnits.call(void 0, value, decimals);
 }
@@ -621,13 +1214,13 @@ async function resolvePrice(ctx, config, meta) {
   if (typeof value === "bigint") return value;
   return parseDisplay(value, (await _asyncNullishCoalesce(meta, async () => ( await currencyMeta(ctx, config)))).decimals);
 }
-var money = (value, decimals, symbol) => ({
+var money2 = (value, decimals, symbol) => ({
   value,
   decimals,
   symbol,
   formatted: _viem.formatUnits.call(void 0, value, decimals)
 });
-function revertData(e) {
+function revertData2(e) {
   for (let cur = e, depth = 0; cur && depth < 12; depth++) {
     const d = cur.data;
     if (typeof d === "string" && d.startsWith("0x") && d.length >= 10) return d;
@@ -644,28 +1237,28 @@ function describeRevert(abi, data) {
     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', _22 => _22.abiItem, 'optionalAccess', _23 => _23.inputs]), () => ( []));
-    const shown = args.map((a, i) => _optionalChain([inputs, 'access', _24 => _24[i], 'optionalAccess', _25 => _25.name]) ? `${inputs[i].name}: ${String(a)}` : String(a));
+    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 (e2) {
+  } catch (e4) {
     return `reverted with unrecognized error ${data.slice(0, 10)}`;
   }
 }
 function toSimulationError(e, abi) {
-  if (_chunkOO6QQT3Mcjs.isMintError.call(void 0, e)) return e;
-  if (isAbortError(e)) throw 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, _chunkOO6QQT3Mcjs.MintError)("INSUFFICIENT_FUNDS", `Payer cannot cover the mint: ${e.shortMessage}`, { cause: e });
+    return new (0, _chunkGO4TR3HBcjs.MintError)("INSUFFICIENT_FUNDS", `Payer cannot cover the mint: ${e.shortMessage}`, { cause: e });
   }
-  const data = revertData(e);
-  if (data) return new (0, _chunkOO6QQT3Mcjs.MintError)("SIMULATION_REVERTED", describeRevert(abi, data), { cause: e });
+  const data = revertData2(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, _chunkOO6QQT3Mcjs.MintError)("SIMULATION_REVERTED", shortMessage(e), { cause: e });
-  return new (0, _chunkOO6QQT3Mcjs.MintError)("RPC_ERROR", `RPC request failed: ${shortMessage(e)}`, { cause: e });
+  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);
   }
@@ -675,22 +1268,22 @@ function encodeMint(config, vars) {
   try {
     return _viem.encodeFunctionData.call(void 0, { abi: [fn], functionName: fn.name, args: fillArgs(config.mint.args, fn.inputs, vars) });
   } catch (e) {
-    if (_chunkOO6QQT3Mcjs.isMintError.call(void 0, e)) throw e;
-    throw new (0, _chunkOO6QQT3Mcjs.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([
@@ -701,11 +1294,11 @@ 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: money(price, meta.decimals, meta.symbol),
-    unitFee: money(0n, native.decimals, native.symbol),
+    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"),
@@ -715,9 +1308,9 @@ async function readDrop(ctx, config) {
     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);
@@ -725,14 +1318,14 @@ 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),
+    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 > (_nullishCoalesce(walletMinted, () => ( 0n))) ? walletMax - (_nullishCoalesce(walletMinted, () => ( 0n))) : 0n;
-  const maxQuantity = remaining === null ? null : Number(remaining < BigInt(_chunkOO6QQT3Mcjs.MAX_QUANTITY) ? remaining : BigInt(_chunkOO6QQT3Mcjs.MAX_QUANTITY));
+  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) {
@@ -741,16 +1334,16 @@ async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
     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 (!_chunkOO6QQT3Mcjs.isMintError.call(void 0, 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,
@@ -761,11 +1354,11 @@ async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
     gasReserve: gas * gasPrice
   };
 }
-async function buildPlan(ctx, attempt, wallet) {
+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(_nullishCoalesce(config.price.per, () => ( "unit")), unitPrice, qty);
@@ -793,11 +1386,11 @@ async function buildPlan(ctx, attempt, wallet) {
   }
   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, simulate };
+var contractAdapter = { readDrop: readDrop2, readWallet: readWallet2, buildPlan: buildPlan2, simulate: simulate2 };
 
 // src/react/useMint.ts
 var REFRESH_MS = 3e4;
@@ -811,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" ? _chunkOO6QQT3Mcjs.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) {
@@ -827,36 +1431,58 @@ function routeChainOf(payChains, accountChainId, payChainId) {
 var ROUTE_DEBOUNCE_MS = 500;
 var symbolOf = (chainId) => {
   try {
-    return _chunkOO6QQT3Mcjs.getChain.call(void 0, chainId).nativeCurrency.symbol;
-  } catch (e3) {
+    return _chunkGO4TR3HBcjs.getChain.call(void 0, chainId).nativeCurrency.symbol;
+  } catch (e5) {
     return "ETH";
   }
 };
-var shortOf = (chainId) => ({ chainId, symbol: symbolOf(chainId), name: _chunkOO6QQT3Mcjs.chainName.call(void 0, 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 : _nullishCoalesce(config.tokenContract, () => ( config.address));
+  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;
+    }
+  }
 }
 function eventAddressOf(config) {
-  return config.type === "manifold-claim" ? config.creatorContract : config.address;
+  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;
+    }
+  }
 }
-var isUnsupported = (reason) => _chunkOO6QQT3Mcjs.UNSUPPORTED_REASONS.includes(reason);
+var isUnsupported = (reason) => _chunkGO4TR3HBcjs.UNSUPPORTED_REASONS.includes(reason);
 function errorReasonOf(e) {
-  const { reason, message } = _chunkOO6QQT3Mcjs.toReason.call(void 0, 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 = _optionalChain([_chunkOO6QQT3Mcjs.getChain.call(void 0, chainId), 'access', _26 => _26.blockExplorers, 'optionalAccess', _27 => _27.default, 'access', _28 => _28.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 (e4) {
+  } 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] = _react.useReducer.call(void 0, _chunkOO6QQT3Mcjs.reducer, void 0, () => _chunkOO6QQT3Mcjs.initialState.call(void 0, { quantity: quantityProp }));
+  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);
@@ -883,15 +1509,15 @@ function useMint(options) {
   });
   const dispatch = _react.useCallback.call(void 0, (event) => {
     if (!mounted.current) return;
-    stateRef.current = _chunkOO6QQT3Mcjs.reducer.call(void 0, stateRef.current, event);
+    stateRef.current = _chunkGO4TR3HBcjs.reducer.call(void 0, stateRef.current, event);
     rawDispatch(event);
   }, []);
   const emit = _react.useCallback.call(void 0, (type, over = {}) => {
     const handler = propsRef.current.onEvent;
     if (!handler || !mounted.current) return;
-    const cfg = _nullishCoalesce(_optionalChain([attemptRef, 'access', _29 => _29.current, 'optionalAccess', _30 => _30.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 = _nullishCoalesce(_optionalChain([attemptRef, 'access', _31 => _31.current, 'optionalAccess', _32 => _32.originChainId]), () => ( (_optionalChain([s, 'access', _33 => _33.route, 'optionalAccess', _34 => _34.kind]) === "relay" ? s.route.originChainId : _nullishCoalesce(_optionalChain([s, 'access', _35 => _35.short, 'optionalAccess', _36 => _36.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,
@@ -905,14 +1531,14 @@ function useMint(options) {
     };
     try {
       handler(payload);
-    } catch (e5) {
+    } catch (e7) {
     }
   }, []);
   const clientFor = _react.useCallback.call(void 0, (life, cfg) => {
-    const rpcUrl = _optionalChain([propsRef, 'access', _37 => _37.current, 'access', _38 => _38.rpcUrls, 'optionalAccess', _39 => _39[cfg.chainId]]);
+    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 = _chunkOO6QQT3Mcjs.createReadClient.call(void 0, { 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;
   }, []);
@@ -925,7 +1551,7 @@ function useMint(options) {
     }),
     [clientFor]
   );
-  const readDrop2 = _react.useCallback.call(void 0, 
+  const readDrop3 = _react.useCallback.call(void 0, 
     async (life, gen, cfg) => {
       const adapter = adapterFor(cfg);
       try {
@@ -934,7 +1560,7 @@ 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 } = _chunkOO6QQT3Mcjs.toReason.call(void 0, 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) });
       }
@@ -945,14 +1571,14 @@ function useMint(options) {
     (key, cfg) => {
       const prev = lifeRef.current;
       lifeRef.current = null;
-      _optionalChain([prev, 'optionalAccess', _40 => _40.controller, 'access', _41 => _41.abort, 'call', _42 => _42()]);
+      _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 = _react.useCallback.call(void 0, 
     async (kind = "refresh") => {
@@ -965,13 +1591,13 @@ 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 = _react.useCallback.call(void 0, () => refreshNow("refresh"), [refreshNow]);
   const isBusy = _react.useCallback.call(void 0, 
-    () => connectingRef.current || attemptRef.current !== null || stateRef.current.attempt !== null || _chunkOO6QQT3Mcjs.IN_FLIGHT_STATES.includes(stateRef.current.name),
+    () => connectingRef.current || attemptRef.current !== null || stateRef.current.attempt !== null || _chunkGO4TR3HBcjs.IN_FLIGHT_STATES.includes(stateRef.current.name),
     []
   );
   const executeAttempt = _react.useCallback.call(void 0, 
@@ -987,20 +1613,20 @@ function useMint(options) {
       };
       const assertPayer = () => {
         assertActive();
-        const live = _chunkOO6QQT3Mcjs.getAccount.call(void 0, );
+        const live = _chunkGO4TR3HBcjs.getAccount.call(void 0, );
         if (!live || live.address.toLowerCase() !== attempt.payer.toLowerCase()) {
-          throw new (0, _chunkOO6QQT3Mcjs.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 = _chunkOO6QQT3Mcjs.getWalletClient.call(void 0, 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: _chunkOO6QQT3Mcjs.getChain.call(void 0, 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;
@@ -1017,19 +1643,19 @@ function useMint(options) {
           receipt2 = await client.waitForTransactionReceipt(params);
         } catch (e) {
           assertActive();
-          if (cancelled) throw new (0, _chunkOO6QQT3Mcjs.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(_viem.publicActions).waitForTransactionReceipt(params);
         }
         assertActive();
-        if (cancelled) throw new (0, _chunkOO6QQT3Mcjs.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 _chunkOO6QQT3Mcjs.switchToChain.call(void 0, attempt.chainId);
+        await _chunkGO4TR3HBcjs.switchToChain.call(void 0, attempt.chainId);
       }
       assertPayer();
       let plan = await adapter.buildPlan(ctx, attempt, walletRead);
@@ -1039,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 (0, _chunkOO6QQT3Mcjs.MintError)("SIMULATION_REVERTED", "The token refused the approval.");
+            throw new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", "The token refused the approval.");
           }
         } catch (e) {
-          if (_chunkOO6QQT3Mcjs.isMintError.call(void 0, e)) throw e;
+          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, _chunkOO6QQT3Mcjs.MintError)("SIMULATION_REVERTED", reverted.shortMessage);
+            throw new (0, _chunkGO4TR3HBcjs.MintError)("SIMULATION_REVERTED", reverted.shortMessage);
           }
           throw e;
         }
@@ -1057,7 +1683,7 @@ function useMint(options) {
         const approveReceipt = await waitReceipt(approveHash);
         assertActive();
         if (!receiptOk(approveReceipt.status)) {
-          throw new (0, _chunkOO6QQT3Mcjs.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();
@@ -1068,11 +1694,11 @@ function useMint(options) {
           drop: freshDrop
         });
         assertPayer();
-        let checked = _chunkOO6QQT3Mcjs.reducer.call(void 0, _chunkOO6QQT3Mcjs.initialState.call(void 0, { quantity: attempt.quantity }), { type: "ACCOUNT_CHANGED", account: account2 });
-        checked = _chunkOO6QQT3Mcjs.reducer.call(void 0, checked, { type: "DROP_LOADED", gen: checked.readGen, drop: freshDrop, now: nowSec() });
-        checked = _chunkOO6QQT3Mcjs.reducer.call(void 0, checked, { type: "WALLET_LOADED", gen: checked.walletGen, read: freshWallet });
-        if (checked.name !== "live" || (_nullishCoalesce(_chunkOO6QQT3Mcjs.selectMaxQuantity.call(void 0, checked), () => ( 0))) < attempt.quantity) {
-          throw new (0, _chunkOO6QQT3Mcjs.MintError)(_nullishCoalesce(checked.reason, () => ( "SIMULATION_REVERTED")), _nullishCoalesce(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();
@@ -1088,13 +1714,13 @@ function useMint(options) {
       assertActive();
       const confirmedHash = _nullishCoalesce(receipt.transactionHash, () => ( hash));
       if (!receiptOk(receipt.status)) {
-        throw new (0, _chunkOO6QQT3Mcjs.MintError)("TX_REVERTED", `The mint transaction reverted (${confirmedHash}).`);
+        throw new (0, _chunkGO4TR3HBcjs.MintError)("TX_REVERTED", `The mint transaction reverted (${confirmedHash}).`);
       }
-      const tokens = _chunkOO6QQT3Mcjs.parseMintReceipt.call(void 0, _nullishCoalesce(receipt.logs, () => ( [])), {
+      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 });
     },
@@ -1111,20 +1737,20 @@ function useMint(options) {
       };
       const outcome = await pollUntilTerminal({ testnet: out.testnet, requestId: out.requestId, signal: life.controller.signal, assertActive });
       assertActive();
-      const where = _chunkOO6QQT3Mcjs.chainName.call(void 0, out.originChainId);
+      const where = _chunkGO4TR3HBcjs.chainName.call(void 0, out.originChainId);
       if (outcome.kind === "timeout") {
-        throw new (0, _chunkOO6QQT3Mcjs.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 (0, _chunkOO6QQT3Mcjs.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 (0, _chunkOO6QQT3Mcjs.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 = _nullishCoalesce(status.txHashes[0], () => ( null));
       let tokens = [];
@@ -1132,9 +1758,9 @@ function useMint(options) {
         try {
           const receipt = await client.waitForTransactionReceipt({ hash: fillHash, confirmations: 1, timeout: 6e4 });
           if (receiptOk(receipt.status)) {
-            tokens = _chunkOO6QQT3Mcjs.parseMintReceipt.call(void 0, _nullishCoalesce(receipt.logs, () => ( [])), { tokenContract: attempt.tokenContract, recipient: attempt.recipient });
+            tokens = _chunkGO4TR3HBcjs.parseMintReceipt.call(void 0, _nullishCoalesce(receipt.logs, () => ( [])), { tokenContract: attempt.tokenContract, recipient: attempt.recipient });
           }
-        } catch (e6) {
+        } catch (e8) {
         }
         assertActive();
       }
@@ -1143,6 +1769,7 @@ function useMint(options) {
         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);
@@ -1162,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 = _chunkOO6QQT3Mcjs.getAccount.call(void 0, );
+        const live = _chunkGO4TR3HBcjs.getAccount.call(void 0, );
         if (!live || live.address.toLowerCase() !== attempt.payer.toLowerCase()) {
-          throw new (0, _chunkOO6QQT3Mcjs.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 _chunkOO6QQT3Mcjs.switchToChain.call(void 0, origin);
+        await _chunkGO4TR3HBcjs.switchToChain.call(void 0, origin);
       }
       assertPayer();
       const plan = await adapter.buildPlan(ctx, attempt, walletRead);
-      if (plan.approve) throw new (0, _chunkOO6QQT3Mcjs.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,
@@ -1187,18 +1814,18 @@ function useMint(options) {
         signal: life.controller.signal
       });
       assertPayer();
-      const balance = await _chunkOO6QQT3Mcjs.getConnectedBalance.call(void 0, 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 (0, _chunkOO6QQT3Mcjs.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 = _chunkOO6QQT3Mcjs.getWalletClient.call(void 0, origin);
+      const wallet2 = _chunkGO4TR3HBcjs.getWalletClient.call(void 0, origin);
       assertPayer();
       if (!claimDeposit(key)) {
-        throw new (0, _chunkOO6QQT3Mcjs.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 {
@@ -1210,7 +1837,7 @@ function useMint(options) {
           data: item.data,
           value: item.value,
           ...item.gas !== null && item.gas > 0n ? { gas: item.gas } : {},
-          chain: _chunkOO6QQT3Mcjs.getChain.call(void 0, origin)
+          chain: _chunkGO4TR3HBcjs.getChain.call(void 0, origin)
         });
         out = { requestId: quote.requestId, testnet, originChainId: origin, originTxHash: originTxHash2, attempt };
         setOutstanding(key, out);
@@ -1221,10 +1848,10 @@ 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 _chunkOO6QQT3Mcjs.waitForDeposit.call(void 0, origin, originTxHash);
+      const deposit = await _chunkGO4TR3HBcjs.waitForDeposit.call(void 0, origin, originTxHash);
       if (deposit === "reverted") {
         clearOutstanding(key);
-        throw new (0, _chunkOO6QQT3Mcjs.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);
     },
@@ -1241,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 } = _chunkOO6QQT3Mcjs.toReason.call(void 0, 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 {
@@ -1262,31 +1889,31 @@ function useMint(options) {
       return;
     }
     const s = stateRef.current;
-    if (!_chunkOO6QQT3Mcjs.canAct.call(void 0, 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 && !_optionalChain([connectLife, 'optionalAccess', _43 => _43.controller, 'access', _44 => _44.signal, 'access', _45 => _45.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 _chunkOO6QQT3Mcjs.openConnectModal.call(void 0, );
+        const outcome = await _chunkGO4TR3HBcjs.openConnectModal.call(void 0, );
         if (!active()) return;
         connectingRef.current = false;
         if (outcome === "connected") {
           accountKeyRef.current = null;
-          _optionalChain([pushAccountRef, 'access', _46 => _46.current, 'optionalCall', _47 => _47(_chunkOO6QQT3Mcjs.getAccount.call(void 0, ))]);
+          _optionalChain([pushAccountRef, 'access', _64 => _64.current, 'optionalCall', _65 => _65(_chunkGO4TR3HBcjs.getAccount.call(void 0, ))]);
         } else dispatch({ type: "CONNECT_DISMISSED" });
-      } catch (e7) {
+      } catch (e9) {
         if (active()) dispatch({ type: "CONNECT_DISMISSED" });
       } finally {
         connectingRef.current = false;
       }
       return;
     }
-    const payer = _optionalChain([s, 'access', _48 => _48.account, 'optionalAccess', _49 => _49.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);
@@ -1298,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;
@@ -1307,7 +1934,7 @@ function useMint(options) {
     const life = lifeRef.current;
     if (!account2 || !walletRead || !life) return;
     const cfg = propsRef.current.config;
-    const relayRoute = _optionalChain([s, 'access', _50 => _50.route, 'optionalAccess', _51 => _51.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),
@@ -1326,13 +1953,13 @@ 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 } = _chunkOO6QQT3Mcjs.toReason.call(void 0, 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]);
+  }, [dispatch, emit, readDrop3, executeAttempt, executeRelayAttempt, resumeOutstanding, refreshNow]);
   const mint = _react.useCallback.call(void 0, () => {
     void runMint();
   }, [runMint]);
@@ -1340,7 +1967,7 @@ function useMint(options) {
     mounted.current = true;
     return () => {
       mounted.current = false;
-      _optionalChain([lifeRef, 'access', _52 => _52.current, 'optionalAccess', _53 => _53.controller, 'access', _54 => _54.abort, 'call', _55 => _55()]);
+      _optionalChain([lifeRef, 'access', _70 => _70.current, 'optionalAccess', _71 => _71.controller, 'access', _72 => _72.abort, 'call', _73 => _73()]);
       lifeRef.current = null;
     };
   }, []);
@@ -1353,8 +1980,8 @@ function useMint(options) {
       dispatch({ type: "ACCOUNT_CHANGED", account: a });
     };
     pushAccountRef.current = push;
-    push(_chunkOO6QQT3Mcjs.getAccount.call(void 0, ));
-    const unsubscribe = _chunkOO6QQT3Mcjs.subscribeAccount.call(void 0, push);
+    push(_chunkGO4TR3HBcjs.getAccount.call(void 0, ));
+    const unsubscribe = _chunkGO4TR3HBcjs.subscribeAccount.call(void 0, push);
     return () => {
       unsubscribe();
     };
@@ -1364,13 +1991,13 @@ function useMint(options) {
     if (isBusy() || recipientRef.current === recipient) return;
     recipientRef.current = recipient;
     accountKeyRef.current = null;
-    _optionalChain([pushAccountRef, 'access', _56 => _56.current, 'optionalCall', _57 => _57(_chunkOO6QQT3Mcjs.getAccount.call(void 0, ))]);
+    _optionalChain([pushAccountRef, 'access', _74 => _74.current, 'optionalCall', _75 => _75(_chunkGO4TR3HBcjs.getAccount.call(void 0, ))]);
   }, [recipient, machine.attempt, isBusy]);
-  const projectId = _optionalChain([connect, 'optionalAccess', _58 => _58.walletConnectProjectId]);
+  const projectId = _optionalChain([connect, 'optionalAccess', _76 => _76.walletConnectProjectId]);
   const widgetChains = [config.chainId, ...payChainsOf(config, options.crossChain).filter((id) => id !== config.chainId)].join(",");
   _react.useEffect.call(void 0, () => {
     let alive = true;
-    const loading = _chunkOO6QQT3Mcjs.loadConnectWidget.call(void 0, { 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(
       () => {
@@ -1378,7 +2005,7 @@ function useMint(options) {
       },
       (e) => {
         if (!alive) return;
-        const { reason, message } = _chunkOO6QQT3Mcjs.toReason.call(void 0, e);
+        const { reason, message } = _chunkGO4TR3HBcjs.toReason.call(void 0, e);
         setWidgetFail({ reason, message });
       }
     );
@@ -1394,10 +2021,10 @@ function useMint(options) {
       pendingQuantityRef.current = null;
       dispatch({ type: "SET_QUANTITY", quantity });
     }
-    if (_optionalChain([lifeRef, 'access', _59 => _59.current, 'optionalAccess', _60 => _60.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 !== _optionalChain([options, 'access', _61 => _61.rpcUrls, 'optionalAccess', _62 => _62[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();
     }
@@ -1431,7 +2058,7 @@ function useMint(options) {
   _react.useEffect.call(void 0, () => {
     if (!account || !loadedDrop || isBusy()) return;
     const previous = lastWalletRead.current;
-    if (stateRef.current.blocked && _optionalChain([previous, 'optionalAccess', _63 => _63.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;
@@ -1449,10 +2076,10 @@ function useMint(options) {
           drop
         });
         if (!alive || life.controller.signal.aborted || lifeRef.current !== life || life.gen !== readGen) return;
-        const ineligible = _optionalChain([read, 'access', _64 => _64.ineligible, 'optionalAccess', _65 => _65.reason]) === "SIMULATION_REVERTED" ? { ...read.ineligible, message: _chunkOO6QQT3Mcjs.friendlyErrorMessage.call(void 0, new (0, _chunkOO6QQT3Mcjs.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 && (_nullishCoalesce(_optionalChain([adapter, 'access', _66 => _66.supportsRelay, 'optionalCall', _67 => _67(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 });
@@ -1475,7 +2102,7 @@ function useMint(options) {
         let tx;
         try {
           tx = (await adapter.buildPlan(ctxFor(life, cfg), draft, fullRead)).mint;
-        } catch (e8) {
+        } catch (e10) {
           if (!alive) return;
           setCrossChainInfo(null);
           if (routePending) dispatch({ type: "ROUTE_LOADED", gen: walletGen, route: { kind: "direct", chainId: cfg.chainId }, short: null });
@@ -1497,11 +2124,11 @@ function useMint(options) {
           if (routeChain !== account.chainId) {
             route = relay;
           } else {
-            const balance = await _chunkOO6QQT3Mcjs.getConnectedBalance.call(void 0, 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 (e9) {
+        } catch (e11) {
         }
         if (!alive || life.controller.signal.aborted || lifeRef.current !== life) return;
         dispatch({ type: "ROUTE_LOADED", gen: walletGen, route: short ? null : route, short });
@@ -1523,9 +2150,9 @@ function useMint(options) {
     const state = stateRef.current;
     if (!propChanged && state.account && !state.walletRead) return;
     const event = { type: "SET_QUANTITY", quantity: quantityProp };
-    const clamped = _chunkOO6QQT3Mcjs.reducer.call(void 0, state, event).quantity;
+    const clamped = _chunkGO4TR3HBcjs.reducer.call(void 0, state, event).quantity;
     if (clamped !== state.quantity) dispatch(event);
-    if (clamped !== quantityProp) _optionalChain([propsRef, 'access', _68 => _68.current, 'access', _69 => _69.onQuantityChange, 'optionalCall', _70 => _70(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]);
   _react.useEffect.call(void 0, () => {
     const timer = setInterval(() => {
@@ -1541,13 +2168,13 @@ 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;
+  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);
@@ -1558,12 +2185,12 @@ function useMint(options) {
     const name = widgetFail ? isUnsupported(widgetFail.reason) ? "unsupported" : "error" : machine.name;
     if (prevName.current === name) return;
     prevName.current = name;
-    emit("state", { state: name, reason: _nullishCoalesce(_optionalChain([widgetFail, 'optionalAccess', _71 => _71.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 = _react.useCallback.call(void 0, 
     (next) => {
       const s = stateRef.current;
-      const max = _nullishCoalesce(_chunkOO6QQT3Mcjs.selectMaxQuantity.call(void 0, 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) {
@@ -1598,16 +2225,16 @@ function useMint(options) {
     wallet,
     quantity: machine.quantity,
     setQuantity,
-    maxQuantity: _chunkOO6QQT3Mcjs.selectMaxQuantity.call(void 0, machine),
-    total: _chunkOO6QQT3Mcjs.selectTotal.call(void 0, 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: _chunkOO6QQT3Mcjs.canAct.call(void 0, { ...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: _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', _72 => _72.gen]) === machine.walletGen ? crossChainInfo.info : null
+    crossChain: machine.crossChain && machine.account && _optionalChain([crossChainInfo, 'optionalAccess', _90 => _90.gen]) === machine.walletGen ? crossChainInfo.info : null
   };
 }
 
@@ -1617,13 +2244,13 @@ function useMint(options) {
 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 money2 = (value, chainId) => {
-  const c = _chunkOO6QQT3Mcjs.getChain.call(void 0, chainId).nativeCurrency;
+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 = _nullishCoalesce(_optionalChain([mint, 'access', _73 => _73.wallet, 'optionalAccess', _74 => _74.chainId]), () => ( null));
+  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);
@@ -1648,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 || _optionalChain([e, 'optionalAccess', _75 => _75.reason]) === "RATE_LIMITED") return;
+            if (controller.signal.aborted || _optionalChain([e, 'optionalAccess', _93 => _93.reason]) === "RATE_LIMITED") return;
             setQuotes((prev) => ({ ...prev, [chainId]: "failed" }));
           }
         );
@@ -1662,7 +2289,7 @@ function usePayOptions(mint, onSelect) {
   _react.useEffect.call(void 0, () => {
     if (!info || current === null || !mint.wallet) return;
     let alive = true;
-    _chunkOO6QQT3Mcjs.getConnectedBalance.call(void 0, mint.wallet.address, current).then(
+    _chunkGO4TR3HBcjs.getConnectedBalance.call(void 0, mint.wallet.address, current).then(
       (value) => {
         if (alive) setBalance({ chainId: current, value });
       },
@@ -1673,12 +2300,12 @@ function usePayOptions(mint, onSelect) {
     return () => {
       alive = false;
     };
-  }, [current, _optionalChain([mint, 'access', _76 => _76.wallet, 'optionalAccess', _77 => _77.address]), key, tick]);
+  }, [current, _optionalChain([mint, 'access', _94 => _94.wallet, 'optionalAccess', _95 => _95.address]), key, tick]);
   const select = _react.useCallback.call(void 0, 
     (chainId) => {
-      _chunkOO6QQT3Mcjs.switchToChain.call(void 0, chainId).then(
-        () => _optionalChain([onSelect, 'optionalCall', _78 => _78(chainId, null)]),
-        (e) => _optionalChain([onSelect, 'optionalCall', _79 => _79(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]
@@ -1690,12 +2317,12 @@ function usePayOptions(mint, onSelect) {
     const quoted = q && q !== "failed" ? q : null;
     return {
       chainId,
-      name: _chunkOO6QQT3Mcjs.chainName.call(void 0, chainId),
+      name: _chunkGO4TR3HBcjs.chainName.call(void 0, chainId),
       selected: chainId === current,
       isDropChain,
-      relayFee: isDropChain ? null : _nullishCoalesce(_optionalChain([quoted, 'optionalAccess', _80 => _80.relayFee]), () => ( null)),
-      amountIn: isDropChain ? null : _nullishCoalesce(_optionalChain([quoted, 'optionalAccess', _81 => _81.amountIn]), () => ( null)),
-      balance: balance && balance.chainId === chainId && chainId === current ? money2(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)
     };
@@ -1736,14 +2363,14 @@ function PayWithPicker(props) {
 // src/react/MintButton.ts
 
 function defaultLabel(m) {
-  const symbol = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([m, 'access', _82 => _82.total, 'optionalAccess', _83 => _83.erc20, 'optionalAccess', _84 => _84.symbol]), () => ( _optionalChain([m, 'access', _85 => _85.total, 'optionalAccess', _86 => _86.native, 'access', _87 => _87.symbol]))), () => ( _optionalChain([m, 'access', _88 => _88.drop, 'optionalAccess', _89 => _89.unitPrice, 'access', _90 => _90.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 = _optionalChain([m, 'access', _91 => _91.drop, 'optionalAccess', _92 => _92.startTime]);
+      const t = _optionalChain([m, 'access', _109 => _109.drop, 'optionalAccess', _110 => _110.startTime]);
       return `Starts ${t ? new Date(t * 1e3).toLocaleString() : "soon"}`;
     }
     case "ended":
@@ -1756,8 +2383,8 @@ function defaultLabel(m) {
       return "Connecting\u2026";
     case "live": {
       const route = m.route;
-      if (_optionalChain([route, 'optionalAccess', _93 => _93.kind]) === "relay") {
-        return `Mint \xB7 ${route.amountIn.formatted} ${route.amountIn.symbol} on ${_chunkOO6QQT3Mcjs.chainName.call(void 0, 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";
@@ -1767,8 +2394,8 @@ function defaultLabel(m) {
     case "ineligible":
       return "Not eligible";
     case "insufficient-funds": {
-      const erc20 = _optionalChain([m, 'access', _94 => _94.total, 'optionalAccess', _95 => _95.erc20]);
-      const shortage = erc20 && m.message === `Not enough ${erc20.symbol} to cover the mint.` ? erc20.symbol : _nullishCoalesce(_optionalChain([m, 'access', _96 => _96.total, 'optionalAccess', _97 => _97.native, 'access', _98 => _98.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":
@@ -1789,7 +2416,7 @@ function MintButton(props) {
   const { className, labels, children, ...options } = props;
   const m = useMint(options);
   if (typeof children === "function") return children(m);
-  const label = _nullishCoalesce(_optionalChain([labels, 'optionalAccess', _99 => _99[m.state]]), () => ( defaultLabel(m)));
+  const label = _nullishCoalesce(_optionalChain([labels, 'optionalAccess', _117 => _117[m.state]]), () => ( defaultLabel(m)));
   return _react.createElement.call(void 0, 
     "button",
     {
@@ -1806,7 +2433,7 @@ function MintButton(props) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.4.0";
 
 
 
@@ -1819,5 +2446,5 @@ var VERSION = "0.3.0";
 
 
 
-exports.CLICKABLE_STATES = _chunkOO6QQT3Mcjs.CLICKABLE_STATES; exports.MAX_QUANTITY = _chunkOO6QQT3Mcjs.MAX_QUANTITY; exports.MINT_STATES = _chunkOO6QQT3Mcjs.MINT_STATES; exports.MintButton = MintButton; exports.MintError = _chunkOO6QQT3Mcjs.MintError; exports.PayWithPicker = PayWithPicker; exports.REASON_CODES = _chunkOO6QQT3Mcjs.REASON_CODES; exports.VERSION = VERSION; exports.isMintError = _chunkOO6QQT3Mcjs.isMintError; exports.useMint = useMint; exports.usePayOptions = usePayOptions;
+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