@artblocks/abx-sdk 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/reconstruct.d.ts

@@ -1,11 +1,50 @@
-import { type Address, type Hex, type PublicClient } from 'viem';
+import { type Address, type Hex, type PublicClient, type Log } from 'viem';
+import { AbxSdkError } from './errors.js';
 import type { DependencyInfo, ExtensionInfo, MetadataField, ParamHooks, ParamSchema, ParamValue, ProjectState, SpineEvent, TokenState } from './types.js';
+/**
+ * Block tags a caller may pick as a reconstruction boundary, beyond a literal number or `'latest'`.
+ * Only the two the issue asked for: `'safe'` (the client's reorg-unlikely tip) and `'finalized'`
+ * (post-merge finality — won't be reorged short of a >1/3-stake slashing event). Hosted operators
+ * want this so a resolver can serve state it's confident will never need to be walked back, without
+ * inventing an ad hoc lookback-window policy on top of `latest`.
+ */
+export type ReconstructBlockTag = 'safe' | 'finalized';
+/**
+ * Resolve `'safe'`/`'finalized'` to a CONCRETE inclusive block number — BEFORE any `eth_getLogs`
+ * scan starts, and before it's persisted anywhere. A stored watermark (`ProjectState.toBlock`) must
+ * always be a literal number, never the tag itself: `"finalized"` is a moving target, so persisting
+ * the string would silently redefine an already-written checkpoint's meaning on every later read,
+ * and two reconstructions minutes apart would disagree about what block a stored `toBlock:
+ * "finalized"` even meant. Resolving once, here, up front, is what makes the persisted value durable.
+ *
+ * Throws {@link BlockTagUnavailableError} — never falls back to `latest` — when the RPC can't answer
+ * the tag. See that error for why silent fallback is the wrong move.
+ */
+export declare function resolveBlockTag(client: PublicClient, tag: ReconstructBlockTag): Promise<bigint>;
 export interface ReconstructOptions {
     address: Address;
     fromBlock: bigint;
-    toBlock?: bigint | 'latest';
+    /** Default `'latest'` (chain head) — unchanged. `'safe'`/`'finalized'` stop the scan at that tag's
+     *  block instead, resolved to a concrete number via {@link resolveBlockTag} before any log fetch
+     *  and persisted as that number, never the tag (see {@link ProjectState.toBlock}). */
+    toBlock?: bigint | 'latest' | ReconstructBlockTag;
     /** Canonical factory — lets reconstruction verify trust (isAbxClone), not just discovery. */
     factory?: Address;
+    /** Override the `eth_getLogs` scan safety cap (env fallback: `ABX_GETLOGS_MAX_CHUNKS`; the
+     *  CLI's `--yes` sets that). */
+    maxChunks?: number;
+    /** Override the starting `eth_getLogs` window, in blocks (env fallback: `ABX_GETLOGS_RANGE`). */
+    getLogsRange?: bigint;
+    /**
+     * Also head-read the composed `contractURI`/`tokenURI` documents (default **false**). These are
+     * diagnostic, not structural — see {@link applyHeadReads} for why they're opt-in: on the on-chain
+     * lane each one assembles a whole metadata document per call, and neither has a settled value a
+     * projection could cache correctly. Leave this off unless something is actually going to display
+     * the composed document (e.g. `abx demo`'s read-back step).
+     */
+    readUriDocuments?: boolean;
+    /** See {@link GetLogsAdaptiveOptions.onChunk} — the only progress signal during a large scan. */
+    onChunk?: GetLogsAdaptiveOptions['onChunk'];
 }
 /**
  * Rebuild a project's full state from the chain alone — the canonical replay.
@@ -28,6 +67,28 @@ export declare function reconstructProject(client: PublicClient, opts: Reconstru
  */
 export declare function reconstructIncremental(client: PublicClient, prior: ProjectState, opts?: {
     factory?: Address;
+    maxChunks?: number;
+    getLogsRange?: bigint;
+    readUriDocuments?: boolean;
+    onChunk?: GetLogsAdaptiveOptions['onChunk'];
+    /** Default `'latest'` (chain head) — unchanged. `'safe'`/`'finalized'` stop the catch-up at that
+     *  tag's block instead; see {@link ReconstructOptions.toBlock}. */
+    toBlock?: 'latest' | ReconstructBlockTag;
+}): Promise<ProjectState>;
+/**
+ * The fold / head-read half of {@link reconstructIncremental}, given logs the caller already
+ * fetched. A multi-address watch loop (`getLogs({address: Address[]})`) holds each touched
+ * project's delta; this consumes it so that loop is the only `eth_getLogs`. Folding stays here.
+ *
+ * `toBlock` is the inclusive scan head those logs cover — required even when `logs` is empty,
+ * so a quiet window still advances the checkpoint to the range the caller scanned, and so a
+ * caller that scanned a capped window (not chain head) cannot stamp `toBlock` past the last
+ * log they actually held.
+ */
+export declare function reconstructFromLogs(client: PublicClient, prior: ProjectState, logs: readonly Log[], opts: {
+    factory?: Address;
+    readUriDocuments?: boolean;
+    toBlock: bigint;
 }): Promise<ProjectState>;
 /** The structural projection folded from the spine (everything that isn't a head read).
  *  Exported for tests and advanced consumers; the shape may evolve with the spine. */
@@ -40,6 +101,8 @@ export interface Fold {
         receiver: Address;
         bps: number;
     } | null;
+    maxRoyaltyBps: number | null;
+    burnable: boolean | null;
     extById: Map<string, ExtensionInfo>;
     tokens: Map<string, TokenState>;
     tokenFields: Map<string, Map<string, MetadataField>>;
@@ -47,6 +110,7 @@ export interface Fold {
     collectionFields: Map<string, MetadataField>;
     collectionLocked: Set<string>;
     maxInvocations: string | null;
+    defaultMaxSupply: string | null;
     minter: Address | null;
     paused: boolean;
     primaryPayee: Address | null;
@@ -54,6 +118,7 @@ export interface Fold {
     contractParams: Map<string, ParamValue>;
     paramSchemas: Map<string, ParamSchema>;
     paramHooks: ParamHooks | null;
+    paramHooksFrozen: boolean;
     delegateRegistry: Address | null | undefined;
     seedSource: Address | null;
     scriptLocked: boolean;
@@ -71,7 +136,7 @@ export declare function foldSpine(events: SpineEvent[]): Fold;
 /** Does this error look like an RPC rejecting the block range (vs a real failure)? */
 export declare function isGetLogsRangeError(err: unknown): boolean;
 /** Thrown when a reconstruction would need more getLogs requests than the cap allows. */
-export declare class GetLogsScanTooLargeError extends Error {
+export declare class GetLogsScanTooLargeError extends AbxSdkError {
     readonly spanBlocks: bigint;
     readonly window: bigint;
     readonly estimatedRequests: number;
@@ -94,4 +159,77 @@ export declare class GetLogsScanTooLargeError extends Error {
  * contract has no code at block 0 (true for every ABX clone — deployed long after genesis).
  */
 export declare function discoverDeployBlock(client: PublicClient, address: Address, toBlock?: bigint): Promise<bigint | null>;
+/**
+ * Ordinary RPC tiers cap how many addresses one `eth_getLogs` filter may carry.
+ * This is an RPC-tier opinion, not a protocol constant — callers with a dedicated
+ * node can raise it; `0` disables splitting (one filter for the whole list).
+ */
+export declare const DEFAULT_GETLOGS_ADDRESS_BATCH = 1000;
+export interface GetLogsAdaptiveOptions {
+    maxChunks?: number;
+    range?: bigint;
+    /** Split `address[]` filters into this many addresses per request. Default
+     *  {@link DEFAULT_GETLOGS_ADDRESS_BATCH}. `0` = no split. */
+    addressBatch?: number;
+    /**
+     * Fired after each `eth_getLogs` chunk with how far the scan has gotten — the signal a caller has
+     * that a large scan is alive, not hung. Pure notification,
+     * no return value; a CLI caller throttles this itself before printing (every chunk would be noise).
+     */
+    onChunk?: (progress: {
+        /** Completed block-filter work across every address batch. */
+        scanned: bigint;
+        /** Total block-filter work (`blockSpan * addressBatches`). */
+        span: bigint;
+        /** Blocks completed in the current address batch. */
+        scannedBlocks: bigint;
+        blockSpan: bigint;
+        /** Zero-based batch index and total batch count. */
+        addressBatch: number;
+        addressBatches: number;
+    }) => void;
+}
+/**
+ * Pull logs over a block range, adapting to RPC range caps — and, when `address` is
+ * a list, splitting that list so a registered-set watch scan stays one code path for
+ * self-host and hosted. Providers cap `eth_getLogs` very differently and the numbers
+ * change, so we don't hard-code a window: try the whole range, and when the RPC
+ * rejects it, halve the window and sweep. `ABX_GETLOGS_RANGE` overrides the starting
+ * window. Address-list chunking is a separate cap (`addressBatch`); 5000-block
+ * per-tick windows belong to the caller (the watcher), not here.
+ *
+ * Once the working window is known we estimate the whole job *before* grinding it: if
+ * it would exceed the cap, we stop early (only the probe calls spent) and throw
+ * {@link GetLogsScanTooLargeError} so the caller can offer the real fix (a higher-range
+ * RPC) or an explicit opt-in to chunk through it.
+ */
+export declare function getLogsAdaptive(client: PublicClient, address: Address | readonly Address[], fromBlock: bigint, toBlock: bigint, opts?: GetLogsAdaptiveOptions): Promise<Log[]>;
+/**
+ * Multicall in chunks, tolerating per-leg failure — and, when a whole chunk comes back failed,
+ * retrying its legs individually before believing it.
+ *
+ * The retry is the point, and it exists to tell apart two failure modes that an aggregate throwing
+ * cannot distinguish on its own:
+ *
+ * 1. **Over budget.** `allowFailure: true` reports per-leg failures, but a multicall is ONE
+ *    `eth_call`: if the aggregate exceeds the node's gas or response cap, the *whole* batch fails
+ *    and every leg in it reports failure — including legs that answer fine on their own. Batching a
+ *    cheap read beside an expensive one therefore turns the expensive one's cost into the cheap
+ *    one's failure. Re-asking each leg alone, with no aggregate overhead, recovers this: the calls
+ *    were always fine, only their batching was too big.
+ * 2. **No multicall3 on this chain.** If the aggregate fails because there's no multicall3
+ *    deployment to call at all, *every* multicall — including a single-leg one — fails the identical
+ *    way. Re-asking through `client.multicall` again, at any width, reproduces the same failure, so
+ *    the retry must go through a call shape that has no multicall3 dependency: `client.readContract`.
+ *    Skipping this means a chain lacking multicall3 reads back as "the contract answered nothing" —
+ *    indistinguishable from a real revert — which is exactly the silent-blank-identity bug this
+ *    retry was reported to have.
+ *
+ * So the fallback always resolves each leg with `readContract`, never with a smaller `multicall`.
+ * `readContract` throws on revert where multicall's `allowFailure` returns a `status: 'failure'`
+ * result instead, so a per-leg throw here is caught and mapped back to `null` — a genuine revert on
+ * one leg must still read as "that leg has no answer," matching the aggregate's own contract,
+ * whichever call shape actually answered it.
+ */
+export declare function multicallChunked(client: PublicClient, contracts: Array<Record<string, unknown>>, chunkSize: number): Promise<Array<unknown>>;
 //# sourceMappingURL=reconstruct.d.ts.map

package/dist/reconstruct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reconstruct.d.ts","sourceRoot":"","sources":["../src/reconstruct.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reconstruct.d.ts","sourceRoot":"","sources":["../src/reconstruct.ts"],"names":[],"mappings":"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"}