@aztec/stdlib 5.0.0-private.20260319 → 5.0.0-rc.1

package/dest/block/test/l2_tips_store_test_suite.js

@@ -1,10 +1,10 @@
-import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { GENESIS_CHECKPOINT_HEADER_HASH, L2Block } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import { jestExpect as expect } from '@jest/expect';
+import { expect } from 'vitest';
+import { GENESIS_BLOCK_HEADER_HASH } from '../block_hash.js';
 export function testL2TipsStore(makeTipsStore) {
     let tipsStore;
     // Track blocks and their hashes for test assertions
@@ -138,7 +138,8 @@ export function testL2TipsStore(makeTipsStore) {
         // Prove up to block 5
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-proven',
-            block: makeBlockId(5)
+            block: makeBlockId(5),
+            checkpoint: makeCheckpointIdForBlock(5)
         });
         const tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(5));
@@ -160,11 +161,13 @@ export function testL2TipsStore(makeTipsStore) {
         // Prove and finalize
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-proven',
-            block: makeBlockId(5)
+            block: makeBlockId(5),
+            checkpoint: makeCheckpointIdForBlock(5)
         });
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-finalized',
-            block: makeBlockId(5)
+            block: makeBlockId(5),
+            checkpoint: makeCheckpointIdForBlock(5)
         });
         const tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(5));
@@ -222,11 +225,13 @@ export function testL2TipsStore(makeTipsStore) {
         // Prove and finalize up to block 3 (checkpoint 1)
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-proven',
-            block: makeBlockId(3)
+            block: makeBlockId(3),
+            checkpoint: makeCheckpointIdForBlock(3)
         });
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-finalized',
-            block: makeBlockId(3)
+            block: makeBlockId(3),
+            checkpoint: makeCheckpointIdForBlock(3)
         });
         // Blocks before finalized should be cleared
         expect(await tipsStore.getL2BlockHash(1)).toBeUndefined();
@@ -246,10 +251,8 @@ export function testL2TipsStore(makeTipsStore) {
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-pruned',
             block: makeBlockId(5),
-            checkpoint: {
-                number: CheckpointNumber.ZERO,
-                hash: GENESIS_CHECKPOINT_HEADER_HASH.toString()
-            }
+            checkpointed: makeTipId(0),
+            proven: makeTipId(0)
         });
         const tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(5));
@@ -271,10 +274,8 @@ export function testL2TipsStore(makeTipsStore) {
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-pruned',
             block: makeTip(0),
-            checkpoint: {
-                number: CheckpointNumber.ZERO,
-                hash: GENESIS_CHECKPOINT_HEADER_HASH.toString()
-            }
+            checkpointed: makeTipId(0),
+            proven: makeTipId(0)
         });
         tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(0));
@@ -335,10 +336,8 @@ export function testL2TipsStore(makeTipsStore) {
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-pruned',
             block: makeBlockId(5),
-            checkpoint: {
-                number: CheckpointNumber.ZERO,
-                hash: GENESIS_CHECKPOINT_HEADER_HASH.toString()
-            }
+            checkpointed: makeTipId(5),
+            proven: makeTipId(0)
         });
         tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(5));
@@ -398,10 +397,8 @@ export function testL2TipsStore(makeTipsStore) {
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-pruned',
             block: makeBlockId(3),
-            checkpoint: {
-                number: CheckpointNumber.ZERO,
-                hash: GENESIS_CHECKPOINT_HEADER_HASH.toString()
-            }
+            checkpointed: makeTipId(3),
+            proven: makeTipId(0)
         });
         tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(3));
@@ -438,7 +435,8 @@ export function testL2TipsStore(makeTipsStore) {
         // Prove up to block 3
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-proven',
-            block: makeBlockId(3)
+            block: makeBlockId(3),
+            checkpoint: makeCheckpointIdForBlock(3)
         });
         let tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(3));
@@ -478,10 +476,8 @@ export function testL2TipsStore(makeTipsStore) {
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-pruned',
             block: makeBlockId(3),
-            checkpoint: {
-                number: CheckpointNumber.ZERO,
-                hash: GENESIS_CHECKPOINT_HEADER_HASH.toString()
-            }
+            checkpointed: makeTipId(3),
+            proven: makeTipId(3)
         });
         tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(3));
@@ -524,22 +520,195 @@ export function testL2TipsStore(makeTipsStore) {
         expect(await tipsStore.getL2BlockHash(6)).not.toEqual(originalHash6);
         expect(await tipsStore.getL2BlockHash(7)).not.toEqual(originalHash7);
     });
-    // Regression test for #13142
-    it('does not blow up when setting proven chain on an unseen block number', async ()=>{
+    // Regression test for #13142: proving an unseen block number (one with no local block->checkpoint
+    // mapping) must not blow up. With per-cursor checkpoint ids, the proven tip resolves to the
+    // checkpoint id carried by the event rather than falling back to checkpoint zero.
+    it('resolves the proven checkpoint from the carried id when setting proven on an unseen block number', async ()=>{
         await tipsStore.handleBlockStreamEvent({
             type: 'blocks-added',
             blocks: [
                 await makeBlock(5)
             ]
         });
+        // Block 3 has no local block->checkpoint mapping, but the event carries a real checkpoint id.
+        const carriedCheckpoint = {
+            number: CheckpointNumber(1),
+            hash: new Fr(42).toString()
+        };
         await tipsStore.handleBlockStreamEvent({
             type: 'chain-proven',
-            block: makeBlockId(3)
+            block: makeBlockId(3),
+            checkpoint: carriedCheckpoint
         });
         const tips = await tipsStore.getL2Tips();
         expect(tips.proposed).toEqual(makeTip(5));
         expect(tips.proven.block).toEqual(makeTip(3));
-        // No checkpoint for block 3 since it wasn't checkpointed
-        expect(tips.proven.checkpoint.number).toEqual(CheckpointNumber.ZERO);
+        // Resolved from the carried id, not the (missing) local mapping.
+        expect(tips.proven.checkpoint).toEqual(carriedCheckpoint);
+    });
+    // proven/finalized resolve to the carried checkpoint id even when the block has no local
+    // block->checkpoint mapping (the cursor legitimately leads the locally-checkpointed frontier).
+    it('resolves proven and finalized checkpoints from carried ids without a local mapping', async ()=>{
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: [
+                await makeBlock(7)
+            ]
+        });
+        const provenCheckpoint = {
+            number: CheckpointNumber(2),
+            hash: new Fr(101).toString()
+        };
+        const finalizedCheckpoint = {
+            number: CheckpointNumber(1),
+            hash: new Fr(100).toString()
+        };
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-proven',
+            block: makeBlockId(5),
+            checkpoint: provenCheckpoint
+        });
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-finalized',
+            block: makeBlockId(3),
+            checkpoint: finalizedCheckpoint
+        });
+        const tips = await tipsStore.getL2Tips();
+        expect(tips.proven.checkpoint).toEqual(provenCheckpoint);
+        expect(tips.finalized.checkpoint).toEqual(finalizedCheckpoint);
+    });
+    // Genuine corruption: a cursor points at a real (non-genesis) block that has a block hash but
+    // neither a stored per-cursor checkpoint id nor a block->checkpoint mapping. getL2Tips must throw
+    // loudly rather than silently report checkpoint zero. We reach this state by reaching past the
+    // event API to place the tip directly, since the normal writers always record an id.
+    it('throws when a cursor points at a real block with neither a stored id nor a mapping', async ()=>{
+        // blocks-added records the block hash for block 5 (so getBlockId succeeds) but no checkpoint id.
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: [
+                await makeBlock(5)
+            ]
+        });
+        // Corrupt the proven cursor to point at block 5 without any id or mapping.
+        const internal = tipsStore;
+        await internal.setTip('proven', BlockNumber(5));
+        await expect(tipsStore.getL2Tips()).rejects.toThrow(/checkpoint/i);
+    });
+    // Backward prune of a leading cursor: a checkpoint-bearing cursor that legitimately leads the source's
+    // confirmed checkpointed tip is clamped down to that tip, resolving to the id the prune event carries
+    // (never genesis, never a throw). This is the skipped-history shape where the cursor sits on a block
+    // ahead of the checkpointed frontier.
+    it('clamps a leading checkpoint cursor down to the source checkpointed tip carried by the prune event', async ()=>{
+        // Checkpoint blocks 1-5 (checkpointed = block 5 / ckpt 1), then add uncheckpointed blocks 6-10.
+        const blocks1to5 = await Promise.all(times(5, (i)=>makeBlock(i + 1)));
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: blocks1to5
+        });
+        const checkpoint1 = await makeCheckpoint(1, blocks1to5);
+        await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+        const blocks6to10 = await Promise.all(times(5, (i)=>makeBlock(i + 6)));
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: blocks6to10
+        });
+        // Advance the proven cursor onto an uncheckpointed block (8) via a carried id, so it LEADS the
+        // source checkpointed tip (block 5) and will be clamped down to it on prune.
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-proven',
+            block: makeBlockId(8),
+            checkpoint: {
+                number: CheckpointNumber(2),
+                hash: new Fr(202).toString()
+            }
+        });
+        // Prune to block 7, carrying the source's confirmed checkpointed and proven tips (both block 5 / ckpt 1
+        // here, the source's proven tip having rolled back together with its checkpointed tip).
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-pruned',
+            block: makeBlockId(7),
+            checkpointed: makeTipId(5),
+            proven: makeTipId(5)
+        });
+        // Must not throw; the proven cursor is clamped to the carried proven tip, resolving to ckpt 1.
+        const tips = await tipsStore.getL2Tips();
+        expect(tips.proposed).toEqual(makeTip(7));
+        expect(tips.proven.block).toEqual(makeTip(5));
+        expect(tips.proven.checkpoint.number).toEqual(CheckpointNumber(1));
+    });
+    it('keeps the checkpointed tip when pruning to an uncheckpointed block ahead of it', async ()=>{
+        const blocks1to5 = await Promise.all(times(5, (i)=>makeBlock(i + 1)));
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: blocks1to5
+        });
+        const checkpoint1 = await makeCheckpoint(1, blocks1to5);
+        await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1)); // checkpointed = block 5 / ckpt 1
+        const blocks6to7 = await Promise.all(times(2, (i)=>makeBlock(i + 6)));
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: blocks6to7
+        }); // proposed = 7
+        // Prune to block 6: an uncheckpointed block AHEAD of the checkpointed tip (block 5). The source
+        // checkpointed tip is still block 5 / ckpt 1, so the checkpointed cursor must not move.
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-pruned',
+            block: makeBlockId(6),
+            checkpointed: makeTipId(5),
+            proven: makeTipId(0)
+        });
+        const tips = await tipsStore.getL2Tips();
+        expect(tips.proposed).toEqual(makeTip(6));
+        expect(tips.checkpointed.block).toEqual(makeTip(5));
+        expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(1)); // must NOT be zero
+    });
+    // Per-cursor clamping on prune: when the source rolls back its proven tip below its checkpointed tip
+    // (e.g. a proof tx dropped by an L1 reorg), the prune event carries both source tips and each local
+    // cursor must clamp to its OWN source tip. Clamping the proven cursor onto the (higher) checkpointed
+    // tip would transiently report unproven blocks as proven until the corrective chain-proven event lands.
+    it('clamps the proven cursor to the source proven tip, separately from the checkpointed cursor, on prune', async ()=>{
+        // Checkpoint blocks 1-15 across three checkpoints (ckpt 1 = 1-5, ckpt 2 = 6-10, ckpt 3 = 11-15).
+        const blocks1to5 = await Promise.all(times(5, (i)=>makeBlock(i + 1)));
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: blocks1to5
+        });
+        await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(await makeCheckpoint(1, blocks1to5)));
+        const blocks6to10 = await Promise.all(times(5, (i)=>makeBlock(i + 6)));
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: blocks6to10
+        });
+        await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(await makeCheckpoint(2, blocks6to10)));
+        const blocks11to15 = await Promise.all(times(5, (i)=>makeBlock(i + 11)));
+        await tipsStore.handleBlockStreamEvent({
+            type: 'blocks-added',
+            blocks: blocks11to15
+        });
+        await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(await makeCheckpoint(3, blocks11to15)));
+        // Prove the whole chain up to block 15 (ckpt 3), so the local proven cursor leads both source tips below.
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-proven',
+            block: makeBlockId(15),
+            checkpoint: makeCheckpointIdForBlock(15)
+        });
+        let tips = await tipsStore.getL2Tips();
+        expect(tips.checkpointed.block).toEqual(makeTip(15));
+        expect(tips.proven.block).toEqual(makeTip(15));
+        // Prune arrives with the source's proven tip (block 5 / ckpt 1) BELOW its checkpointed tip (block 10 /
+        // ckpt 2) and below the local proven cursor (block 15). Each cursor must clamp to its own source tip.
+        await tipsStore.handleBlockStreamEvent({
+            type: 'chain-pruned',
+            block: makeBlockId(10),
+            checkpointed: makeTipId(10),
+            proven: makeTipId(5)
+        });
+        tips = await tipsStore.getL2Tips();
+        // The proven cursor lands exactly on the source proven tip, NOT on the (higher) checkpointed tip.
+        expect(tips.proven.block).toEqual(makeTip(5));
+        expect(tips.proven.checkpoint.number).toEqual(CheckpointNumber(1));
+        // The checkpointed cursor lands on the source checkpointed tip.
+        expect(tips.checkpointed.block).toEqual(makeTip(10));
+        expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(2));
     });
 }

package/dest/checkpoint/checkpoint.d.ts

@@ -31,115 +31,43 @@ export declare class Checkpoint {
     /** Fee asset price modifier in basis points (from oracle). Defaults to 0 (no change). */
     feeAssetPriceModifier?: bigint);
     get slot(): SlotNumber;
-    static get schema(): z.ZodEffects<z.ZodObject<{
-        archive: z.ZodEffects<z.ZodObject<{
-            root: z.ZodType<Fr, any, string>;
-            nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        archive: z.ZodPipe<z.ZodObject<{
+            root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+            nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
             root: Fr;
             nextAvailableLeafIndex: number;
-        }, {
-            root: string;
-            nextAvailableLeafIndex: string | number | bigint;
-        }>, AppendOnlyTreeSnapshot, {
-            root: string;
-            nextAvailableLeafIndex: string | number | bigint;
-        }>;
+        }>>;
         header: import("../schemas/schemas.js").ZodFor<CheckpointHeader>;
-        blocks: z.ZodArray<z.ZodEffects<z.ZodObject<{
-            archive: z.ZodEffects<z.ZodObject<{
-                root: z.ZodType<Fr, any, string>;
-                nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
-            }, "strip", z.ZodTypeAny, {
+        blocks: z.ZodArray<z.ZodPipe<z.ZodObject<{
+            archive: z.ZodPipe<z.ZodObject<{
+                root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+                nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+            }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
                 root: Fr;
                 nextAvailableLeafIndex: number;
-            }, {
-                root: string;
-                nextAvailableLeafIndex: string | number | bigint;
-            }>, AppendOnlyTreeSnapshot, {
-                root: string;
-                nextAvailableLeafIndex: string | number | bigint;
-            }>;
+            }>>;
             header: import("../schemas/schemas.js").ZodFor<import("../tx/block_header.js").BlockHeader>;
             body: import("../schemas/schemas.js").ZodFor<import("../block/body.js").Body>;
-            checkpointNumber: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodNumber>, CheckpointNumber, string | number | bigint>;
-            indexWithinCheckpoint: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodNumber>, IndexWithinCheckpoint, string | number | bigint>;
-        }, "strip", z.ZodTypeAny, {
+            checkpointNumber: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<CheckpointNumber, number>>;
+            indexWithinCheckpoint: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<IndexWithinCheckpoint, number>>;
+        }, z.core.$strip>, z.ZodTransform<L2Block, {
             archive: AppendOnlyTreeSnapshot;
             header: import("../tx/block_header.js").BlockHeader;
             body: import("../block/body.js").Body;
-            checkpointNumber: number & {
-                _branding: "CheckpointNumber";
-            };
-            indexWithinCheckpoint: number & {
-                _branding: "IndexWithinCheckpoint";
-            };
-        }, {
-            archive: {
-                root: string;
-                nextAvailableLeafIndex: string | number | bigint;
-            };
-            header?: any;
-            body?: any;
-            checkpointNumber: string | number | bigint;
-            indexWithinCheckpoint: string | number | bigint;
-        }>, L2Block, {
-            archive: {
-                root: string;
-                nextAvailableLeafIndex: string | number | bigint;
-            };
-            header?: any;
-            body?: any;
-            checkpointNumber: string | number | bigint;
-            indexWithinCheckpoint: string | number | bigint;
-        }>, "many">;
-        number: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodNumber>, CheckpointNumber, string | number | bigint>;
-        feeAssetPriceModifier: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    }, "strip", z.ZodTypeAny, {
+            checkpointNumber: CheckpointNumber;
+            indexWithinCheckpoint: IndexWithinCheckpoint;
+        }>>>;
+        number: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<CheckpointNumber, number>>;
+        feeAssetPriceModifier: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+    }, z.core.$strip>, z.ZodTransform<Checkpoint, {
         archive: AppendOnlyTreeSnapshot;
         header: CheckpointHeader;
         blocks: L2Block[];
-        number: number & {
-            _branding: "CheckpointNumber";
-        };
+        number: CheckpointNumber;
         feeAssetPriceModifier: bigint;
-    }, {
-        archive: {
-            root: string;
-            nextAvailableLeafIndex: string | number | bigint;
-        };
-        header?: any;
-        blocks: {
-            archive: {
-                root: string;
-                nextAvailableLeafIndex: string | number | bigint;
-            };
-            header?: any;
-            body?: any;
-            checkpointNumber: string | number | bigint;
-            indexWithinCheckpoint: string | number | bigint;
-        }[];
-        number: string | number | bigint;
-        feeAssetPriceModifier: string | number | bigint;
-    }>, Checkpoint, {
-        archive: {
-            root: string;
-            nextAvailableLeafIndex: string | number | bigint;
-        };
-        header?: any;
-        blocks: {
-            archive: {
-                root: string;
-                nextAvailableLeafIndex: string | number | bigint;
-            };
-            header?: any;
-            body?: any;
-            checkpointNumber: string | number | bigint;
-            indexWithinCheckpoint: string | number | bigint;
-        }[];
-        number: string | number | bigint;
-        feeAssetPriceModifier: string | number | bigint;
-    }>;
+    }>>;
     static from(fields: FieldsOfCheckpoint): Checkpoint;
     static getFields(fields: FieldsOfCheckpoint): readonly [AppendOnlyTreeSnapshot, CheckpointHeader, L2Block[], CheckpointNumber, bigint];
     static fromBuffer(buf: Buffer | BufferReader): Checkpoint;
@@ -152,6 +80,12 @@ export declare class Checkpoint {
      * checkpoints up to and including this one in the epoch.
      */
     getCheckpointOutHash(): Fr;
+    /**
+     * Returns the out hash computed from all l2-to-l1 messages in this checkpoint.
+     * Note: This value is different from the out hash in the header, which is the **accumulated** out hash over all
+     * checkpoints up to and including this one in the epoch.
+     */
+    static getCheckpointOutHash(blocks: L2Block[]): Fr;
     getState(): import("../tx/state_reference.js").StateReference;
     toCheckpointInfo(): CheckpointInfo;
     /** Returns stats used for logging */
@@ -175,4 +109,4 @@ export declare class Checkpoint {
     } & Partial<Parameters<typeof CheckpointHeader.random>[0]> & Partial<Parameters<typeof L2Block.random>[1]>): Promise<Checkpoint>;
 }
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/checkpoint/checkpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkpoint.d.ts","sourceRoot":"","sources":["../../src/checkpoint/checkpoint.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,gBAAgB,EAEhB,qBAAqB,EACrB,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAA4C,MAAM,6BAA6B,CAAC;AACrG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAG/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAElE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,KAAK,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC;AAE7D,qBAAa,UAAU;IAEnB,8DAA8D;IACvD,OAAO,EAAE,sBAAsB;IACtC,gCAAgC;IACzB,MAAM,EAAE,gBAAgB;IAC/B,mCAAmC;IAC5B,MAAM,EAAE,OAAO,EAAE;IACxB,gCAAgC;IACzB,MAAM,EAAE,gBAAgB;IAC/B,yFAAyF;IAClF,qBAAqB,EAAE,MAAM;IAVtC;IACE,8DAA8D;IACvD,OAAO,EAAE,sBAAsB;IACtC,gCAAgC;IACzB,MAAM,EAAE,gBAAgB;IAC/B,mCAAmC;IAC5B,MAAM,EAAE,OAAO,EAAE;IACxB,gCAAgC;IACzB,MAAM,EAAE,gBAAgB;IAC/B,yFAAyF;IAClF,qBAAqB,GAAE,MAAW,EACvC;IAEJ,IAAI,IAAI,IAAI,UAAU,CAErB;IAED,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAahB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,kBAAkB,cAErC;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,kBAAkB,4FAE1C;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,cAQ3C;IAEM,QAAQ,4BASd;IAEM,YAAY,IAAI,EAAE,EAAE,CAG1B;IAEM,IAAI,IAAI,EAAE,CAEhB;IAED;;;;OAIG;IACI,oBAAoB,IAAI,EAAE,CAGhC;IAEM,QAAQ,sDAEd;IAEM,gBAAgB,IAAI,cAAc,CAQxC;IAED,qCAAqC;IAC9B,QAAQ;;;;;;;;;;MAkBd;IAED,OAAa,MAAM,CACjB,gBAAgB,mBAAsB,EACtC,EACE,SAAa,EACb,gBAAoB,EACpB,eAAe,EACf,qBAA0B,EAC1B,GAAG,OAAO,EACX,GAAE;QACD,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,eAAe,CAAC,EAAE,sBAAsB,CAAC;QACzC,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,OAAO,CAAC,EAAE,sBAAsB,CAAC;KAClC,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GACxD,OAAO,CAAC,UAAU,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAM,uBA2BrD;CACF"}
+{"version":3,"file":"checkpoint.d.ts","sourceRoot":"","sources":["../../src/checkpoint/checkpoint.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,gBAAgB,EAEhB,qBAAqB,EACrB,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAA4C,MAAM,6BAA6B,CAAC;AACrG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAG/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAElE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,KAAK,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC;AAE7D,qBAAa,UAAU;IAEnB,8DAA8D;IACvD,OAAO,EAAE,sBAAsB;IACtC,gCAAgC;IACzB,MAAM,EAAE,gBAAgB;IAC/B,mCAAmC;IAC5B,MAAM,EAAE,OAAO,EAAE;IACxB,gCAAgC;IACzB,MAAM,EAAE,gBAAgB;IAC/B,yFAAyF;IAClF,qBAAqB,EAAE,MAAM;IAVtC;IACE,8DAA8D;IACvD,OAAO,EAAE,sBAAsB;IACtC,gCAAgC;IACzB,MAAM,EAAE,gBAAgB;IAC/B,mCAAmC;IAC5B,MAAM,EAAE,OAAO,EAAE;IACxB,gCAAgC;IACzB,MAAM,EAAE,gBAAgB;IAC/B,yFAAyF;IAClF,qBAAqB,GAAE,MAAW,EACvC;IAEJ,IAAI,IAAI,IAAI,UAAU,CAErB;IAED,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAahB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,kBAAkB,cAErC;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,kBAAkB,4FAE1C;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,cAQ3C;IAEM,QAAQ,4BASd;IAEM,YAAY,IAAI,EAAE,EAAE,CAG1B;IAEM,IAAI,IAAI,EAAE,CAEhB;IAED;;;;OAIG;IACI,oBAAoB,IAAI,EAAE,CAEhC;IAED;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAGjD;IAEM,QAAQ,sDAEd;IAEM,gBAAgB,IAAI,cAAc,CAQxC;IAED,qCAAqC;IAC9B,QAAQ;;;;;;;;;;MAkBd;IAED,OAAa,MAAM,CACjB,gBAAgB,mBAAsB,EACtC,EACE,SAAa,EACb,gBAAoB,EACpB,eAAe,EACf,qBAA0B,EAC1B,GAAG,OAAO,EACX,GAAE;QACD,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,eAAe,CAAC,EAAE,sBAAsB,CAAC;QACzC,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,OAAO,CAAC,EAAE,sBAAsB,CAAC;KAClC,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GACxD,OAAO,CAAC,UAAU,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAM,uBA4BrD;CACF"}

package/dest/checkpoint/checkpoint.js

@@ -4,7 +4,7 @@ import { pick, sum } from '@aztec/foundation/collection';
 import { BufferReader, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
 import { z } from 'zod';
 import { L2Block } from '../block/l2_block.js';
-import { MAX_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
+import { MAX_CAPACITY_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
 import { computeCheckpointOutHash } from '../messaging/out_hash.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { schemas } from '../schemas/schemas.js';
@@ -50,7 +50,7 @@ export class Checkpoint {
         const reader = BufferReader.asReader(buf);
         const archive = reader.readObject(AppendOnlyTreeSnapshot);
         const header = reader.readObject(CheckpointHeader);
-        const blocks = reader.readVector(L2Block, MAX_BLOCKS_PER_CHECKPOINT);
+        const blocks = reader.readVector(L2Block, MAX_CAPACITY_BLOCKS_PER_CHECKPOINT);
         const number = CheckpointNumber(reader.readNumber());
         const feeAssetPriceModifier = reader.readInt256();
         return new Checkpoint(archive, header, blocks, number, feeAssetPriceModifier);
@@ -70,7 +70,14 @@ export class Checkpoint {
    * Note: This value is different from the out hash in the header, which is the **accumulated** out hash over all
    * checkpoints up to and including this one in the epoch.
    */ getCheckpointOutHash() {
-        const msgs = this.blocks.map((block)=>block.body.txEffects.map((txEffect)=>txEffect.l2ToL1Msgs));
+        return Checkpoint.getCheckpointOutHash(this.blocks);
+    }
+    /**
+   * Returns the out hash computed from all l2-to-l1 messages in this checkpoint.
+   * Note: This value is different from the out hash in the header, which is the **accumulated** out hash over all
+   * checkpoints up to and including this one in the epoch.
+   */ static getCheckpointOutHash(blocks) {
+        const msgs = blocks.map((block)=>block.body.txEffects.map((txEffect)=>txEffect.l2ToL1Msgs));
         return computeCheckpointOutHash(msgs);
     }
     getState() {
@@ -114,6 +121,7 @@ export class Checkpoint {
         let lastArchive = previousArchive;
         for(let i = 0; i < numBlocks; i++){
             const block = await L2Block.random(BlockNumber(startBlockNumber + i), {
+                checkpointNumber,
                 indexWithinCheckpoint: IndexWithinCheckpoint(i),
                 ...options,
                 ...lastArchive ? {