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

package/src/interfaces/tx_provider.ts

@@ -1,4 +1,4 @@
-import type { L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block } 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: L2BlockNew, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+  getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 }

package/src/interfaces/validator.ts

@@ -51,12 +51,10 @@ export type ValidatorClientConfig = ValidatorHASignerConfig & {
   /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
   fishermanMode?: boolean;
 
-  // TODO(palla/mbps): Change default to false once checkpoint validation is stable
-  /** Skip checkpoint proposal validation and always attest (default: true) */
+  /** Skip checkpoint proposal validation and always attest (default: false) */
   skipCheckpointProposalValidation?: boolean;
 
-  // TODO(palla/mbps): Change default to false once block sync is stable
-  /** Skip pushing re-executed blocks to archiver (default: true) */
+  /** Skip pushing re-executed blocks to archiver (default: false) */
   skipPushProposedBlocksToArchiver?: boolean;
 };
 

package/src/kernel/hints/build_nullifier_read_request_hints.ts

@@ -6,7 +6,6 @@ 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';
@@ -74,7 +73,6 @@ 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);
 
@@ -90,12 +88,7 @@ export async function buildNullifierReadRequestHintsFromResetActions<PENDING ext
     }
   }
 
-  // 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)),
-      );
+  const siloedValues = settledRequests.map(({ readRequest }) => readRequest.value);
 
   // Fetch all membership witnesses in parallel
   const membershipWitnesses = await Promise.all(siloedValues.map(value => oracle.getNullifierMembershipWitness(value)));
@@ -121,7 +114,6 @@ 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(
@@ -130,6 +122,5 @@ export async function buildNullifierReadRequestHints<PENDING extends number, SET
     resetActions,
     maxPending,
     maxSettled,
-    siloed,
   );
 }

package/src/keys/derivation.ts

@@ -10,8 +10,8 @@ import type { KeyPrefix } from './key_types.js';
 import { PublicKeys } from './public_keys.js';
 import { getKeyGenerator } from './utils.js';
 
-export function computeAppNullifierSecretKey(masterNullifierSecretKey: GrumpkinScalar, app: AztecAddress): Promise<Fr> {
-  return computeAppSecretKey(masterNullifierSecretKey, app, 'n'); // 'n' is the key prefix for nullifier secret key
+export function computeAppNullifierHidingKey(masterNullifierHidingKey: GrumpkinScalar, app: AztecAddress): Promise<Fr> {
+  return computeAppSecretKey(masterNullifierHidingKey, app, 'n'); // 'n' is the key prefix for nullifier hiding key
 }
 
 export function computeAppSecretKey(skM: GrumpkinScalar, app: AztecAddress, keyPrefix: KeyPrefix): Promise<Fr> {
@@ -26,8 +26,8 @@ export async function computeOvskApp(ovsk: GrumpkinScalar, app: AztecAddress): P
   return GrumpkinScalar.fromBuffer(ovskAppFr.toBuffer());
 }
 
-export function deriveMasterNullifierSecretKey(secretKey: Fr): GrumpkinScalar {
-  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.NSK_M]);
+export function deriveMasterNullifierHidingKey(secretKey: Fr): GrumpkinScalar {
+  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.NHK_M]);
 }
 
 export function deriveMasterIncomingViewingSecretKey(secretKey: Fr): GrumpkinScalar {
@@ -93,15 +93,15 @@ export function derivePublicKeyFromSecretKey(secretKey: Fq) {
  * @returns The derived keys.
  */
 export async function deriveKeys(secretKey: Fr) {
-  // First we derive master secret keys -  we use sha512 here because this derivation will never take place
+  // First we derive master secret/hiding keys -  we use sha512 here because this derivation will never take place
   // in a circuit
-  const masterNullifierSecretKey = deriveMasterNullifierSecretKey(secretKey);
+  const masterNullifierHidingKey = deriveMasterNullifierHidingKey(secretKey);
   const masterIncomingViewingSecretKey = deriveMasterIncomingViewingSecretKey(secretKey);
   const masterOutgoingViewingSecretKey = deriveMasterOutgoingViewingSecretKey(secretKey);
   const masterTaggingSecretKey = sha512ToGrumpkinScalar([secretKey, GeneratorIndex.TSK_M]);
 
   // Then we derive master public keys
-  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierSecretKey);
+  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierHidingKey);
   const masterIncomingViewingPublicKey = await derivePublicKeyFromSecretKey(masterIncomingViewingSecretKey);
   const masterOutgoingViewingPublicKey = await derivePublicKeyFromSecretKey(masterOutgoingViewingSecretKey);
   const masterTaggingPublicKey = await derivePublicKeyFromSecretKey(masterTaggingSecretKey);
@@ -115,7 +115,7 @@ export async function deriveKeys(secretKey: Fr) {
   );
 
   return {
-    masterNullifierSecretKey,
+    masterNullifierHidingKey,
     masterIncomingViewingSecretKey,
     masterOutgoingViewingSecretKey,
     masterTaggingSecretKey,

package/src/keys/key_types.ts

@@ -1,5 +1,5 @@
 import type { GeneratorIndex } from '@aztec/constants';
 
-export type KeyGenerator = GeneratorIndex.NSK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
+export type KeyGenerator = GeneratorIndex.NHK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
 export type KeyPrefix = 'n' | 'iv' | 'ov' | 't';
 export const KEY_PREFIXES: KeyPrefix[] = ['n', 'iv', 'ov', 't'];

package/src/keys/utils.ts

@@ -3,7 +3,11 @@ import { GeneratorIndex } from '@aztec/constants';
 import type { KeyGenerator, KeyPrefix } from './key_types.js';
 
 export function getKeyGenerator(prefix: KeyPrefix): KeyGenerator {
-  // We get enum key by capitalizing key prefix and concatenating it with 'SK_M'
-  const enumKey = `${prefix.toUpperCase()}SK_M`;
-  return GeneratorIndex[enumKey as keyof typeof GeneratorIndex] as KeyGenerator;
+  const map: Record<KeyPrefix, KeyGenerator> = {
+    n: GeneratorIndex.NHK_M,
+    iv: GeneratorIndex.IVSK_M,
+    ov: GeneratorIndex.OVSK_M,
+    t: GeneratorIndex.TSK_M,
+  };
+  return map[prefix];
 }

package/src/l1-contracts/slash_factory.ts

@@ -41,6 +41,7 @@ export class SlashFactoryContract {
 
     return {
       to: this.contract.address,
+      abi: SlashFactoryAbi,
       data: encodeFunctionData({
         abi: SlashFactoryAbi,
         functionName: 'createSlashPayload',

package/src/logs/log_id.ts

@@ -1,11 +1,12 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { L2BlockHash } from '../block/block_hash.js';
+import { BlockHash } from '../block/block_hash.js';
 import { schemas } from '../schemas/index.js';
 
 /** A globally unique log id. */
@@ -20,7 +21,7 @@ export class LogId {
     /** The block number the log was emitted in. */
     public readonly blockNumber: BlockNumber,
     /** The hash of the block the log was emitted in. */
-    public readonly blockHash: L2BlockHash,
+    public readonly blockHash: BlockHash,
     /** The index of a tx in a block the log was emitted in. */
     public readonly txIndex: number,
     /** The index of a log the tx was emitted in. */
@@ -40,7 +41,7 @@ export class LogId {
   static random() {
     return new LogId(
       BlockNumber(Math.floor(Math.random() * 1000) + 1),
-      L2BlockHash.random(),
+      BlockHash.random(),
       Math.floor(Math.random() * 1000),
       Math.floor(Math.random() * 100),
     );
@@ -50,7 +51,7 @@ export class LogId {
     return z
       .object({
         blockNumber: BlockNumberSchema,
-        blockHash: L2BlockHash.schema,
+        blockHash: BlockHash.schema,
         txIndex: schemas.Integer,
         logIndex: schemas.Integer,
       })
@@ -81,7 +82,7 @@ export class LogId {
     const reader = BufferReader.asReader(buffer);
 
     const blockNumber = BlockNumber(reader.readNumber());
-    const blockHash = reader.readObject(L2BlockHash);
+    const blockHash = new BlockHash(reader.readObject(Fr));
     const txIndex = reader.readNumber();
     const logIndex = reader.readNumber();
 
@@ -104,7 +105,7 @@ export class LogId {
   static fromString(data: string): LogId {
     const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash] = data.split('-');
     const blockNumber = BlockNumber(Number(rawBlockNumber));
-    const blockHash = L2BlockHash.fromString(rawBlockHash);
+    const blockHash = BlockHash.fromString(rawBlockHash);
     const txIndex = Number(rawTxIndex);
     const logIndex = Number(rawLogIndex);
 

package/src/logs/siloed_tag.ts

@@ -1,4 +1,5 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { ZodFor } from '@aztec/foundation/schemas';
 
@@ -22,7 +23,7 @@ export class SiloedTag {
   constructor(public readonly value: Fr) {}
 
   static async compute(tag: Tag, app: AztecAddress): Promise<SiloedTag> {
-    const siloedTag = await poseidon2Hash([app, tag.value]);
+    const siloedTag = await poseidon2HashWithSeparator([app, tag.value], GeneratorIndex.PRIVATE_LOG_FIRST_FIELD);
     return new SiloedTag(siloedTag);
   }
 

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';
@@ -30,8 +30,15 @@ export class BlockProposalHash extends Buffer32 {
 }
 
 export type BlockProposalOptions = {
-  publishFullTxs: boolean;
-  /** Whether to generate an invalid block proposal for broadcasting. Use only for testing. */
+  /**
+   * Whether to include the tx objects along with the block proposal.
+   * Dramatically increases size of the payload but eliminates failed reexecutions due to missing txs.
+   */
+  publishFullTxs?: boolean;
+  /**
+   * Whether to generate an invalid block proposal for broadcasting.
+   * Use only for testing.
+   */
   broadcastInvalidBlockProposal?: boolean;
 };
 
@@ -284,10 +291,10 @@ export class BlockProposal extends Gossipable {
   /**
    * Check if this proposal matches the given block.
    * Compares the archive root and block header.
-   * @param block - The L2BlockNew to compare against
+   * @param block - The L2Block to compare against
    * @returns True if the proposal matches the block
    */
-  matchesBlock(block: L2BlockNew): boolean {
+  matchesBlock(block: L2Block): boolean {
     return this.archiveRoot.equals(block.archive.root) && this.blockHeader.equals(block.header);
   }
 

package/src/p2p/checkpoint_proposal.ts

@@ -32,8 +32,15 @@ export class CheckpointProposalHash extends Buffer32 {
 }
 
 export type CheckpointProposalOptions = {
-  publishFullTxs: boolean;
-  /** Whether to generate an invalid checkpoint proposal for broadcasting. Use only for testing. */
+  /**
+   * Whether to include the tx objects along with the block proposal.
+   * Dramatically increases size of the payload but eliminates failed reexecutions due to missing txs.
+   */
+  publishFullTxs?: boolean;
+  /**
+   * Whether to generate an invalid checkpoint proposal for broadcasting.
+   * Use only for testing.
+   */
   broadcastInvalidCheckpointProposal?: boolean;
 };
 

package/src/p2p/message_validator.ts

@@ -1,10 +1,22 @@
 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 severity of error to be applied to the peer
+ * A validator for P2P messages, which returns a ValidationResult indicating
+ * whether to accept, ignore, or reject the message
  */
 export interface P2PValidator<T> {
-  validate(message: T): Promise<PeerErrorSeverity | undefined>;
+  validate(message: T): Promise<ValidationResult>;
 }

package/src/stats/stats.ts

@@ -202,8 +202,6 @@ export type L2BlockBuiltStats = {
   duration: number;
   /** Time for processing public txs in ms. */
   publicProcessDuration: number;
-  /** Time for running rollup circuits in ms.  */
-  rollupCircuitsDuration: number;
 } & L2BlockStats;
 
 /** Stats for an L2 block processed by the world state synchronizer. */

package/src/tests/factories.ts

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

package/src/tests/jest.ts

@@ -1,26 +1,26 @@
-import { L2BlockNew } from '../block/l2_block_new.js';
+import { L2Block } from '../block/l2_block.js';
 
 /**
- * Checks if two objects are the same L2BlockNew.
+ * Checks if two objects are the same L2Block.
  *
- * Sometimes we might be comparing two L2BlockNew instances that represent the same block but one of them might not have
+ * Sometimes we might be comparing two L2Block 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 L2BlockNew.
+ * are really the same L2Block.
  *
  * @param a - An object
  * @param b - Another object
- * @returns True if both a and b are the same L2BlockNew
+ * @returns True if both a and b are the same L2Block
  */
 export function equalL2Blocks(a: any, b: any) {
-  const aAsL2Block = a && a instanceof L2BlockNew ? a : undefined;
-  const bAsL2Block = b && b instanceof L2BlockNew ? b : undefined;
+  const aAsL2Block = a && a instanceof L2Block ? a : undefined;
+  const bAsL2Block = b && b instanceof L2Block ? b : undefined;
 
   if (aAsL2Block && bAsL2Block) {
-    // we got two L2BlockNew instances, so we can compare them
+    // we got two L2Block 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 L2BlockNew and the other isn't. Definitely not equal.
+    // one value is an L2Block 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, L2BlockNew } from '../block/index.js';
+import { CheckpointedL2Block, CommitteeAttestation, L2Block } 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';
@@ -97,12 +97,14 @@ export const mockTx = async (
     publicCalldataSize = 2,
     feePayer,
     chonkProof = ChonkProof.random(),
+    maxFeesPerGas = new GasFees(10, 10),
     maxPriorityFeesPerGas,
     gasUsed = Gas.empty(),
     chainId = Fr.ZERO,
     version = Fr.ZERO,
     vkTreeRoot = Fr.ZERO,
     protocolContractsHash = Fr.ZERO,
+    anchorBlockHeader = BlockHeader.empty(),
   }: {
     numberOfNonRevertiblePublicCallRequests?: number;
     numberOfRevertiblePublicCallRequests?: number;
@@ -111,12 +113,14 @@ export const mockTx = async (
     publicCalldataSize?: number;
     feePayer?: AztecAddress;
     chonkProof?: ChonkProof;
+    maxFeesPerGas?: GasFees;
     maxPriorityFeesPerGas?: GasFees;
     gasUsed?: Gas;
     chainId?: Fr;
     version?: Fr;
     vkTreeRoot?: Fr;
     protocolContractsHash?: Fr;
+    anchorBlockHeader?: BlockHeader;
   } = {},
 ) => {
   const totalPublicCallRequests =
@@ -126,10 +130,8 @@ export const mockTx = async (
   const isForPublic = totalPublicCallRequests > 0;
   const data = PrivateKernelTailCircuitPublicInputs.empty();
   const firstNullifier = new Nullifier(new Fr(seed + 1), Fr.ZERO, 0);
-  data.constants.txContext.gasSettings = GasSettings.default({
-    maxFeesPerGas: new GasFees(10, 10),
-    maxPriorityFeesPerGas,
-  });
+  data.constants.anchorBlockHeader = anchorBlockHeader;
+  data.constants.txContext.gasSettings = GasSettings.default({ maxFeesPerGas, maxPriorityFeesPerGas });
   data.feePayer = feePayer ?? (await AztecAddress.random());
   data.gasUsed = gasUsed;
   data.constants.txContext.chainId = chainId;
@@ -404,32 +406,37 @@ export async function mockCheckpointAndMessages(
     numL1ToL2Messages = 1,
     makeBlockOptions = () => ({}),
     previousArchive,
+    maxEffects,
     ...options
   }: {
     startBlockNumber?: BlockNumber;
     numBlocks?: number;
     numTxsPerBlock?: number;
     numL1ToL2Messages?: number;
-    makeBlockOptions?: (blockNumber: BlockNumber) => Partial<Parameters<typeof L2BlockNew.random>[1]>;
+    makeBlockOptions?: (blockNumber: BlockNumber) => Partial<Parameters<typeof L2Block.random>[1]>;
     previousArchive?: AppendOnlyTreeSnapshot;
-    blocks?: L2BlockNew[];
+    blocks?: L2Block[];
+    maxEffects?: number;
   } & Partial<Parameters<typeof Checkpoint.random>[1]> &
-    Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+    Partial<Parameters<typeof L2Block.random>[1]> = {},
 ) {
-  const slotNumber = options.slotNumber ?? SlotNumber(checkpointNumber * 10);
+  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: 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 L2BlockNew.random(blockNumber, {
+        (await L2Block.random(blockNumber, {
           checkpointNumber,
           indexWithinCheckpoint: IndexWithinCheckpoint(i),
           txsPerBlock: numTxsPerBlock,
+          txOptions,
           slotNumber,
           ...options,
           ...makeBlockOptions(blockNumber),
@@ -670,15 +677,15 @@ export const makeCheckpointAttestationFromCheckpoint = (
 };
 
 /**
- * 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: L2BlockNew,
+  block: L2Block,
   attesterSigner?: Secp256k1Signer,
   proposerSigner?: Secp256k1Signer,
 ): CheckpointAttestation => {
-  // 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,
@@ -694,7 +701,7 @@ export async function randomPublishedL2Block(
   l2BlockNumber: number,
   opts: { signers?: Secp256k1Signer[] } = {},
 ): Promise<CheckpointedL2Block> {
-  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,
@@ -702,7 +709,9 @@ export async function randomPublishedL2Block(
   });
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
-  const checkpoint = await Checkpoint.random(CheckpointNumber(l2BlockNumber), { numBlocks: 0 });
+  const checkpoint = await Checkpoint.random(CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)), {
+    numBlocks: 0,
+  });
   checkpoint.blocks = [block];
   const atts = signers.map(signer =>
     makeCheckpointAttestation({
@@ -714,5 +723,5 @@ export async function randomPublishedL2Block(
   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/src/tx/block_header.ts

@@ -11,13 +11,14 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import { BlockHash } from '../block/block_hash.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { GlobalVariables } from './global_variables.js';
 import { StateReference } from './state_reference.js';
 
 /** A header of an L2 block. */
 export class BlockHeader {
-  private _cachedHash?: Promise<Fr>;
+  private _cachedHash?: Promise<BlockHash>;
 
   constructor(
     /** Snapshot of archive before the block is applied. */
@@ -161,16 +162,18 @@ export class BlockHeader {
     return BlockHeader.fromBuffer(hexToBuffer(str));
   }
 
-  hash(): Promise<Fr> {
+  hash(): Promise<BlockHash> {
     if (!this._cachedHash) {
-      this._cachedHash = poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
+      this._cachedHash = poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HEADER_HASH).then(
+        fr => new BlockHash(fr),
+      );
     }
     return this._cachedHash;
   }
 
   /** Manually set the hash for this block header if already computed */
   setHash(hashed: Fr) {
-    this._cachedHash = Promise.resolve(hashed);
+    this._cachedHash = Promise.resolve(new BlockHash(hashed));
   }
 
   static random(overrides: Partial<FieldsOf<BlockHeader>> & Partial<FieldsOf<GlobalVariables>> = {}): BlockHeader {

package/src/tx/indexed_tx_effect.ts

@@ -1,8 +1,9 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import { L2BlockHash } from '../block/block_hash.js';
+import { BlockHash } from '../block/block_hash.js';
 import { type DataInBlock, dataInBlockSchemaFor, randomDataInBlock } from '../block/in_block.js';
 import { TxEffect } from './tx_effect.js';
 
@@ -26,7 +27,7 @@ export function serializeIndexedTxEffect(effect: IndexedTxEffect): Buffer {
 export function deserializeIndexedTxEffect(buffer: Buffer): IndexedTxEffect {
   const reader = BufferReader.asReader(buffer);
 
-  const l2BlockHash = reader.readObject(L2BlockHash);
+  const l2BlockHash = new BlockHash(reader.readObject(Fr));
   const l2BlockNumber = BlockNumber(reader.readNumber());
   const txIndexInBlock = reader.readNumber();
   const data = reader.readObject(TxEffect);