@aztec/stdlib 0.0.1-commit.2ed92850 → 0.0.1-commit.3469e52

package/dest/tx/tx_receipt.js

@@ -4,30 +4,17 @@ import { RevertCode } from '../avm/revert_code.js';
 import { L2BlockHash } from '../block/block_hash.js';
 import { schemas } from '../schemas/schemas.js';
 import { TxHash } from './tx_hash.js';
-/** Block inclusion/finalization status. */ export var TxStatus = /*#__PURE__*/ function(TxStatus) {
+/**
+ * Possible status of a transaction.
+ */ export var TxStatus = /*#__PURE__*/ function(TxStatus) {
     TxStatus["DROPPED"] = "dropped";
     TxStatus["PENDING"] = "pending";
-    TxStatus["PROPOSED"] = "proposed";
-    TxStatus["CHECKPOINTED"] = "checkpointed";
-    TxStatus["PROVEN"] = "proven";
-    TxStatus["FINALIZED"] = "finalized";
+    TxStatus["SUCCESS"] = "success";
+    TxStatus["APP_LOGIC_REVERTED"] = "app_logic_reverted";
+    TxStatus["TEARDOWN_REVERTED"] = "teardown_reverted";
+    TxStatus["BOTH_REVERTED"] = "both_reverted";
     return TxStatus;
 }({});
-/** Tx status sorted by finalization progress. */ export const SortedTxStatuses = [
-    "dropped",
-    "pending",
-    "proposed",
-    "checkpointed",
-    "proven",
-    "finalized"
-];
-/** Execution result - only set when tx is in a block. */ export var TxExecutionResult = /*#__PURE__*/ function(TxExecutionResult) {
-    TxExecutionResult["SUCCESS"] = "success";
-    TxExecutionResult["APP_LOGIC_REVERTED"] = "app_logic_reverted";
-    TxExecutionResult["TEARDOWN_REVERTED"] = "teardown_reverted";
-    TxExecutionResult["BOTH_REVERTED"] = "both_reverted";
-    return TxExecutionResult;
-}({});
 /**
  * Represents a transaction receipt in the Aztec network.
  * Contains essential information about the transaction including its status, origin, and associated addresses.
@@ -36,53 +23,35 @@ import { TxHash } from './tx_hash.js';
  */ export class TxReceipt {
     txHash;
     status;
-    executionResult;
     error;
     transactionFee;
     blockHash;
     blockNumber;
-    constructor(/** A unique identifier for a transaction. */ txHash, /** The transaction's block finalization status. */ status, /** The execution result of the transaction, only set when tx is in a block. */ executionResult, /** Description of transaction error, if any. */ error, /** The transaction fee paid for the transaction. */ transactionFee, /** The hash of the block containing the transaction. */ blockHash, /** The block number in which the transaction was included. */ blockNumber){
+    constructor(/** A unique identifier for a transaction. */ txHash, /** The transaction's status. */ status, /** Description of transaction error, if any. */ error, /** The transaction fee paid for the transaction. */ transactionFee, /** The hash of the block containing the transaction. */ blockHash, /** The block number in which the transaction was included. */ blockNumber){
         this.txHash = txHash;
         this.status = status;
-        this.executionResult = executionResult;
         this.error = error;
         this.transactionFee = transactionFee;
         this.blockHash = blockHash;
         this.blockNumber = blockNumber;
     }
-    /** Returns true if the transaction was executed successfully. */ hasExecutionSucceeded() {
-        return this.executionResult === "success";
-    }
-    /** Returns true if the transaction execution reverted. */ hasExecutionReverted() {
-        return this.executionResult !== undefined && this.executionResult !== "success";
-    }
-    /** Returns true if the transaction has been included in a block (proposed, checkpointed, proven, or finalized). */ isMined() {
-        return this.status === "proposed" || this.status === "checkpointed" || this.status === "proven" || this.status === "finalized";
-    }
-    /** Returns true if the transaction is pending. */ isPending() {
-        return this.status === "pending";
-    }
-    /** Returns true if the transaction was dropped. */ isDropped() {
-        return this.status === "dropped";
-    }
     static empty() {
-        return new TxReceipt(TxHash.zero(), "dropped", undefined, undefined);
+        return new TxReceipt(TxHash.zero(), "dropped", '');
     }
     static get schema() {
         return z.object({
             txHash: TxHash.schema,
             status: z.nativeEnum(TxStatus),
-            executionResult: z.nativeEnum(TxExecutionResult).optional(),
-            error: z.string().optional(),
+            error: z.string(),
             blockHash: L2BlockHash.schema.optional(),
             blockNumber: BlockNumberSchema.optional(),
             transactionFee: schemas.BigInt.optional()
-        }).transform((fields)=>TxReceipt.from(fields));
+        }).transform(TxReceipt.from);
     }
     static from(fields) {
-        return new TxReceipt(fields.txHash, fields.status, fields.executionResult, fields.error, fields.transactionFee, fields.blockHash, fields.blockNumber);
+        return new TxReceipt(fields.txHash, fields.status, fields.error, fields.transactionFee, fields.blockHash, fields.blockNumber);
     }
-    static executionResultFromRevertCode(revertCode) {
+    static statusFromRevertCode(revertCode) {
         if (revertCode.equals(RevertCode.OK)) {
             return "success";
         } else if (revertCode.equals(RevertCode.APP_LOGIC_REVERTED)) {

package/package.json

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

package/src/block/block_hash.ts

@@ -48,7 +48,7 @@ export class L2BlockHash extends Buffer32 {
     return new L2BlockHash(reader.readBytes(L2BlockHash.SIZE));
   }
 
-  static override fromString(str: string): L2BlockHash {
+  static override fromString(str: string): Buffer32 {
     return new L2BlockHash(super.fromString(str).toBuffer());
   }
 
@@ -63,8 +63,4 @@ export class L2BlockHash extends Buffer32 {
   static override fromField(hash: Fr) {
     return new L2BlockHash(hash.toBuffer());
   }
-
-  toField(): Fr {
-    return Fr.fromBuffer(this.toBuffer());
-  }
 }

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 { L2Block } from './l2_block.js';
+import { L2BlockNew } from './l2_block_new.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: L2Block,
+    public block: L2BlockNew,
     public l1: L1PublishedData,
     public attestations: CommitteeAttestation[],
   ) {}
@@ -24,7 +24,7 @@ export class CheckpointedL2Block {
     return z
       .object({
         checkpointNumber: CheckpointNumberSchema,
-        block: L2Block.schema,
+        block: L2BlockNew.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(L2Block);
+    const block = reader.readObject(L2BlockNew);
     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 { L2Block } from './l2_block.js';
+import type { L2BlockNew } from './l2_block_new.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: L2Block): Promise<DataInBlock<T>> {
+export async function wrapDataInBlock<T>(data: T, block: L2BlockNew): Promise<DataInBlock<T>> {
   return {
     data,
     l2BlockNumber: block.number,

package/src/block/index.ts

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

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

@@ -18,10 +18,15 @@ 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 L2Block {
+export class L2BlockNew {
   constructor(
     /** Snapshot of archive tree after the block is applied. */
     public archive: AppendOnlyTreeSnapshot,
@@ -58,7 +63,7 @@ export class L2Block {
       })
       .transform(
         ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
-          new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint),
+          new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint),
       );
   }
 
@@ -74,7 +79,7 @@ export class L2Block {
     const checkpointNumber = CheckpointNumber(reader.readNumber());
     const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
 
-    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -89,9 +94,8 @@ export class L2Block {
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.
    */
-  public async hash(): Promise<Fr> {
-    const blockHash = await this.header.hash();
-    return blockHash.toField();
+  public hash(): Promise<Fr> {
+    return this.header.hash();
   }
 
   /**
@@ -139,7 +143,7 @@ export class L2Block {
   }
 
   static empty(header?: BlockHeader) {
-    return new L2Block(
+    return new L2BlockNew(
       AppendOnlyTreeSnapshot.empty(),
       header ?? BlockHeader.empty(),
       Body.empty(),
@@ -173,11 +177,11 @@ export class L2Block {
       txOptions?: Partial<Parameters<typeof Body.random>[0]>;
       makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
     } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
-  ): Promise<L2Block> {
+  ): Promise<L2BlockNew> {
     const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
     const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
     const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
-    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+    return new L2BlockNew(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 { 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,