@manifoldxyz/dropkit 0.4.0 → 0.5.0

package/README.md

@@ -151,11 +151,15 @@ export function mintedLine(result: MintResult): string {
 | `quantity` | Initial quantity, or controlled quantity with `onQuantityChange`. Defaults to 1. |
 | `onQuantityChange` | Receives the clamped requested quantity. The parent must update `quantity`. |
 | `connect` | Optional `{ walletConnectProjectId }` forwarded to the shared connect widget. Defaults to Manifold's project id. |
-| `onEvent` | Optional event callback. No telemetry is sent by the package. |
+| `onEvent` | Optional event callback. The package sends no analytics. It does send Manifold's mint record for Manifold claim mints (see [Manifold mint record](#manifold-mint-record)). |
 | `crossChain` | Manifold claims only. Default on. `false` turns cross-chain minting off; `{ chains: [8453] }` narrows the pay chains. |
 | `payChainId` | Forces the pay chain. The drop chain means a direct mint. Must be a pay chain. |
 
 `MintButton` additionally accepts `className`, `labels`, and `children`.
+
+### Manifold mint record
+
+Every Manifold claim mint sends the same mint record the Manifold claim widget sends: once the mint transaction is sent, `POST https://apps.api.manifoldxyz.dev/public/instance/tx?appId=…&instanceId=…&hash=…`. For a Relay mint it records the drop-chain fill hash; for the cart, each line's hash. It carries no wallet address. It is fire and forget: it never delays or fails a mint. `contract` and `tl-stacks` mints send nothing; only Manifold claims are recorded, as in the widget. Sites can't turn it off.
 A function child receives the full `MintState` and replaces the default button.
 
 ```tsx
@@ -369,6 +373,96 @@ Things to know:
 - **A mint that cannot be confirmed** is never retried for you. It is listed in `cart.unconfirmed` until the collector dismisses it or adds the item back. Each entry has `wallet` (the wallet that sent it) and `message`, which names that wallet: "We couldn't confirm this. Check wallet 0x1234…abcd. If it didn't go through, add it again."
 - **Any wallet works**, smart accounts included. A wallet that returns a request id instead of a transaction hash (a Safe through WalletConnect, for example) shows "Still confirming", then settles from the collector's holdings: Collected if the mint landed, otherwise Unconfirmed. The cart never resends it.
 
+## Drop status
+
+`@manifoldxyz/dropkit/status` tells a sale page whether each of many drops is upcoming, live, ended or sold out, how much supply is left, what the current bid is, and shows a countdown that can appear only close to a start or end time. It is read-only: no wallet, no mint. Use it for the strip of status around your mint buttons. Importing only `@manifoldxyz/dropkit` never loads it.
+
+Read dates and status from Manifold; never ask the creator to type a date Studio already has.
+
+```tsx
+import { DropCountdown, useDropStatus } from '@manifoldxyz/dropkit/status';
+import type { StatusSource } from '@manifoldxyz/dropkit/status';
+
+const sources: StatusSource[] = [
+  { type: 'manifold-claim', chainId: 1, creatorContract: '0x0000000000000000000000000000000000000001', instanceId: '1' },
+  { type: 'marketplace-listing', chainId: 1, listingId: '1538' },
+];
+
+export function Strip({ rpcUrl }: { rpcUrl: string }) {
+  // A new array every render is fine: sources are keyed by content.
+  const [edition, auction] = useDropStatus(sources, { rpcUrls: { 1: rpcUrl }, refreshMs: 30_000 });
+  return (
+    <div>
+      <p data-phase={edition?.phase}>{edition?.remaining === null ? 'Open edition' : `${edition?.remaining ?? '…'} left`}</p>
+      <p data-phase={auction?.phase}>{auction?.bid ? `Current bid ${auction.bid.amount} wei` : auction?.phase}</p>
+      {/* Only inside the last 6 hours before the claim opens. */}
+      <DropCountdown to={edition?.startTime ?? null} showWithin="6h" className="countdown" />
+    </div>
+  );
+}
+```
+
+Each status is `{ phase, startTime, endTime, durationAfterFirstBid, totalMinted, maxSupply, remaining, price, paymentToken, bid, soldFor, stale, updatedAt, error, clockOffsetMs }`, aligned with the sources you pass:
+
+- `phase` is `'upcoming' | 'live' | 'ended' | 'sold-out' | 'unknown'`. Times are unix seconds, supply and amounts are `bigint` in base units, and `maxSupply` / `remaining` are `null` for an open edition. `paymentToken` is `null` for the chain's native currency.
+- `soldFor` is set when the phase is `'sold-out'`: the winning bid for an auction, the price for a fixed-price listing.
+- `bid` is the highest bid of an auction listing. The marketplace API reports no bid count.
+- A listing whose timer starts on the first bid or purchase has `startTime: null`, `endTime: null` and `durationAfterFirstBid` set to the seconds it will then run. Its phase is `'live'`.
+
+**Sources.**
+
+- `{ type: 'manifold-claim', chainId, creatorContract, instanceId, extensionAddress? }` reads the claim from its extension contract. Every claim of one chain is read with one multicall per refresh. `extensionAddress` pins the extension; without it the claim is looked up on all of Manifold's extensions on that chain, and once found, only on that one.
+- `{ type: 'marketplace-listing', chainId, listingId, marketplace? }` reads a Manifold marketplace listing. All listings are read with one batch request per refresh, plus one request for each listing that is running or has just ended, because the batch answer has no bid and no units sold. At most 3 of those run at once, and a finalized listing is never read again. Mainnet, Optimism, Base, Shape and Sepolia have a default `marketplace` address; on other chains the listing cannot be read.
+
+**A failed read never changes the page.** If a read fails, each affected status keeps its last good values with `stale: true` and `error` set, and the next good read clears both. If there has been no good read yet, `phase` is `'unknown'` and every value is `null`. A failed read never becomes `'upcoming'`, so a sale page cannot hide a live drop because an RPC call failed. Show `'unknown'` as a loading or retry state, not as "not open yet".
+
+**Polling.** The hook reads on mount, every `refreshMs` (default 30 s) while the tab is visible, when the tab becomes visible again, and about a second after the nearest start or end time passes. Options: `rpcUrls`, `enabled` (false reads nothing), `getClient(chainId)` to bring your own viem client, and `fetch` to replace `fetch`.
+
+**Clock.** A device clock that is wrong must not flip a phase. After each read the hook compares device time with server time (the HTTP `Date` header for listings, the block timestamp for claims) and, when they differ by more than 30 s, sets `clockOffsetMs` to the difference. Phases are computed on server time. Give the countdown the same clock with its `now` prop:
+
+```tsx
+import { DropCountdown, useDropStatus } from '@manifoldxyz/dropkit/status';
+
+export function OpensIn({ rpcUrl }: { rpcUrl: string }) {
+  const [claim] = useDropStatus(
+    [{ type: 'manifold-claim', chainId: 1, creatorContract: '0x0000000000000000000000000000000000000001', instanceId: '1' }],
+    { rpcUrls: { 1: rpcUrl } },
+  );
+  const clockOffsetMs = claim?.clockOffsetMs ?? 0;
+  return (
+    <DropCountdown to={claim?.startTime ?? null} showWithin="6h" hideAfter="1m" now={() => Date.now() + clockOffsetMs}>
+      {(c) => (c.visible ? <b data-state={c.state}>{c.state === 'done' ? 'Open now' : `Opens in ${c.text}`}</b> : null)}
+    </DropCountdown>
+  );
+}
+```
+
+**`<DropCountdown to showWithin? hideAfter? now? format? className? children? />`** is unstyled.
+
+- `to` is unix seconds. `null` renders nothing.
+- `showWithin` (`'6h'`, `'30m'`, `'2d'`, `'90s'`, `'1w'` or seconds) shows it only that long before `to`. Outside the window it renders nothing and does not tick.
+- `hideAfter` (same units) keeps the done state on screen that long after `to`. By default it disappears when `to` passes.
+- The default markup is `<span role="timer" data-state="counting" | "done">2d 03h 04m 05s</span>`. `format` picks the units (`"dhms"`, `"hms"` turns 2 days into 48 hours). A string `children` replaces the text. A function child gets `{ state, visible, secondsLeft, parts: { d, h, m, s }, text }` and replaces the markup entirely.
+- It ticks once a second only while the tab is visible and `to` is inside the window. The server render and the first client render are both empty, so hydration always matches.
+
+The logic is plain functions you can call on a server, with no React and no browser globals: `phaseOf(snapshot, nowSeconds)`, `statusOf`, `readSources(sources, deps)`, `parseDuration` and `countdownParts`.
+
+```ts
+import { readSources, statusOf } from '@manifoldxyz/dropkit/status';
+
+export async function phases(rpcUrl: string): Promise<string[]> {
+  const { outcomes } = await readSources(
+    [{ type: 'marketplace-listing', chainId: 1, listingId: '1538' }],
+    { rpcUrls: { 1: rpcUrl } },
+  );
+  const now = Math.floor(Date.now() / 1000);
+  const meta = { stale: false, updatedAt: Date.now(), error: null, clockOffsetMs: 0 };
+  return outcomes.map((o) => (o.ok ? statusOf(o.snapshot, now, meta).phase : 'unknown'));
+}
+```
+
+Out of scope: hiding a drop that is not published yet. The hook reads published state only.
+
 ## Local verification
 
 From the repository root, use Node 24 and pnpm 10.34.5:

package/dist/cart.cjs

@@ -9,6 +9,7 @@
 
 
 
+var _chunkYGBIJOKQcjs = require('./chunk-YGBIJOKQ.cjs');
 
 
 
@@ -18,7 +19,9 @@
 
 
 
-var _chunkGO4TR3HBcjs = require('./chunk-GO4TR3HB.cjs');
+
+
+var _chunkXWONUCGAcjs = require('./chunk-XWONUCGA.cjs');
 
 // src/cart/react.ts
 var _react = require('react');
@@ -34,13 +37,13 @@ var CartError = class extends Error {
 };
 function cartReason(e) {
   if (e instanceof CartError) return { reason: e.reason, message: e.message };
-  if (_chunkGO4TR3HBcjs.isMintError.call(void 0, e)) return _chunkGO4TR3HBcjs.toReason.call(void 0, e);
-  return _chunkGO4TR3HBcjs.toReason.call(void 0, e);
+  if (_chunkXWONUCGAcjs.isMintError.call(void 0, e)) return _chunkXWONUCGAcjs.toReason.call(void 0, e);
+  return _chunkXWONUCGAcjs.toReason.call(void 0, e);
 }
 
 // src/cart/line.ts
 var _viem = require('viem');
-var isUnsupportedReason = (r) => _chunkGO4TR3HBcjs.UNSUPPORTED_REASONS.includes(r);
+var isUnsupportedReason = (r) => _chunkXWONUCGAcjs.UNSUPPORTED_REASONS.includes(r);
 function deriveLine(args) {
   const { drop, walletRead, readError, now, pending, walletConnected } = args;
   const out = (state, reason = null, message = null) => ({ state, reason, message });
@@ -63,7 +66,7 @@ function lineMaxQuantity(drop, walletRead) {
   let max = null;
   if (drop.maxSupply !== null && drop.maxSupply > 0n) {
     const left = drop.maxSupply - drop.totalMinted;
-    max = left > 0n ? left < BigInt(_chunkGO4TR3HBcjs.MAX_QUANTITY) ? Number(left) : _chunkGO4TR3HBcjs.MAX_QUANTITY : 0;
+    max = left > 0n ? left < BigInt(_chunkYGBIJOKQcjs.MAX_QUANTITY) ? Number(left) : _chunkYGBIJOKQcjs.MAX_QUANTITY : 0;
   }
   if (walletRead !== null && walletRead.maxQuantity !== null) {
     const cap = Math.max(0, Math.floor(walletRead.maxQuantity));
@@ -100,7 +103,7 @@ function sharedReadClient(raw) {
   const overrides = {
     getCode: (args) => {
       const address = args.address.toLowerCase();
-      if (_chunkGO4TR3HBcjs.findExtension.call(void 0, chainId(), address)) return memo(forever, `code:${address}`, () => raw.getCode(args));
+      if (_chunkXWONUCGAcjs.findExtension.call(void 0, chainId(), address)) return memo(forever, `code:${address}`, () => raw.getCode(args));
       return raw.getCode(args);
     },
     readContract: (args) => {
@@ -185,19 +188,19 @@ function itemKey(config) {
 function canonicalConfig(config, chainId) {
   const c = _nullishCoalesce(config, () => ( {}));
   if (c.type !== "manifold-claim") {
-    throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", 'The cart takes only Manifold claims (type: "manifold-claim").', { field: "type" });
+    throw new (0, _chunkXWONUCGAcjs.MintError)("INVALID_CONFIG", 'The cart takes only Manifold claims (type: "manifold-claim").', { field: "type" });
   }
   if (c.chainId !== chainId) {
-    throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", `This cart is on chain ${String(chainId)}; the config is on chain ${String(c.chainId)}.`, { field: "chainId" });
+    throw new (0, _chunkXWONUCGAcjs.MintError)("INVALID_CONFIG", `This cart is on chain ${String(chainId)}; the config is on chain ${String(c.chainId)}.`, { field: "chainId" });
   }
   if (typeof c.creatorContract !== "string" || !_viem.isAddress.call(void 0, c.creatorContract, { strict: false })) {
-    throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", "creatorContract is not a valid address.", { field: "creatorContract" });
+    throw new (0, _chunkXWONUCGAcjs.MintError)("INVALID_CONFIG", "creatorContract is not a valid address.", { field: "creatorContract" });
   }
   if (typeof c.extension !== "string" || !_viem.isAddress.call(void 0, c.extension, { strict: false })) {
-    throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", "Cart configs must set extension (the claim extension address).", { field: "extension" });
+    throw new (0, _chunkXWONUCGAcjs.MintError)("INVALID_CONFIG", "Cart configs must set extension (the claim extension address).", { field: "extension" });
   }
   if (typeof c.instanceId !== "string" || !/^\d+$/.test(c.instanceId)) {
-    throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", "instanceId must be a non-negative integer string.", { field: "instanceId" });
+    throw new (0, _chunkXWONUCGAcjs.MintError)("INVALID_CONFIG", "instanceId must be a non-negative integer string.", { field: "instanceId" });
   }
   return {
     type: "manifold-claim",
@@ -207,13 +210,13 @@ function canonicalConfig(config, chainId) {
     extension: _viem.getAddress.call(void 0, c.extension)
   };
 }
-var clampQuantity = (q) => Math.max(1, Math.min(Math.floor(Number.isFinite(q) ? q : 1), _chunkGO4TR3HBcjs.MAX_QUANTITY));
+var clampQuantity = (q) => Math.max(1, Math.min(Math.floor(Number.isFinite(q) ? q : 1), _chunkYGBIJOKQcjs.MAX_QUANTITY));
 var EMPTY_VALUE = (chainId) => ({ v: CART_VALUE_VERSION, chainId, items: [], pending: [], results: [] });
 var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isHash = (v) => typeof v === "string" && /^0x[0-9a-fA-F]{64}$/.test(v);
 var isAddr = (v) => typeof v === "string" && _viem.isAddress.call(void 0, v, { strict: false });
 var isIntStr = (v) => typeof v === "string" && /^\d+$/.test(v);
-var isQuantity = (v) => typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= _chunkGO4TR3HBcjs.MAX_QUANTITY;
+var isQuantity = (v) => typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= _chunkYGBIJOKQcjs.MAX_QUANTITY;
 function restoreConfig(v, chainId) {
   try {
     return canonicalConfig(v, chainId);
@@ -552,7 +555,7 @@ var CART_TIMING = {
   merklePerMinute: 10
 };
 var nowSec = () => Math.floor(Date.now() / 1e3);
-var adapter = _chunkGO4TR3HBcjs.manifoldClaimAdapter;
+var adapter = _chunkXWONUCGAcjs.manifoldClaimAdapter;
 var LineSkipped = class extends Error {
   
   
@@ -603,11 +606,11 @@ async function prepareLine(env, line, payer) {
   try {
     await adapter.simulate(a.ctx, a.attempt, a.plan);
   } catch (e) {
-    if (e instanceof _chunkGO4TR3HBcjs.MintError && e.reason === "SIMULATION_REVERTED") throw new LineSkipped("ineligible", "SIMULATION_REVERTED", _chunkGO4TR3HBcjs.friendlyErrorMessage.call(void 0, e));
+    if (e instanceof _chunkXWONUCGAcjs.MintError && e.reason === "SIMULATION_REVERTED") throw new LineSkipped("ineligible", "SIMULATION_REVERTED", _chunkXWONUCGAcjs.friendlyErrorMessage.call(void 0, e));
     throw e;
   }
   const query = _nullishCoalesce(_optionalChain([adapter, 'access', _27 => _27.holdingsQuery, 'optionalCall', _28 => _28(a.drop)]), () => ( null));
-  if (!query || !adapter.readHoldings) throw new (0, _chunkGO4TR3HBcjs.MintError)("RPC_ERROR", "The cart cannot count holdings for this item.");
+  if (!query || !adapter.readHoldings) throw new (0, _chunkXWONUCGAcjs.MintError)("RPC_ERROR", "The cart cannot count holdings for this item.");
   const before = await adapter.readHoldings(a.ctx, query, a.recipient);
   const unit = a.drop.unitPrice;
   return {
@@ -635,8 +638,8 @@ async function withRetries(fn, delaysMs, isFinal, signal) {
     }
   }
 }
-var sendSwitch = (chainId) => _chunkGO4TR3HBcjs.requestSwitch.call(void 0, chainId);
-var sendAddChain = (chainId) => _chunkGO4TR3HBcjs.requestAddChain.call(void 0, chainId);
+var sendSwitch = (chainId) => _chunkYGBIJOKQcjs.requestSwitch.call(void 0, chainId);
+var sendAddChain = (chainId) => _chunkYGBIJOKQcjs.requestAddChain.call(void 0, chainId);
 var openCalls = /* @__PURE__ */ new Set();
 var notSentCalls = /* @__PURE__ */ new Set();
 var markCallOpen = (id) => void openCalls.add(id);
@@ -647,15 +650,15 @@ var wasNotSent = (id) => notSentCalls.has(id);
 var SEND_METHODS = /* @__PURE__ */ new Set(["eth_sendTransaction", "wallet_sendTransaction"]);
 async function sendMint(prepared, hooks) {
   const notSent = (message, cause) => new CartError("REQUEST_NOT_SENT", message, { cause });
-  const live = _chunkGO4TR3HBcjs.getAccount.call(void 0, );
+  const live = _chunkYGBIJOKQcjs.getAccount.call(void 0, );
   if (!live || live.address.toLowerCase() !== prepared.payer.toLowerCase()) {
     throw notSent("The connected wallet changed before the transaction was sent.");
   }
   let provider;
   let chain;
   try {
-    provider = _chunkGO4TR3HBcjs.getWalletProvider.call(void 0, );
-    chain = _chunkGO4TR3HBcjs.getChain.call(void 0, prepared.config.chainId);
+    provider = _chunkYGBIJOKQcjs.getWalletProvider.call(void 0, );
+    chain = _chunkXWONUCGAcjs.getChain.call(void 0, prepared.config.chainId);
   } catch (e) {
     throw notSent("No wallet is connected.", e);
   }
@@ -673,12 +676,13 @@ async function sendMint(prepared, hooks) {
     throw e;
   }
   hooks.onHash(hash);
+  void _chunkYGBIJOKQcjs.recordClaimMint.call(void 0, { instanceId: prepared.config.instanceId, hash });
   return hash;
 }
 var receiptOk = (status) => status === "success" || status === 1 || status === 1n || status === "0x1";
 function toMintReceipt(receipt, hash, tokenContract, recipient) {
   const ok = receiptOk(receipt.status);
-  const parsed = ok ? _chunkGO4TR3HBcjs.parseMintReceipt.call(void 0, _nullishCoalesce(receipt.logs, () => ( [])), { tokenContract, recipient }) : [];
+  const parsed = ok ? _chunkYGBIJOKQcjs.parseMintReceipt.call(void 0, _nullishCoalesce(receipt.logs, () => ( [])), { tokenContract, recipient }) : [];
   const minted = parsed.reduce((n, t) => n + t.amount, 0n);
   const tokens = parsed.map((t) => ({ contract: t.contract, tokenId: t.tokenId.toString() }));
   return { status: ok ? "success" : "reverted", hash: _nullishCoalesce(receipt.transactionHash, () => ( hash)), minted, tokens };
@@ -811,7 +815,7 @@ function explorerTx(chainId, hash) {
   if (!hash) return null;
   let base;
   try {
-    base = _optionalChain([_chunkGO4TR3HBcjs.getChain.call(void 0, chainId), 'access', _34 => _34.blockExplorers, 'optionalAccess', _35 => _35.default, 'access', _36 => _36.url]);
+    base = _optionalChain([_chunkXWONUCGAcjs.getChain.call(void 0, chainId), 'access', _34 => _34.blockExplorers, 'optionalAccess', _35 => _35.default, 'access', _36 => _36.url]);
   } catch (e11) {
     return null;
   }
@@ -845,17 +849,17 @@ var StateContext = _react.createContext.call(void 0, null);
 var InternalsContext = _react.createContext.call(void 0, null);
 function useCartInternals() {
   const v = _react.useContext.call(void 0, InternalsContext);
-  if (!v) throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", "useCheckout must be used inside <CartProvider>.");
+  if (!v) throw new (0, _chunkXWONUCGAcjs.MintError)("INVALID_CONFIG", "useCheckout must be used inside <CartProvider>.");
   return v;
 }
 function useCart() {
   const v = _react.useContext.call(void 0, StateContext);
-  if (!v) throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", "useCart must be used inside <CartProvider>.");
+  if (!v) throw new (0, _chunkXWONUCGAcjs.MintError)("INVALID_CONFIG", "useCart must be used inside <CartProvider>.");
   return v;
 }
 var isFinalRead = (e) => {
   const r = cartReason(e).reason;
-  return _chunkGO4TR3HBcjs.UNSUPPORTED_REASONS.includes(r) || r === "INVALID_CONFIG";
+  return _chunkXWONUCGAcjs.UNSUPPORTED_REASONS.includes(r) || r === "INVALID_CONFIG";
 };
 var emptyValue = (chainId) => ({ v: 6, chainId, items: [], pending: [], results: [] });
 var LineBook = (_class3 = class {constructor() { _class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this); }
@@ -908,9 +912,9 @@ var Core = (_class4 = class {constructor() { _class4.prototype.__init16.call(thi
     return this.lifetime;
   }
 }, _class4);
-var subscribeAccountChanges = (notify) => _chunkGO4TR3HBcjs.subscribeAccount.call(void 0, () => notify());
+var subscribeAccountChanges = (notify) => _chunkYGBIJOKQcjs.subscribeAccount.call(void 0, () => notify());
 var accountSnapshot = () => {
-  const a = _chunkGO4TR3HBcjs.getAccount.call(void 0, );
+  const a = _chunkYGBIJOKQcjs.getAccount.call(void 0, );
   return a ? `${a.address}:${String(a.chainId)}` : "";
 };
 function buildLines(value, book, payer, now, version) {
@@ -944,7 +948,7 @@ function CartProvider(props) {
   _react.useEffect.call(void 0, () => core.sync(value.items, payer), [core, value.items, payer]);
   _react.useEffect.call(void 0, () => {
     if (activeKeys.has(storageKey)) {
-      throw new (0, _chunkGO4TR3HBcjs.MintError)("INVALID_CONFIG", "Only one CartProvider per storageKey. Wrap your app once.", { field: "storageKey" });
+      throw new (0, _chunkXWONUCGAcjs.MintError)("INVALID_CONFIG", "Only one CartProvider per storageKey. Wrap your app once.", { field: "storageKey" });
     }
     activeKeys.add(storageKey);
     core.setRegistered(storageKey);
@@ -963,7 +967,7 @@ function CartProvider(props) {
   }, []);
   const rpcKey = _nullishCoalesce(_optionalChain([rpcUrls, 'optionalAccess', _44 => _44[chainId]]), () => ( ""));
   const readClient = _react.useMemo.call(void 0, 
-    () => _chunkGO4TR3HBcjs.createReadClient.call(void 0, { chainId, ...rpcKey ? { rpcUrls: { [chainId]: rpcKey } } : {}, useBridge: true }),
+    () => _chunkXWONUCGAcjs.createReadClient.call(void 0, { chainId, ...rpcKey ? { rpcUrls: { [chainId]: rpcKey } } : {}, useBridge: true }),
     [chainId, rpcKey]
   );
   const shared = _react.useMemo.call(void 0, () => sharedReadClient(readClient), [readClient]);
@@ -986,14 +990,14 @@ function CartProvider(props) {
     [shared, chainId, merkleFetch, core]
   );
   _react.useEffect.call(void 0, () => {
-    const loading = _chunkGO4TR3HBcjs.loadConnectWidget.call(void 0, { chainIds: [chainId], ...projectId ? { walletConnectProjectId: projectId } : {} });
+    const loading = _chunkYGBIJOKQcjs.loadConnectWidget.call(void 0, { chainIds: [chainId], ...projectId ? { walletConnectProjectId: projectId } : {} });
     core.setWidgetLoad(loading);
     loading.catch(() => void 0);
   }, [chainId, projectId, core]);
   const connect = _react.useCallback.call(void 0, async () => {
     try {
       await core.widgetLoad;
-      return await _chunkGO4TR3HBcjs.openConnectModal.call(void 0, );
+      return await _chunkYGBIJOKQcjs.openConnectModal.call(void 0, );
     } catch (e13) {
       return "dismissed";
     }
@@ -1290,11 +1294,11 @@ function useCheckout() {
     };
     try {
       if (!k.store.persistenceOk()) return blocked("PERSISTENCE_UNAVAILABLE", "The cart could not save its state in this tab, so nothing was sent.");
-      let account = _chunkGO4TR3HBcjs.getAccount.call(void 0, );
+      let account = _chunkYGBIJOKQcjs.getAccount.call(void 0, );
       if (!account) {
         const outcome = await k.connect();
         if (!live()) return;
-        account = _chunkGO4TR3HBcjs.getAccount.call(void 0, );
+        account = _chunkYGBIJOKQcjs.getAccount.call(void 0, );
         if (outcome === "dismissed" || !account) return idle();
       }
       const payer = account.address;
@@ -1561,7 +1565,7 @@ function useCheckout() {
           const out2 = await k.settle(pending.id);
           return applyOutcome(pending.lineKey, pending.id, out2, null);
         }
-        if (_chunkGO4TR3HBcjs.isRejection.call(void 0, e)) {
+        if (_chunkXWONUCGAcjs.isRejection.call(void 0, e)) {
           try {
             k.store.removePending(pending.id);
           } catch (e18) {