@manifoldxyz/dropkit 0.3.0 → 0.4.0

package/dist/index.js

@@ -27,11 +27,11 @@ import {
   switchToChain,
   toReason,
   waitForDeposit
-} from "./chunk-3PA74M2L.js";
+} from "./chunk-SUJQB3SL.js";
 
 // src/react/useMint.ts
 import { useCallback, useEffect, useReducer, useRef, useState } from "react";
-import { BaseError as BaseError2, ExecutionRevertedError, publicActions } from "viem";
+import { BaseError as BaseError3, ExecutionRevertedError, publicActions } from "viem";
 
 // src/core/relay/client.ts
 import { formatUnits, getAddress, isHex, keccak256, zeroAddress } from "viem";
@@ -83,8 +83,8 @@ function parseQuote(body, originChainId) {
   });
   const requestId = isHex(step.requestId) ? step.requestId : isHex(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 !== zeroAddress) throw unknownStep();
@@ -243,12 +243,605 @@ async function pollUntilTerminal(a) {
   }
 }
 
+// src/core/adapters/tl-stacks/index.ts
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  InsufficientFundsError,
+  decodeErrorResult,
+  encodeFunctionData,
+  formatUnits as formatUnits2,
+  getAddress as getAddress3,
+  isAddress,
+  zeroAddress as zeroAddress2
+} from "viem";
+
+// 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
+import { concatHex, encodeAbiParameters, getAddress as getAddress2, keccak256 as keccak2562 } from "viem";
+var HASH = /^0x[0-9a-fA-F]{64}$/;
+var UINT = /^\d+$/;
+var MAX_UINT256 = 2n ** 256n - 1n;
+var unavailable = (message, cause) => new MintError("ALLOWLIST_UNAVAILABLE", message, cause === void 0 ? void 0 : { cause });
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var hashWallet = (wallet) => keccak2562(encodeAbiParameters([{ type: "address" }], [getAddress2(wallet)]));
+var leafOf = (hashedWallet, allowance) => keccak2562(concatHex([keccak2562(encodeAbiParameters([{ type: "bytes32" }, { type: "uint256" }], [hashedWallet, allowance]))]));
+var hashPair = (a, b) => BigInt(a) < BigInt(b) ? keccak2562(concatHex([a, b])) : keccak2562(concatHex([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) => 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 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 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 MintError ? reason : unavailable("The allowlist request was cancelled.", reason));
+    };
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+  });
+  const onLifetimeAbort = () => controller.abort(signal?.reason);
+  if (signal?.aborted) onLifetimeAbort();
+  else signal?.addEventListener("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);
+    signal?.removeEventListener("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 (args.signal?.aborted) return Promise.reject(unavailable("The allowlist request was cancelled.", args.signal.reason));
+  const fetchFn = args.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  let scoped = scopeCaches.get(args.scope);
+  if (!scoped || scoped.signal?.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 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" || !isAddress(config.stacks, { strict: false })) bad("stacks", "is not a valid address");
+  if (typeof config.nftContract !== "string" || !isAddress(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 {
+        return false;
+      }
+    })();
+    if (!https) bad("allowlistUrl", "must be an https: URL");
+  }
+}
+var abortError = () => new DOMException("The operation was aborted", "AbortError");
+var isAbortError = (e) => e?.name === "AbortError";
+function throwIfAborted(ctx) {
+  if (ctx.signal?.aborted) throw abortError();
+}
+function io(ctx, start) {
+  const signal = ctx.signal;
+  if (!signal) return start();
+  if (signal.aborted) return Promise.reject(abortError());
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    start().then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+var shortMessage = (e) => e instanceof BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
+function rpcError(e) {
+  if (isMintError(e) || isAbortError(e)) throw e;
+  throw new 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: getAddress3(config.stacks), abi: stacksAbi, functionName, args })
+    );
+  } catch (e) {
+    if (isMintError(e) || isAbortError(e)) throw e;
+    if (e instanceof BaseError && e.walk((x) => x instanceof ContractFunctionRevertedError || x instanceof ContractFunctionZeroDataError)) {
+      throw new 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: formatUnits2(value, decimals) });
+function nativeMeta(ctx) {
+  const n = ctx.client.chain?.nativeCurrency;
+  return { decimals: n?.decimals ?? 18, symbol: n?.symbol ?? "ETH" };
+}
+function seconds(v, field) {
+  if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new 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 = getAddress3(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 MintError("DROP_NOT_FOUND", "No Transient Labs drop is configured for this NFT contract on this chain.");
+  }
+  if (drop.currencyAddress !== zeroAddress2) {
+    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 = getAddress3(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 = getAddress3(config.nftContract);
+  const presale = detail.phase === DROP_PHASE.PRESALE;
+  const [minted, native, gasPrice, list] = await Promise.all([
+    readStacks(ctx, config, "getNumberMinted", [nft, getAddress3(recipient)]),
+    io(ctx, () => ctx.client.getBalance({ address: payer })).catch(rpcError),
+    io(ctx, () => ctx.client.getGasPrice()).catch(rpcError),
+    presale ? loadAllowlist({ scope: 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(MAX_QUANTITY) ? remaining : BigInt(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(MAX_QUANTITY) ? remaining : BigInt(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: getAddress3(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 encodeFunctionData({
+    abi: stacksAbi,
+    functionName: "purchase",
+    args: [getAddress3(config.nftContract), getAddress3(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 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 MintError("SIMULATION_REVERTED", "Choose at least one token to mint.");
+  }
+  const data = walletData(wallet);
+  const qty = BigInt(attempt.quantity);
+  return {
+    approve: null,
+    mint: {
+      to: getAddress3(config.stacks),
+      data: encodePurchase(config, recipient, qty, data),
+      value: qty * (data.unitPrice + data.unitFee)
+    },
+    tokenContract: getAddress3(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 (isMintError(e)) return e;
+  if (isAbortError(e)) throw e;
+  if (e instanceof BaseError && e.walk((x) => x instanceof InsufficientFundsError)) {
+    return new MintError("INSUFFICIENT_FUNDS", `The wallet cannot cover the mint: ${e.shortMessage}`, { cause: e });
+  }
+  const data = revertData(e);
+  if (data) {
+    try {
+      const { errorName, args } = decodeErrorResult({ abi: stacksAbi, data });
+      const known = TL_MESSAGES[errorName];
+      if (known) return new MintError("SIMULATION_REVERTED", known, { cause: e, domain: "tl-stacks" });
+      const shown = (args ?? []).map(String).join(", ");
+      return new MintError("SIMULATION_REVERTED", `Transient Labs rejected the mint (${errorName}(${shown})).`, { cause: e, domain: "tl-stacks" });
+    } catch {
+      return new MintError("SIMULATION_REVERTED", `Transient Labs rejected the mint (unrecognized error ${data.slice(0, 10)}).`, { cause: e, domain: "tl-stacks" });
+    }
+  }
+  const reverted = e instanceof BaseError && e.walk((x) => x.code === 3 || /execution reverted/i.test(x.message));
+  if (reverted) return new MintError("SIMULATION_REVERTED", shortMessage(e), { cause: e });
+  return new 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) => memory.get(key) ?? null;
 var setOutstanding = (key, out) => void memory.set(key, out);
@@ -262,15 +855,15 @@ var releaseDeposit = (key) => void claimed.delete(key);
 
 // src/core/adapters/contract/index.ts
 import {
-  BaseError,
-  ContractFunctionRevertedError,
-  ContractFunctionZeroDataError,
-  InsufficientFundsError,
-  decodeErrorResult,
-  encodeFunctionData,
-  formatUnits as formatUnits2,
-  getAddress as getAddress2,
-  isAddress,
+  BaseError as BaseError2,
+  ContractFunctionRevertedError as ContractFunctionRevertedError2,
+  ContractFunctionZeroDataError as ContractFunctionZeroDataError2,
+  InsufficientFundsError as InsufficientFundsError2,
+  decodeErrorResult as decodeErrorResult2,
+  encodeFunctionData as encodeFunctionData2,
+  formatUnits as formatUnits3,
+  getAddress as getAddress4,
+  isAddress as isAddress2,
   parseAbi,
   parseUnits
 } from "viem";
@@ -287,25 +880,25 @@ 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) {
+function bad2(field, message) {
   throw new MintError("INVALID_CONFIG", `${field} ${message}`, { field });
 }
-var isHexAddress = (a) => typeof a === "string" && isAddress(a, { strict: false });
+var isHexAddress = (a) => typeof a === "string" && isAddress2(a, { strict: false });
 function functionsNamed(abi, name) {
   return abi.filter((i) => i.type === "function" && i.name === name);
 }
 function validateTemplate(t, path, allowed) {
   if (typeof t === "string") {
     for (const token of t.match(PLACEHOLDER_TOKEN) ?? []) {
-      if (!PLACEHOLDERS.includes(token)) bad(path, `"${t}" is not a known placeholder (${token})`);
-      if (!allowed.includes(token)) bad(path, `"${t}" uses ${token}, which is not available in this field`);
+      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*)\]$/;
@@ -347,7 +940,7 @@ function typeIssue(t, p, path) {
   if (Array.isArray(t)) return no(`must not be an array for ${p.type}`);
   if (p.type === "address") {
     if (isExactPlaceholder(t)) return t === "{recipient}" || t === "{payer}" ? null : no(`${t} is a number, but the abi input is an address`);
-    return typeof t === "string" && !hasPlaceholder(t) && isAddress(t) ? null : no(`${JSON.stringify(String(t))} is not an address`);
+    return typeof t === "string" && !hasPlaceholder(t) && isAddress2(t) ? null : no(`${JSON.stringify(String(t))} is not an address`);
   }
   if (p.type === "bool") return typeof t === "boolean" ? null : no(`${JSON.stringify(String(t))} is not a boolean`);
   if (p.type === "string") return typeof t === "string" ? null : no(`${JSON.stringify(String(t))} is not a string`);
@@ -373,15 +966,15 @@ var NO_PLACEHOLDERS = [];
 function validateCall(abi, call, prefix, kind, allowed) {
   const c = call ?? {};
   const named = typeof c.functionName === "string" ? functionsNamed(abi, c.functionName) : [];
-  if (named.length === 0) bad(`${prefix}.functionName`, `"${String(c.functionName)}" is not a function in the abi`);
-  if (c.args !== void 0 && !Array.isArray(c.args)) bad(`${prefix}.args`, "must be an array");
-  if (kind === "mint" && c.args === void 0) bad(`${prefix}.args`, "is required");
+  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 = 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 ? 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);
@@ -504,7 +1097,7 @@ function varFor(token, vars) {
   const key = token.slice(1, -1);
   const v = vars[key];
   if (v === void 0) throw new MintError("INVALID_CONFIG", `placeholder ${token} has no value here`);
-  return typeof v === "string" ? getAddress2(v) : v;
+  return typeof v === "string" ? getAddress4(v) : v;
 }
 function fill(t, p, vars) {
   const arr = ARRAY_TYPE.exec(p.type);
@@ -519,38 +1112,38 @@ function fill(t, p, vars) {
 }
 var fillArgs = (args, inputs, vars) => (args ?? []).map((a, i) => fill(a, inputs[i], vars));
 var totalFor = (per, price, quantity) => per === "total" ? price : price * quantity;
-function shortMessage(e) {
-  return e instanceof BaseError ? e.shortMessage : e instanceof Error ? e.message : String(e);
+function shortMessage2(e) {
+  return e instanceof BaseError2 ? e.shortMessage : e instanceof Error ? e.message : String(e);
 }
-var abortError = () => new DOMException("The operation was aborted", "AbortError");
-var isAbortError = (e) => e?.name === "AbortError";
-function throwIfAborted(ctx) {
-  if (ctx.signal?.aborted) throw abortError();
+var abortError2 = () => new DOMException("The operation was aborted", "AbortError");
+var isAbortError2 = (e) => e?.name === "AbortError";
+function throwIfAborted2(ctx) {
+  if (ctx.signal?.aborted) throw abortError2();
 }
-function io(ctx, start) {
+function io2(ctx, start) {
   const signal = ctx.signal;
   if (!signal) return start();
-  if (signal.aborted) return Promise.reject(abortError());
+  if (signal.aborted) return Promise.reject(abortError2());
   return new Promise((resolve, reject) => {
-    const onAbort = () => reject(abortError());
+    const onAbort = () => reject(abortError2());
     signal.addEventListener("abort", onAbort, { once: true });
     start().then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
   });
 }
-function rpcError(e) {
-  if (isMintError(e) || isAbortError(e)) throw e;
-  throw new MintError("RPC_ERROR", `RPC request failed: ${shortMessage(e)}`, { cause: e });
+function rpcError2(e) {
+  if (isMintError(e) || isAbortError2(e)) throw e;
+  throw new MintError("RPC_ERROR", `RPC request failed: ${shortMessage2(e)}`, { cause: e });
 }
 function classifyReadError(e, field) {
-  if (isMintError(e) || isAbortError(e)) throw e;
-  if (e instanceof BaseError && e.walk((x) => x instanceof ContractFunctionRevertedError || x instanceof ContractFunctionZeroDataError)) {
+  if (isMintError(e) || isAbortError2(e)) throw e;
+  if (e instanceof BaseError2 && e.walk((x) => x instanceof ContractFunctionRevertedError2 || x instanceof ContractFunctionZeroDataError2)) {
     throw new 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);
   }
@@ -589,14 +1182,14 @@ function toSeconds(v, field) {
   if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new MintError("INVALID_CONFIG", `${field} is too large for a unix timestamp`, { field });
   return Number(v);
 }
-function nativeMeta(ctx) {
+function nativeMeta2(ctx) {
   const n = ctx.client.chain?.nativeCurrency;
   return { decimals: n?.decimals ?? 18, symbol: n?.symbol ?? "ETH" };
 }
-var erc20Of = (config) => config.price.currency === "native" ? null : getAddress2(config.price.currency.address);
+var erc20Of = (config) => config.price.currency === "native" ? null : getAddress4(config.price.currency.address);
 async function currencyMeta(ctx, config) {
   const token = erc20Of(config);
-  if (!token) return { token, ...nativeMeta(ctx) };
+  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),
@@ -621,13 +1214,13 @@ async function resolvePrice(ctx, config, meta) {
   if (typeof value === "bigint") return value;
   return parseDisplay(value, (meta ?? await currencyMeta(ctx, config)).decimals);
 }
-var money = (value, decimals, symbol) => ({
+var money2 = (value, decimals, symbol) => ({
   value,
   decimals,
   symbol,
-  formatted: formatUnits2(value, decimals)
+  formatted: formatUnits3(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;
@@ -641,7 +1234,7 @@ function revertData(e) {
 }
 function describeRevert(abi, data) {
   try {
-    const d = decodeErrorResult({ abi, data });
+    const d = decodeErrorResult2({ abi, data });
     const args = d.args ?? [];
     if (d.errorName === "Error") return String(args[0] ?? "execution reverted");
     const inputs = d.abiItem?.inputs ?? [];
@@ -653,19 +1246,19 @@ function describeRevert(abi, data) {
 }
 function toSimulationError(e, abi) {
   if (isMintError(e)) return e;
-  if (isAbortError(e)) throw e;
-  if (e instanceof BaseError && e.walk((x) => x instanceof InsufficientFundsError)) {
+  if (isAbortError2(e)) throw e;
+  if (e instanceof BaseError2 && e.walk((x) => x instanceof InsufficientFundsError2)) {
     return new MintError("INSUFFICIENT_FUNDS", `Payer cannot cover the mint: ${e.shortMessage}`, { cause: e });
   }
-  const data = revertData(e);
+  const data = revertData2(e);
   if (data) return new MintError("SIMULATION_REVERTED", describeRevert(abi, data), { cause: e });
-  const isRevert = e instanceof BaseError && e.walk((x) => x.code === 3 || /execution reverted/i.test(x.message));
-  if (isRevert) return new MintError("SIMULATION_REVERTED", shortMessage(e), { cause: e });
-  return new MintError("RPC_ERROR", `RPC request failed: ${shortMessage(e)}`, { cause: e });
+  const isRevert = e instanceof BaseError2 && e.walk((x) => x.code === 3 || /execution reverted/i.test(x.message));
+  if (isRevert) return new MintError("SIMULATION_REVERTED", shortMessage2(e), { cause: e });
+  return new 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);
   }
@@ -673,24 +1266,24 @@ async function simulateMint(ctx, config, call) {
 function encodeMint(config, vars) {
   const fn = validateCall(config.abi, config.mint, "mint", "mint", PLACEHOLDERS);
   try {
-    return encodeFunctionData({ abi: [fn], functionName: fn.name, args: fillArgs(config.mint.args, fn.inputs, vars) });
+    return encodeFunctionData2({ abi: [fn], functionName: fn.name, args: fillArgs(config.mint.args, fn.inputs, vars) });
   } catch (e) {
     if (isMintError(e)) throw e;
-    throw new MintError("INVALID_CONFIG", `mint.args cannot be encoded for ${signature(fn)}: ${shortMessage(e)}`, { field: "mint.args", cause: e });
+    throw new 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: totalMinted ?? 0n,
     maxSupply: maxSupply === null || maxSupply === 0n ? null : maxSupply,
     startTime: toSeconds(start, "startTime"),
@@ -715,9 +1308,9 @@ async function readDrop(ctx, config) {
     pricePer: 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,7 +1318,7 @@ 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)
@@ -738,10 +1331,10 @@ async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
   if (remaining === 0n) {
     ineligible = { reason: "WALLET_LIMIT", message: `This wallet has already minted its limit of ${walletMax}.` };
   } else if (drop.paymentToken === null && native >= totalPrice) {
-    const call = { payer, to: getAddress2(config.address), data: encodeMint(config, vars), value: mintValue(config, null, totalPrice) };
+    const call = { payer, to: getAddress4(config.address), data: encodeMint(config, vars), value: mintValue(config, null, totalPrice) };
     try {
       await simulateMint(ctx, config, call);
-      gas = await io(ctx, () => ctx.client.estimateGas({ account: payer, to: call.to, data: call.data, value: call.value })).catch((e) => {
+      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) {
@@ -750,7 +1343,7 @@ async function readWallet(ctx, config, { payer, recipient, quantity, drop }) {
     }
   }
   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,15 +1354,15 @@ 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(config.price.per ?? "unit", unitPrice, qty);
-  const to = getAddress2(config.address);
+  const to = getAddress4(config.address);
   const token = erc20Of(config);
   const mint = {
     to,
@@ -787,17 +1380,17 @@ async function buildPlan(ctx, attempt, wallet) {
         token,
         spender: to,
         amount: totalPrice,
-        tx: { to: token, data: encodeFunctionData({ abi: ERC20_ABI, functionName: "approve", args: [to, totalPrice] }), value: 0n }
+        tx: { to: token, data: encodeFunctionData2({ abi: ERC20_ABI, functionName: "approve", args: [to, totalPrice] }), value: 0n }
       };
     }
   }
-  return { approve, mint, tokenContract: getAddress2(attempt.tokenContract) };
+  return { approve, mint, tokenContract: getAddress4(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" ? manifoldClaimAdapter : contractAdapter;
+  switch (config.type) {
+    case "manifold-claim":
+      return 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) {
@@ -834,10 +1438,32 @@ var symbolOf = (chainId) => {
 };
 var shortOf = (chainId) => ({ chainId, symbol: symbolOf(chainId), name: chainName(chainId) });
 function tokenContractOf(config) {
-  return config.type === "manifold-claim" ? config.creatorContract : config.tokenContract ?? config.address;
+  switch (config.type) {
+    case "manifold-claim":
+      return config.creatorContract;
+    case "contract":
+      return 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) => UNSUPPORTED_REASONS.includes(reason);
 function errorReasonOf(e) {
@@ -925,7 +1551,7 @@ function useMint(options) {
     }),
     [clientFor]
   );
-  const readDrop2 = useCallback(
+  const readDrop3 = useCallback(
     async (life, gen, cfg) => {
       const adapter = adapterFor(cfg);
       try {
@@ -950,9 +1576,9 @@ function useMint(options) {
       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 = useCallback(
     async (kind = "refresh") => {
@@ -965,9 +1591,9 @@ 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 = useCallback(() => refreshNow("refresh"), [refreshNow]);
   const isBusy = useCallback(
@@ -1043,7 +1669,7 @@ function useMint(options) {
           }
         } catch (e) {
           if (isMintError(e)) throw e;
-          const reverted = e instanceof BaseError2 ? e.walk((cause) => cause instanceof ExecutionRevertedError) : null;
+          const reverted = e instanceof BaseError3 ? e.walk((cause) => cause instanceof ExecutionRevertedError) : null;
           if (reverted instanceof ExecutionRevertedError) {
             throw new MintError("SIMULATION_REVERTED", reverted.shortMessage);
           }
@@ -1094,7 +1720,7 @@ function useMint(options) {
         tokenContract: 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 });
     },
@@ -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);
@@ -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;
@@ -1332,7 +1959,7 @@ function useMint(options) {
     } finally {
       attemptRef.current = null;
     }
-  }, [dispatch, emit, readDrop2, executeAttempt, executeRelayAttempt, resumeOutstanding, refreshNow]);
+  }, [dispatch, emit, readDrop3, executeAttempt, executeRelayAttempt, resumeOutstanding, refreshNow]);
   const mint = useCallback(() => {
     void runMint();
   }, [runMint]);
@@ -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, machine.drop.phaseEndsAt ?? null].some((t) => t !== null && t > machine.now) : false;
   useEffect(() => {
     if (!boundary) return;
     const timer = setInterval(() => {
       const s = stateRef.current;
       const now = nowSec();
-      const crossed = s.drop && [s.drop.startTime, s.drop.endTime].some((t) => t !== null && t > s.now && t <= now);
+      const crossed = s.drop && [s.drop.startTime, s.drop.endTime, s.drop.phaseEndsAt ?? null].some((t) => t !== null && t > s.now && t <= now);
       dispatch({ type: "TICK", now });
       if (crossed) void refreshNow();
     }, TICK_MS);
@@ -1613,13 +2240,13 @@ function useMint(options) {
 
 // src/react/PayWithPicker.ts
 import { createElement, useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
-import { formatUnits as formatUnits3 } from "viem";
+import { formatUnits as formatUnits4 } from "viem";
 var PICKER_REFRESH_MS = 2e4;
 var PICKER_DEBOUNCE_MS = 500;
 var RELAY_REASONS = /* @__PURE__ */ new Set(["BRIDGE_UNAVAILABLE", "BRIDGE_TIMEOUT", "BRIDGE_REFUNDED", "BRIDGE_FAILED"]);
-var money2 = (value, chainId) => {
+var money3 = (value, chainId) => {
   const c = getChain(chainId).nativeCurrency;
-  return { value, decimals: c.decimals, symbol: c.symbol, formatted: formatUnits3(value, c.decimals) };
+  return { value, decimals: c.decimals, symbol: c.symbol, formatted: formatUnits4(value, c.decimals) };
 };
 function usePayOptions(mint, onSelect) {
   const info = mint.crossChain;
@@ -1695,7 +2322,7 @@ function usePayOptions(mint, onSelect) {
       isDropChain,
       relayFee: isDropChain ? null : quoted?.relayFee ?? null,
       amountIn: isDropChain ? null : quoted?.amountIn ?? null,
-      balance: balance && balance.chainId === chainId && chainId === current ? money2(balance.value, chainId) : null,
+      balance: balance && balance.chainId === chainId && chainId === current ? money3(balance.value, chainId) : null,
       loading: !isDropChain && q === void 0,
       select: () => select(chainId)
     };
@@ -1806,7 +2433,7 @@ function MintButton(props) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.4.0";
 export {
   CLICKABLE_STATES,
   MAX_QUANTITY,