@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/block/l2_block_source.js

@@ -1,21 +1,111 @@
+import { BlockNumberSchema, CheckpointNumberSchema, EpochNumberSchema, SlotNumberSchema } from '@aztec/foundation/branded-types';
+import { schemas } from '@aztec/foundation/schemas';
 import { z } from 'zod';
-// TODO(palla/schemas): This package should know what is the block hash of the genesis block 0.
-const L2BlockIdSchema = z.union([
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { BlockHash } from './block_hash.js';
+import { BlockTagWithoutLatestSchema } from './block_parameter.js';
+export const BlockQuerySchema = z.union([
     z.object({
-        number: z.literal(0),
-        hash: z.undefined()
-    }),
+        number: BlockNumberSchema
+    }).strict(),
     z.object({
-        number: z.number(),
-        hash: z.string()
-    })
+        hash: BlockHash.schema
+    }).strict(),
+    z.object({
+        archive: schemas.Fr
+    }).strict(),
+    z.object({
+        tag: BlockTagWithoutLatestSchema
+    }).strict()
+]);
+export const BlocksQuerySchema = z.union([
+    z.object({
+        from: BlockNumberSchema,
+        limit: z.number().int().min(1),
+        onlyCheckpointed: z.boolean().optional()
+    }).strict(),
+    z.object({
+        epoch: EpochNumberSchema,
+        onlyCheckpointed: z.literal(true)
+    }).strict()
 ]);
+export const CheckpointQuerySchema = z.union([
+    z.object({
+        number: CheckpointNumberSchema
+    }).strict(),
+    z.object({
+        slot: SlotNumberSchema
+    }).strict(),
+    z.object({
+        tag: z.union([
+            z.literal('checkpointed'),
+            z.literal('proven'),
+            z.literal('finalized')
+        ])
+    }).strict()
+]);
+export const CheckpointsQuerySchema = z.union([
+    z.object({
+        from: CheckpointNumberSchema,
+        limit: z.number().int().min(1)
+    }).strict(),
+    z.object({
+        epoch: EpochNumberSchema
+    }).strict()
+]);
+export const ProposedCheckpointQuerySchema = z.union([
+    z.object({
+        number: CheckpointNumberSchema
+    }).strict(),
+    z.object({
+        slot: SlotNumberSchema
+    }).strict(),
+    z.object({
+        tag: z.literal('proposed')
+    }).strict()
+]);
+export const GENESIS_CHECKPOINT_HEADER_HASH = CheckpointHeader.empty().hash();
+/** Creates an L2 block id */ export function makeL2BlockId(number, hash) {
+    if (number !== 0 && !hash) {
+        throw new Error(`Hash is required for non-genesis blocks (got block number ${number})`);
+    }
+    return {
+        number,
+        hash: hash
+    };
+}
+/** Creates an L2 checkpoint id */ export function makeL2CheckpointId(number, hash) {
+    return {
+        number,
+        hash
+    };
+}
+const L2BlockIdSchema = z.object({
+    number: BlockNumberSchema,
+    hash: z.string()
+});
+const L2CheckpointIdSchema = z.object({
+    number: CheckpointNumberSchema,
+    hash: z.string()
+});
+const L2TipIdSchema = z.object({
+    block: L2BlockIdSchema,
+    checkpoint: L2CheckpointIdSchema
+});
 export const L2TipsSchema = z.object({
-    latest: L2BlockIdSchema,
-    proven: L2BlockIdSchema,
-    finalized: L2BlockIdSchema
+    proposed: L2BlockIdSchema,
+    checkpointed: L2TipIdSchema,
+    proposedCheckpoint: L2TipIdSchema,
+    proven: L2TipIdSchema,
+    finalized: L2TipIdSchema
 });
 export var L2BlockSourceEvents = /*#__PURE__*/ function(L2BlockSourceEvents) {
-    L2BlockSourceEvents["L2PruneDetected"] = "l2PruneDetected";
+    L2BlockSourceEvents["L2PruneUnproven"] = "l2PruneUnproven";
+    L2BlockSourceEvents["L2PruneUncheckpointed"] = "l2PruneUncheckpointed";
+    L2BlockSourceEvents["L2BlockProven"] = "l2BlockProven";
+    L2BlockSourceEvents["L2BlocksCheckpointed"] = "l2BlocksCheckpointed";
+    L2BlockSourceEvents["InvalidAttestationsCheckpointDetected"] = "invalidCheckpointDetected";
+    L2BlockSourceEvents["CheckpointEquivocationDetected"] = "checkpointEquivocationDetected";
+    L2BlockSourceEvents["DescendentOfInvalidAttestationsCheckpointDetected"] = "descendentOfInvalidAttestationsCheckpointDetected";
     return L2BlockSourceEvents;
 }({});

package/dest/block/l2_block_stream/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interfaces.js';
+export * from './l2_block_stream.js';
+export * from './l2_tips_memory_store.js';
+export * from './l2_tips_store_base.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ibG9jay9sMl9ibG9ja19zdHJlYW0vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx5QkFBeUIsQ0FBQyJ9

package/dest/block/l2_block_stream/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/block/l2_block_stream/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC"}

package/dest/block/l2_block_stream/index.js

@@ -0,0 +1,4 @@
+export * from './interfaces.js';
+export * from './l2_block_stream.js';
+export * from './l2_tips_memory_store.js';
+export * from './l2_tips_store_base.js';

package/dest/block/l2_block_stream/interfaces.d.ts

@@ -0,0 +1,39 @@
+import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import type { L2Block } from '../l2_block.js';
+import type { CheckpointId, L2BlockId, L2Tips } from '../l2_block_source.js';
+/** Provides the current chain tips. Implemented by world-state, l2-tips-store, and AztecNode. */
+export interface L2TipsProvider {
+    getL2Tips(): Promise<L2Tips>;
+}
+/** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
+export interface L2BlockStreamLocalDataProvider extends L2TipsProvider {
+    getL2BlockHash(number: number): Promise<string | undefined>;
+}
+/** Interface to a handler of events emitted. */
+export interface L2BlockStreamEventHandler {
+    handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
+}
+export type L2BlockStreamEvent = /** Emits blocks added to the chain. */ {
+    type: 'blocks-added';
+    blocks: L2Block[];
+} | /** Emits checkpoints published to L1. */ {
+    type: 'chain-checkpointed';
+    checkpoint: PublishedCheckpoint;
+    block: L2BlockId;
+} | /**
+ * Reports last correct block (new tip of the proposed chain). Note that this is not necessarily the anchor block
+ * that will be used in the transaction - if the chain has already moved past the reorg, we'll also see blocks-added
+ * events that will push the anchor block forward.
+ */ {
+    type: 'chain-pruned';
+    block: L2BlockId;
+    checkpoint: CheckpointId;
+} | /** Reports new proven block. */ {
+    type: 'chain-proven';
+    block: L2BlockId;
+} | /** Reports new finalized block (proven and finalized on L1). */ {
+    type: 'chain-finalized';
+    block: L2BlockId;
+};
+export type L2TipsStore = L2BlockStreamEventHandler & L2BlockStreamLocalDataProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2Jsb2NrL2wyX2Jsb2NrX3N0cmVhbS9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDcEYsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDOUMsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUU3RSxpR0FBaUc7QUFDakcsTUFBTSxXQUFXLGNBQWM7SUFDN0IsU0FBUyxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztDQUM5QjtBQUVELDhGQUE4RjtBQUM5RixNQUFNLFdBQVcsOEJBQStCLFNBQVEsY0FBYztJQUNwRSxjQUFjLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQUFDO0NBQzdEO0FBRUQsZ0RBQWdEO0FBQ2hELE1BQU0sV0FBVyx5QkFBeUI7SUFDeEMsc0JBQXNCLENBQUMsS0FBSyxFQUFFLGtCQUFrQixHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztDQUNsRTtBQUVELE1BQU0sTUFBTSxrQkFBa0IsR0FDMUIsdUNBQXVDLENBQUM7SUFDdEMsSUFBSSxFQUFFLGNBQWMsQ0FBQztJQUNyQixNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7Q0FDbkIsR0FDRCx5Q0FBeUMsQ0FBQztJQUN4QyxJQUFJLEVBQUUsb0JBQW9CLENBQUM7SUFDM0IsVUFBVSxFQUFFLG1CQUFtQixDQUFDO0lBQ2hDLEtBQUssRUFBRSxTQUFTLENBQUM7Q0FDbEIsR0FDRDs7OztHQUlDLENBQUM7SUFDQSxJQUFJLEVBQUUsY0FBYyxDQUFDO0lBQ3JCLEtBQUssRUFBRSxTQUFTLENBQUM7SUFDakIsVUFBVSxFQUFFLFlBQVksQ0FBQztDQUMxQixHQUNELGdDQUFnQyxDQUFDO0lBQy9CLElBQUksRUFBRSxjQUFjLENBQUM7SUFDckIsS0FBSyxFQUFFLFNBQVMsQ0FBQztDQUNsQixHQUNELGdFQUFnRSxDQUFDO0lBQy9ELElBQUksRUFBRSxpQkFBaUIsQ0FBQztJQUN4QixLQUFLLEVBQUUsU0FBUyxDQUFDO0NBQ2xCLENBQUM7QUFFTixNQUFNLE1BQU0sV0FBVyxHQUFHLHlCQUF5QixHQUFHLDhCQUE4QixDQUFDIn0=

package/dest/block/l2_block_stream/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../src/block/l2_block_stream/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AACpF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE7E,iGAAiG;AACjG,MAAM,WAAW,cAAc;IAC7B,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAC9B;AAED,8FAA8F;AAC9F,MAAM,WAAW,8BAA+B,SAAQ,cAAc;IACpE,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CAC7D;AAED,gDAAgD;AAChD,MAAM,WAAW,yBAAyB;IACxC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClE;AAED,MAAM,MAAM,kBAAkB,GAC1B,uCAAuC,CAAC;IACtC,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB,GACD,yCAAyC,CAAC;IACxC,IAAI,EAAE,oBAAoB,CAAC;IAC3B,UAAU,EAAE,mBAAmB,CAAC;IAChC,KAAK,EAAE,SAAS,CAAC;CAClB,GACD;;;;GAIC,CAAC;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,YAAY,CAAC;CAC1B,GACD,gCAAgC,CAAC;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,SAAS,CAAC;CAClB,GACD,gEAAgE,CAAC;IAC/D,IAAI,EAAE,iBAAiB,CAAC;IACxB,KAAK,EAAE,SAAS,CAAC;CAClB,CAAC;AAEN,MAAM,MAAM,WAAW,GAAG,yBAAyB,GAAG,8BAA8B,CAAC"}

package/dest/block/l2_block_stream/l2_block_stream.d.ts

@@ -0,0 +1,40 @@
+import { type L2BlockSource } from '../l2_block_source.js';
+import type { L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
+/** Maximum number of checkpoints to prefetch at once during sync. Matches MAX_RPC_CHECKPOINTS_LEN. */
+export declare const CHECKPOINT_PREFETCH_LIMIT = 50;
+/** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
+export declare class L2BlockStream {
+    private l2BlockSource;
+    private localData;
+    private handler;
+    private readonly log;
+    private opts;
+    private readonly runningPromise;
+    private isSyncing;
+    private hasStarted;
+    constructor(l2BlockSource: Pick<L2BlockSource, 'getBlocks' | 'getBlockData' | 'getL2Tips' | 'getCheckpoints'>, localData: L2BlockStreamLocalDataProvider, handler: L2BlockStreamEventHandler, log?: import("@aztec/foundation/log").Logger, opts?: {
+        pollIntervalMS?: number;
+        batchSize?: number;
+        startingBlock?: number;
+        /** Instead of downloading all blocks, only fetch the smallest subset that results in reliable reorg detection. */
+        skipFinalized?: boolean;
+        /** When true, checkpoint events will not be emitted. Blocks are still fetched via checkpoints but only blocks-added events are emitted. */
+        ignoreCheckpoints?: boolean;
+        /** Maximum number of checkpoints to prefetch at once during sync. Defaults to CHECKPOINT_PREFETCH_LIMIT (50). */
+        checkpointPrefetchLimit?: number;
+    });
+    start(): void;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    /**
+     * Runs the synchronization process once.
+     *
+     * If you want to run this process continuously use `start` and `stop` instead.
+     */
+    sync(): Promise<void>;
+    protected work(): Promise<void>;
+    private areBlockHashesEqualAt;
+    private getBlockHashFromSource;
+    private emitEvent;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDJfYmxvY2tfc3RyZWFtLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmxvY2svbDJfYmxvY2tfc3RyZWFtL2wyX2Jsb2NrX3N0cmVhbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxPQUFPLEVBQWtCLEtBQUssYUFBYSxFQUFpQixNQUFNLHVCQUF1QixDQUFDO0FBQzFGLE9BQU8sS0FBSyxFQUFzQix5QkFBeUIsRUFBRSw4QkFBOEIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRXJILHNHQUFzRztBQUN0RyxlQUFPLE1BQU0seUJBQXlCLEtBQUssQ0FBQztBQUU1Qyx1SEFBdUg7QUFDdkgscUJBQWEsYUFBYTtJQU10QixPQUFPLENBQUMsYUFBYTtJQUNyQixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsT0FBTztJQUNmLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRztJQUNwQixPQUFPLENBQUMsSUFBSTtJQVRkLE9BQU8sQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFpQjtJQUNoRCxPQUFPLENBQUMsU0FBUyxDQUFTO0lBQzFCLE9BQU8sQ0FBQyxVQUFVLENBQVM7SUFFM0IsWUFDVSxhQUFhLEVBQUUsSUFBSSxDQUFDLGFBQWEsRUFBRSxXQUFXLEdBQUcsY0FBYyxHQUFHLFdBQVcsR0FBRyxnQkFBZ0IsQ0FBQyxFQUNqRyxTQUFTLEVBQUUsOEJBQThCLEVBQ3pDLE9BQU8sRUFBRSx5QkFBeUIsRUFDekIsR0FBRyx5Q0FBcUMsRUFDakQsSUFBSSxHQUFFO1FBQ1osY0FBYyxDQUFDLEVBQUUsTUFBTSxDQUFDO1FBQ3hCLFNBQVMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztRQUNuQixhQUFhLENBQUMsRUFBRSxNQUFNLENBQUM7UUFDdkIsa0hBQWtIO1FBQ2xILGFBQWEsQ0FBQyxFQUFFLE9BQU8sQ0FBQztRQUN4QiwySUFBMkk7UUFDM0ksaUJBQWlCLENBQUMsRUFBRSxPQUFPLENBQUM7UUFDNUIsaUhBQWlIO1FBQ2pILHVCQUF1QixDQUFDLEVBQUUsTUFBTSxDQUFDO0tBQzdCLEVBT1A7SUFFTSxLQUFLLFNBR1g7SUFFWSxJQUFJLGtCQUVoQjtJQUVNLFNBQVMsWUFFZjtJQUVEOzs7O09BSUc7SUFDVSxJQUFJLGtCQUloQjtJQUVELFVBQWdCLElBQUksa0JBZ05uQjtZQU9hLHFCQUFxQjtJQXFCbkMsT0FBTyxDQUFDLHNCQUFzQjtZQU9oQixTQUFTO0NBU3hCIn0=

package/dest/block/l2_block_stream/l2_block_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l2_block_stream.d.ts","sourceRoot":"","sources":["../../../src/block/l2_block_stream/l2_block_stream.ts"],"names":[],"mappings":"AAMA,OAAO,EAAkB,KAAK,aAAa,EAAiB,MAAM,uBAAuB,CAAC;AAC1F,OAAO,KAAK,EAAsB,yBAAyB,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AAErH,sGAAsG;AACtG,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,uHAAuH;AACvH,qBAAa,aAAa;IAMtB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,IAAI;IATd,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAS;IAE3B,YACU,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,WAAW,GAAG,cAAc,GAAG,WAAW,GAAG,gBAAgB,CAAC,EACjG,SAAS,EAAE,8BAA8B,EACzC,OAAO,EAAE,yBAAyB,EACzB,GAAG,yCAAqC,EACjD,IAAI,GAAE;QACZ,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,kHAAkH;QAClH,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,2IAA2I;QAC3I,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,iHAAiH;QACjH,uBAAuB,CAAC,EAAE,MAAM,CAAC;KAC7B,EAOP;IAEM,KAAK,SAGX;IAEY,IAAI,kBAEhB;IAEM,SAAS,YAEf;IAED;;;;OAIG;IACU,IAAI,kBAIhB;IAED,UAAgB,IAAI,kBAgNnB;YAOa,qBAAqB;IAqBnC,OAAO,CAAC,sBAAsB;YAOhB,SAAS;CASxB"}

package/dest/block/l2_block_stream/l2_block_stream.js

@@ -0,0 +1,309 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { AbortError } from '@aztec/foundation/error';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { makeL2BlockId } from '../l2_block_source.js';
+/** Maximum number of checkpoints to prefetch at once during sync. Matches MAX_RPC_CHECKPOINTS_LEN. */ export const CHECKPOINT_PREFETCH_LIMIT = 50;
+/** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */ export class L2BlockStream {
+    l2BlockSource;
+    localData;
+    handler;
+    log;
+    opts;
+    runningPromise;
+    isSyncing;
+    hasStarted;
+    constructor(l2BlockSource, localData, handler, log = createLogger('types:block_stream'), opts = {}){
+        this.l2BlockSource = l2BlockSource;
+        this.localData = localData;
+        this.handler = handler;
+        this.log = log;
+        this.opts = opts;
+        this.isSyncing = false;
+        this.hasStarted = false;
+        // Note that RunningPromise is in stopped state by default. This promise won't run until someone invokes `start`,
+        // which makes it run periodically, or `sync`, which triggers it once.
+        // Users of L2BlockStream decide what mode to run it in (_periodically_ vs _manually triggered_).
+        // The default is _manually triggered_.
+        this.runningPromise = new RunningPromise(()=>this.work(), log, this.opts.pollIntervalMS ?? 1000);
+    }
+    start() {
+        this.log.verbose(`Starting L2 block stream`, this.opts);
+        this.runningPromise.start();
+    }
+    async stop() {
+        await this.runningPromise.stop();
+    }
+    isRunning() {
+        return this.runningPromise.isRunning();
+    }
+    /**
+   * Runs the synchronization process once.
+   *
+   * If you want to run this process continuously use `start` and `stop` instead.
+   */ async sync() {
+        this.isSyncing = true;
+        await this.runningPromise.trigger();
+        this.isSyncing = false;
+    }
+    async work() {
+        try {
+            const sourceTips = await this.l2BlockSource.getL2Tips();
+            const localTips = await this.localData.getL2Tips();
+            this.log.trace(`Running L2 block stream`, {
+                sourceTips,
+                localTips
+            });
+            // Check if there was a reorg and emit a chain-pruned event if so.
+            let latestBlockNumber = localTips.proposed.number;
+            const sourceCache = new BlockHashCache([
+                sourceTips.proposed
+            ]);
+            while(!await this.areBlockHashesEqualAt(latestBlockNumber, {
+                sourceCache
+            })){
+                if (latestBlockNumber === 0) {
+                    // We walked all the way back to genesis and the hashes still differ. This means the
+                    // local store and the source disagree on the genesis block itself — typically because
+                    // they were configured with different `genesisTimestamp`/prefilled state. Continuing
+                    // would underflow into negative block numbers and surface as "block hash not found
+                    // for -1" further down. Fail loudly with a meaningful error instead.
+                    this.log.error(`Genesis block hash mismatch between local store and source`, {
+                        localBlockHash: await this.localData.getL2BlockHash(BlockNumber.ZERO),
+                        sourceBlockHash: sourceCache.get(0) ?? await this.getBlockHashFromSource(BlockNumber.ZERO)
+                    });
+                    throw new Error('Genesis block hash mismatch between local store and source: refusing to walk past block 0. ' + 'This usually indicates the two sides were configured with different genesis values ' + '(e.g. genesisTimestamp or prefilled public data).');
+                }
+                latestBlockNumber--;
+            }
+            if (latestBlockNumber < localTips.proposed.number) {
+                latestBlockNumber = BlockNumber(Math.min(latestBlockNumber, sourceTips.proposed.number)); // see #13471
+                const hash = sourceCache.get(latestBlockNumber) ?? await this.getBlockHashFromSource(latestBlockNumber);
+                if (latestBlockNumber !== 0 && !hash) {
+                    throw new Error(`Block hash not found in block source for block number ${latestBlockNumber}`);
+                }
+                this.log.verbose(`Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.proposed.number}.`);
+                await this.emitEvent({
+                    type: 'chain-pruned',
+                    block: makeL2BlockId(latestBlockNumber, hash),
+                    checkpoint: sourceTips.checkpointed.checkpoint
+                });
+            }
+            // If we are just starting, use the starting block number from the options.
+            const startingBlock = this.opts.startingBlock !== undefined ? BlockNumber(this.opts.startingBlock) : undefined;
+            if (latestBlockNumber === 0 && startingBlock !== undefined) {
+                latestBlockNumber = BlockNumber(Math.max(startingBlock - 1, 0));
+            }
+            // Only log this entry once (for sanity)
+            if (!this.hasStarted) {
+                this.log.verbose(`Starting sync from block number ${latestBlockNumber}`);
+                this.hasStarted = true;
+            }
+            let nextBlockNumber = latestBlockNumber + 1;
+            let nextCheckpointToEmit = CheckpointNumber(localTips.checkpointed.checkpoint.number + 1);
+            // When startingBlock is set, also skip ahead for checkpoints.
+            if (startingBlock !== undefined && startingBlock >= 1 && nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number) {
+                if (startingBlock > sourceTips.checkpointed.block.number) {
+                    // startingBlock is past all checkpointed blocks; skip Loop 1 entirely.
+                    nextCheckpointToEmit = CheckpointNumber(sourceTips.checkpointed.checkpoint.number + 1);
+                } else {
+                    const startingBlockData = await this.l2BlockSource.getBlockData({
+                        number: startingBlock
+                    });
+                    if (startingBlockData) {
+                        nextCheckpointToEmit = CheckpointNumber(Math.max(nextCheckpointToEmit, startingBlockData.checkpointNumber));
+                    }
+                }
+            }
+            if (this.opts.skipFinalized) {
+                // When skipping finalized blocks we need to provide reliable reorg detection while fetching as few blocks as
+                // possible. Finalized blocks cannot be reorged by definition, so we can skip most of them. We do need the very
+                // last finalized block however in order to guarantee that we will eventually find a block in which our local
+                // store matches the source.
+                // If the last finalized block is behind our local tip, there is nothing to skip.
+                nextBlockNumber = Math.max(sourceTips.finalized.block.number, nextBlockNumber);
+                // If the next checkpoint to emit is behind the finalized tip then skip forward
+                nextCheckpointToEmit = CheckpointNumber(Math.max(nextCheckpointToEmit, sourceTips.finalized.checkpoint.number));
+            }
+            // Loop 1: Emit checkpoint events for checkpoints whose blocks are already in local storage.
+            // This handles the case where blocks were synced as uncheckpointed and later became checkpointed.
+            // The guard `lastBlockInCheckpoint.number > localTips.proposed.number` ensures we don't emit
+            // checkpoints for blocks we don't have (e.g., when startingBlock skips earlier blocks).
+            // Since only one checkpoint can ever be uncheckpointed, this loop should iterate at most once.
+            if (!this.opts.ignoreCheckpoints) {
+                let loop1Iterations = 0;
+                while(nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number){
+                    const checkpoints = await this.l2BlockSource.getCheckpoints({
+                        from: nextCheckpointToEmit,
+                        limit: 1
+                    });
+                    if (checkpoints.length === 0) {
+                        break;
+                    }
+                    const lastBlockInCheckpoint = checkpoints[0].checkpoint.blocks.at(-1);
+                    // If this checkpoint has blocks we haven't seen yet, stop - they need to be fetched first
+                    if (lastBlockInCheckpoint.number > localTips.proposed.number) {
+                        break;
+                    }
+                    loop1Iterations++;
+                    if (loop1Iterations > 1) {
+                        this.log.warn(`Emitting multiple checkpoints (${loop1Iterations}) for already-local blocks. ` + `Next checkpoint: ${nextCheckpointToEmit}, source checkpointed: ${sourceTips.checkpointed.checkpoint.number}`);
+                    }
+                    const lastBlockHash = await lastBlockInCheckpoint.hash();
+                    await this.emitEvent({
+                        type: 'chain-checkpointed',
+                        checkpoint: checkpoints[0],
+                        block: makeL2BlockId(lastBlockInCheckpoint.number, lastBlockHash.toString())
+                    });
+                    nextCheckpointToEmit = CheckpointNumber(nextCheckpointToEmit + 1);
+                }
+            }
+            // Loop 2: Fetch new checkpointed blocks. For each checkpoint, emit all blocks
+            // from that checkpoint that we need, then emit the checkpoint event.
+            // We prefetch multiple checkpoints, then process them one by one.
+            let prefetchedCheckpoints = [];
+            let prefetchIdx = 0;
+            let nextCheckpointNumber;
+            // Find the starting checkpoint number
+            if (nextBlockNumber <= sourceTips.checkpointed.block.number) {
+                const blockData = await this.l2BlockSource.getBlockData({
+                    number: BlockNumber(nextBlockNumber)
+                });
+                if (blockData) {
+                    nextCheckpointNumber = blockData.checkpointNumber;
+                }
+            }
+            while(nextBlockNumber <= sourceTips.checkpointed.block.number && nextCheckpointNumber !== undefined){
+                // Refill the prefetch buffer when exhausted
+                if (prefetchIdx >= prefetchedCheckpoints.length) {
+                    const prefetchLimit = this.opts.checkpointPrefetchLimit ?? CHECKPOINT_PREFETCH_LIMIT;
+                    prefetchedCheckpoints = await this.l2BlockSource.getCheckpoints({
+                        from: nextCheckpointNumber,
+                        limit: prefetchLimit
+                    });
+                    prefetchIdx = 0;
+                    if (prefetchedCheckpoints.length === 0) {
+                        break;
+                    }
+                }
+                const checkpoint = prefetchedCheckpoints[prefetchIdx];
+                // Get all blocks from this checkpoint that we need, respecting batchSize
+                const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.checkpointed.block.number - nextBlockNumber + 1);
+                const blocksForCheckpoint = checkpoint.checkpoint.blocks.filter((b)=>b.number >= nextBlockNumber).slice(0, limit);
+                if (blocksForCheckpoint.length === 0) {
+                    break;
+                }
+                await this.emitEvent({
+                    type: 'blocks-added',
+                    blocks: blocksForCheckpoint
+                });
+                nextBlockNumber = blocksForCheckpoint.at(-1).number + 1;
+                // If we've reached the end of this checkpoint, emit the checkpoint event and move to next
+                const lastBlockInCheckpoint = checkpoint.checkpoint.blocks.at(-1);
+                if (nextBlockNumber > lastBlockInCheckpoint.number) {
+                    if (!this.opts.ignoreCheckpoints) {
+                        const lastBlockHash = await lastBlockInCheckpoint.hash();
+                        await this.emitEvent({
+                            type: 'chain-checkpointed',
+                            checkpoint,
+                            block: makeL2BlockId(lastBlockInCheckpoint.number, lastBlockHash.toString())
+                        });
+                    }
+                    prefetchIdx++;
+                    nextCheckpointNumber = CheckpointNumber(nextCheckpointNumber + 1);
+                }
+            }
+            // Loop 3: Fetch any remaining uncheckpointed (proposed) blocks.
+            while(nextBlockNumber <= sourceTips.proposed.number){
+                const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.proposed.number - nextBlockNumber + 1);
+                this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit}`);
+                const blocks = await this.l2BlockSource.getBlocks({
+                    from: BlockNumber(nextBlockNumber),
+                    limit
+                });
+                if (blocks.length === 0) {
+                    break;
+                }
+                await this.emitEvent({
+                    type: 'blocks-added',
+                    blocks
+                });
+                nextBlockNumber = blocks.at(-1).number + 1;
+            }
+            // Update the proven and finalized tips.
+            if (localTips.proven !== undefined && sourceTips.proven.block.number !== localTips.proven.block.number) {
+                await this.emitEvent({
+                    type: 'chain-proven',
+                    block: sourceTips.proven.block
+                });
+            }
+            if (localTips.finalized !== undefined && sourceTips.finalized.block.number !== localTips.finalized.block.number) {
+                await this.emitEvent({
+                    type: 'chain-finalized',
+                    block: sourceTips.finalized.block
+                });
+            }
+        } catch (err) {
+            if (err.name === 'AbortError') {
+                return;
+            }
+            this.log.error(`Error processing block stream`, err);
+        }
+    }
+    /**
+   * Returns whether the source and local agree on the block hash at a given height.
+   * @param blockNumber - The block number to test.
+   * @param args - A cache of data already requested from source, to avoid re-requesting it.
+   */ async areBlockHashesEqualAt(blockNumber, args) {
+        const localBlockHash = await this.localData.getL2BlockHash(blockNumber);
+        if (!localBlockHash && this.opts.skipFinalized) {
+            // Failing to find a block hash when skipping finalized blocks can be highly problematic as we'd potentially need
+            // to go all the way back to the genesis block to find a block in which we agree with the source (since we've
+            // potentially skipped all history). This means that stores that prune old blocks must be careful to leave no gaps
+            // when going back from latest block to the last finalized one.
+            this.log.error(`No local block hash for block number ${blockNumber}`);
+            throw new AbortError();
+        }
+        const sourceBlockHashFromCache = args.sourceCache.get(blockNumber);
+        const sourceBlockHash = args.sourceCache.get(blockNumber) ?? await this.getBlockHashFromSource(blockNumber);
+        if (!sourceBlockHashFromCache && sourceBlockHash) {
+            args.sourceCache.add({
+                number: blockNumber,
+                hash: sourceBlockHash
+            });
+        }
+        this.log.trace(`Comparing block hashes for block ${blockNumber}`, {
+            localBlockHash,
+            sourceBlockHash
+        });
+        return localBlockHash === sourceBlockHash;
+    }
+    getBlockHashFromSource(blockNumber) {
+        return this.l2BlockSource.getBlockData({
+            number: blockNumber
+        }).then((d)=>d?.header.hash()).then((hash)=>hash?.toString());
+    }
+    async emitEvent(event) {
+        this.log.debug(`Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.type === 'chain-checkpointed' ? event.checkpoint.checkpoint.number : event.block.number})`);
+        await this.handler.handleBlockStreamEvent(event);
+        if (!this.isRunning() && !this.isSyncing) {
+            throw new AbortError();
+        }
+    }
+}
+class BlockHashCache {
+    cache = new Map();
+    constructor(initial = []){
+        for (const block of initial){
+            this.add(block);
+        }
+    }
+    add(block) {
+        if (block.hash) {
+            this.cache.set(block.number, block.hash);
+        }
+    }
+    get(blockNumber) {
+        return this.cache.get(blockNumber);
+    }
+}

package/dest/block/l2_block_stream/l2_tips_memory_store.d.ts

@@ -0,0 +1,29 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import type { BlockHash } from '../block_hash.js';
+import type { L2BlockTag } from '../l2_block_source.js';
+import { L2TipsStoreBase } from './l2_tips_store_base.js';
+/**
+ * In-memory implementation of L2 tips store. Useful for testing and lightweight clients.
+ * @dev Tests in kv-store/src/stores/l2_tips_memory_store.test.ts
+ */
+export declare class L2TipsMemoryStore extends L2TipsStoreBase {
+    constructor(initialBlockHash: BlockHash);
+    private readonly tips;
+    private readonly blockHashes;
+    private readonly blockToCheckpoint;
+    private readonly checkpoints;
+    protected getTip(tag: L2BlockTag): Promise<BlockNumber | undefined>;
+    protected setTip(tag: L2BlockTag, blockNumber: BlockNumber): Promise<void>;
+    protected getStoredBlockHash(blockNumber: BlockNumber): Promise<string | undefined>;
+    protected setBlockHash(blockNumber: BlockNumber, hash: string): Promise<void>;
+    protected deleteBlockHashesBefore(blockNumber: BlockNumber): Promise<void>;
+    protected getCheckpointNumberForBlock(blockNumber: BlockNumber): Promise<CheckpointNumber | undefined>;
+    protected setCheckpointNumberForBlock(blockNumber: BlockNumber, checkpointNumber: CheckpointNumber): Promise<void>;
+    protected deleteBlockToCheckpointBefore(blockNumber: BlockNumber): Promise<void>;
+    protected getCheckpoint(checkpointNumber: CheckpointNumber): Promise<PublishedCheckpoint | undefined>;
+    protected saveCheckpointData(checkpoint: PublishedCheckpoint): Promise<void>;
+    protected deleteCheckpointsBefore(checkpointNumber: CheckpointNumber): Promise<void>;
+    protected runInTransaction<T>(fn: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/block/l2_block_stream/l2_tips_memory_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l2_tips_memory_store.d.ts","sourceRoot":"","sources":["../../../src/block/l2_block_stream/l2_tips_memory_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AACpF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,eAAe;IACpD,YAAY,gBAAgB,EAAE,SAAS,EAEtC;IAED,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsC;IAC3D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IACzD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuC;IACzE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA0C;IAEtE,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAElE;IAED,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAGzE;IAED,SAAS,CAAC,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAElF;IAED,SAAS,CAAC,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG5E;IAED,SAAS,CAAC,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAOzE;IAED,SAAS,CAAC,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAErG;IAED,SAAS,CAAC,2BAA2B,CAAC,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjH;IAED,SAAS,CAAC,6BAA6B,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/E;IAED,SAAS,CAAC,aAAa,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAEpG;IAED,SAAS,CAAC,kBAAkB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG3E;IAED,SAAS,CAAC,uBAAuB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOnF;IAED,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAG9D;CACF"}

package/dest/block/l2_block_stream/l2_tips_memory_store.js

@@ -0,0 +1,69 @@
+import { L2TipsStoreBase } from './l2_tips_store_base.js';
+/**
+ * In-memory implementation of L2 tips store. Useful for testing and lightweight clients.
+ * @dev Tests in kv-store/src/stores/l2_tips_memory_store.test.ts
+ */ export class L2TipsMemoryStore extends L2TipsStoreBase {
+    constructor(initialBlockHash){
+        super(initialBlockHash);
+    }
+    tips = new Map();
+    blockHashes = new Map();
+    blockToCheckpoint = new Map();
+    checkpoints = new Map();
+    getTip(tag) {
+        return Promise.resolve(this.tips.get(tag));
+    }
+    setTip(tag, blockNumber) {
+        this.tips.set(tag, blockNumber);
+        return Promise.resolve();
+    }
+    getStoredBlockHash(blockNumber) {
+        return Promise.resolve(this.blockHashes.get(blockNumber));
+    }
+    setBlockHash(blockNumber, hash) {
+        this.blockHashes.set(blockNumber, hash);
+        return Promise.resolve();
+    }
+    deleteBlockHashesBefore(blockNumber) {
+        for (const key of this.blockHashes.keys()){
+            if (key < blockNumber) {
+                this.blockHashes.delete(key);
+            }
+        }
+        return Promise.resolve();
+    }
+    getCheckpointNumberForBlock(blockNumber) {
+        return Promise.resolve(this.blockToCheckpoint.get(blockNumber));
+    }
+    setCheckpointNumberForBlock(blockNumber, checkpointNumber) {
+        this.blockToCheckpoint.set(blockNumber, checkpointNumber);
+        return Promise.resolve();
+    }
+    deleteBlockToCheckpointBefore(blockNumber) {
+        for (const key of this.blockToCheckpoint.keys()){
+            if (key < blockNumber) {
+                this.blockToCheckpoint.delete(key);
+            }
+        }
+        return Promise.resolve();
+    }
+    getCheckpoint(checkpointNumber) {
+        return Promise.resolve(this.checkpoints.get(checkpointNumber));
+    }
+    saveCheckpointData(checkpoint) {
+        this.checkpoints.set(checkpoint.checkpoint.number, checkpoint);
+        return Promise.resolve();
+    }
+    deleteCheckpointsBefore(checkpointNumber) {
+        for (const key of this.checkpoints.keys()){
+            if (key < checkpointNumber) {
+                this.checkpoints.delete(key);
+            }
+        }
+        return Promise.resolve();
+    }
+    runInTransaction(fn) {
+        // Memory store doesn't need transactions - just execute immediately
+        return fn();
+    }
+}