@subsquid/ponder 0.15.17-sqd.1

package/dist/types/sync-historical/portal-realtime.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Portal-native realtime — serve `[portal-finalized-head → tip]` from the Portal `/stream` (fork-aware
+ * hot-blocks) instead of RPC.
+ *
+ * WHY: in realtime mode the fork currently backfills `[deploy → portal-finalized-head]` from the Portal,
+ * then fetches `[portal-finalized-head → chain-finalized-head]` over RPC (the "finality gap") and runs
+ * ponder's RPC RealtimeSync for the tip. For dense chains under multichain load that RPC gap-fetch stalls
+ * — ponder's single-thread global ordering blocks on the slowest chain's gap. The Portal already holds
+ * these hot-blocks; streaming them removes the RPC gap at its source.
+ *
+ * HOW: `/stream` with `includeAllBlocks:true` yields EVERY block header (a consecutive parentHash chain,
+ * for reorg tracking) plus the filtered euler logs, in one request. We reconcile each block into a local
+ * unfinalized chain and emit ponder's own `RealtimeSyncEvent`s (`block` / `reorg` / `finalize`) reusing
+ * `portal-transform` — so the downstream indexing + checkpointing in runtime/realtime.ts is UNCHANGED.
+ *
+ * The reorg/finalize reconciliation is pure + unit-tested; the `/stream` read and `/finalized-head` poll
+ * are the I/O shell.
+ */
+import type { SyncBlockHeader, SyncLog } from '../internal/types.js';
+import { hexToNumber, type Hex } from "viem";
+import { hx, type RawHeader } from "./portal-transform.js";
+/** The minimum a block needs for chain reconciliation. `number` is a decimal string (Portal-native). */
+export type Light = {
+    number: number;
+    hash: string;
+    parentHash: string;
+    timestamp: number;
+};
+export type Reconcile = {
+    kind: "append";
+} | {
+    kind: "duplicate";
+} | {
+    kind: "reorg";
+    commonAncestor: Light;
+    reorgedBlocks: Light[];
+} | {
+    kind: "gap";
+};
+/**
+ * Reconcile a newly-streamed block against the local unfinalized chain (oldest→newest, linked
+ * parentHash→hash). Pure. With `includeAllBlocks` the happy path is always `append`; a reorg re-streams
+ * from the fork point, so the new block's `parentHash` matches an EARLIER block — everything after that
+ * common ancestor is reorged.
+ */
+export declare function reconcile(unfinalized: Light[], next: Light): Reconcile;
+/** Split the unfinalized chain at a newly-finalized block number. Pure. */
+export declare function takeFinalized(unfinalized: Light[], finalizedNumber: number): {
+    finalizedTip: Light | undefined;
+    remaining: Light[];
+};
+export declare const toLight: (h: RawHeader) => Light;
+export type PortalRealtimeArgs = {
+    portalUrl: string;
+    headers: Record<string, string>;
+    /** first block to stream (exclusive of already-indexed finalized head): syncProgress.finalized.number + 1 */
+    fromBlock: number;
+    /** euler log filters (address/topics), already merged — passed straight into the Portal query */
+    logs: Array<Record<string, unknown>>;
+    /** the block header fields ponder needs */
+    blockFields?: Record<string, boolean>;
+    logFields?: Record<string, boolean>;
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+};
+/**
+ * Stream fork-aware hot-blocks with `includeAllBlocks` (every header + filtered logs). Yields raw Portal
+ * batch objects `{ header, logs }`. Re-opens the stream from the last seen block on disconnect so it runs
+ * continuously; a reorg simply re-streams from the fork point (reconcile() detects it).
+ */
+export declare function streamHotBlocks(args: PortalRealtimeArgs): AsyncGenerator<{
+    header: RawHeader;
+    logs: any[];
+}>;
+export type PortalRealtimeEvent = {
+    type: "block";
+    block: SyncBlockHeader;
+    logs: SyncLog[];
+    hasMatchedFilter: boolean;
+} | {
+    type: "reorg";
+    block: Light;
+    reorgedBlocks: Light[];
+} | {
+    type: "finalize";
+    block: Light;
+};
+export declare function portalRealtimeEvents(args: PortalRealtimeArgs & {
+    finalizedHead: () => Promise<number | undefined>;
+    finalizePollMs?: number;
+}): AsyncGenerator<PortalRealtimeEvent>;
+export { hx as _hx };
+export type { SyncBlockHeader, SyncLog, Hex };
+export { hexToNumber };
+//# sourceMappingURL=portal-realtime.d.ts.map

package/dist/types/sync-historical/portal-realtime.d.ts.map

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

package/dist/types/sync-historical/portal-transform.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Pure transforms: SQD Portal NDJSON → Ponder Sync* / geth callTracer shapes.
+ *
+ * Portal uses a SPLIT encoding (verified live, block 21,000,000): small bounded
+ * values are DECIMAL numbers (status, type, transactionIndex, nonce, chainId,
+ * yParity, traceAddress[], subtraces, block number/timestamp) while 256-bit /
+ * byte quantities are HEX strings (gas*, value, effectiveGasPrice, v/r/s, all
+ * addresses/hashes, and ALL trace action/result quantities). So e.g. `status` is
+ * `1` not `"0x1"`, but `gasUsed` is `"0x317fa"`. These functions normalise to
+ * viem RPC conventions. Kept pure + exported so they're unit-testable against
+ * real captured fixtures.
+ */
+import type { SyncBlockHeader, SyncLog, SyncTransaction, SyncTransactionReceipt } from '../internal/types.js';
+import { type Address, type Hex } from "viem";
+export type RawHeader = Record<string, any> & {
+    number: number;
+};
+/** Traces are ~100x denser than logs; buffering a wide chunk's worth over a busy contract OOMs.
+ * For trace-index parity we fetch the FULL (unfiltered) trace set, which is denser still, so the
+ * default cap is conservative. When a chain has trace sources, cap the chunk to a trace-safe width
+ * (PORTAL_TRACE_CHUNK_BLOCKS, default 2k). Pure so it's unit-testable. */
+export declare const traceSafeChunkBlocks: (base: number, needTraces: boolean, cap?: number) => number;
+/** An interval reaching past Portal's finalized head must fall back to RPC for the gap.
+ * (undefined head = not yet known → treat as no gap.) Pure so it's unit-testable. */
+export declare const isFinalityGap: (intervalEnd: number, portalHead: number | undefined) => boolean;
+/** number|decimal-string|hex → 0x-hex; passes existing hex through. */
+export declare const hx: (v: unknown) => Hex;
+export declare const opt: (v: unknown) => Hex | undefined;
+export declare const toSyncLog: (l: any, h: RawHeader) => SyncLog;
+export declare const toSyncBlockHeader: (h: RawHeader) => SyncBlockHeader;
+export declare const toSyncTransaction: (tx: any, h: RawHeader) => SyncTransaction;
+/** receipt fields ride on Portal's transaction object; status/type are DECIMAL → hex. */
+export declare const toSyncReceipt: (tx: any, h: RawHeader) => SyncTransactionReceipt;
+export declare const CALL_TYPE: Record<string, string>;
+/** lexicographic, parent-before-child: [] < [0] < [0,0] < [1] — i.e. DFS pre-order. */
+export declare const cmpTraceAddr: (a: number[], b: number[]) => number;
+/** Portal Parity trace → geth callTracer CallFrame (+ index/subcalls). Reads nested
+ * action/result; callType lives at action.callType. CREATE2 is indistinguishable. */
+export declare const parityToCallFrame: (t: any, index: number) => any | undefined;
+/** State diffs — Portal has them; Ponder has no state-diff source today, so this is
+ * engine-level only (available via the standalone client, not wired into HistoricalSync). */
+export type StateDiff = {
+    transactionIndex: number;
+    address: Address;
+    key: string;
+    kind: "=" | "+" | "*" | "-";
+    prev: Hex | null;
+    next: Hex | null;
+};
+export declare const toStateDiff: (d: any) => StateDiff;
+//# sourceMappingURL=portal-transform.d.ts.map

package/dist/types/sync-historical/portal-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal-transform.d.ts","sourceRoot":"","sources":["../../../src/sync-historical/portal-transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EACV,eAAe,EACf,OAAO,EACP,eAAe,EACf,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,GAAG,EAAsB,MAAM,MAAM,CAAC;AAElE,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE;;;0EAG0E;AAC1E,eAAO,MAAM,oBAAoB,SAAU,MAAM,cAAc,OAAO,mBAAiE,MAChG,CAAC;AAExC;qFACqF;AACrF,eAAO,MAAM,aAAa,gBAAiB,MAAM,cAAc,MAAM,GAAG,SAAS,KAAG,OAC9B,CAAC;AAEvD,uEAAuE;AACvE,eAAO,MAAM,EAAE,MAAO,OAAO,KAAG,GAO/B,CAAC;AACF,eAAO,MAAM,GAAG,MAAO,OAAO,KAAG,GAAG,GAAG,SAAgE,CAAC;AAExG,eAAO,MAAM,SAAS,MAAO,GAAG,KAAK,SAAS,KAAG,OAIzB,CAAC;AAEzB,eAAO,MAAM,iBAAiB,MAAO,SAAS,KAAG,eAOjB,CAAC;AAEjC,eAAO,MAAM,iBAAiB,OAAQ,GAAG,KAAK,SAAS,KAAG,eAU1B,CAAC;AAEjC,yFAAyF;AACzF,eAAO,MAAM,aAAa,OAAQ,GAAG,KAAK,SAAS,KAAG,sBAUf,CAAC;AAExC,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAkG,CAAC;AAEhJ,uFAAuF;AACvF,eAAO,MAAM,YAAY,MAAO,MAAM,EAAE,KAAK,MAAM,EAAE,KAAG,MAIvD,CAAC;AAEF;qFACqF;AACrF,eAAO,MAAM,iBAAiB,MAAO,GAAG,SAAS,MAAM,KAAG,GAAG,GAAG,SAkB/D,CAAC;AAEF;6FAC6F;AAC7F,MAAM,MAAM,SAAS,GAAG;IAAE,gBAAgB,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAAA;CAAE,CAAC;AACrJ,eAAO,MAAM,WAAW,MAAO,GAAG,KAAG,SAGnC,CAAC"}

package/dist/types/sync-historical/portal.d.ts

@@ -0,0 +1,34 @@
+import type { Common } from '../internal/common.js';
+import type { Chain, FactoryId, Filter } from '../internal/types.js';
+import type { Rpc } from '../rpc/index.js';
+import { type Address } from "viem";
+import { type HistoricalSync } from "./index.js";
+/**
+ * Portal-backed historical sync with a PARALLEL read-ahead chunk buffer.
+ *
+ * Ponder feeds small intervals; Portal is latency-bound per request but has huge
+ * parallel bandwidth. So we fetch large aligned CHUNKS and serve every interval
+ * from cache — and we fetch chunks IN PARALLEL (read-ahead depth N) so the
+ * Portal's per-request latency overlaps instead of serializing.
+ *
+ * Correctness for factory sources: the discovery timeline is decoupled from the
+ * data timeline. Each chunk's children are discovered independently (clamped to
+ * the factory's real start block), and a data chunk only fetches once discovery
+ * is complete THROUGH its own block range — so no child event is missed even
+ * though data chunks are fetched out of order.
+ *
+ * Tunables: PORTAL_CHUNK_BLOCKS (default 500k), PORTAL_READAHEAD (default 6).
+ * Selected at runtime/historical.ts when `chain.portal` is set; realtime → rpc.
+ */
+type CreateHistoricalSyncParameters = {
+    common: Common;
+    chain: Chain;
+    rpc: Rpc;
+    childAddresses: Map<FactoryId, Map<Address, number>>;
+    eventCallbacks: {
+        filter: Filter;
+    }[];
+};
+export declare const createPortalHistoricalSync: (args: CreateHistoricalSyncParameters) => HistoricalSync;
+export {};
+//# sourceMappingURL=portal.d.ts.map

package/dist/types/sync-historical/portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../../../src/sync-historical/portal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EACV,KAAK,EACL,SAAS,EACT,MAAM,EAQP,MAAM,qBAAqB,CAAC;AAY7B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,MAAM,CAAC;AAC9C,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,YAAY,CAAC;AAGvE;;;;;;;;;;;;;;;;GAgBG;AAEH,KAAK,8BAA8B,GAAG;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,cAAc,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;IAIrD,cAAc,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACtC,CAAC;AAmFF,eAAO,MAAM,0BAA0B,SAC/B,8BAA8B,KACnC,cA2pBF,CAAC"}

package/dist/types/sync-historical/realtime.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Realtime source helpers + endpoint instrumentation.
+ *
+ * Ponder owns realtime and reorg handling natively (RealtimeSync: parent-hash tracking + rollback to the
+ * common ancestor, bounded by the finalized block). The fork only swaps the HISTORICAL sync to the Portal.
+ * So the realtime source is purely a `rpc` config choice — ponder polls whatever transport(s) you give it
+ * and reorg-handles the result identically. The lib is RPC-agnostic: an authenticated RPC (an x-api-key
+ * header, a keyed proxy, …) is just `http(url, { fetchOptions: { headers } })` — nothing special.
+ *
+ *   import { http, fallback } from "viem";
+ *   // a plain list (Ponder-style), or latency-ranked for fastest-tip:
+ *   rpc: [process.env.RPC_1!, process.env.RPC_1B!],
+ *   rpc: fallback([http(process.env.RPC_1!), http(process.env.RPC_1B!)], { rank: true }),
+ *   // an authenticated RPC + fallback:
+ *   rpc: fallback([ http(process.env.RPC_URL!, { fetchOptions: { headers: { "x-api-key": process.env.RPC_KEY! } } }), http(process.env.RPC_1!) ]),
+ *
+ * `fallback` gives smooth failover; `{ rank: true }` probes latency and routes to the fastest tip. Either
+ * way ponder's reorg safety comes for free.
+ */
+import { type Transport } from "viem";
+/**
+ * Compose realtime RPC(s) into a latency-ranked fallback so the fastest tip lands. Accepts URL strings or
+ * viem Transports — pass a Transport for an authenticated RPC: `http(url, { fetchOptions: { headers } })`.
+ */
+export declare function rpcRealtime(rpcs: Array<string | Transport>, opts?: {
+    rank?: boolean;
+}): Transport;
+export type Endpoint = {
+    name: string;
+    url: string;
+    headers?: Record<string, string>;
+};
+export type ChainEndpoints = {
+    chainId: number;
+    endpoints: Endpoint[];
+};
+export type ProbeSample = {
+    chainId: number;
+    name: string;
+    ok: boolean;
+    latencyMs: number;
+    tip: number | null;
+    error?: string;
+    lag?: number | null;
+};
+/** Probe every endpoint once. Pure w.r.t. state — takes a `fetchImpl` for testability. */
+export declare function probeOnce(chains: ChainEndpoints[], fetchImpl?: typeof fetch, timeoutMs?: number): Promise<ProbeSample[]>;
+/** Freshness lag (blocks behind the freshest endpoint for the same chain). Pure. */
+export declare function freshnessLag(samples: ProbeSample[]): Map<string, number | null>;
+/** Roll a window of samples into per-endpoint stats. Pure. */
+export declare function summarize(window: ProbeSample[]): Record<string, {
+    chainId: number;
+    name: string;
+    n: number;
+    okRate: number;
+    latP50: number;
+    latP95: number;
+    latMean: number;
+    avgLag: number | null;
+    lastError?: string;
+}>;
+/** Start the periodic endpoint probe. Returns a stop() fn. Writes `<metricsFile>` (JSON) each tick. */
+export declare function startEndpointProbe(chains: ChainEndpoints[], opts?: {
+    intervalMs?: number;
+    windowTicks?: number;
+    metricsFile?: string;
+    fetchImpl?: typeof fetch;
+    onSummary?: (s: ReturnType<typeof summarize>) => void;
+    log?: (m: string) => void;
+}): () => void;
+//# sourceMappingURL=realtime.d.ts.map

package/dist/types/sync-historical/realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.d.ts","sourceRoot":"","sources":["../../../src/sync-historical/realtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,MAAM,CAAC;AAEtD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAEjG;AASD,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC;AACvF,MAAM,MAAM,cAAc,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAC;AACxE,MAAM,MAAM,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAErJ,0FAA0F;AAC1F,wBAAsB,SAAS,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,SAAS,GAAE,OAAO,KAAa,EAAE,SAAS,SAAQ,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAyBpI;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAS/E;AAQD,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAiBzN;AAED,uGAAuG;AACvG,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,cAAc,EAAE,EACxB,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IAAC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,KAAK,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GACzL,MAAM,IAAI,CAqBZ"}

package/dist/types/sync-realtime/bloom.d.ts

@@ -0,0 +1,18 @@
+import type { LogFilter, SyncBlock } from '../internal/types.js';
+import { type Hex } from "viem";
+export declare const zeroLogsBloom = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
+export declare const isInBloom: (_bloom: Hex, input: Hex) => boolean;
+/**
+ * Return true if `filter` is in `bloom`.
+ *
+ * A filter with an address of type `LogFactory` is matched
+ * if the address filter is matched (new child contract) or the log
+ * filter is matched (log on child contract).
+ *
+ * Note: False positives are possible.
+ */
+export declare function isFilterInBloom({ block, filter, }: {
+    block: Pick<SyncBlock, "number" | "logsBloom">;
+    filter: LogFilter;
+}): boolean;
+//# sourceMappingURL=bloom.d.ts.map

package/dist/types/sync-realtime/bloom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bloom.d.ts","sourceRoot":"","sources":["../../../src/sync-realtime/bloom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAMhE,OAAO,EAAE,KAAK,GAAG,EAAsC,MAAM,MAAM,CAAC;AAEpE,eAAO,MAAM,aAAa,ugBAC4e,CAAC;AAIvgB,eAAO,MAAM,SAAS,WAAY,GAAG,SAAS,GAAG,KAAG,OAenD,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,MAAM,GACP,EAAE;IACD,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,GAAG,WAAW,CAAC,CAAC;IAC/C,MAAM,EAAE,SAAS,CAAC;CACnB,GAAG,OAAO,CAwDV"}

package/dist/types/sync-realtime/index.d.ts

@@ -0,0 +1,47 @@
+import type { Common } from '../internal/common.js';
+import type { Chain, EventCallback, Factory, FactoryId, LightBlock, SyncBlock, SyncBlockHeader, SyncLog, SyncTrace, SyncTransaction, SyncTransactionReceipt } from '../internal/types.js';
+import type { Rpc } from '../rpc/index.js';
+import type { SyncProgress } from '../runtime/index.js';
+import { type Address } from "viem";
+export type RealtimeSync = {
+    /**
+     * Fetch block event data and reconcile it into the local chain.
+     *
+     * @param block - The block to reconcile.
+     */
+    sync(block: SyncBlock | SyncBlockHeader, blockCallback?: (isAccepted: boolean) => void): AsyncGenerator<RealtimeSyncEvent>;
+    onError(error: Error): void;
+    /** Local chain of blocks that have not been finalized. */
+    unfinalizedBlocks: LightBlock[];
+};
+export type BlockWithEventData = {
+    block: SyncBlock | SyncBlockHeader;
+    transactions: SyncTransaction[];
+    transactionReceipts: SyncTransactionReceipt[];
+    logs: SyncLog[];
+    traces: SyncTrace[];
+    childAddresses: Map<Factory, Set<Address>>;
+};
+export type RealtimeSyncEvent = ({
+    type: "block";
+    hasMatchedFilter: boolean;
+    blockCallback?: (isAccepted: boolean) => void;
+} & BlockWithEventData) | {
+    type: "finalize";
+    block: LightBlock;
+} | {
+    type: "reorg";
+    block: LightBlock;
+    reorgedBlocks: LightBlock[];
+};
+type CreateRealtimeSyncParameters = {
+    common: Common;
+    chain: Chain;
+    rpc: Rpc;
+    eventCallbacks: EventCallback[];
+    syncProgress: Pick<SyncProgress, "finalized">;
+    childAddresses: Map<FactoryId, Map<Address, number>>;
+};
+export declare const createRealtimeSync: (args: CreateRealtimeSyncParameters) => RealtimeSync;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/sync-realtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sync-realtime/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAEV,KAAK,EACL,aAAa,EACb,OAAO,EACP,SAAS,EAET,UAAU,EAEV,SAAS,EACT,eAAe,EACf,OAAO,EACP,SAAS,EACT,eAAe,EACf,sBAAsB,EAIvB,MAAM,qBAAqB,CAAC;AAa7B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAa1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIvD,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,MAAM,CAAC;AAGd,MAAM,MAAM,YAAY,GAAG;IACzB;;;;OAIG;IACH,IAAI,CACF,KAAK,EAAE,SAAS,GAAG,eAAe,EAClC,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,GAC5C,cAAc,CAAC,iBAAiB,CAAC,CAAC;IACrC,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC5B,0DAA0D;IAC1D,iBAAiB,EAAE,UAAU,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,SAAS,GAAG,eAAe,CAAC;IACnC,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,mBAAmB,EAAE,sBAAsB,EAAE,CAAC;IAC9C,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,cAAc,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,iBAAiB,GACzB,CAAC;IACC,IAAI,EAAE,OAAO,CAAC;IACd,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;CAC/C,GAAG,kBAAkB,CAAC,GACvB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,aAAa,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC;AAEtE,KAAK,4BAA4B,GAAG;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;IAC9C,cAAc,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;CACtD,CAAC;AAKF,eAAO,MAAM,kBAAkB,SACvB,4BAA4B,KACjC,YAuqCF,CAAC"}

package/dist/types/sync-store/encode.d.ts

@@ -0,0 +1,25 @@
+import type { SyncBlock, SyncBlockHeader, SyncLog, SyncTrace, SyncTransaction, SyncTransactionReceipt } from '../internal/types.js';
+import type * as ponderSyncSchema from "./schema.js";
+export declare const encodeBlock: ({ block, chainId, }: {
+    block: SyncBlock | SyncBlockHeader;
+    chainId: number;
+}) => typeof ponderSyncSchema.blocks.$inferInsert;
+export declare const encodeLog: ({ log, chainId, }: {
+    log: SyncLog;
+    chainId: number;
+}) => typeof ponderSyncSchema.logs.$inferInsert;
+export declare const encodeTransaction: ({ transaction, chainId, }: {
+    transaction: SyncTransaction;
+    chainId: number;
+}) => typeof ponderSyncSchema.transactions.$inferInsert;
+export declare const encodeTransactionReceipt: ({ transactionReceipt, chainId, }: {
+    transactionReceipt: SyncTransactionReceipt;
+    chainId: number;
+}) => typeof ponderSyncSchema.transactionReceipts.$inferInsert;
+export declare const encodeTrace: ({ trace, block, transaction, chainId, }: {
+    trace: SyncTrace;
+    block: Pick<SyncBlock, "number">;
+    transaction: Pick<SyncTransaction, "transactionIndex">;
+    chainId: number;
+}) => typeof ponderSyncSchema.traces.$inferInsert;
+//# sourceMappingURL=encode.d.ts.map

package/dist/types/sync-store/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../src/sync-store/encode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,OAAO,EACP,SAAS,EACT,eAAe,EACf,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,KAAK,KAAK,gBAAgB,MAAM,aAAa,CAAC;AAErD,eAAO,MAAM,WAAW;WAIf,SAAS,GAAG,eAAe;aACzB,MAAM;MACb,OAAO,iBAAiB,MAAM,CAAC,YAuBjC,CAAC;AAEH,eAAO,MAAM,SAAS;SAIf,OAAO;aACH,MAAM;MACb,OAAO,iBAAiB,IAAI,CAAC,YAa/B,CAAC;AAEH,eAAO,MAAM,iBAAiB;iBAIf,eAAe;aACnB,MAAM;MACb,OAAO,iBAAiB,YAAY,CAAC,YA0BvC,CAAC;AAEH,eAAO,MAAM,wBAAwB;wBAIf,sBAAsB;aACjC,MAAM;MACb,OAAO,iBAAiB,mBAAmB,CAAC,YAiB9C,CAAC;AAEH,eAAO,MAAM,WAAW;WAMf,SAAS;WACT,KAAK,SAAS,EAAE,QAAQ,CAAC;iBACnB,KAAK,eAAe,EAAE,kBAAkB,CAAC;aAC7C,MAAM;MACb,OAAO,iBAAiB,MAAM,CAAC,YAkBjC,CAAC"}

package/dist/types/sync-store/index.d.ts

@@ -0,0 +1,135 @@
+import type { QB } from '../database/queryBuilder.js';
+import type { Common } from '../internal/common.js';
+import type { Logger } from '../internal/logger.js';
+import type { BlockFilter, Factory, Filter, Fragment, InternalBlock, InternalLog, InternalTrace, InternalTransaction, InternalTransactionReceipt, LightBlock, LogFilter, SyncBlock, SyncBlockHeader, SyncLog, SyncTrace, SyncTransaction, SyncTransactionReceipt, TraceFilter, TransactionFilter, TransferFilter } from '../internal/types.js';
+import type { RequestParameters } from '../rpc/index.js';
+import type { IntervalWithFactory, IntervalWithFilter } from '../runtime/index.js';
+import type { Interval } from '../utils/interval.js';
+import { type SQL } from "drizzle-orm";
+import { type Address } from "viem";
+import * as PONDER_SYNC from "./schema.js";
+export type SyncStore = {
+    insertIntervals(args: {
+        intervals: IntervalWithFilter[];
+        factoryIntervals: IntervalWithFactory[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    getIntervals(args: {
+        filters: Filter[];
+    }, context?: {
+        logger?: Logger;
+    }): Promise<Map<Filter | Factory, {
+        fragment: Fragment;
+        intervals: Interval[];
+    }[]>>;
+    insertChildAddresses(args: {
+        factory: Factory;
+        childAddresses: Map<Address, number>;
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    getChildAddresses(args: {
+        factory: Factory;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<Map<Address, number>>;
+    getSafeCrashRecoveryBlock(args: {
+        chainId: number;
+        timestamp: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<{
+        number: bigint;
+        timestamp: bigint;
+    } | undefined>;
+    insertLogs(args: {
+        logs: SyncLog[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    insertBlocks(args: {
+        blocks: (SyncBlock | SyncBlockHeader)[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    insertTransactions(args: {
+        transactions: SyncTransaction[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    insertTransactionReceipts(args: {
+        transactionReceipts: SyncTransactionReceipt[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    insertTraces(args: {
+        traces: {
+            trace: SyncTrace;
+            block: SyncBlock;
+            transaction: SyncTransaction;
+        }[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    getEventData(args: {
+        filters: Filter[];
+        fromBlock: number;
+        toBlock: number;
+        chainId: number;
+        limit: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<{
+        blocks: InternalBlock[];
+        logs: InternalLog[];
+        transactions: InternalTransaction[];
+        transactionReceipts: InternalTransactionReceipt[];
+        traces: InternalTrace[];
+        cursor: number;
+    }>;
+    insertRpcRequestResults(args: {
+        requests: {
+            request: RequestParameters;
+            blockNumber: number | undefined;
+            result: string;
+        }[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    getRpcRequestResults(args: {
+        requests: RequestParameters[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<(string | undefined)[]>;
+    pruneRpcRequestResults(args: {
+        blocks: Pick<LightBlock, "number">[];
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+    pruneByChain(args: {
+        chainId: number;
+    }, context?: {
+        logger?: Logger;
+    }): Promise<void>;
+};
+export declare const createSyncStore: ({ common, qb, }: {
+    common: Common;
+    qb: QB<typeof PONDER_SYNC>;
+}) => SyncStore;
+export declare const logFilter: (filter: LogFilter) => SQL;
+export declare const blockFilter: (filter: BlockFilter) => SQL;
+export declare const transactionFilter: (filter: TransactionFilter) => SQL;
+export declare const transferFilter: (filter: TransferFilter) => SQL;
+export declare const traceFilter: (filter: TraceFilter) => SQL;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/sync-store/index.d.ts.map

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

package/dist/types/sync-store/migrations.d.ts

@@ -0,0 +1,8 @@
+import { type Logger } from '../internal/logger.js';
+import type { Migration, MigrationProvider } from "kysely";
+declare class StaticMigrationProvider implements MigrationProvider {
+    getMigrations(): Promise<Record<string, Migration>>;
+}
+export declare function buildMigrationProvider(logger_: Logger): StaticMigrationProvider;
+export {};
+//# sourceMappingURL=migrations.d.ts.map

package/dist/types/sync-store/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../../src/sync-store/migrations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAoB,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAU,SAAS,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAMnE,cAAM,uBAAwB,YAAW,iBAAiB;IAClD,aAAa;CAGpB;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,2BAIrD"}