@aztec/stdlib 4.0.0-nightly.20260122 → 4.0.0-nightly.20260124

package/dest/tests/mocks.js

@@ -12,7 +12,7 @@ import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { CheckpointedL2Block, CommitteeAttestation, L2BlockNew } from '../block/index.js';
+import { CheckpointedL2Block, CommitteeAttestation, L2Block } from '../block/index.js';
 import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
@@ -212,19 +212,24 @@ export function mockL1ToL2Messages(numL1ToL2Messages) {
         length: numL1ToL2Messages
     }, ()=>Fr.random());
 }
-export async function mockCheckpointAndMessages(checkpointNumber, { startBlockNumber = BlockNumber(1), numBlocks = 1, blocks, numTxsPerBlock = 1, numL1ToL2Messages = 1, makeBlockOptions = ()=>({}), previousArchive, ...options } = {}) {
-    const slotNumber = options.slotNumber ?? SlotNumber(checkpointNumber * 10);
+export async function mockCheckpointAndMessages(checkpointNumber, { startBlockNumber = BlockNumber(1), numBlocks = 1, blocks, numTxsPerBlock = 1, numL1ToL2Messages = 1, makeBlockOptions = ()=>({}), previousArchive, maxEffects, ...options } = {}) {
+    const slotNumber = options.slotNumber ?? SlotNumber(Number(checkpointNumber) * 10);
     const blocksAndMessages = [];
     // Track the previous block's archive to ensure consecutive blocks have consistent archive roots.
     // The current block's header.lastArchive must equal the previous block's archive.
     let lastArchive = previousArchive;
+    // Pass maxEffects via txOptions so it reaches TxEffect.random
+    const txOptions = maxEffects !== undefined ? {
+        maxEffects
+    } : {};
     for(let i = 0; i < (blocks?.length ?? numBlocks); i++){
         const blockNumber = BlockNumber(startBlockNumber + i);
         const { block, messages } = {
-            block: blocks?.[i] ?? await L2BlockNew.random(blockNumber, {
+            block: blocks?.[i] ?? await L2Block.random(blockNumber, {
                 checkpointNumber,
                 indexWithinCheckpoint: IndexWithinCheckpoint(i),
                 txsPerBlock: numTxsPerBlock,
+                txOptions,
                 slotNumber,
                 ...options,
                 ...makeBlockOptions(blockNumber),
@@ -390,10 +395,10 @@ export const makeCheckpointProposal = (options)=>{
     });
 };
 /**
- * Create a checkpoint attestation from an L2BlockNew
- * Note: This is a compatibility function for tests. L2BlockNew doesn't have a checkpoint header directly.
+ * Create a checkpoint attestation from an L2Block
+ * Note: This is a compatibility function for tests. L2Block doesn't have a checkpoint header directly.
  */ export const makeCheckpointAttestationFromBlock = (block, attesterSigner, proposerSigner)=>{
-    // For L2BlockNew, we create a minimal checkpoint header for testing purposes
+    // For L2Block, we create a minimal checkpoint header for testing purposes
     const header = CheckpointHeader.empty({
         lastArchiveRoot: block.header.lastArchive.root,
         slotNumber: block.slot,
@@ -409,14 +414,14 @@ export const makeCheckpointProposal = (options)=>{
     });
 };
 export async function randomPublishedL2Block(l2BlockNumber, opts = {}) {
-    const block = await L2BlockNew.random(BlockNumber(l2BlockNumber));
+    const block = await L2Block.random(BlockNumber(l2BlockNumber));
     const l1 = L1PublishedData.fromFields({
         blockNumber: BigInt(block.number),
         timestamp: block.header.globalVariables.timestamp,
         blockHash: Buffer32.random().toString()
     });
     const signers = opts.signers ?? times(3, ()=>Secp256k1Signer.random());
-    const checkpoint = await Checkpoint.random(CheckpointNumber(l2BlockNumber), {
+    const checkpoint = await Checkpoint.random(CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)), {
         numBlocks: 0
     });
     checkpoint.blocks = [
@@ -428,5 +433,5 @@ export async function randomPublishedL2Block(l2BlockNumber, opts = {}) {
             header: checkpoint.header
         }));
     const attestations = atts.map((attestation, i)=>new CommitteeAttestation(signers[i].address, attestation.signature));
-    return new CheckpointedL2Block(CheckpointNumber(l2BlockNumber), block, l1, attestations);
+    return new CheckpointedL2Block(CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)), block, l1, attestations);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "4.0.0-nightly.20260122",
+  "version": "4.0.0-nightly.20260124",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -78,14 +78,14 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.892.0",
-    "@aztec/bb.js": "4.0.0-nightly.20260122",
-    "@aztec/blob-lib": "4.0.0-nightly.20260122",
-    "@aztec/constants": "4.0.0-nightly.20260122",
-    "@aztec/ethereum": "4.0.0-nightly.20260122",
-    "@aztec/foundation": "4.0.0-nightly.20260122",
-    "@aztec/l1-artifacts": "4.0.0-nightly.20260122",
-    "@aztec/noir-noirc_abi": "4.0.0-nightly.20260122",
-    "@aztec/validator-ha-signer": "4.0.0-nightly.20260122",
+    "@aztec/bb.js": "4.0.0-nightly.20260124",
+    "@aztec/blob-lib": "4.0.0-nightly.20260124",
+    "@aztec/constants": "4.0.0-nightly.20260124",
+    "@aztec/ethereum": "4.0.0-nightly.20260124",
+    "@aztec/foundation": "4.0.0-nightly.20260124",
+    "@aztec/l1-artifacts": "4.0.0-nightly.20260124",
+    "@aztec/noir-noirc_abi": "4.0.0-nightly.20260124",
+    "@aztec/validator-ha-signer": "4.0.0-nightly.20260124",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.12.0",
     "json-stringify-deterministic": "1.0.12",

package/src/block/checkpointed_l2_block.ts

@@ -7,7 +7,7 @@ import { z } from 'zod';
 
 import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
 import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
-import { L2BlockNew } from './l2_block_new.js';
+import { L2Block } from './l2_block.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /**
@@ -16,7 +16,7 @@ import { CommitteeAttestation } from './proposal/committee_attestation.js';
 export class CheckpointedL2Block {
   constructor(
     public checkpointNumber: CheckpointNumber,
-    public block: L2BlockNew,
+    public block: L2Block,
     public l1: L1PublishedData,
     public attestations: CommitteeAttestation[],
   ) {}
@@ -24,7 +24,7 @@ export class CheckpointedL2Block {
     return z
       .object({
         checkpointNumber: CheckpointNumberSchema,
-        block: L2BlockNew.schema,
+        block: L2Block.schema,
         l1: L1PublishedData.schema,
         attestations: z.array(CommitteeAttestation.schema),
       })
@@ -34,7 +34,7 @@ export class CheckpointedL2Block {
   static fromBuffer(bufferOrReader: Buffer | BufferReader): CheckpointedL2Block {
     const reader = BufferReader.asReader(bufferOrReader);
     const checkpointNumber = reader.readNumber();
-    const block = reader.readObject(L2BlockNew);
+    const block = reader.readObject(L2Block);
     const l1BlockNumber = reader.readBigInt();
     const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();

package/src/block/in_block.ts

@@ -3,7 +3,7 @@ import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types'
 import { type ZodTypeAny, z } from 'zod';
 
 import { L2BlockHash } from './block_hash.js';
-import type { L2BlockNew } from './l2_block_new.js';
+import type { L2Block } from './l2_block.js';
 
 export type InBlock = {
   l2BlockNumber: BlockNumber;
@@ -29,7 +29,7 @@ export function randomDataInBlock<T>(data: T): DataInBlock<T> {
   };
 }
 
-export async function wrapDataInBlock<T>(data: T, block: L2BlockNew): Promise<DataInBlock<T>> {
+export async function wrapDataInBlock<T>(data: T, block: L2Block): Promise<DataInBlock<T>> {
   return {
     data,
     l2BlockNumber: block.number,

package/src/block/index.ts

@@ -1,4 +1,4 @@
-export * from './l2_block_new.js';
+export * from './l2_block.js';
 export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';

package/src/block/{l2_block_new.ts → l2_block.ts}

@@ -18,15 +18,10 @@ import { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
 import type { L2BlockInfo } from './l2_block_info.js';
 
-// TODO(palla/mbps): Delete the existing `L2Block` class and rename this to `L2Block`.
-// TODO(palla/mbps): Consider moving the checkpointNumber and indexWithinCheckpoint to the header:
-// if the blockNumber is there, why not these as well? Consider whether they should be part of the
-// circuits structs though.
-
 /**
  * An L2 block with a header and a body.
  */
-export class L2BlockNew {
+export class L2Block {
   constructor(
     /** Snapshot of archive tree after the block is applied. */
     public archive: AppendOnlyTreeSnapshot,
@@ -63,7 +58,7 @@ export class L2BlockNew {
       })
       .transform(
         ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
-          new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint),
+          new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint),
       );
   }
 
@@ -79,7 +74,7 @@ export class L2BlockNew {
     const checkpointNumber = CheckpointNumber(reader.readNumber());
     const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
 
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -143,7 +138,7 @@ export class L2BlockNew {
   }
 
   static empty(header?: BlockHeader) {
-    return new L2BlockNew(
+    return new L2Block(
       AppendOnlyTreeSnapshot.empty(),
       header ?? BlockHeader.empty(),
       Body.empty(),
@@ -177,11 +172,11 @@ export class L2BlockNew {
       txOptions?: Partial<Parameters<typeof Body.random>[0]>;
       makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
     } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
-  ): Promise<L2BlockNew> {
+  ): Promise<L2Block> {
     const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
     const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
     const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**

package/src/block/l2_block_source.ts

@@ -21,7 +21,7 @@ import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
 import type { TxReceipt } from '../tx/tx_receipt.js';
 import type { CheckpointedL2Block } from './checkpointed_l2_block.js';
-import type { L2BlockNew } from './l2_block_new.js';
+import type { L2Block } from './l2_block.js';
 import type { ValidateCheckpointNegativeResult, ValidateCheckpointResult } from './validate_block_result.js';
 
 /**
@@ -81,15 +81,15 @@ export interface L2BlockSource {
    */
   getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
-  getCheckpointedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]>;
+  getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]>;
 
   /**
-   * Retrieves a collection of published checkpoints
-   * @param checkpointNumber The first checkpoint to be retrieved
-   * @param limit The number of checkpoints to be retrieved
-   * @returns The collection of complete checkpoints
+   * Retrieves a collection of checkpoints.
+   * @param checkpointNumber The first checkpoint to be retrieved.
+   * @param limit The number of checkpoints to be retrieved.
+   * @returns The collection of complete checkpoints.
    */
-  getPublishedCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+  getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
 
   /**
    * Gets the checkpoints for a given epoch
@@ -116,21 +116,21 @@ export interface L2BlockSource {
    * @param number - The block number to return.
    * @returns The requested L2 block (or undefined if not found).
    */
-  getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined>;
+  getL2Block(number: BlockNumber): Promise<L2Block | undefined>;
 
   /**
    * Gets an L2 block by its hash.
    * @param blockHash - The block hash to retrieve.
    * @returns The requested L2 block (or undefined if not found).
    */
-  getL2BlockNewByHash(blockHash: Fr): Promise<L2BlockNew | undefined>;
+  getL2BlockByHash(blockHash: Fr): Promise<L2Block | undefined>;
 
   /**
    * Gets an L2 block by its archive root.
    * @param archive - The archive root to retrieve.
    * @returns The requested L2 block (or undefined if not found).
    */
-  getL2BlockNewByArchive(archive: Fr): Promise<L2BlockNew | undefined>;
+  getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined>;
 
   /**
    * Gets a tx effect.
@@ -157,11 +157,11 @@ export interface L2BlockSource {
   getL2EpochNumber(): Promise<EpochNumber | undefined>;
 
   /**
-   * Returns all block headers for a given epoch.
+   * Returns all checkpointed block headers for a given epoch.
    * @dev Use this method only with recent epochs, since it walks the block list backwards.
    * @param epochNumber - The epoch number to return headers for.
    */
-  getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
+  getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
 
   /**
    * Returns whether the given epoch is completed on L1, based on the current L1 and L2 block numbers.
@@ -207,49 +207,43 @@ export interface L2BlockSource {
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  getBlock(number: BlockNumber): Promise<L2BlockNew | undefined>;
-
-  getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]>;
+  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
 
   /**
-   * Returns all blocks for a given epoch.
+   * Returns all checkpointed blocks for a given epoch.
    * @dev Use this method only with recent epochs, since it walks the block list backwards.
    * @param epochNumber - The epoch number to return blocks for.
    */
-  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2BlockNew[]>;
+  getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]>;
 
   /**
    * Returns all blocks for a given slot.
    * @dev Use this method only with recent slots, since it walks the block list backwards.
    * @param slotNumber - The slot number to return blocks for.
    */
-  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]>;
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]>;
 
   /**
-   * Gets a published block by its block hash.
+   * Gets a checkpointed block by its block hash.
    * @param blockHash - The block hash to retrieve.
    * @returns The requested block (or undefined if not found).
    */
-  getPublishedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined>;
+  getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined>;
 
   /**
-   * Gets a published block by its archive root.
+   * Gets a checkpointed block by its archive root.
    * @param archive - The archive root to retrieve.
    * @returns The requested block (or undefined if not found).
    */
-  getPublishedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined>;
+  getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined>;
 
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
    * @param limit - The maximum number of blocks to return.
-   * @param proven - If true, only return blocks that have been proven.
    * @returns The requested L2 blocks.
    */
-  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]>;
-
-  /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]>;
+  getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]>;
 }
 
 /**
@@ -261,7 +255,7 @@ export interface L2BlockSink {
    * @param block - The L2 block to add.
    * @throws If block number is not incremental (i.e., not exactly one more than the last stored block).
    */
-  addBlock(block: L2BlockNew): Promise<void>;
+  addBlock(block: L2Block): Promise<void>;
 }
 
 /**
@@ -358,13 +352,13 @@ export type L2BlockProvenEvent = {
 export type L2PruneUnprovenEvent = {
   type: 'l2PruneUnproven';
   epochNumber: EpochNumber;
-  blocks: L2BlockNew[];
+  blocks: L2Block[];
 };
 
 export type L2PruneUncheckpointedEvent = {
   type: 'l2PruneUncheckpointed';
   slotNumber: SlotNumber;
-  blocks: L2BlockNew[];
+  blocks: L2Block[];
 };
 
 export type L2CheckpointEvent = {

package/src/block/l2_block_stream/interfaces.ts

@@ -1,5 +1,5 @@
 import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
-import type { L2BlockNew } from '../l2_block_new.js';
+import type { L2Block } from '../l2_block.js';
 import type { CheckpointId, L2BlockId, L2Tips } from '../l2_block_source.js';
 
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
@@ -16,7 +16,7 @@ export interface L2BlockStreamEventHandler {
 export type L2BlockStreamEvent =
   | /** Emits blocks added to the chain. */ {
       type: 'blocks-added';
-      blocks: L2BlockNew[];
+      blocks: L2Block[];
     }
   | /** Emits checkpoints published to L1. */ {
       type: 'chain-checkpointed';

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -19,13 +19,12 @@ export class L2BlockStream {
   constructor(
     private l2BlockSource: Pick<
       L2BlockSource,
-      'getL2BlocksNew' | 'getBlockHeader' | 'getL2Tips' | 'getPublishedCheckpoints' | 'getCheckpointedBlocks'
+      'getBlocks' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpoints' | 'getCheckpointedBlocks'
     >,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
     private opts: {
-      proven?: boolean;
       pollIntervalMS?: number;
       batchSize?: number;
       startingBlock?: number;
@@ -129,7 +128,7 @@ export class L2BlockStream {
       if (!this.opts.ignoreCheckpoints) {
         let loop1Iterations = 0;
         while (nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number) {
-          const checkpoints = await this.l2BlockSource.getPublishedCheckpoints(nextCheckpointToEmit, 1);
+          const checkpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointToEmit, 1);
           if (checkpoints.length === 0) {
             break;
           }
@@ -174,7 +173,7 @@ export class L2BlockStream {
         // Refill the prefetch buffer when exhausted
         if (prefetchIdx >= prefetchedCheckpoints.length) {
           const prefetchLimit = this.opts.checkpointPrefetchLimit ?? CHECKPOINT_PREFETCH_LIMIT;
-          prefetchedCheckpoints = await this.l2BlockSource.getPublishedCheckpoints(nextCheckpointNumber, prefetchLimit);
+          prefetchedCheckpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointNumber, prefetchLimit);
           prefetchIdx = 0;
           if (prefetchedCheckpoints.length === 0) {
             break;
@@ -213,8 +212,8 @@ export class L2BlockStream {
       // 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} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getL2BlocksNew(BlockNumber(nextBlockNumber), limit, this.opts.proven);
+        this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit}`);
+        const blocks = await this.l2BlockSource.getBlocks(BlockNumber(nextBlockNumber), BlockNumber(limit));
         if (blocks.length === 0) {
           break;
         }

package/src/block/l2_block_stream/l2_tips_store_base.ts

@@ -2,7 +2,7 @@ import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 
 import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
-import type { L2BlockNew } from '../l2_block_new.js';
+import type { L2Block } from '../l2_block.js';
 import {
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
@@ -109,7 +109,7 @@ export abstract class L2TipsStoreBase implements L2BlockStreamEventHandler, L2Bl
   }
 
   // Protected helper that subclasses can override for block hash computation
-  protected computeBlockHash(block: L2BlockNew): Promise<string> {
+  protected computeBlockHash(block: L2Block): Promise<string> {
     return block.hash().then(hash => hash.toString());
   }
 

package/src/block/test/l2_tips_store_test_suite.ts

@@ -5,8 +5,8 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
+  L2Block,
   type L2BlockId,
-  L2BlockNew,
   type L2TipId,
 } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
@@ -31,8 +31,8 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     blockToCheckpoint.clear();
   });
 
-  const makeBlock = async (number: number): Promise<L2BlockNew> => {
-    const block = await L2BlockNew.random(BlockNumber(number));
+  const makeBlock = async (number: number): Promise<L2Block> => {
+    const block = await L2Block.random(BlockNumber(number));
     blockHashes.set(number, (await block.hash()).toString());
     return block;
   };
@@ -74,7 +74,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     checkpointed: makeTipId(checkpointed),
   });
 
-  const makeCheckpoint = async (checkpointNumber: number, blocks: L2BlockNew[]): Promise<PublishedCheckpoint> => {
+  const makeCheckpoint = async (checkpointNumber: number, blocks: L2Block[]): Promise<PublishedCheckpoint> => {
     const checkpoint = await Checkpoint.random(CheckpointNumber(checkpointNumber), {
       numBlocks: blocks.length,
       startBlockNumber: blocks[0].number,

package/src/checkpoint/checkpoint.ts

@@ -13,7 +13,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { L2BlockNew } from '../block/l2_block_new.js';
+import { L2Block } from '../block/l2_block.js';
 import { MAX_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
 import { computeCheckpointOutHash } from '../messaging/out_hash.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
@@ -29,7 +29,7 @@ export class Checkpoint {
     /** Header of the checkpoint. */
     public header: CheckpointHeader,
     /** L2 blocks in the checkpoint. */
-    public blocks: L2BlockNew[],
+    public blocks: L2Block[],
     /** Number of the checkpoint. */
     public number: CheckpointNumber,
   ) {}
@@ -43,7 +43,7 @@ export class Checkpoint {
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
         header: CheckpointHeader.schema,
-        blocks: z.array(L2BlockNew.schema),
+        blocks: z.array(L2Block.schema),
         number: CheckpointNumberSchema,
       })
       .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
@@ -62,7 +62,7 @@ export class Checkpoint {
     return new Checkpoint(
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(CheckpointHeader),
-      reader.readVector(L2BlockNew, MAX_BLOCKS_PER_CHECKPOINT),
+      reader.readVector(L2Block, MAX_BLOCKS_PER_CHECKPOINT),
       CheckpointNumber(reader.readNumber()),
     );
   }
@@ -135,16 +135,16 @@ export class Checkpoint {
       startBlockNumber?: number;
       previousArchive?: AppendOnlyTreeSnapshot;
     } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
-      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+      Partial<Parameters<typeof L2Block.random>[1]> = {},
   ) {
     const header = CheckpointHeader.random(options);
 
     // Create blocks sequentially to chain archive roots properly.
     // Each block's header.lastArchive must equal the previous block's archive.
-    const blocks: L2BlockNew[] = [];
+    const blocks: L2Block[] = [];
     let lastArchive = previousArchive;
     for (let i = 0; i < numBlocks; i++) {
-      const block = await L2BlockNew.random(BlockNumber(startBlockNumber + i), {
+      const block = await L2Block.random(BlockNumber(startBlockNumber + i), {
         indexWithinCheckpoint: IndexWithinCheckpoint(i),
         ...options,
         ...(lastArchive ? { lastArchive } : {}),

package/src/contract/private_function.ts

@@ -1,5 +1,4 @@
 import { FUNCTION_TREE_HEIGHT, GeneratorIndex } from '@aztec/constants';
-import { pedersenHash } from '@aztec/foundation/crypto/pedersen';
 import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';
@@ -38,7 +37,7 @@ export async function computePrivateFunctionLeaf(fn: PrivateFunction): Promise<B
 async function getPrivateFunctionTreeCalculator(): Promise<MerkleTreeCalculator> {
   if (!privateFunctionTreeCalculator) {
     const functionTreeZeroLeaf = (
-      await pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
+      await poseidon2Hash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
     ).toBuffer() as Buffer<ArrayBuffer>;
     privateFunctionTreeCalculator = await MerkleTreeCalculator.create(
       FUNCTION_TREE_HEIGHT,

package/src/delayed_public_mutable/delayed_public_mutable_values.ts

@@ -68,23 +68,22 @@ export class DelayedPublicMutableValues {
   }
 
   static async readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
-    const fields = [];
-    for (let i = 0; i < DELAYED_PUBLIC_MUTABLE_VALUES_LEN; i++) {
-      fields.push(await readStorage(delayedPublicMutableSlot.add(new Fr(i))));
-    }
-    return DelayedPublicMutableValues.fromFields(fields);
+    const fieldPromises = Array.from({ length: DELAYED_PUBLIC_MUTABLE_VALUES_LEN }).map((_, i) =>
+      readStorage(delayedPublicMutableSlot.add(new Fr(i))),
+    );
+    return DelayedPublicMutableValues.fromFields(await Promise.all(fieldPromises));
   }
 
   isEmpty(): boolean {
     return this.svc.isEmpty() && this.sdc.isEmpty();
   }
 
-  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
-    const fields = this.toFields();
+  writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fieldPromises = this.toFields().map((field, i) =>
+      storageWrite(delayedPublicMutableSlot.add(new Fr(i)), field),
+    );
 
-    for (let i = 0; i < fields.length; i++) {
-      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
-    }
+    return Promise.all(fieldPromises);
   }
 
   async hash(): Promise<Fr> {

package/src/epoch-helpers/index.ts

@@ -69,7 +69,7 @@ export function getSlotRangeForEpoch(
   epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
 ): [SlotNumber, SlotNumber] {
-  const startSlot = SlotNumber(epochNumber * constants.epochDuration);
+  const startSlot = SlotNumber(Number(epochNumber) * constants.epochDuration);
   return [startSlot, SlotNumber(startSlot + constants.epochDuration - 1)];
 }