@manifoldxyz/dropkit 0.4.0 → 0.5.0

package/dist/status.cjs

@@ -0,0 +1,570 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _chunkXWONUCGAcjs = require('./chunk-XWONUCGA.cjs');
+
+// src/status/useDropStatus.ts
+var _react = require('react');
+
+// src/status/core.ts
+var soldOut = (s) => s.maxSupply !== null && s.maxSupply > 0n && s.totalMinted !== null && s.totalMinted >= s.maxSupply;
+var windowClosed = (s, nowSec) => s.endTime !== null && nowSec >= s.endTime;
+function phaseOf(s, nowSec) {
+  if (soldOut(s)) return "sold-out";
+  if (s.auction && s.bid !== null && (s.closed || windowClosed(s, nowSec))) return "sold-out";
+  if (s.closed) return "ended";
+  if (s.startTime !== null && nowSec < s.startTime) return "upcoming";
+  if (windowClosed(s, nowSec)) return "ended";
+  return "live";
+}
+function unknownStatus(error = null) {
+  return {
+    phase: "unknown",
+    startTime: null,
+    endTime: null,
+    durationAfterFirstBid: null,
+    totalMinted: null,
+    maxSupply: null,
+    remaining: null,
+    price: null,
+    paymentToken: null,
+    bid: null,
+    soldFor: null,
+    stale: false,
+    updatedAt: null,
+    error,
+    clockOffsetMs: 0
+  };
+}
+function statusOf(s, nowSec, meta) {
+  const phase = phaseOf(s, nowSec);
+  const remaining = s.maxSupply !== null && s.totalMinted !== null ? s.maxSupply > s.totalMinted ? s.maxSupply - s.totalMinted : 0n : null;
+  const soldFor = phase !== "sold-out" ? null : s.auction ? _nullishCoalesce(_optionalChain([s, 'access', _ => _.bid, 'optionalAccess', _2 => _2.amount]), () => ( null)) : s.price;
+  return {
+    phase,
+    startTime: s.startTime,
+    endTime: s.endTime,
+    durationAfterFirstBid: s.durationAfterFirstBid,
+    totalMinted: s.totalMinted,
+    maxSupply: s.maxSupply,
+    remaining,
+    price: s.price,
+    paymentToken: s.paymentToken,
+    bid: s.bid,
+    soldFor,
+    ...meta
+  };
+}
+var CLOCK_TOLERANCE_MS = 3e4;
+function clockOffsetOf(serverNowMs, deviceNowMs) {
+  const offset = serverNowMs - deviceNowMs;
+  return Math.abs(offset) <= CLOCK_TOLERANCE_MS ? 0 : offset;
+}
+var UNIT_SECONDS = { s: 1, m: 60, h: 3600, d: 86400, w: 604800 };
+function parseDuration(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) throw new RangeError(`Invalid duration ${String(value)}: use seconds >= 0 or a string like "6h".`);
+    return value;
+  }
+  const m = /^(\d+(?:\.\d+)?)\s*([smhdw])?$/i.exec(value.trim());
+  if (!m) throw new RangeError(`Invalid duration "${value}": use seconds or a string like "6h", "30m", "2d".`);
+  return Number(m[1]) * UNIT_SECONDS[(_nullishCoalesce(m[2], () => ( "s"))).toLowerCase()];
+}
+function countdownParts(totalSeconds, units = "dhms") {
+  let left = Math.max(0, Math.floor(totalSeconds));
+  const shown = ["d", "h", "m", "s"].filter((u) => units.includes(u));
+  const use = shown.length > 0 ? shown : ["d", "h", "m", "s"];
+  const out = { d: 0, h: 0, m: 0, s: 0 };
+  for (const u of use) {
+    const size = UNIT_SECONDS[u];
+    out[u] = Math.floor(left / size);
+    left -= out[u] * size;
+  }
+  return out;
+}
+
+// src/status/read.ts
+var _viem = require('viem');
+var MARKETPLACE_API = {
+  1: "https://marketplace.api.manifoldxyz.dev",
+  11155111: "https://sepolia.marketplace.api.manifoldxyz.dev",
+  8453: "https://base.marketplace.api.manifoldxyz.dev",
+  10: "https://optimism.marketplace.api.manifoldxyz.dev",
+  360: "https://shape.marketplace.api.manifoldxyz.dev"
+};
+var MARKETPLACE_ADDRESSES = {
+  1: "0x3a3548e060be10c2614d0a4cb0c03cc9093fd799",
+  10: "0x5246807fb65d87b0d0a234e0f3d42374de83b421",
+  8453: "0x5246807fb65d87b0d0a234e0f3d42374de83b421",
+  360: "0x5246807fb65d87b0d0a234e0f3d42374de83b421",
+  11155111: "0x5246807fb65d87b0d0a234e0f3d42374de83b421"
+};
+var SINGLE_CONCURRENCY = 3;
+var DURATION_CUTOFF = 1e11;
+var asError = (e) => e instanceof Error ? e : new Error(String(e));
+var fail = (message, cause) => ({ ok: false, error: new Error(message, cause === void 0 ? void 0 : { cause }) });
+function sourceKey(source) {
+  if (source.type === "manifold-claim") {
+    return JSON.stringify(["claim", source.chainId, source.creatorContract.toLowerCase(), source.instanceId, _nullishCoalesce(_optionalChain([source, 'access', _3 => _3.extensionAddress, 'optionalAccess', _4 => _4.toLowerCase, 'call', _5 => _5()]), () => ( null))]);
+  }
+  return JSON.stringify(["listing", source.chainId, source.listingId, _nullishCoalesce(_optionalChain([source, 'access', _6 => _6.marketplace, 'optionalAccess', _7 => _7.toLowerCase, 'call', _8 => _8()]), () => ( null))]);
+}
+var TIMESTAMP_ABI = _viem.parseAbi.call(void 0, ["function getCurrentBlockTimestamp() view returns (uint256 timestamp)"]);
+function seconds(v, field) {
+  if (v === 0n) return null;
+  if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error(`Claim ${field} does not fit a safe integer`);
+  return Number(v);
+}
+function snapshotFromClaim(claim) {
+  return {
+    kind: "claim",
+    startTime: seconds(BigInt(claim.startDate), "startDate"),
+    endTime: seconds(BigInt(claim.endDate), "endDate"),
+    durationAfterFirstBid: null,
+    totalMinted: claim.total,
+    maxSupply: claim.totalMax === 0n ? null : claim.totalMax,
+    price: claim.cost,
+    paymentToken: claim.erc20 === _viem.zeroAddress ? null : _viem.getAddress.call(void 0, claim.erc20),
+    bid: null,
+    auction: false,
+    closed: false
+  };
+}
+function validateClaim(source) {
+  if (!_viem.isAddress.call(void 0, source.creatorContract, { strict: false })) return new Error("creatorContract is not a valid address.");
+  if (typeof source.instanceId !== "string" || !/^\d+$/.test(source.instanceId)) return new Error("instanceId must be a non-negative integer string.");
+  let pinned = null;
+  if (source.extensionAddress !== void 0) {
+    if (!_viem.isAddress.call(void 0, source.extensionAddress, { strict: false })) return new Error("extensionAddress is not a valid address.");
+    pinned = _nullishCoalesce(_chunkXWONUCGAcjs.findExtension.call(void 0, source.chainId, source.extensionAddress.toLowerCase()), () => ( null));
+    if (!pinned) return new Error(`Extension ${source.extensionAddress} is not a supported Manifold claim extension on chain ${String(source.chainId)}.`);
+  }
+  return { creator: _viem.getAddress.call(void 0, source.creatorContract), instanceId: BigInt(source.instanceId), pinned };
+}
+async function multicall(client, calls) {
+  const multicall3 = _optionalChain([client, 'access', _9 => _9.chain, 'optionalAccess', _10 => _10.contracts, 'optionalAccess', _11 => _11.multicall3, 'optionalAccess', _12 => _12.address]);
+  const contracts = multicall3 ? [...calls, { address: multicall3, abi: TIMESTAMP_ABI, functionName: "getCurrentBlockTimestamp" }] : calls;
+  const raw = await client.multicall({ contracts, allowFailure: true, batchSize: 0 });
+  const results = raw.slice(0, calls.length).map((r) => r.status === "success" ? r : { status: "failure", error: asError(r.error) });
+  const last = multicall3 ? raw[calls.length] : void 0;
+  return { results, blockTimestamp: _optionalChain([last, 'optionalAccess', _13 => _13.status]) === "success" && typeof last.result === "bigint" ? last.result : null };
+}
+async function readClaimChain(client, chainId, work, deps) {
+  const outcomes = /* @__PURE__ */ new Map();
+  const cache = deps.extensionCache;
+  const cacheKey = (w) => `${String(chainId)}:${w.creator.toLowerCase()}:${w.instanceId.toString()}`;
+  const onChain = _chunkXWONUCGAcjs.EXTENSIONS.filter((e) => e.chainId === chainId);
+  const probes = [];
+  for (const w of work) {
+    const known = _nullishCoalesce(_nullishCoalesce(w.pinned, () => ( _optionalChain([cache, 'optionalAccess', _14 => _14.get, 'call', _15 => _15(cacheKey(w))]))), () => ( null));
+    const candidates = known ? [known] : onChain;
+    if (candidates.length === 0) outcomes.set(w.index, fail(`Manifold claims are not available on chain ${String(chainId)}.`));
+    for (const entry of candidates) probes.push({ w, entry });
+  }
+  if (probes.length === 0) return { outcomes, blockTimestamp: null };
+  const { results, blockTimestamp } = await multicall(
+    client,
+    probes.map(({ w, entry }) => ({ address: _viem.getAddress.call(void 0, entry.address), abi: _chunkXWONUCGAcjs.CLAIM_ABIS[entry.abi], functionName: "getClaim", args: [w.creator, w.instanceId] }))
+  );
+  const byWork = /* @__PURE__ */ new Map();
+  probes.forEach((p, i) => byWork.set(p.w, [..._nullishCoalesce(byWork.get(p.w), () => ( [])), { entry: p.entry, result: results[i] }]));
+  for (const [w, list] of byWork) {
+    const hits = list.filter((x) => x.result.status === "success");
+    const narrowed = list.length === 1;
+    if (hits.length === 0) {
+      outcomes.set(w.index, fail(narrowed ? `Could not read claim ${w.source.instanceId} on ${w.source.creatorContract}.` : `No Manifold claim ${w.source.instanceId} found on ${w.source.creatorContract}.`));
+    } else if (hits.length > 1) {
+      outcomes.set(w.index, fail(`Claim ${w.source.instanceId} exists on ${String(hits.length)} extensions of ${w.source.creatorContract}. Set extensionAddress.`));
+    } else {
+      const hit = hits[0];
+      try {
+        const snapshot = snapshotFromClaim(_chunkXWONUCGAcjs.decodeClaim.call(void 0, hit.entry.abi, hit.result.result));
+        if (!w.pinned) _optionalChain([cache, 'optionalAccess', _16 => _16.set, 'call', _17 => _17(cacheKey(w), hit.entry)]);
+        outcomes.set(w.index, { ok: true, snapshot });
+      } catch (e) {
+        outcomes.set(w.index, fail(asError(e).message, e));
+      }
+    }
+  }
+  return { outcomes, blockTimestamp };
+}
+function bigOf(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "number") return Number.isInteger(v) ? BigInt(v) : null;
+  if (typeof v === "string") return /^(0x[0-9a-f]+|\d+)$/i.test(v) ? BigInt(v) : null;
+  const hex = typeof v.hex === "string" ? v.hex : typeof v._hex === "string" ? v._hex : null;
+  return hex !== null && /^0x[0-9a-f]*$/i.test(hex) ? BigInt(hex === "0x" ? "0x0" : hex) : null;
+}
+function listingIdOf(raw) {
+  const id = bigOf(raw.id);
+  return id === null ? null : id.toString();
+}
+function timeOf(v) {
+  if (typeof v !== "number" || !Number.isSafeInteger(v) || v < 0) throw new Error("Listing has an invalid start or end time.");
+  return v;
+}
+function snapshotFromListing(batch, single) {
+  const src = _nullishCoalesce(single, () => ( batch));
+  const d = _nullishCoalesce(src.details, () => ( batch.details));
+  if (!d) throw new Error("Listing has no details.");
+  const start = timeOf(d.startTime);
+  const end = timeOf(d.endTime);
+  const duration = start === 0 && end > 0 && end < DURATION_CUTOFF;
+  const auction = d.type_ === 1;
+  const amount = _nullishCoalesce(bigOf(_optionalChain([src, 'access', _18 => _18.bid, 'optionalAccess', _19 => _19.amount])), () => ( 0n));
+  const erc20 = typeof d.erc20 === "string" && _viem.isAddress.call(void 0, d.erc20, { strict: false }) && d.erc20 !== _viem.zeroAddress ? _viem.getAddress.call(void 0, d.erc20) : null;
+  return {
+    kind: "listing",
+    startTime: start === 0 ? null : start,
+    endTime: duration || end === 0 ? null : end,
+    durationAfterFirstBid: duration ? end : null,
+    // totalSold is left out when it is 0 on some routes.
+    totalMinted: single ? _nullishCoalesce(bigOf(single.totalSold), () => ( 0n)) : null,
+    maxSupply: bigOf(d.totalAvailable),
+    price: bigOf(d.initialAmount),
+    paymentToken: erc20,
+    bid: auction && amount > 0n ? { amount } : null,
+    auction,
+    closed: src.finalized === true
+  };
+}
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      out[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+async function getJson(f, url, init, signal) {
+  const res = await f(url, { ...init, ...signal ? { signal } : {} });
+  if (!res.ok) throw new Error(`Marketplace API answered ${String(res.status)} for ${url.replace(/^https?:\/\/[^/]+/, "")}`);
+  const header = _nullishCoalesce(_optionalChain([res, 'access', _20 => _20.headers, 'optionalAccess', _21 => _21.get, 'call', _22 => _22("date")]), () => ( null));
+  const date = header ? Date.parse(header) : NaN;
+  return { json: await res.json(), date: Number.isNaN(date) ? null : date };
+}
+async function readListings(work, deps, outcomes) {
+  const f = _nullishCoalesce(deps.fetch, () => ( globalThis.fetch));
+  const nowMs = _nullishCoalesce(deps.nowMs, () => ( Date.now));
+  let clock = null;
+  const groups = /* @__PURE__ */ new Map();
+  for (const w of work) {
+    const done = _optionalChain([deps, 'access', _23 => _23.finalCache, 'optionalAccess', _24 => _24.get, 'call', _25 => _25(w.key)]);
+    if (done) {
+      outcomes.set(w.index, { ok: true, snapshot: done });
+      continue;
+    }
+    const gk = `${w.api}|${w.marketplace.toLowerCase()}`;
+    groups.set(gk, [..._nullishCoalesce(groups.get(gk), () => ( [])), w]);
+  }
+  for (const items of groups.values()) {
+    const { api, marketplace } = items[0];
+    const ids = [...new Set(items.map((w) => w.source.listingId))];
+    let rows;
+    try {
+      const { json, date } = await getJson(f, `${api}/listing/${marketplace}/batch`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ listingIds: ids }) }, deps.signal);
+      if (!Array.isArray(json)) throw new Error("Marketplace API answered with something other than a list.");
+      rows = json;
+      if (date !== null) clock = { serverNowMs: date, measuredAtMs: nowMs() };
+    } catch (e) {
+      for (const w of items) outcomes.set(w.index, fail(asError(e).message, e));
+      continue;
+    }
+    const byId = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const id = listingIdOf(r);
+      if (id !== null) byId.set(id, r);
+    }
+    const nowSec = Math.floor((clock ? clock.serverNowMs : nowMs()) / 1e3);
+    const pending = [];
+    for (const w of items) {
+      const row = byId.get(w.source.listingId);
+      if (!row) {
+        outcomes.set(w.index, fail(`Listing ${w.source.listingId} was not found on chain ${String(w.source.chainId)}.`));
+        continue;
+      }
+      try {
+        const s = snapshotFromListing(row);
+        const upcoming = s.startTime !== null && s.startTime > nowSec && row.finalized !== true;
+        if (upcoming) outcomes.set(w.index, { ok: true, snapshot: s });
+        else pending.push({ w, row });
+      } catch (e) {
+        outcomes.set(w.index, fail(asError(e).message, e));
+      }
+    }
+    const singles = await mapLimit(pending, SINGLE_CONCURRENCY, async ({ w, row }) => {
+      try {
+        const { json } = await getJson(f, `${api}/listing/${marketplace}/${w.source.listingId}`, void 0, deps.signal);
+        if (typeof json !== "object" || json === null || Array.isArray(json)) throw new Error("Marketplace API answered with something other than a listing.");
+        const answer = json;
+        const id = listingIdOf(answer);
+        if (id !== null && id !== w.source.listingId) throw new Error(`Marketplace API answered listing ${id} for listing ${w.source.listingId}.`);
+        const snapshot = snapshotFromListing(row, answer);
+        if (snapshot.closed) _optionalChain([deps, 'access', _26 => _26.finalCache, 'optionalAccess', _27 => _27.set, 'call', _28 => _28(w.key, snapshot)]);
+        return { ok: true, snapshot };
+      } catch (e) {
+        return fail(asError(e).message, e);
+      }
+    });
+    pending.forEach((p, i) => outcomes.set(p.w.index, singles[i]));
+  }
+  return { serverNowMs: _nullishCoalesce(_optionalChain([clock, 'optionalAccess', _29 => _29.serverNowMs]), () => ( null)), measuredAtMs: _nullishCoalesce(_optionalChain([clock, 'optionalAccess', _30 => _30.measuredAtMs]), () => ( null)) };
+}
+function resolveMarketplace(source) {
+  const api = MARKETPLACE_API[source.chainId];
+  if (!api) return new Error(`The marketplace API does not serve chain ${String(source.chainId)}.`);
+  const marketplace = _nullishCoalesce(source.marketplace, () => ( MARKETPLACE_ADDRESSES[source.chainId]));
+  if (!marketplace) return new Error(`Pass marketplace for chain ${String(source.chainId)}: there is no default marketplace address.`);
+  if (!_viem.isAddress.call(void 0, marketplace, { strict: false })) return new Error("marketplace is not a valid address.");
+  if (typeof source.listingId !== "string" || !/^\d+$/.test(source.listingId)) return new Error("listingId must be a non-negative integer string.");
+  return { marketplace: marketplace.toLowerCase(), api };
+}
+async function readSources(sources, deps = {}) {
+  const nowMs = _nullishCoalesce(deps.nowMs, () => ( Date.now));
+  const outcomes = new Array(sources.length);
+  const out = /* @__PURE__ */ new Map();
+  const claimsByChain = /* @__PURE__ */ new Map();
+  const listings = [];
+  sources.forEach((source, index) => {
+    if (source.type === "manifold-claim") {
+      const v = validateClaim(source);
+      if (v instanceof Error) out.set(index, { ok: false, error: v });
+      else claimsByChain.set(source.chainId, [..._nullishCoalesce(claimsByChain.get(source.chainId), () => ( [])), { index, source, ...v }]);
+    } else if (source.type === "marketplace-listing") {
+      const v = resolveMarketplace(source);
+      if (v instanceof Error) out.set(index, { ok: false, error: v });
+      else listings.push({ index, source, ...v, key: sourceKey(source) });
+    } else {
+      out.set(index, fail("Unknown source type."));
+    }
+  });
+  let blockClock = null;
+  const clients = /* @__PURE__ */ new Map();
+  const clientFor = (chainId) => {
+    let c = clients.get(chainId);
+    if (!c) {
+      c = deps.getClient ? deps.getClient(chainId) : _chunkXWONUCGAcjs.createReadClient.call(void 0, { chainId, ...deps.rpcUrls ? { rpcUrls: deps.rpcUrls } : {}, useBridge: false });
+      clients.set(chainId, c);
+    }
+    return c;
+  };
+  const claimJobs = [...claimsByChain].map(async ([chainId, work]) => {
+    try {
+      const r = await readClaimChain(clientFor(chainId), chainId, work, deps);
+      for (const [i, o] of r.outcomes) out.set(i, o);
+      if (r.blockTimestamp !== null) blockClock = { serverNowMs: Number(r.blockTimestamp) * 1e3, measuredAtMs: nowMs() };
+    } catch (e) {
+      for (const w of work) out.set(w.index, fail(asError(e).message, e));
+    }
+  });
+  const listingJob = readListings(listings, deps, out).catch((e) => {
+    for (const w of listings) if (!out.has(w.index)) out.set(w.index, fail(asError(e).message, e));
+    return { serverNowMs: null, measuredAtMs: null };
+  });
+  const [, listingClock] = await Promise.all([Promise.all(claimJobs), listingJob]);
+  for (let i = 0; i < sources.length; i++) outcomes[i] = _nullishCoalesce(out.get(i), () => ( fail("Source was not read.")));
+  const clock = listingClock.serverNowMs !== null ? { serverNowMs: listingClock.serverNowMs, measuredAtMs: listingClock.measuredAtMs } : blockClock;
+  return { outcomes, serverNowMs: _nullishCoalesce(_optionalChain([clock, 'optionalAccess', _31 => _31.serverNowMs]), () => ( null)), measuredAtMs: _nullishCoalesce(_optionalChain([clock, 'optionalAccess', _32 => _32.measuredAtMs]), () => ( null)) };
+}
+
+// src/status/useDropStatus.ts
+var DEFAULT_REFRESH_MS = 3e4;
+var BOUNDARY_DELAY_MS = 1e3;
+var MAX_TIMEOUT_MS = 2147483647;
+var hidden = () => typeof document !== "undefined" && document.hidden;
+function nextBoundary(entries, nowSec) {
+  let next = null;
+  for (const { snapshot } of entries) {
+    if (!snapshot) continue;
+    for (const t of [snapshot.startTime, snapshot.endTime]) if (t !== null && t > nowSec && (next === null || t < next)) next = t;
+  }
+  return next;
+}
+function useDropStatus(sources, options = {}) {
+  const { refreshMs = DEFAULT_REFRESH_MS, enabled = true } = options;
+  const keys = sources.map(sourceKey);
+  const key = JSON.stringify(keys);
+  const rpcKey = JSON.stringify(_nullishCoalesce(options.rpcUrls, () => ( null)));
+  const sourcesRef = _react.useRef.call(void 0, sources);
+  const optionsRef = _react.useRef.call(void 0, options);
+  _react.useEffect.call(void 0, () => {
+    sourcesRef.current = sources;
+    optionsRef.current = options;
+  });
+  const [entries, setEntries] = _react.useState.call(void 0, () => /* @__PURE__ */ new Map());
+  const [clockOffsetMs, setClockOffsetMs] = _react.useState.call(void 0, 0);
+  const [nowSec, setNowSec] = _react.useState.call(void 0, null);
+  const caches = _react.useRef.call(void 0, { extensionCache: /* @__PURE__ */ new Map(), finalCache: /* @__PURE__ */ new Map() });
+  const refreshRef = _react.useRef.call(void 0, () => Promise.resolve());
+  const offsetRef = _react.useRef.call(void 0, 0);
+  _react.useEffect.call(void 0, () => {
+    offsetRef.current = clockOffsetMs;
+  }, [clockOffsetMs]);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) return;
+    let active = true;
+    let inFlight = null;
+    const controller = new AbortController();
+    const run = async () => {
+      const wanted = /* @__PURE__ */ new Map();
+      sourcesRef.current.forEach((s) => wanted.set(sourceKey(s), s));
+      const list = [...wanted.values()];
+      const o = optionsRef.current;
+      const deps = {
+        ...caches.current,
+        signal: controller.signal,
+        ...o.rpcUrls ? { rpcUrls: o.rpcUrls } : {},
+        ...o.getClient ? { getClient: o.getClient } : {},
+        ...o.fetch ? { fetch: o.fetch } : {}
+      };
+      const result = await readSources(list, deps);
+      if (!active) return;
+      const finishedAt = Date.now();
+      setEntries((prev) => {
+        const next = /* @__PURE__ */ new Map();
+        [...wanted.keys()].forEach((k, i) => {
+          const outcome = result.outcomes[i];
+          const before = prev.get(k);
+          next.set(
+            k,
+            outcome.ok ? { snapshot: outcome.snapshot, updatedAt: finishedAt, error: null } : { snapshot: _nullishCoalesce(_optionalChain([before, 'optionalAccess', _33 => _33.snapshot]), () => ( null)), updatedAt: _nullishCoalesce(_optionalChain([before, 'optionalAccess', _34 => _34.updatedAt]), () => ( null)), error: outcome.error }
+          );
+        });
+        return next;
+      });
+      const offset = result.serverNowMs !== null && result.measuredAtMs !== null ? clockOffsetOf(result.serverNowMs, result.measuredAtMs) : null;
+      if (offset !== null) setClockOffsetMs(offset);
+      setNowSec(Math.floor((finishedAt + (_nullishCoalesce(offset, () => ( offsetRef.current)))) / 1e3));
+    };
+    const refresh = () => {
+      inFlight ??= run().finally(() => {
+        inFlight = null;
+      });
+      return inFlight;
+    };
+    refreshRef.current = refresh;
+    void refresh();
+    const timer = refreshMs > 0 ? setInterval(() => {
+      if (!hidden()) void refresh();
+    }, refreshMs) : null;
+    const onVisible = () => {
+      if (!hidden()) void refresh();
+    };
+    document.addEventListener("visibilitychange", onVisible);
+    return () => {
+      active = false;
+      controller.abort();
+      if (timer !== null) clearInterval(timer);
+      document.removeEventListener("visibilitychange", onVisible);
+      refreshRef.current = () => Promise.resolve();
+    };
+  }, [key, enabled, refreshMs, rpcKey]);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) return;
+    const serverNow = Date.now() + clockOffsetMs;
+    const next = nextBoundary(entries.values(), Math.floor(serverNow / 1e3));
+    if (next === null) return;
+    const delay = Math.min(Math.max(next * 1e3 - serverNow + BOUNDARY_DELAY_MS, 0), MAX_TIMEOUT_MS);
+    const timer = setTimeout(() => {
+      setNowSec(Math.floor((Date.now() + clockOffsetMs) / 1e3));
+      if (!hidden()) void refreshRef.current();
+    }, delay);
+    return () => clearTimeout(timer);
+  }, [entries, clockOffsetMs, enabled, nowSec]);
+  return _react.useMemo.call(void 0, () => {
+    return keys.map((k) => {
+      const e = entries.get(k);
+      if (!_optionalChain([e, 'optionalAccess', _35 => _35.snapshot])) return { ...unknownStatus(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _36 => _36.error]), () => ( null))), clockOffsetMs };
+      return statusOf(e.snapshot, _nullishCoalesce(nowSec, () => ( Math.floor(e.updatedAt / 1e3))), { stale: e.error !== null, updatedAt: e.updatedAt, error: e.error, clockOffsetMs });
+    });
+  }, [key, entries, clockOffsetMs, nowSec]);
+}
+
+// src/status/DropCountdown.ts
+
+var MAX_TIMEOUT_MS2 = 2147483647;
+var pad = (n) => String(n).padStart(2, "0");
+function formatCountdown(parts, units = "dhms") {
+  const shown = ["d", "h", "m", "s"].filter((u) => units.includes(u));
+  const use = shown.length > 0 ? shown : ["d", "h", "m", "s"];
+  let first = use.findIndex((u) => parts[u] > 0);
+  if (first === -1) first = use.length - 1;
+  return use.slice(first).map((u, i) => `${i === 0 ? String(parts[u]) : pad(parts[u])}${u}`).join(" ");
+}
+var hidden2 = () => typeof document !== "undefined" && document.hidden;
+function DropCountdown(props) {
+  const { to, showWithin, hideAfter, now, format = "dhms", className, children } = props;
+  const within = showWithin === void 0 ? Infinity : parseDuration(showWithin);
+  const keep = hideAfter === void 0 ? 0 : parseDuration(hideAfter);
+  const [nowMs, setNowMs] = _react.useState.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    if (to === null) return;
+    const clock = _nullishCoalesce(now, () => ( Date.now));
+    let timer = null;
+    const stop = () => {
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+    };
+    const step = () => {
+      stop();
+      const t = clock();
+      setNowMs(t);
+      if (hidden2()) return;
+      const untilTo = to * 1e3 - t;
+      let delay;
+      if (untilTo > 0) {
+        delay = untilTo > within * 1e3 ? untilTo - within * 1e3 : Math.min(1e3, untilTo);
+      } else if (keep > 0 && -untilTo < keep * 1e3) {
+        delay = keep * 1e3 + untilTo;
+      } else {
+        return;
+      }
+      timer = setTimeout(step, Math.min(Math.max(delay, 0), MAX_TIMEOUT_MS2));
+    };
+    const onVisibility = () => {
+      if (hidden2()) stop();
+      else step();
+    };
+    step();
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      stop();
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }, [to, within, keep, now]);
+  if (to === null || nowMs === null) return null;
+  const left = to - nowMs / 1e3;
+  const counting = left > 0;
+  const secondsLeft = counting ? Math.ceil(left) : 0;
+  const visible = counting ? left <= within : -left < keep;
+  const parts = countdownParts(secondsLeft, format);
+  const text = formatCountdown(parts, format);
+  const state = { state: counting ? "counting" : "done", visible, secondsLeft, parts, text };
+  if (typeof children === "function") return children(state);
+  if (!visible) return null;
+  return _react.createElement.call(void 0, "span", { className, role: "timer", "data-state": state.state }, _nullishCoalesce(children, () => ( text)));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DropCountdown = DropCountdown; exports.MARKETPLACE_ADDRESSES = MARKETPLACE_ADDRESSES; exports.MARKETPLACE_API = MARKETPLACE_API; exports.clockOffsetOf = clockOffsetOf; exports.countdownParts = countdownParts; exports.formatCountdown = formatCountdown; exports.parseDuration = parseDuration; exports.phaseOf = phaseOf; exports.readSources = readSources; exports.snapshotFromListing = snapshotFromListing; exports.sourceKey = sourceKey; exports.statusOf = statusOf; exports.unknownStatus = unknownStatus; exports.useDropStatus = useDropStatus;
+//# sourceMappingURL=status.cjs.map