@manifoldxyz/dropkit 0.4.0 → 0.5.0

package/dist/chunk-W7OBZPCY.js

@@ -0,0 +1,619 @@
+import {
+  INELIGIBLE_REASONS,
+  MintError,
+  getChain
+} from "./chunk-VHAAGH7Z.js";
+
+// src/core/machine.ts
+import { formatUnits } from "viem";
+var MINT_STATES = [
+  "loading",
+  "unsupported",
+  "upcoming",
+  "ended",
+  "sold-out",
+  "disconnected",
+  "connecting",
+  "live",
+  "ineligible",
+  "insufficient-funds",
+  "switching-chain",
+  "approving",
+  "minting",
+  "confirming",
+  "success",
+  "error"
+];
+var CLICKABLE_STATES = ["disconnected", "live", "success", "error"];
+var IN_FLIGHT_STATES = ["switching-chain", "approving", "minting", "confirming"];
+var MAX_QUANTITY = 65535;
+function initialState(opts) {
+  return {
+    name: "loading",
+    reason: null,
+    message: null,
+    readGen: 0,
+    walletGen: 0,
+    drop: null,
+    account: null,
+    walletRead: null,
+    blocked: null,
+    quantity: toQuantity(opts?.quantity ?? 1, MAX_QUANTITY),
+    attempt: null,
+    result: null,
+    pendingRefresh: false,
+    now: 0,
+    crossChain: false,
+    routePending: false,
+    route: null,
+    short: null
+  };
+}
+var NO_ROUTE = { crossChain: false, routePending: false, route: null, short: null };
+var PICK_ANOTHER = "Pick another network to pay from.";
+function toQuantity(q, max) {
+  if (Number.isNaN(q)) return 1;
+  return Math.max(1, Math.min(Math.floor(q), max));
+}
+function isInFlight(s) {
+  return s.attempt !== null || IN_FLIGHT_STATES.includes(s.name);
+}
+function isIdle(s) {
+  return !isInFlight(s) && s.name !== "connecting" && s.name !== "success" && s.name !== "error";
+}
+function derive(s, unsupported) {
+  const named = (name) => ({ name, reason: null, message: null });
+  const { drop, walletRead } = s;
+  if (unsupported) return { name: "unsupported", reason: s.reason, message: s.message };
+  if (drop === null) return named("loading");
+  if (drop.endTime !== null && drop.endTime <= s.now) return named("ended");
+  if (drop.maxSupply !== null && drop.maxSupply > 0n && drop.totalMinted >= drop.maxSupply) return named("sold-out");
+  if (drop.startTime !== null && drop.startTime > s.now) return named("upcoming");
+  if (s.account === null) return named("disconnected");
+  if (walletRead === null) return named("loading");
+  if (s.blocked !== null) return s.blocked;
+  if (walletRead.ineligible !== null) {
+    return { name: "ineligible", reason: walletRead.ineligible.reason, message: walletRead.ineligible.message };
+  }
+  if (s.routePending) return named("loading");
+  if (s.route?.kind === "relay") return named("live");
+  if (s.short !== null) {
+    return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${s.short.symbol} on ${s.short.name}. ${PICK_ANOTHER}` };
+  }
+  const total = selectTotal(s);
+  if (total !== null) {
+    const { native, erc20 } = total;
+    if (native.value + walletRead.gasReserve > walletRead.balances.native) {
+      const more = s.crossChain ? ` ${PICK_ANOTHER}` : "";
+      return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${native.symbol} to cover the mint.${more}` };
+    }
+    if (erc20 !== null && walletRead.balances.erc20 !== null && erc20.value > walletRead.balances.erc20) {
+      return { name: "insufficient-funds", reason: "INSUFFICIENT_FUNDS", message: `Not enough ${erc20.symbol} to cover the mint.` };
+    }
+  }
+  return named("live");
+}
+function settle(s, unsupported = s.name === "unsupported") {
+  if (!isIdle(s)) return s;
+  return { ...s, ...derive(s, unsupported) };
+}
+function clampQuantity(s) {
+  const quantity = toQuantity(s.quantity, selectMaxQuantity(s) ?? MAX_QUANTITY);
+  return quantity === s.quantity ? s : { ...s, quantity };
+}
+function reducer(state, event) {
+  const inFlight = isInFlight(state);
+  const failed = (reason, message) => {
+    if (inFlight) return { ...state, pendingRefresh: true };
+    if (state.name === "success" || state.name === "error") return state;
+    return { ...state, name: "error", reason, message };
+  };
+  switch (event.type) {
+    case "LOAD": {
+      if (event.kind === "refresh") {
+        const next2 = { ...state, readGen: event.gen };
+        return inFlight ? { ...next2, pendingRefresh: true } : settle(next2);
+      }
+      const next = { ...state, ...NO_ROUTE, readGen: event.gen, drop: null, walletRead: null, blocked: null, walletGen: state.walletGen + 1 };
+      return inFlight ? { ...next, pendingRefresh: true } : settle(next, false);
+    }
+    case "DROP_LOADED": {
+      if (event.gen !== state.readGen) return state;
+      let next = { ...state, drop: event.drop, now: Math.max(state.now, event.now) };
+      const oldKey = state.drop?.walletKey;
+      const newKey = event.drop.walletKey;
+      if (oldKey !== void 0 && newKey !== void 0 && oldKey !== newKey) {
+        next = { ...next, walletRead: null, walletGen: state.walletGen + 1 };
+      }
+      if (inFlight) return { ...next, pendingRefresh: true };
+      return isIdle(next) ? settle(clampQuantity(next), false) : clampQuantity(next);
+    }
+    case "DROP_UNSUPPORTED": {
+      if (event.gen !== state.readGen) return state;
+      if (inFlight) return { ...state, pendingRefresh: true };
+      if (state.name === "success" || state.name === "error") return state;
+      return { ...state, name: "unsupported", reason: event.reason, message: event.message };
+    }
+    case "READ_FAILED":
+      return event.gen !== state.readGen ? state : failed(event.reason, event.message);
+    case "ACCOUNT_CHANGED": {
+      const next = { ...state, ...NO_ROUTE, account: event.account, walletRead: null, blocked: null, walletGen: state.walletGen + 1 };
+      if (inFlight) return { ...next, pendingRefresh: true };
+      if (state.name === "connecting") return event.account === null ? next : settle({ ...next, name: "loading" }, false);
+      return settle(next);
+    }
+    case "WALLET_LOADED": {
+      if (event.gen !== state.walletGen) return state;
+      const route = event.routePending ? { routePending: state.route === null && state.short === null, route: state.route, short: state.short } : { routePending: false, route: null, short: null };
+      const next = { ...state, ...route, crossChain: event.crossChain ?? false, walletRead: event.read, blocked: null };
+      return inFlight ? { ...next, pendingRefresh: true } : settle(clampQuantity(next));
+    }
+    case "ROUTE_LOADED": {
+      if (event.gen !== state.walletGen) return state;
+      const next = { ...state, routePending: false, route: event.route, short: event.short };
+      return inFlight ? { ...next, pendingRefresh: true } : settle(next);
+    }
+    case "WALLET_FAILED":
+      return event.gen !== state.walletGen ? state : failed(event.reason, event.message);
+    case "CONNECT_STARTED":
+      return state.name === "disconnected" && state.attempt === null ? { ...state, name: "connecting", reason: null, message: null } : state;
+    case "CONNECT_DISMISSED":
+      return state.name === "connecting" ? settle({ ...state, name: "disconnected" }, false) : state;
+    case "TICK":
+      return settle({ ...state, now: Math.max(state.now, event.now) });
+    case "SET_QUANTITY": {
+      const next = { ...state, quantity: toQuantity(event.quantity, selectMaxQuantity(state) ?? MAX_QUANTITY) };
+      return inFlight ? { ...next, pendingRefresh: true } : settle(next);
+    }
+    case "ATTEMPT_STARTED":
+      if (state.attempt !== null) return state;
+      if (event.resume === true) return IN_FLIGHT_STATES.includes(state.name) ? state : { ...state, attempt: event.attempt };
+      return state.name === "live" ? { ...state, attempt: event.attempt } : state;
+    case "SWITCHING_CHAIN":
+      return step(state, event.attemptId, "switching-chain");
+    case "APPROVING":
+      return step(state, event.attemptId, "approving");
+    case "MINT_PROMPTED":
+      return step(state, event.attemptId, "minting");
+    case "TX_SUBMITTED":
+      return step(state, event.attemptId, "confirming");
+    case "ATTEMPT_SUCCEEDED":
+      return state.attempt?.attemptId === event.attemptId ? {
+        ...state,
+        name: "success",
+        reason: null,
+        message: null,
+        attempt: null,
+        result: event.result,
+        drop: null,
+        readGen: state.readGen + 1
+      } : state;
+    case "ATTEMPT_FAILED": {
+      if (state.attempt?.attemptId !== event.attemptId) return state;
+      const { reason, message } = event;
+      const done = { ...state, reason, message, attempt: null, result: null };
+      if (INELIGIBLE_REASONS.includes(reason)) {
+        return { ...done, name: "ineligible", blocked: { name: "ineligible", reason, message } };
+      }
+      if (reason === "INSUFFICIENT_FUNDS") {
+        return { ...done, name: "insufficient-funds", blocked: { name: "insufficient-funds", reason, message } };
+      }
+      return {
+        ...done,
+        name: "error",
+        drop: state.name === "confirming" ? null : state.drop,
+        readGen: state.name === "confirming" ? state.readGen + 1 : state.readGen
+      };
+    }
+    case "RESET": {
+      if (state.name !== "success" && state.name !== "error") return state;
+      const next = {
+        ...state,
+        readGen: event.gen,
+        ...NO_ROUTE,
+        walletRead: null,
+        blocked: null,
+        walletGen: state.walletGen + 1,
+        result: null,
+        pendingRefresh: false
+      };
+      return settle(clampQuantity({ ...next, name: "loading" }), false);
+    }
+  }
+}
+var STEP_ORDER = ["switching-chain", "approving", "minting", "confirming"];
+function step(state, attemptId, name) {
+  if (state.attempt?.attemptId !== attemptId) return state;
+  if (STEP_ORDER.indexOf(name) <= STEP_ORDER.indexOf(state.name)) return state;
+  return { ...state, name, reason: null, message: null };
+}
+function selectMaxQuantity(state) {
+  const { drop, walletRead } = state;
+  if (drop === null) return null;
+  let max = MAX_QUANTITY;
+  if (drop.maxSupply !== null && drop.maxSupply > 0n) {
+    const remaining = drop.maxSupply - drop.totalMinted;
+    if (remaining < BigInt(max)) max = remaining > 0n ? Number(remaining) : 0;
+  }
+  if (walletRead !== null && walletRead.maxQuantity !== null) {
+    max = Math.min(max, Math.max(0, Math.floor(walletRead.maxQuantity)));
+  }
+  return max;
+}
+function selectTotal(state) {
+  const { drop } = state;
+  if (drop === null) return null;
+  const q = BigInt(state.quantity);
+  const price = drop.unitPrice;
+  const fee = drop.unitFee;
+  const priceTotal = drop.pricePer === "total" ? price.value : price.value * q;
+  if (drop.paymentToken !== null) {
+    return {
+      native: money(fee.value * q, fee),
+      erc20: money(priceTotal, price)
+    };
+  }
+  return { native: money(priceTotal + fee.value * q, price), erc20: null };
+}
+function money(value, like) {
+  return { value, decimals: like.decimals, symbol: like.symbol, formatted: formatUnits(value, like.decimals) };
+}
+function canAct(state) {
+  return state.attempt === null && CLICKABLE_STATES.includes(state.name);
+}
+
+// src/core/wallet/index.ts
+import { createWalletClient, custom, getAddress, publicActions } from "viem";
+var CONNECT_WIDGET_VERSION = "6.5.0";
+var CONNECT_BASE_URL = `https://connect.manifoldxyz.dev/${CONNECT_WIDGET_VERSION}`;
+var CONNECT_ID = "mint-button";
+var ADDRESS_CHANGED = "ethereum-address-changed";
+var CHAIN_CHANGED = "frontend-provider-chain-changed";
+var LOADER_KEY = "__manifoldMintConnectLoader";
+var DEFAULT_WALLETCONNECT_PROJECT_ID = "a03ac1695f309dc8d756e7b4006e5e7d";
+var STATE_KEY = "__manifoldMintConnectStateV1";
+var win = () => window;
+var pageState = () => win()[STATE_KEY] ??= {};
+var TOO_OLD = "A Manifold connect widget older than 6.4.0 is already on this page; update it or remove it so dropkit can load " + CONNECT_WIDGET_VERSION + ".";
+var MANIFOLD_HOST = /(^|\.)(manifoldxyz\.dev|manifold\.xyz)$/;
+function isManifoldConnectScript(src) {
+  try {
+    const url = new URL(src, document.baseURI);
+    return url.hostname === "connect.manifoldxyz.dev" || MANIFOLD_HOST.test(url.hostname) && /\/connect\.umd[^/]*\.js$/.test(url.pathname);
+  } catch {
+    return false;
+  }
+}
+function applyState(state) {
+  if (!state.div) return;
+  const network = state.networks.join(",");
+  if (state.div.dataset.network !== network) state.div.dataset.network = network;
+  const projectId = state.projectId ?? state.div.dataset.walletConnectProjectId ?? DEFAULT_WALLETCONNECT_PROJECT_ID;
+  if (state.div.dataset.walletConnectProjectId !== projectId) state.div.dataset.walletConnectProjectId = projectId;
+}
+function register(state, opts) {
+  for (const id2 of opts.chainIds) if (!state.networks.includes(id2)) state.networks.push(id2);
+  const id = opts.walletConnectProjectId;
+  if (id) {
+    if (!state.projectId) state.projectId = id;
+    else if (state.projectId !== id) {
+      console.warn(`dropkit: walletConnectProjectId "${id}" ignored; this page already uses "${state.projectId}" for the shared connect widget.`);
+    }
+  }
+  applyState(state);
+}
+function startLoad(state) {
+  const connect = win().ManifoldConnect;
+  if (connect?.capabilities?.includes("open")) return Promise.resolve(connect.ready).then(() => void 0);
+  const hasScript = Array.from(document.querySelectorAll("script[src]")).some((s) => isManifoldConnectScript(s.src));
+  if (hasScript || document.querySelector('[data-widget="m-connect"]')) {
+    return Promise.reject(new MintError("CONNECT_WIDGET_TOO_OLD", TOO_OLD));
+  }
+  return new Promise((resolve, reject) => {
+    const css = document.createElement("link");
+    css.rel = "stylesheet";
+    css.href = `${CONNECT_BASE_URL}/connect.css`;
+    document.head.appendChild(css);
+    state.nodes.push(css);
+    const div = document.createElement("div");
+    div.hidden = true;
+    div.style.display = "none";
+    div.dataset.widget = "m-connect";
+    div.dataset.connectId = CONNECT_ID;
+    div.dataset.autoReconnect = "true";
+    div.dataset.enableNetworkSwitching = "true";
+    state.div = div;
+    applyState(state);
+    document.body.appendChild(div);
+    state.nodes.push(div);
+    const script = document.createElement("script");
+    script.src = `${CONNECT_BASE_URL}/connect.umd.min.js`;
+    script.async = true;
+    script.addEventListener("load", () => {
+      const ready = win().ManifoldConnect?.ready;
+      if (!ready) return reject(new MintError("CONNECT_WIDGET_TOO_OLD", TOO_OLD));
+      Promise.resolve(ready).then(() => resolve(), reject);
+    });
+    script.addEventListener("error", () => reject(new MintError("RPC_ERROR", `Could not load the Manifold connect widget from ${CONNECT_BASE_URL}`)));
+    document.head.appendChild(script);
+    state.nodes.push(script);
+  });
+}
+function loadConnectWidget(opts) {
+  const w = win();
+  const page = pageState();
+  const existing = w[LOADER_KEY];
+  if (existing) {
+    if (page.load?.promise !== existing) {
+      const div = document.querySelector(`[data-widget="m-connect"][data-connect-id="${CONNECT_ID}"]`) ?? void 0;
+      page.load = {
+        promise: existing,
+        networks: div?.dataset.network?.split(",").filter(Boolean).map(Number) ?? [],
+        // The default id is a placeholder, not a choice: a caller's real id may still replace it.
+        projectId: div?.dataset.walletConnectProjectId === DEFAULT_WALLETCONNECT_PROJECT_ID ? void 0 : div?.dataset.walletConnectProjectId,
+        div,
+        nodes: []
+      };
+    }
+    register(page.load, opts);
+    return existing;
+  }
+  let resolve;
+  let reject;
+  const p = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  const state = { promise: p, networks: [], nodes: [] };
+  page.load = state;
+  w[LOADER_KEY] = p;
+  p.catch(() => {
+    if (w[LOADER_KEY] === p) delete w[LOADER_KEY];
+    if (page.load === state) page.load = void 0;
+    for (const node of state.nodes) node.parentNode?.removeChild(node);
+    state.nodes.length = 0;
+    state.div = void 0;
+  });
+  register(state, opts);
+  try {
+    startLoad(state).then(resolve, reject);
+  } catch (error) {
+    reject(error);
+  }
+  return p;
+}
+function openConnectModal() {
+  const page = pageState();
+  if (page.pendingModal) return page.pendingModal;
+  const p = new Promise((resolve) => {
+    const onClosed = (e) => {
+      const detail = e.detail ?? {};
+      if (detail.connectId !== void 0 && detail.connectId !== CONNECT_ID) return;
+      window.removeEventListener("m-connect:closed", onClosed);
+      page.pendingModal = void 0;
+      resolve(detail.reason === "connected" ? "connected" : "dismissed");
+    };
+    window.addEventListener("m-connect:closed", onClosed);
+  });
+  page.pendingModal = p;
+  window.dispatchEvent(new CustomEvent("m-connect:open", { detail: { connectId: CONNECT_ID } }));
+  return p;
+}
+function getAccount() {
+  const p = win().ManifoldEthereumProvider;
+  const address = p?.selectedAddress?.();
+  let chainId = p?.chainId?.();
+  if (chainId === void 0 || chainId === null) {
+    try {
+      chainId = p?.browserChainId?.();
+    } catch {
+      chainId = void 0;
+    }
+  }
+  if (!address || chainId === void 0 || chainId === null) return null;
+  return { address: getAddress(address), chainId: Number(chainId) };
+}
+function subscribeAccount(cb) {
+  const handler = () => cb(getAccount());
+  window.addEventListener(ADDRESS_CHANGED, handler);
+  window.addEventListener(CHAIN_CHANGED, handler);
+  return () => {
+    window.removeEventListener(ADDRESS_CHANGED, handler);
+    window.removeEventListener(CHAIN_CHANGED, handler);
+  };
+}
+function eip1193() {
+  const p = win().ManifoldEthereumProvider;
+  const provider = (p?.provider?.(true) ?? p?.browserProvider?.())?.provider;
+  if (!provider) throw new MintError("CHAIN_SWITCH_FAILED", "No wallet is connected.");
+  return provider;
+}
+function getWalletClient(chainId) {
+  const provider = eip1193();
+  const request = ((args) => provider.request(args));
+  return createWalletClient({ chain: getChain(chainId), transport: custom({ request }) });
+}
+async function waitForDeposit(chainId, hash, timeoutMs = 12e4) {
+  try {
+    const receipt = await getWalletClient(chainId).extend(publicActions).waitForTransactionReceipt({ hash, confirmations: 1, timeout: timeoutMs });
+    return receipt.status === "reverted" ? "reverted" : "mined";
+  } catch {
+    return "unknown";
+  }
+}
+var WALLET_READ_TIMEOUT = { ms: 1e4 };
+async function getConnectedBalance(address, chainId) {
+  const provider = eip1193();
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new MintError("RPC_ERROR", "The wallet did not report a balance in time.")), WALLET_READ_TIMEOUT.ms);
+  });
+  try {
+    return await Promise.race([
+      (async () => {
+        const current = Number(await provider.request({ method: "eth_chainId" }));
+        if (current !== chainId) {
+          throw new MintError("CHAIN_SWITCH_FAILED", `The wallet is on chain ${String(current)}, not ${String(chainId)}.`);
+        }
+        const hex = await provider.request({ method: "eth_getBalance", params: [address, "latest"] });
+        return BigInt(hex);
+      })(),
+      timeout
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var code = (e) => e?.code;
+var hexChainId = (chainId) => `0x${chainId.toString(16)}`;
+var sendSwitchRequest = (provider, chainId) => provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: hexChainId(chainId) }] });
+var sendAddRequest = (provider, chainId) => {
+  const chain = getChain(chainId);
+  return provider.request({
+    method: "wallet_addEthereumChain",
+    params: [
+      {
+        chainId: hexChainId(chainId),
+        chainName: chain.name,
+        nativeCurrency: chain.nativeCurrency,
+        rpcUrls: [...chain.rpcUrls.default.http],
+        ...chain.blockExplorers ? { blockExplorerUrls: [chain.blockExplorers.default.url] } : {}
+      }
+    ]
+  });
+};
+function chainRequestError(e, chainId) {
+  if (code(e) === 4001) return new MintError("USER_REJECTED", "You rejected the network switch.", { cause: e });
+  return new MintError("CHAIN_SWITCH_FAILED", `Could not switch the wallet to chain ${String(chainId)}.`, { cause: e });
+}
+async function switchToChain(chainId) {
+  getChain(chainId);
+  const provider = eip1193();
+  try {
+    try {
+      await sendSwitchRequest(provider, chainId);
+    } catch (e) {
+      if (code(e) !== 4902) throw e;
+      await sendAddRequest(provider, chainId);
+      await sendSwitchRequest(provider, chainId);
+    }
+  } catch (e) {
+    throw chainRequestError(e, chainId);
+  }
+}
+async function requestSwitch(chainId) {
+  getChain(chainId);
+  const provider = eip1193();
+  try {
+    await sendSwitchRequest(provider, chainId);
+    return { needsAdd: false };
+  } catch (e) {
+    if (code(e) === 4902) return { needsAdd: true };
+    throw chainRequestError(e, chainId);
+  }
+}
+async function requestAddChain(chainId) {
+  getChain(chainId);
+  const provider = eip1193();
+  try {
+    await sendAddRequest(provider, chainId);
+  } catch (e) {
+    throw chainRequestError(e, chainId);
+  }
+}
+function getWalletProvider() {
+  return eip1193();
+}
+
+// src/core/adapters/receipt.ts
+import { decodeAbiParameters, getAddress as getAddress2, zeroAddress } from "viem";
+var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+var TRANSFER_SINGLE_TOPIC = "0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62";
+var TRANSFER_BATCH_TOPIC = "0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb";
+var topicAddress = (t) => t && t.length === 66 ? getAddress2(`0x${t.slice(26)}`) : null;
+function parseMintReceipt(logs, { tokenContract, recipient }) {
+  const contract = getAddress2(tokenContract);
+  const to = getAddress2(recipient);
+  const out = /* @__PURE__ */ new Map();
+  const add = (id, amount) => out.set(id, (out.get(id) ?? 0n) + amount);
+  for (const log of logs) {
+    if (getAddress2(log.address) !== contract) continue;
+    const [t0, t1, t2, t3] = log.topics;
+    if (t0 === TRANSFER_TOPIC && log.topics.length === 4) {
+      if (topicAddress(t1) !== zeroAddress || topicAddress(t2) !== to || !t3) continue;
+      add(BigInt(t3), 1n);
+    } else if (t0 === TRANSFER_SINGLE_TOPIC && log.topics.length === 4) {
+      if (topicAddress(t2) !== zeroAddress || topicAddress(t3) !== to) continue;
+      const [id, value] = decodeAbiParameters([{ type: "uint256" }, { type: "uint256" }], log.data);
+      add(id, value);
+    } else if (t0 === TRANSFER_BATCH_TOPIC && log.topics.length === 4) {
+      if (topicAddress(t2) !== zeroAddress || topicAddress(t3) !== to) continue;
+      const [ids, values] = decodeAbiParameters([{ type: "uint256[]" }, { type: "uint256[]" }], log.data);
+      if (ids.length !== values.length) continue;
+      ids.forEach((id, i) => add(id, values[i]));
+    }
+  }
+  return [...out].map(([tokenId, amount]) => ({ contract, tokenId, amount }));
+}
+
+// src/core/mint-record.ts
+var APPS_API = "https://apps.api.manifoldxyz.dev";
+var isRecord = (v) => typeof v === "object" && v !== null;
+var appIds = /* @__PURE__ */ new Map();
+async function loadAppId(fetchFn, instanceId) {
+  const res = await fetchFn(`${APPS_API}/public/instance/data?id=${encodeURIComponent(instanceId)}`, { keepalive: true });
+  if (!res.ok) throw new Error(`instance data HTTP ${res.status}`);
+  const body = await res.json();
+  const appId = isRecord(body) ? body.appId : void 0;
+  if (typeof appId !== "number" && typeof appId !== "string") throw new Error("instance data has no appId");
+  return String(appId);
+}
+function appIdFor(fetchFn, instanceId) {
+  const hit = appIds.get(instanceId);
+  if (hit) return hit;
+  const p = loadAppId(fetchFn, instanceId);
+  appIds.set(instanceId, p);
+  p.catch(() => {
+    if (appIds.get(instanceId) === p) appIds.delete(instanceId);
+  });
+  return p;
+}
+function recordClaimMint(args) {
+  const fetchFn = args.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  const send = async () => {
+    let appId = "";
+    try {
+      appId = await appIdFor(fetchFn, args.instanceId);
+    } catch {
+    }
+    const query = new URLSearchParams({ appId, instanceId: args.instanceId, hash: args.hash });
+    await fetchFn(`${APPS_API}/public/instance/tx?${query.toString()}`, { method: "POST", keepalive: true });
+  };
+  return send().catch(() => void 0);
+}
+
+export {
+  loadConnectWidget,
+  openConnectModal,
+  getAccount,
+  subscribeAccount,
+  getWalletClient,
+  waitForDeposit,
+  getConnectedBalance,
+  switchToChain,
+  requestSwitch,
+  requestAddChain,
+  getWalletProvider,
+  MINT_STATES,
+  CLICKABLE_STATES,
+  IN_FLIGHT_STATES,
+  MAX_QUANTITY,
+  initialState,
+  reducer,
+  selectMaxQuantity,
+  selectTotal,
+  canAct,
+  parseMintReceipt,
+  recordClaimMint
+};
+//# sourceMappingURL=chunk-W7OBZPCY.js.map