@aztec/stdlib 0.86.0 → 0.87.0

package/src/rollup/base_rollup_hints.ts

@@ -7,7 +7,7 @@ import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { PublicDataHint } from '../avm/public_data_hint.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLogFields } from '../logs/index.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { ConstantRollupData } from './constant_rollup_data.js';
 import { PrivateBaseStateDiffHints } from './state_diff_hints.js';
@@ -39,7 +39,7 @@ export class PrivateBaseRollupHints {
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
-    public contractClassLogsPreimages: Tuple<ContractClassLog, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsPreimages: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Data which is not modified by the base rollup circuit.
      */
@@ -86,7 +86,7 @@ export class PrivateBaseRollupHints {
       reader.readObject(PrivateBaseStateDiffHints),
       reader.readObject(PublicDataHint),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
       reader.readObject(ConstantRollupData),
     );
   }
@@ -102,7 +102,7 @@ export class PrivateBaseRollupHints {
       PrivateBaseStateDiffHints.empty(),
       PublicDataHint.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.empty),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
       ConstantRollupData.empty(),
     );
   }
@@ -121,7 +121,7 @@ export class PublicBaseRollupHints {
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
-    public contractClassLogsPreimages: Tuple<ContractClassLog, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsPreimages: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Data which is not modified by the base rollup circuit.
      */
@@ -162,7 +162,7 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       reader.readObject(SpongeBlob),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
       reader.readObject(ConstantRollupData),
     );
   }
@@ -175,7 +175,7 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       SpongeBlob.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.empty),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
       ConstantRollupData.empty(),
     );
   }

package/src/rollup/block_root_or_block_merge_public_inputs.ts

@@ -36,6 +36,10 @@ export class BlockRootOrBlockMergePublicInputs {
      * Note: Truncated to 31 bytes to fit in Fr.
      */
     public outHash: Fr,
+    /**
+     * The hashes of the proposed block headers of the constituent blocks.
+     */
+    public proposedBlockHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     /**
      * The summed `transaction_fee`s and recipients of the constituent blocks.
      */
@@ -71,6 +75,7 @@ export class BlockRootOrBlockMergePublicInputs {
       reader.readObject(GlobalVariables),
       reader.readObject(GlobalVariables),
       Fr.fromBuffer(reader),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
@@ -90,6 +95,7 @@ export class BlockRootOrBlockMergePublicInputs {
       this.startGlobalVariables,
       this.endGlobalVariables,
       this.outHash,
+      this.proposedBlockHeaderHashes,
       this.fees,
       this.vkTreeRoot,
       this.protocolContractTreeRoot,
@@ -127,7 +133,10 @@ export class BlockRootOrBlockMergePublicInputs {
 }
 
 export class FeeRecipient {
-  constructor(public recipient: EthAddress, public value: Fr) {}
+  constructor(
+    public recipient: EthAddress,
+    public value: Fr,
+  ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader): FeeRecipient {
     const reader = BufferReader.asReader(buffer);

package/src/rollup/private_base_rollup_inputs.ts

@@ -7,7 +7,10 @@ import { PrivateBaseRollupHints } from './base_rollup_hints.js';
 import { PrivateTubeData } from './private_tube_data.js';
 
 export class PrivateBaseRollupInputs {
-  constructor(public tubeData: PrivateTubeData, public hints: PrivateBaseRollupHints) {}
+  constructor(
+    public tubeData: PrivateTubeData,
+    public hints: PrivateBaseRollupHints,
+  ) {}
 
   static from(fields: FieldsOf<PrivateBaseRollupInputs>): PrivateBaseRollupInputs {
     return new PrivateBaseRollupInputs(...PrivateBaseRollupInputs.getFields(fields));

package/src/rollup/root_rollup.ts

@@ -107,7 +107,10 @@ export class RootRollupPublicInputs {
     public endTimestamp: Fr,
     public endBlockNumber: Fr,
     public outHash: Fr,
+    public proposedBlockHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public chainId: Fr,
+    public version: Fr,
     public vkTreeRoot: Fr,
     public protocolContractTreeRoot: Fr,
     public proverId: Fr,
@@ -121,7 +124,10 @@ export class RootRollupPublicInputs {
       fields.endTimestamp,
       fields.endBlockNumber,
       fields.outHash,
+      fields.proposedBlockHeaderHashes,
       fields.fees,
+      fields.chainId,
+      fields.version,
       fields.vkTreeRoot,
       fields.protocolContractTreeRoot,
       fields.proverId,
@@ -154,10 +160,13 @@ export class RootRollupPublicInputs {
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, BlockBlobPublicInputs),
     );
   }
@@ -188,10 +197,13 @@ export class RootRollupPublicInputs {
       Fr.random(),
       Fr.random(),
       Fr.random(),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),
       makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
       Fr.random(),
       Fr.random(),
       Fr.random(),
+      Fr.random(),
+      Fr.random(),
       makeTuple(AZTEC_MAX_EPOCH_DURATION, BlockBlobPublicInputs.empty),
     );
   }

package/src/rollup/tube_inputs.ts

@@ -10,7 +10,10 @@ import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
  * 'usePublicTailVk' signifies if we should prove this with the public or private kernel tail client IVC VKs.
  */
 export class TubeInputs {
-  constructor(public usePublicTailVk: boolean, public clientIVCData: ClientIvcProof) {}
+  constructor(
+    public usePublicTailVk: boolean,
+    public clientIVCData: ClientIvcProof,
+  ) {}
 
   static from(fields: FieldsOf<TubeInputs>): TubeInputs {
     return new TubeInputs(...TubeInputs.getFields(fields));

package/src/shared_mutable/scheduled_delay_change.ts

@@ -1,7 +1,11 @@
 import type { UInt32 } from '../types/shared.js';
 
 export class ScheduledDelayChange {
-  constructor(public pre: UInt32 | undefined, public post: UInt32 | undefined, public blockOfChange: UInt32) {}
+  constructor(
+    public pre: UInt32 | undefined,
+    public post: UInt32 | undefined,
+    public blockOfChange: UInt32,
+  ) {}
 
   static empty() {
     return new this(undefined, undefined, 0);

package/src/shared_mutable/scheduled_value_change.ts

@@ -1,7 +1,11 @@
 import { Fr } from '@aztec/foundation/fields';
 
 export class ScheduledValueChange {
-  constructor(public previous: Fr[], public post: Fr[], public blockOfChange: number) {
+  constructor(
+    public previous: Fr[],
+    public post: Fr[],
+    public blockOfChange: number,
+  ) {
     if (this.previous.length !== this.post.length) {
       throw new Error('Previous and post must have the same length');
     }

package/src/shared_mutable/shared_mutable_values.ts

@@ -9,7 +9,10 @@ import { ScheduledValueChange } from './scheduled_value_change.js';
 export const SHARED_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
 
 export class SharedMutableValues {
-  constructor(public svc: ScheduledValueChange, public sdc: ScheduledDelayChange) {}
+  constructor(
+    public svc: ScheduledValueChange,
+    public sdc: ScheduledDelayChange,
+  ) {}
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);

package/src/snapshots/download.ts

@@ -2,8 +2,6 @@ import { fromEntries, getEntries, maxBy } from '@aztec/foundation/collection';
 import { jsonParseWithSchemaSync } from '@aztec/foundation/json-rpc';
 import type { ReadOnlyFileStore } from '@aztec/stdlib/file-store';
 
-import { join } from 'path';
-
 import {
   SnapshotDataKeys,
   type SnapshotDataUrls,
@@ -47,8 +45,9 @@ export function getSnapshotIndexPath(metadata: SnapshotsIndexMetadata): string {
   return `${getBasePath(metadata)}/index.json`;
 }
 
-export function makeSnapshotLocalPaths(baseDir: string): SnapshotDataUrls {
-  return fromEntries(SnapshotDataKeys.map(key => [key, join(baseDir, `${key}.db`)]));
+export function makeSnapshotPaths(baseDir: string): SnapshotDataUrls {
+  // We do not use path.join since that screws up protocol prefixes
+  return fromEntries(SnapshotDataKeys.map(key => [key, `${baseDir}/${key}.db`]));
 }
 
 export async function downloadSnapshot(

package/src/snapshots/index.ts

@@ -1,3 +1,3 @@
 export * from './types.js';
 export * from './upload.js';
-export { downloadSnapshot, getLatestSnapshotMetadata, makeSnapshotLocalPaths } from './download.js';
+export { getBasePath, downloadSnapshot, getLatestSnapshotMetadata, makeSnapshotPaths } from './download.js';

package/src/snapshots/types.ts

@@ -35,6 +35,9 @@ export type SnapshotsIndex = SnapshotsIndexMetadata & {
   snapshots: SnapshotMetadata[];
 };
 
+export type UploadSnapshotMetadata = Pick<SnapshotMetadata, 'l2BlockNumber' | 'l2BlockHash' | 'l1BlockNumber'> &
+  Pick<SnapshotsIndex, 'l1ChainId' | 'rollupVersion' | 'rollupAddress'>;
+
 export const SnapshotsIndexSchema = z.object({
   l1ChainId: z.number(),
   rollupVersion: z.number(),
@@ -56,3 +59,12 @@ export const SnapshotsIndexSchema = z.object({
     }),
   ),
 }) satisfies ZodFor<SnapshotsIndex>;
+
+export const UploadSnapshotMetadataSchema = z.object({
+  l2BlockNumber: z.number(),
+  l2BlockHash: z.string(),
+  l1BlockNumber: z.number(),
+  l1ChainId: z.number(),
+  rollupVersion: z.number(),
+  rollupAddress: schemas.EthAddress,
+}) satisfies ZodFor<UploadSnapshotMetadata>;

package/src/snapshots/upload.ts

@@ -1,41 +1,49 @@
 import { fromEntries, getEntries, pick } from '@aztec/foundation/collection';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { isoDate } from '@aztec/foundation/string';
 import type { FileStore } from '@aztec/stdlib/file-store';
 
 import { getBasePath, getSnapshotIndex, getSnapshotIndexPath } from './download.js';
-import type { SnapshotDataKeys, SnapshotMetadata, SnapshotsIndex } from './types.js';
+import type { SnapshotDataKeys, SnapshotMetadata, SnapshotsIndex, UploadSnapshotMetadata } from './types.js';
 
-export type UploadSnapshotMetadata = Pick<SnapshotMetadata, 'l2BlockNumber' | 'l2BlockHash' | 'l1BlockNumber'> &
-  Pick<SnapshotsIndex, 'l1ChainId' | 'rollupVersion' | 'rollupAddress'>;
-
-export async function uploadSnapshot(
+export async function uploadSnapshotData(
   localPaths: Record<SnapshotDataKeys, string>,
   schemaVersions: SnapshotMetadata['schemaVersions'],
   metadata: UploadSnapshotMetadata,
   store: FileStore,
+  opts: { pathFor?: (key: SnapshotDataKeys) => string; private?: boolean } = {},
 ): Promise<SnapshotMetadata> {
   const timestamp = Date.now();
-  const date = new Date().toISOString().replace(/[-:T]/g, '').replace(/\..+$/, '');
+  const date = isoDate();
   const basePath = getBasePath(metadata);
-  const targetPathFor = (key: SnapshotDataKeys) => `${basePath}/${key}-${date}-${metadata.l2BlockHash}.db`;
+  const targetPathFor =
+    opts.pathFor ?? ((key: SnapshotDataKeys) => `${basePath}/${key}-${date}-${metadata.l2BlockHash}.db`);
 
   const dataUrls = fromEntries(
     await Promise.all(
       getEntries(localPaths).map(
         async ([key, path]) =>
-          [key, await store.upload(targetPathFor(key), path, { compress: true, public: true })] as const,
+          [key, await store.upload(targetPathFor(key), path, { compress: true, public: !opts.private })] as const,
       ),
     ),
   );
 
-  const snapshotsIndex = (await getSnapshotIndex(metadata, store)) ?? createEmptyIndex(metadata);
-
-  const newSnapshotMetadata: SnapshotMetadata = {
+  return {
     ...pick(metadata, 'l1BlockNumber', 'l2BlockHash', 'l2BlockNumber'),
     schemaVersions,
     timestamp,
     dataUrls,
   };
+}
+
+export async function uploadSnapshotToIndex(
+  localPaths: Record<SnapshotDataKeys, string>,
+  schemaVersions: SnapshotMetadata['schemaVersions'],
+  metadata: UploadSnapshotMetadata,
+  store: FileStore,
+): Promise<SnapshotMetadata> {
+  const newSnapshotMetadata = await uploadSnapshotData(localPaths, schemaVersions, metadata, store);
+  const snapshotsIndex = (await getSnapshotIndex(metadata, store)) ?? createEmptyIndex(metadata);
   snapshotsIndex.snapshots.unshift(newSnapshotMetadata);
 
   await store.save(getSnapshotIndexPath(metadata), Buffer.from(jsonStringify(snapshotsIndex, true)), {

package/src/tests/factories.ts

@@ -4,7 +4,7 @@ import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AZTEC_MAX_EPOCH_DURATION,
   BLOBS_PER_BLOCK,
-  CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS,
+  CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
   FIELDS_PER_BLOB,
   FIXED_DA_GAS,
   FIXED_L2_GAS,
@@ -36,7 +36,7 @@ import {
   NUM_MSGS_PER_BASE_PARITY,
   PRIVATE_LOG_SIZE_IN_FIELDS,
   PUBLIC_DATA_TREE_HEIGHT,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+  PUBLIC_LOG_SIZE_IN_FIELDS,
   RECURSIVE_PROOF_LENGTH,
   TUBE_PROOF_LENGTH,
   VK_TREE_HEIGHT,
@@ -108,7 +108,7 @@ import {
   PrivateToRollupAccumulatedData,
   mergeAccumulatedData,
 } from '../kernel/index.js';
-import { LogHash, ScopedLogHash } from '../kernel/log_hash.js';
+import { CountedLogHash, LogHash, ScopedLogHash } from '../kernel/log_hash.js';
 import { NoteHash } from '../kernel/note_hash.js';
 import { Nullifier } from '../kernel/nullifier.js';
 import { PrivateCallRequest } from '../kernel/private_call_request.js';
@@ -117,7 +117,7 @@ import { PrivateLogData } from '../kernel/private_log_data.js';
 import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
 import { CountedPublicCallRequest, PublicCallRequest } from '../kernel/public_call_request.js';
 import { PublicKeys, computeAddress } from '../keys/index.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { PublicLog } from '../logs/public_log.js';
 import { L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
@@ -178,7 +178,11 @@ import { mockTx } from './mocks.js';
  * @returns A side effect object.
  */
 function makeLogHash(seed: number) {
-  return new LogHash(fr(seed), seed + 1, seed + 2);
+  return new LogHash(fr(seed), seed + 1);
+}
+
+function makeCountedLogHash(seed: number) {
+  return new CountedLogHash(makeLogHash(seed), seed + 0x10);
 }
 
 function makeScopedLogHash(seed: number) {
@@ -193,16 +197,8 @@ function makeNullifier(seed: number) {
   return new Nullifier(fr(seed), seed + 1, fr(seed + 2));
 }
 
-function makeContractClassLog(seed: number) {
-  // The '* 1' removes the 'Type instantiation is excessively deep and possibly infinite. ts(2589)' err
-  return new ContractClassLog(
-    makeAztecAddress(seed),
-    makeTuple(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS * 1, fr, seed + 1),
-  );
-}
-
 function makePrivateLog(seed: number) {
-  return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed));
+  return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed), PRIVATE_LOG_SIZE_IN_FIELDS);
 }
 
 function makePrivateLogData(seed: number) {
@@ -210,7 +206,11 @@ function makePrivateLogData(seed: number) {
 }
 
 function makePublicLog(seed: number) {
-  return new PublicLog(makeAztecAddress(seed), makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, fr, seed + 1));
+  return new PublicLog(
+    makeAztecAddress(seed),
+    makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, fr, seed + 1),
+    PUBLIC_LOG_SIZE_IN_FIELDS,
+  );
 }
 
 /**
@@ -548,6 +548,7 @@ export function makeTxRequest(seed = 1): TxRequest {
     functionData: new FunctionData(makeSelector(seed + 0x100), /*isPrivate=*/ true),
     argsHash: fr(seed + 0x200),
     txContext: makeTxContext(seed + 0x400),
+    salt: fr(seed + 0x500),
   });
 }
 
@@ -577,7 +578,7 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn
     publicTeardownCallRequest: makePublicCallRequest(seed + 0x800),
     l2ToL1Msgs: makeTuple(MAX_L2_TO_L1_MSGS_PER_CALL, makeL2ToL1Message, seed + 0x800),
     privateLogs: makeTuple(MAX_PRIVATE_LOGS_PER_CALL, makePrivateLogData, seed + 0x875),
-    contractClassLogsHashes: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeLogHash, seed + 0xa00),
+    contractClassLogsHashes: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeCountedLogHash, seed + 0xa00),
     startSideEffectCounter: fr(seed + 0x849),
     endSideEffectCounter: fr(seed + 0x850),
     historicalHeader: makeHeader(seed + 0xd00, undefined),
@@ -716,6 +717,7 @@ export function makeBlockRootOrBlockMergeRollupPublicInputs(
     globalVariables ?? makeGlobalVariables(seed + 0x400),
     globalVariables ?? makeGlobalVariables(seed + 0x500),
     fr(seed + 0x600),
+    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x650),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x700),
     fr(seed + 0x800),
     fr(seed + 0x801),
@@ -884,10 +886,13 @@ export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs {
     fr(seed + 0x300),
     fr(seed + 0x400),
     fr(seed + 0x500),
+    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x650),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x600),
     fr(seed + 0x700),
     fr(seed + 0x701),
     fr(seed + 0x702),
+    fr(seed + 0x703),
+    fr(seed + 0x704),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeBlockBlobPublicInputs(seed), 0x800),
   );
 }
@@ -1077,6 +1082,10 @@ function makePrivateTubeData(seed = 1, kernelPublicInputs?: PrivateToRollupKerne
   );
 }
 
+function makeContractClassLogFields(seed = 1) {
+  return new ContractClassLogFields(makeArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, fr, seed));
+}
+
 function makePrivateBaseRollupHints(seed = 1) {
   const start = makePartialStateReference(seed + 0x100);
 
@@ -1086,7 +1095,11 @@ function makePrivateBaseRollupHints(seed = 1) {
 
   const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
 
-  const contractClassLogsPreimages = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLog, seed + 0x800);
+  const contractClassLogsPreimages = makeTuple(
+    MAX_CONTRACT_CLASS_LOGS_PER_TX,
+    makeContractClassLogFields,
+    seed + 0x800,
+  );
 
   const constants = makeConstantRollupData(0x100);
 
@@ -1108,7 +1121,11 @@ function makePublicBaseRollupHints(seed = 1) {
 
   const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
 
-  const contractClassLogsPreimages = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLog, seed + 0x800);
+  const contractClassLogsPreimages = makeTuple(
+    MAX_CONTRACT_CLASS_LOGS_PER_TX,
+    makeContractClassLogFields,
+    seed + 0x800,
+  );
 
   const constants = makeConstantRollupData(0x100);
 

package/src/tests/mocks.ts

@@ -1,10 +1,13 @@
 import { MAX_ENQUEUED_CALLS_PER_TX } from '@aztec/constants';
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { times } from '@aztec/foundation/collection';
 import { Secp256k1Signer, randomBytes } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 
 import type { ContractArtifact } from '../abi/abi.js';
 import { AztecAddress } from '../aztec-address/index.js';
+import { L2Block } from '../block/l2_block.js';
+import type { PublishedL2Block } from '../block/published_l2_block.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
 import { SerializableContractInstance } from '../contract/contract_instance.js';
@@ -25,7 +28,14 @@ import { BlockProposal } from '../p2p/block_proposal.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
-import { BlockHeader, HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, Tx } from '../tx/index.js';
+import {
+  BlockHeader,
+  HashedValues,
+  PrivateCallExecutionResult,
+  PrivateExecutionResult,
+  StateReference,
+  Tx,
+} from '../tx/index.js';
 import { PublicSimulationOutput } from '../tx/public_simulation_output.js';
 import { TxSimulationResult, accumulatePrivateReturnValues } from '../tx/simulated_tx.js';
 import { TxEffect } from '../tx/tx_effect.js';
@@ -79,6 +89,10 @@ export const mockTx = async (
     feePayer,
     clientIvcProof = ClientIvcProof.empty(),
     maxPriorityFeesPerGas,
+    chainId = Fr.ZERO,
+    version = Fr.ZERO,
+    vkTreeRoot = Fr.ZERO,
+    protocolContractTreeRoot = Fr.ZERO,
   }: {
     numberOfNonRevertiblePublicCallRequests?: number;
     numberOfRevertiblePublicCallRequests?: number;
@@ -88,6 +102,10 @@ export const mockTx = async (
     feePayer?: AztecAddress;
     clientIvcProof?: ClientIvcProof;
     maxPriorityFeesPerGas?: GasFees;
+    chainId?: Fr;
+    version?: Fr;
+    vkTreeRoot?: Fr;
+    protocolContractTreeRoot?: Fr;
   } = {},
 ) => {
   const totalPublicCallRequests =
@@ -102,6 +120,10 @@ export const mockTx = async (
     maxPriorityFeesPerGas,
   });
   data.feePayer = feePayer ?? (await AztecAddress.random());
+  data.constants.txContext.chainId = chainId;
+  data.constants.txContext.version = version;
+  data.constants.vkTreeRoot = vkTreeRoot;
+  data.constants.protocolContractTreeRoot = protocolContractTreeRoot;
 
   const publicFunctionCalldata: HashedValues[] = [];
   if (!isForPublic) {
@@ -143,8 +165,8 @@ export const mockTx = async (
   return new Tx(data, clientIvcProof, [], publicFunctionCalldata);
 };
 
-export const mockTxForRollup = (seed = 1) =>
-  mockTx(seed, { numberOfNonRevertiblePublicCallRequests: 0, numberOfRevertiblePublicCallRequests: 0 });
+export const mockTxForRollup = (seed = 1, opts: Parameters<typeof mockTx>[1] = {}) =>
+  mockTx(seed, { ...opts, numberOfNonRevertiblePublicCallRequests: 0, numberOfRevertiblePublicCallRequests: 0 });
 
 const emptyPrivateCallExecutionResult = () =>
   new PrivateCallExecutionResult(
@@ -218,39 +240,76 @@ export interface MakeConsensusPayloadOptions {
   signer?: Secp256k1Signer;
   header?: BlockHeader;
   archive?: Fr;
+  stateReference?: StateReference;
   txHashes?: TxHash[];
+  txs?: Tx[];
 }
 
 const makeAndSignConsensusPayload = (
   domainSeparator: SignatureDomainSeparator,
   options?: MakeConsensusPayloadOptions,
 ) => {
+  const header = options?.header ?? makeHeader(1);
   const {
     signer = Secp256k1Signer.random(),
-    header = makeHeader(1),
     archive = Fr.random(),
+    stateReference = header.state,
     txHashes = [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
   } = options ?? {};
 
   const payload = ConsensusPayload.fromFields({
-    header,
+    header: header.toPropose(),
     archive,
+    stateReference,
     txHashes,
   });
 
   const hash = getHashedSignaturePayloadEthSignedMessage(payload, domainSeparator);
   const signature = signer.sign(hash);
 
-  return { payload, signature };
+  return { blockNumber: header.globalVariables.blockNumber, payload, signature };
 };
 
 export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockProposal => {
-  const { payload, signature } = makeAndSignConsensusPayload(SignatureDomainSeparator.blockProposal, options);
-  return new BlockProposal(payload, signature);
+  const { blockNumber, payload, signature } = makeAndSignConsensusPayload(
+    SignatureDomainSeparator.blockProposal,
+    options,
+  );
+  return new BlockProposal(blockNumber, payload, signature, options?.txs ?? []);
 };
 
 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)
 export const makeBlockAttestation = (options?: MakeConsensusPayloadOptions): BlockAttestation => {
-  const { payload, signature } = makeAndSignConsensusPayload(SignatureDomainSeparator.blockAttestation, options);
-  return new BlockAttestation(payload, signature);
+  const { blockNumber, payload, signature } = makeAndSignConsensusPayload(
+    SignatureDomainSeparator.blockAttestation,
+    options,
+  );
+  return new BlockAttestation(blockNumber, payload, signature);
 };
+
+export async function randomPublishedL2Block(
+  l2BlockNumber: number,
+  opts: { signers?: Secp256k1Signer[] } = {},
+): Promise<PublishedL2Block> {
+  const block = await L2Block.random(l2BlockNumber);
+  const l1 = {
+    blockNumber: BigInt(block.number),
+    timestamp: block.header.globalVariables.timestamp.toBigInt(),
+    blockHash: Buffer32.random().toString(),
+  };
+
+  const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
+  const attestations = await Promise.all(
+    signers.map(signer =>
+      makeBlockAttestation({
+        signer,
+        header: block.header,
+        archive: block.archive.root,
+        stateReference: block.header.state,
+        txHashes: block.body.txEffects.map(tx => tx.txHash),
+      }),
+    ),
+  );
+  const signatures = attestations.map(attestation => attestation.signature);
+  return { block, l1, signatures };
+}

package/src/tx/block_header.ts

@@ -12,6 +12,7 @@ import { z } from 'zod';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { ContentCommitment } from './content_commitment.js';
 import { GlobalVariables } from './global_variables.js';
+import { ProposedBlockHeader } from './proposed_block_header.js';
 import { StateReference } from './state_reference.js';
 
 /** A header of an L2 block. */
@@ -64,8 +65,8 @@ export class BlockHeader {
     return this.globalVariables.slotNumber.toBigInt();
   }
 
-  getBlockNumber(): number {
-    return Number(this.globalVariables.blockNumber.toBigInt());
+  getBlockNumber() {
+    return this.globalVariables.blockNumber.toNumber();
   }
 
   getSize() {
@@ -160,6 +161,19 @@ export class BlockHeader {
     return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
   }
 
+  toPropose(): ProposedBlockHeader {
+    return new ProposedBlockHeader(
+      this.lastArchive.root,
+      this.contentCommitment,
+      this.globalVariables.slotNumber,
+      this.globalVariables.timestamp.toBigInt(),
+      this.globalVariables.coinbase,
+      this.globalVariables.feeRecipient,
+      this.globalVariables.gasFees,
+      this.totalManaUsed,
+    );
+  }
+
   toInspect() {
     return {
       lastArchive: this.lastArchive.root.toString(),