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

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()),

package/src/interfaces/block-builder.ts

@@ -1,7 +1,7 @@
 import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 
-import type { L2Block } from '../block/l2_block.js';
+import type { L2BlockNew } from '../block/l2_block_new.js';
 import type { ChainConfig, SequencerConfig } from '../config/chain-config.js';
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
 import type { Gas } from '../gas/gas.js';
@@ -31,7 +31,7 @@ export interface IBlockFactory extends ProcessedTxHandler {
   /**
    * Assembles the block and updates the archive tree.
    */
-  setBlockCompleted(expectedBlockHeader?: BlockHeader): Promise<L2Block>;
+  setBlockCompleted(expectedBlockHeader?: BlockHeader): Promise<L2BlockNew>;
 }
 
 export interface PublicProcessorLimits {
@@ -63,7 +63,7 @@ export const FullNodeBlockBuilderConfigKeys: (keyof FullNodeBlockBuilderConfig)[
 
 /** Result of building a block within a checkpoint. */
 export interface BuildBlockInCheckpointResult {
-  block: L2Block;
+  block: L2BlockNew;
   publicGas: Gas;
   publicProcessorDuration: number;
   numTxs: number;

package/src/interfaces/configs.ts

@@ -67,7 +67,9 @@ export interface SequencerConfig {
   blockDurationMs?: number;
   /** Have sequencer build and publish an empty checkpoint if there are no txs */
   buildCheckpointIfEmpty?: boolean;
-  /** Skip pushing proposed blocks to archiver (default: false) */
+
+  // TODO(palla/mbps): Change default to false once block sync is stable
+  /** Skip pushing proposed blocks to archiver (default: true) */
   skipPushProposedBlocksToArchiver?: boolean;
 }
 

package/src/interfaces/prover-client.ts

@@ -17,12 +17,6 @@ export type ActualProverConfig = {
   proverTestDelayMs: number;
   /** If using realistic delays, what percentage of realistic times to apply. */
   proverTestDelayFactor: number;
-  /**
-   * Whether to abort pending proving jobs when the orchestrator is cancelled.
-   * When false (default), jobs remain in the broker queue and can be reused on restart/reorg.
-   * When true, jobs are explicitly cancelled with the broker, which prevents reuse.
-   */
-  cancelJobsOnStop: boolean;
 };
 
 /**
@@ -49,7 +43,6 @@ export const ProverConfigSchema = zodFor<ProverConfig>()(
     proverTestDelayFactor: z.number(),
     proverAgentCount: z.number(),
     failedProofStore: z.string().optional(),
-    cancelJobsOnStop: z.boolean(),
   }),
 );
 
@@ -92,14 +85,6 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
     description:
       'Store for failed proof inputs. Google cloud storage is only supported at the moment. Set this value as gs://bucket-name/path/to/store.',
   },
-  cancelJobsOnStop: {
-    env: 'PROVER_CANCEL_JOBS_ON_STOP',
-    description:
-      'Whether to abort pending proving jobs when the orchestrator is cancelled. ' +
-      'When false (default), jobs remain in the broker queue and can be reused on restart/reorg. ' +
-      'When true, jobs are explicitly cancelled with the broker, which prevents reuse.',
-    ...booleanConfigHelper(false),
-  },
 };
 
 function parseProverId(str?: string) {

package/src/interfaces/tx_provider.ts

@@ -1,4 +1,4 @@
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
@@ -13,5 +13,5 @@ export interface ITxProvider {
     opts: { pinnedPeer: PeerId | undefined; deadline: Date },
   ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 
-  getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+  getTxsForBlock(block: L2BlockNew, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 }

package/src/interfaces/validator.ts

@@ -55,7 +55,8 @@ export type ValidatorClientConfig = ValidatorHASignerConfig & {
   /** Skip checkpoint proposal validation and always attest (default: true) */
   skipCheckpointProposalValidation?: boolean;
 
-  /** Skip pushing re-executed blocks to archiver (default: false) */
+  // TODO(palla/mbps): Change default to false once block sync is stable
+  /** Skip pushing re-executed blocks to archiver (default: true) */
   skipPushProposedBlocksToArchiver?: boolean;
 };
 

package/src/kernel/hints/build_nullifier_read_request_hints.ts

@@ -6,6 +6,7 @@ import {
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
+import { siloNullifier } from '../../hash/hash.js';
 import type { NullifierLeafPreimage } from '../../trees/nullifier_leaf.js';
 import type { ClaimedLengthArray } from '../claimed_length_array.js';
 import type { ScopedNullifier } from '../nullifier.js';
@@ -73,6 +74,7 @@ export async function buildNullifierReadRequestHintsFromResetActions<PENDING ext
   resetActions: ReadRequestResetActions<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
   maxPending: PENDING = MAX_NULLIFIER_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NULLIFIER_READ_REQUESTS_PER_TX as SETTLED,
+  siloed = false,
 ) {
   const builder = new NullifierReadRequestHintsBuilder(maxPending, maxSettled);
 
@@ -88,7 +90,12 @@ export async function buildNullifierReadRequestHintsFromResetActions<PENDING ext
     }
   }
 
-  const siloedValues = settledRequests.map(({ readRequest }) => readRequest.value);
+  // Compute siloed values in parallel (if not already siloed)
+  const siloedValues = siloed
+    ? settledRequests.map(({ readRequest }) => readRequest.value)
+    : await Promise.all(
+        settledRequests.map(({ readRequest }) => siloNullifier(readRequest.contractAddress, readRequest.value)),
+      );
 
   // Fetch all membership witnesses in parallel
   const membershipWitnesses = await Promise.all(siloedValues.map(value => oracle.getNullifierMembershipWitness(value)));
@@ -114,6 +121,7 @@ export async function buildNullifierReadRequestHints<PENDING extends number, SET
   futureNullifiers: ScopedNullifier[],
   maxPending: PENDING = MAX_NULLIFIER_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NULLIFIER_READ_REQUESTS_PER_TX as SETTLED,
+  siloed = false,
 ) {
   const resetActions = getNullifierReadRequestResetActions(nullifierReadRequests, nullifiers, futureNullifiers);
   return await buildNullifierReadRequestHintsFromResetActions(
@@ -122,5 +130,6 @@ export async function buildNullifierReadRequestHints<PENDING extends number, SET
     resetActions,
     maxPending,
     maxSettled,
+    siloed,
   );
 }

package/src/p2p/block_proposal.ts

@@ -8,8 +8,8 @@ import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
 
-import type { L2Block } from '../block/l2_block.js';
 import type { L2BlockInfo } from '../block/l2_block_info.js';
+import type { L2BlockNew } from '../block/l2_block_new.js';
 import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
@@ -284,10 +284,10 @@ export class BlockProposal extends Gossipable {
   /**
    * Check if this proposal matches the given block.
    * Compares the archive root and block header.
-   * @param block - The L2Block to compare against
+   * @param block - The L2BlockNew to compare against
    * @returns True if the proposal matches the block
    */
-  matchesBlock(block: L2Block): boolean {
+  matchesBlock(block: L2BlockNew): boolean {
     return this.archiveRoot.equals(block.archive.root) && this.blockHeader.equals(block.header);
   }
 

package/src/p2p/message_validator.ts

@@ -1,22 +1,10 @@
 import type { PeerErrorSeverity } from './peer_error.js';
 
-/**
- * Result of validating a P2P message.
- * - 'accept': Message is valid and should be accepted and processed
- * - 'ignore': Message should be ignored (not propagated or processed, but sender not penalized)
- * - 'reject': Message is invalid (rejected and sender penalized)
- */
-export type ValidationResult =
-  | { result: 'accept' }
-  | { result: 'ignore' }
-  | { result: 'reject'; severity: PeerErrorSeverity };
-
 /**
  * P2PValidator
  *
- * A validator for P2P messages, which returns a ValidationResult indicating
- * whether to accept, ignore, or reject the message
+ * A validator for P2P messages, which returns a severity of error to be applied to the peer
  */
 export interface P2PValidator<T> {
-  validate(message: T): Promise<ValidationResult>;
+  validate(message: T): Promise<PeerErrorSeverity | undefined>;
 }

package/src/tests/factories.ts

@@ -1739,7 +1739,7 @@ export function makeL2Tips(
       ? typeof checkpointNumber === 'number'
         ? CheckpointNumber(checkpointNumber)
         : checkpointNumber
-      : CheckpointNumber.fromBlockNumber(bn);
+      : CheckpointNumber(bn);
   const cph = checkpointHash ?? hash;
   return {
     proposed: { number: bn, hash },

package/src/tests/jest.ts

@@ -1,26 +1,26 @@
-import { L2Block } from '../block/l2_block.js';
+import { L2BlockNew } from '../block/l2_block_new.js';
 
 /**
- * Checks if two objects are the same L2Block.
+ * Checks if two objects are the same L2BlockNew.
  *
- * Sometimes we might be comparing two L2Block instances that represent the same block but one of them might not have
+ * Sometimes we might be comparing two L2BlockNew instances that represent the same block but one of them might not have
  * calculated and filled its `blockHash` property (which is computed on demand). This function ensures both objects
- * are really the same L2Block.
+ * are really the same L2BlockNew.
  *
  * @param a - An object
  * @param b - Another object
- * @returns True if both a and b are the same L2Block
+ * @returns True if both a and b are the same L2BlockNew
  */
 export function equalL2Blocks(a: any, b: any) {
-  const aAsL2Block = a && a instanceof L2Block ? a : undefined;
-  const bAsL2Block = b && b instanceof L2Block ? b : undefined;
+  const aAsL2Block = a && a instanceof L2BlockNew ? a : undefined;
+  const bAsL2Block = b && b instanceof L2BlockNew ? b : undefined;
 
   if (aAsL2Block && bAsL2Block) {
-    // we got two L2Block instances, so we can compare them
+    // we got two L2BlockNew instances, so we can compare them
     // use a custom comparator because the blockHash property is lazily computed and one instance might not have it
     return aAsL2Block.toBuffer().equals(bAsL2Block.toBuffer());
   } else if (aAsL2Block || bAsL2Block) {
-    // one value is an L2Block and the other isn't. Definitely not equal.
+    // one value is an L2BlockNew and the other isn't. Definitely not equal.
     return false;
   } else {
     // we don't know what they are, tell Jest to keep looking

package/src/tests/mocks.ts

@@ -22,7 +22,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, L2Block } from '../block/index.js';
+import { CheckpointedL2Block, CommitteeAttestation, L2BlockNew } from '../block/index.js';
 import type { CommitteeAttestationsAndSigners } from '../block/proposal/attestations_and_signers.js';
 import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
@@ -404,37 +404,32 @@ export async function mockCheckpointAndMessages(
     numL1ToL2Messages = 1,
     makeBlockOptions = () => ({}),
     previousArchive,
-    maxEffects,
     ...options
   }: {
     startBlockNumber?: BlockNumber;
     numBlocks?: number;
     numTxsPerBlock?: number;
     numL1ToL2Messages?: number;
-    makeBlockOptions?: (blockNumber: BlockNumber) => Partial<Parameters<typeof L2Block.random>[1]>;
+    makeBlockOptions?: (blockNumber: BlockNumber) => Partial<Parameters<typeof L2BlockNew.random>[1]>;
     previousArchive?: AppendOnlyTreeSnapshot;
-    blocks?: L2Block[];
-    maxEffects?: number;
+    blocks?: L2BlockNew[];
   } & Partial<Parameters<typeof Checkpoint.random>[1]> &
-    Partial<Parameters<typeof L2Block.random>[1]> = {},
+    Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
 ) {
-  const slotNumber = options.slotNumber ?? SlotNumber(Number(checkpointNumber) * 10);
+  const slotNumber = options.slotNumber ?? SlotNumber(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: AppendOnlyTreeSnapshot | undefined = 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 L2Block.random(blockNumber, {
+        (await L2BlockNew.random(blockNumber, {
           checkpointNumber,
           indexWithinCheckpoint: IndexWithinCheckpoint(i),
           txsPerBlock: numTxsPerBlock,
-          txOptions,
           slotNumber,
           ...options,
           ...makeBlockOptions(blockNumber),
@@ -675,15 +670,15 @@ export const makeCheckpointAttestationFromCheckpoint = (
 };
 
 /**
- * Create a checkpoint attestation from an L2Block
- * Note: This is a compatibility function for tests. L2Block doesn't have a checkpoint header directly.
+ * Create a checkpoint attestation from an L2BlockNew
+ * Note: This is a compatibility function for tests. L2BlockNew doesn't have a checkpoint header directly.
  */
 export const makeCheckpointAttestationFromBlock = (
-  block: L2Block,
+  block: L2BlockNew,
   attesterSigner?: Secp256k1Signer,
   proposerSigner?: Secp256k1Signer,
 ): CheckpointAttestation => {
-  // For L2Block, we create a minimal checkpoint header for testing purposes
+  // For L2BlockNew, we create a minimal checkpoint header for testing purposes
   const header = CheckpointHeader.empty({
     lastArchiveRoot: block.header.lastArchive.root,
     slotNumber: block.slot,
@@ -699,7 +694,7 @@ export async function randomPublishedL2Block(
   l2BlockNumber: number,
   opts: { signers?: Secp256k1Signer[] } = {},
 ): Promise<CheckpointedL2Block> {
-  const block = await L2Block.random(BlockNumber(l2BlockNumber));
+  const block = await L2BlockNew.random(BlockNumber(l2BlockNumber));
   const l1 = L1PublishedData.fromFields({
     blockNumber: BigInt(block.number),
     timestamp: block.header.globalVariables.timestamp,
@@ -707,9 +702,7 @@ export async function randomPublishedL2Block(
   });
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
-  const checkpoint = await Checkpoint.random(CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)), {
-    numBlocks: 0,
-  });
+  const checkpoint = await Checkpoint.random(CheckpointNumber(l2BlockNumber), { numBlocks: 0 });
   checkpoint.blocks = [block];
   const atts = signers.map(signer =>
     makeCheckpointAttestation({
@@ -721,5 +714,5 @@ export async function randomPublishedL2Block(
   const attestations = atts.map(
     (attestation, i) => new CommitteeAttestation(signers[i].address, attestation.signature),
   );
-  return new CheckpointedL2Block(CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)), block, l1, attestations);
+  return new CheckpointedL2Block(CheckpointNumber(l2BlockNumber), block, l1, attestations);
 }