@aztec/stdlib 0.0.1-commit.d1f2d6c → 0.0.1-commit.d431d1c

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 { L2Block } from './l2_block.js';
+import type { L2BlockNew } from './l2_block_new.js';
 import type { ValidateCheckpointNegativeResult, ValidateCheckpointResult } from './validate_block_result.js';
 
 /**
@@ -52,20 +52,6 @@ export interface L2BlockSource {
    */
   getProvenBlockNumber(): Promise<BlockNumber>;
 
-  /**
-   * Gets the number of the latest L2 block checkpointed seen by the block source implementation.
-   * @returns The number of the latest L2 block checkpointed seen by the block source implementation.
-   */
-  getCheckpointedL2BlockNumber(): Promise<BlockNumber>;
-
-  /**
-   * Computes the finalized block number based on the proven block number.
-   * A block is considered finalized when it's 2 epochs behind the proven block.
-   * TODO(#13569): Compute proper finalized block number based on L1 finalized block.
-   * @returns The finalized block number.
-   */
-  getFinalizedL2BlockNumber(): Promise<BlockNumber>;
-
   /**
    * Gets an l2 block header.
    * @param number - The block number to return or 'latest' for the most recent one.
@@ -81,15 +67,15 @@ export interface L2BlockSource {
    */
   getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
-  getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]>;
+  getCheckpointedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]>;
 
   /**
-   * 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.
+   * 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
    */
-  getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+  getPublishedCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
 
   /**
    * Gets the checkpoints for a given epoch
@@ -116,21 +102,21 @@ export interface L2BlockSource {
    * @param number - The block number to return.
    * @returns The requested L2 block (or undefined if not found).
    */
-  getL2Block(number: BlockNumber): Promise<L2Block | undefined>;
+  getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | 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).
    */
-  getL2BlockByHash(blockHash: Fr): Promise<L2Block | undefined>;
+  getL2BlockNewByHash(blockHash: Fr): Promise<L2BlockNew | 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).
    */
-  getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined>;
+  getL2BlockNewByArchive(archive: Fr): Promise<L2BlockNew | undefined>;
 
   /**
    * Gets a tx effect.
@@ -157,11 +143,11 @@ export interface L2BlockSource {
   getL2EpochNumber(): Promise<EpochNumber | undefined>;
 
   /**
-   * Returns all checkpointed block headers for a given epoch.
+   * Returns all 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.
    */
-  getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
+  getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
 
   /**
    * Returns whether the given epoch is completed on L1, based on the current L1 and L2 block numbers.
@@ -207,43 +193,49 @@ export interface L2BlockSource {
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
+  getBlock(number: BlockNumber): Promise<L2BlockNew | undefined>;
+
+  getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]>;
 
   /**
-   * Returns all checkpointed blocks for a given epoch.
+   * Returns all 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.
    */
-  getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]>;
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2BlockNew[]>;
 
   /**
    * 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<L2Block[]>;
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]>;
 
   /**
-   * Gets a checkpointed block by its block hash.
+   * Gets a published block by its block hash.
    * @param blockHash - The block hash to retrieve.
    * @returns The requested block (or undefined if not found).
    */
-  getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined>;
+  getPublishedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined>;
 
   /**
-   * Gets a checkpointed block by its archive root.
+   * Gets a published block by its archive root.
    * @param archive - The archive root to retrieve.
    * @returns The requested block (or undefined if not found).
    */
-  getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined>;
+  getPublishedBlockByArchive(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): Promise<L2Block[]>;
+  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[]>;
 }
 
 /**
@@ -255,7 +247,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: L2Block): Promise<void>;
+  addBlock(block: L2BlockNew): Promise<void>;
 }
 
 /**
@@ -352,13 +344,13 @@ export type L2BlockProvenEvent = {
 export type L2PruneUnprovenEvent = {
   type: 'l2PruneUnproven';
   epochNumber: EpochNumber;
-  blocks: L2Block[];
+  blocks: L2BlockNew[];
 };
 
 export type L2PruneUncheckpointedEvent = {
   type: 'l2PruneUncheckpointed';
   slotNumber: SlotNumber;
-  blocks: L2Block[];
+  blocks: L2BlockNew[];
 };
 
 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 { L2Block } from '../l2_block.js';
+import type { L2BlockNew } from '../l2_block_new.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: L2Block[];
+      blocks: L2BlockNew[];
     }
   | /** Emits checkpoints published to L1. */ {
       type: 'chain-checkpointed';

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -19,12 +19,13 @@ export class L2BlockStream {
   constructor(
     private l2BlockSource: Pick<
       L2BlockSource,
-      'getBlocks' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpoints' | 'getCheckpointedBlocks'
+      'getL2BlocksNew' | 'getBlockHeader' | 'getL2Tips' | 'getPublishedCheckpoints' | 'getCheckpointedBlocks'
     >,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
     private opts: {
+      proven?: boolean;
       pollIntervalMS?: number;
       batchSize?: number;
       startingBlock?: number;
@@ -128,7 +129,7 @@ export class L2BlockStream {
       if (!this.opts.ignoreCheckpoints) {
         let loop1Iterations = 0;
         while (nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number) {
-          const checkpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointToEmit, 1);
+          const checkpoints = await this.l2BlockSource.getPublishedCheckpoints(nextCheckpointToEmit, 1);
           if (checkpoints.length === 0) {
             break;
           }
@@ -173,7 +174,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.getCheckpoints(nextCheckpointNumber, prefetchLimit);
+          prefetchedCheckpoints = await this.l2BlockSource.getPublishedCheckpoints(nextCheckpointNumber, prefetchLimit);
           prefetchIdx = 0;
           if (prefetchedCheckpoints.length === 0) {
             break;
@@ -212,8 +213,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}`);
-        const blocks = await this.l2BlockSource.getBlocks(BlockNumber(nextBlockNumber), BlockNumber(limit));
+        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);
         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 { L2Block } from '../l2_block.js';
+import type { L2BlockNew } from '../l2_block_new.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: L2Block): Promise<string> {
+  protected computeBlockHash(block: L2BlockNew): 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<L2Block> => {
-    const block = await L2Block.random(BlockNumber(number));
+  const makeBlock = async (number: number): Promise<L2BlockNew> => {
+    const block = await L2BlockNew.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: L2Block[]): Promise<PublishedCheckpoint> => {
+  const makeCheckpoint = async (checkpointNumber: number, blocks: L2BlockNew[]): 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 { L2Block } from '../block/l2_block.js';
+import { L2BlockNew } from '../block/l2_block_new.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: L2Block[],
+    public blocks: L2BlockNew[],
     /** Number of the checkpoint. */
     public number: CheckpointNumber,
   ) {}
@@ -43,7 +43,7 @@ export class Checkpoint {
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
         header: CheckpointHeader.schema,
-        blocks: z.array(L2Block.schema),
+        blocks: z.array(L2BlockNew.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(L2Block, MAX_BLOCKS_PER_CHECKPOINT),
+      reader.readVector(L2BlockNew, 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 L2Block.random>[1]> = {},
+      Partial<Parameters<typeof L2BlockNew.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: L2Block[] = [];
+    const blocks: L2BlockNew[] = [];
     let lastArchive = previousArchive;
     for (let i = 0; i < numBlocks; i++) {
-      const block = await L2Block.random(BlockNumber(startBlockNumber + i), {
+      const block = await L2BlockNew.random(BlockNumber(startBlockNumber + i), {
         indexWithinCheckpoint: IndexWithinCheckpoint(i),
         ...options,
         ...(lastArchive ? { lastArchive } : {}),

package/src/config/node-rpc-config.ts

@@ -21,7 +21,7 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
   rpcMaxBodySize: {
     env: 'RPC_MAX_BODY_SIZE',
     description: 'Maximum allowed batch size for JSON RPC batch requests.',
-    defaultValue: '1mb',
+    defaultValue: '50mb',
   },
 };
 

package/src/contract/private_function.ts

@@ -1,4 +1,5 @@
 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';
@@ -37,7 +38,7 @@ export async function computePrivateFunctionLeaf(fn: PrivateFunction): Promise<B
 async function getPrivateFunctionTreeCalculator(): Promise<MerkleTreeCalculator> {
   if (!privateFunctionTreeCalculator) {
     const functionTreeZeroLeaf = (
-      await poseidon2Hash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
+      await pedersenHash(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,22 +68,23 @@ export class DelayedPublicMutableValues {
   }
 
   static async readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
-    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));
+    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);
   }
 
   isEmpty(): boolean {
     return this.svc.isEmpty() && this.sdc.isEmpty();
   }
 
-  writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
-    const fieldPromises = this.toFields().map((field, i) =>
-      storageWrite(delayedPublicMutableSlot.add(new Fr(i)), field),
-    );
+  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fields = this.toFields();
 
-    return Promise.all(fieldPromises);
+    for (let i = 0; i < fields.length; i++) {
+      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
+    }
   }
 
   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(Number(epochNumber) * constants.epochDuration);
+  const startSlot = SlotNumber(epochNumber * constants.epochDuration);
   return [startSlot, SlotNumber(startSlot + constants.epochDuration - 1)];
 }
 

package/src/interfaces/archiver.ts

@@ -5,7 +5,7 @@ import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 import { z } from 'zod';
 
 import { CheckpointedL2Block } from '../block/checkpointed_l2_block.js';
-import { L2Block } from '../block/l2_block.js';
+import { L2BlockNew } from '../block/l2_block_new.js';
 import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
 import { ValidateCheckpointResultSchema } from '../block/validate_block_result.js';
 import { Checkpoint } from '../checkpoint/checkpoint.js';
@@ -82,9 +82,7 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getRegistryAddress: z.function().args().returns(schemas.EthAddress),
   getBlockNumber: z.function().args().returns(BlockNumberSchema),
   getProvenBlockNumber: z.function().args().returns(BlockNumberSchema),
-  getCheckpointedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
-  getFinalizedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
-  getBlock: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
+  getBlock: z.function().args(BlockNumberSchema).returns(L2BlockNew.schema.optional()),
   getBlockHeader: z
     .function()
     .args(z.union([BlockNumberSchema, z.literal('latest')]))
@@ -92,28 +90,39 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getCheckpointedBlock: z.function().args(BlockNumberSchema).returns(CheckpointedL2Block.schema.optional()),
   getCheckpointedBlocks: z
     .function()
-    .args(BlockNumberSchema, schemas.Integer)
+    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
     .returns(z.array(CheckpointedL2Block.schema)),
-  getBlocks: z.function().args(BlockNumberSchema, schemas.Integer).returns(z.array(L2Block.schema)),
-  getCheckpoints: z
+  getBlocks: z
+    .function()
+    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
+    .returns(z.array(L2BlockNew.schema)),
+  getPublishedCheckpoints: z
     .function()
     .args(CheckpointNumberSchema, schemas.Integer)
     .returns(z.array(PublishedCheckpoint.schema)),
-  getCheckpointedBlockByHash: z.function().args(schemas.Fr).returns(CheckpointedL2Block.schema.optional()),
-  getCheckpointedBlockByArchive: z.function().args(schemas.Fr).returns(CheckpointedL2Block.schema.optional()),
+  getPublishedBlocks: z
+    .function()
+    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
+    .returns(z.array(CheckpointedL2Block.schema)),
+  getL2BlocksNew: z
+    .function()
+    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
+    .returns(z.array(L2BlockNew.schema)),
+  getPublishedBlockByHash: z.function().args(schemas.Fr).returns(CheckpointedL2Block.schema.optional()),
+  getPublishedBlockByArchive: z.function().args(schemas.Fr).returns(CheckpointedL2Block.schema.optional()),
   getBlockHeaderByHash: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
   getBlockHeaderByArchive: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
-  getL2Block: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
-  getL2BlockByHash: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
-  getL2BlockByArchive: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
+  getL2BlockNew: z.function().args(BlockNumberSchema).returns(L2BlockNew.schema.optional()),
+  getL2BlockNewByHash: z.function().args(schemas.Fr).returns(L2BlockNew.schema.optional()),
+  getL2BlockNewByArchive: z.function().args(schemas.Fr).returns(L2BlockNew.schema.optional()),
   getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
   getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
   getL2SlotNumber: z.function().args().returns(schemas.SlotNumber.optional()),
   getL2EpochNumber: z.function().args().returns(EpochNumberSchema.optional()),
   getCheckpointsForEpoch: z.function().args(EpochNumberSchema).returns(z.array(Checkpoint.schema)),
-  getCheckpointedBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointedL2Block.schema)),
-  getBlocksForSlot: z.function().args(schemas.SlotNumber).returns(z.array(L2Block.schema)),
-  getCheckpointedBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
+  getBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(L2BlockNew.schema)),
+  getBlocksForSlot: z.function().args(schemas.SlotNumber).returns(z.array(L2BlockNew.schema)),
+  getBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
   isEpochComplete: z.function().args(EpochNumberSchema).returns(z.boolean()),
   getL2Tips: z.function().args().returns(L2TipsSchema),
   getPrivateLogsByTags: z

package/src/interfaces/aztec-node.ts

@@ -23,11 +23,10 @@ import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 import { z } from 'zod';
 
 import type { AztecAddress } from '../aztec-address/index.js';
-import { L2BlockHash } from '../block/block_hash.js';
 import { type BlockParameter, BlockParameterSchema } from '../block/block_parameter.js';
 import { CheckpointedL2Block } from '../block/checkpointed_l2_block.js';
 import { type DataInBlock, dataInBlockSchemaFor } from '../block/in_block.js';
-import { L2Block } from '../block/l2_block.js';
+import { L2BlockNew } from '../block/l2_block_new.js';
 import { type L2BlockSource, type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
 import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
@@ -78,7 +77,13 @@ import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_s
 export interface AztecNode
   extends Pick<
     L2BlockSource,
-    'getBlocks' | 'getCheckpoints' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpointedBlocks'
+    | 'getBlocks'
+    | 'getL2BlocksNew'
+    | 'getPublishedBlocks'
+    | 'getPublishedCheckpoints'
+    | 'getBlockHeader'
+    | 'getL2Tips'
+    | 'getCheckpointedBlocks'
   > {
   /**
    * Returns the tips of the L2 chain.
@@ -227,21 +232,21 @@ export interface AztecNode
    * @param number - The block number or 'latest'.
    * @returns The requested block.
    */
-  getBlock(number: BlockParameter): Promise<L2Block | undefined>;
+  getBlock(number: BlockParameter): Promise<L2BlockNew | undefined>;
 
   /**
    * Get a block specified by its hash.
    * @param blockHash - The block hash being requested.
    * @returns The requested block.
    */
-  getBlockByHash(blockHash: Fr): Promise<L2Block | undefined>;
+  getBlockByHash(blockHash: Fr): Promise<L2BlockNew | undefined>;
 
   /**
    * Get a block specified by its archive root.
    * @param archive - The archive root being requested.
    * @returns The requested block.
    */
-  getBlockByArchive(archive: Fr): Promise<L2Block | undefined>;
+  getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined>;
 
   /**
    * Method to fetch the latest block number synchronized by the node.
@@ -255,12 +260,6 @@ export interface AztecNode
    */
   getProvenBlockNumber(): Promise<BlockNumber>;
 
-  /**
-   * Fetches the latest checkpointed block number.
-   * @returns The block number.
-   */
-  getCheckpointedBlockNumber(): Promise<BlockNumber>;
-
   /**
    * Method to determine if the node is ready to accept transactions.
    * @returns - Flag indicating the readiness for tx submission.
@@ -280,7 +279,7 @@ export interface AztecNode
    * @param limit - The maximum number of blocks to return.
    * @returns The blocks requested.
    */
-  getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]>;
+  getBlocks(from: BlockNumber, limit: number): Promise<L2BlockNew[]>;
 
   /**
    * Method to fetch the current min fees.
@@ -348,14 +347,10 @@ export interface AztecNode
    * array implies no logs match that tag.
    * @param tags - The tags to search for.
    * @param page - The page number (0-indexed) for pagination.
-   * @param referenceBlock - Optional block hash used to ensure the block still exists before logs are retrieved.
-   * This block is expected to represent the latest block to which the client has synced (called anchor block in PXE).
-   * If specified and the block is not found, an error is thrown. This helps detect reorgs, which could result in
-   * undefined behavior in the client's code.
    * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
    * for a tag, the caller should fetch the next page to check for more logs.
    */
-  getPrivateLogsByTags(tags: SiloedTag[], page?: number, referenceBlock?: L2BlockHash): Promise<TxScopedL2Log[][]>;
+  getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]>;
 
   /**
    * Gets public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
@@ -363,10 +358,6 @@ export interface AztecNode
    * @param contractAddress - The contract address to search logs for.
    * @param tags - The tags to search for.
    * @param page - The page number (0-indexed) for pagination.
-   * @param referenceBlock - Optional block hash used to ensure the block still exists before logs are retrieved.
-   * This block is expected to represent the latest block to which the client has synced (called anchor block in PXE).
-   * If specified and the block is not found, an error is thrown. This helps detect reorgs, which could result in
-   * undefined behavior in the client's code.
    * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
    * for a tag, the caller should fetch the next page to check for more logs.
    */
@@ -374,7 +365,6 @@ export interface AztecNode
     contractAddress: AztecAddress,
     tags: Tag[],
     page?: number,
-    referenceBlock?: L2BlockHash,
   ): Promise<TxScopedL2Log[][]>;
 
   /**
@@ -577,18 +567,16 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
     .args(EpochNumberSchema)
     .returns(z.array(z.array(z.array(z.array(schemas.Fr))))),
 
-  getBlock: z.function().args(BlockParameterSchema).returns(L2Block.schema.optional()),
+  getBlock: z.function().args(BlockParameterSchema).returns(L2BlockNew.schema.optional()),
 
-  getBlockByHash: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
+  getBlockByHash: z.function().args(schemas.Fr).returns(L2BlockNew.schema.optional()),
 
-  getBlockByArchive: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
+  getBlockByArchive: z.function().args(schemas.Fr).returns(L2BlockNew.schema.optional()),
 
   getBlockNumber: z.function().returns(BlockNumberSchema),
 
   getProvenBlockNumber: z.function().returns(BlockNumberSchema),
 
-  getCheckpointedBlockNumber: z.function().returns(BlockNumberSchema),
-
   isReady: z.function().returns(z.boolean()),
 
   getNodeInfo: z.function().returns(NodeInfoSchema),
@@ -596,16 +584,26 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
   getBlocks: z
     .function()
     .args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN))
-    .returns(z.array(L2Block.schema)),
+    .returns(z.array(L2BlockNew.schema)),
 
-  getCheckpoints: z
+  getPublishedBlocks: z
+    .function()
+    .args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN))
+    .returns(z.array(CheckpointedL2Block.schema)),
+
+  getPublishedCheckpoints: z
     .function()
     .args(CheckpointNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_CHECKPOINTS_LEN))
     .returns(z.array(PublishedCheckpoint.schema)),
 
-  getCheckpointedBlocks: z
+  getL2BlocksNew: z
     .function()
     .args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN))
+    .returns(z.array(L2BlockNew.schema)),
+
+  getCheckpointedBlocks: z
+    .function()
+    .args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN), optional(z.boolean()))
     .returns(z.array(CheckpointedL2Block.schema)),
 
   getCurrentMinFees: z.function().returns(GasFees.schema),
@@ -633,17 +631,12 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getPrivateLogsByTags: z
     .function()
-    .args(z.array(SiloedTag.schema).max(MAX_RPC_LEN), optional(z.number().gte(0)), optional(L2BlockHash.schema))
+    .args(z.array(SiloedTag.schema).max(MAX_RPC_LEN), optional(z.number().gte(0)))
     .returns(z.array(z.array(TxScopedL2Log.schema))),
 
   getPublicLogsByTagsFromContract: z
     .function()
-    .args(
-      schemas.AztecAddress,
-      z.array(Tag.schema).max(MAX_RPC_LEN),
-      optional(z.number().gte(0)),
-      optional(L2BlockHash.schema),
-    )
+    .args(schemas.AztecAddress, z.array(Tag.schema).max(MAX_RPC_LEN), optional(z.number().gte(0)))
     .returns(z.array(z.array(TxScopedL2Log.schema))),
 
   sendTx: z.function().args(Tx.schema).returns(z.void()),