@aztec/stdlib 3.0.0-nightly.20250908 → 3.0.0-nightly.20250911

package/src/kernel/private_kernel_prover_output.ts

@@ -45,7 +45,7 @@ export interface PrivateKernelExecutionProofOutput<
   /** The public inputs used by the proof generation process. */
   publicInputs: PublicInputsType;
   /** The private IVC proof optimized for user devices. It will be consumed by an Aztec prover,
-   * which recursively verifies it through the "tube" circuit.*/
+   * which recursively verifies it through the "private tx base" or the "public tube" circuit.*/
   clientIvcProof: ClientIvcProof;
   /**
    * The trace the clientIvcProof corresponds to.

package/src/kernel/private_to_public_kernel_circuit_public_inputs.ts

@@ -1,6 +1,7 @@
 import { GeneratorIndex, PRIVATE_TO_PUBLIC_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import type { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -93,4 +94,12 @@ export class PrivateToPublicKernelCircuitPublicInputs {
   hash() {
     return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.PUBLIC_TX_HASH);
   }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(PrivateToPublicKernelCircuitPublicInputs);
+  }
 }

package/src/noir/index.ts

@@ -87,6 +87,15 @@ export interface NoirCompiledCircuit {
   abi: NoirFunctionAbi;
   /** The bytecode of the circuit in base64. */
   bytecode: string;
+  /** The verification key of the circuit. */
+  verificationKey: {
+    /** hex-encoded binary */
+    bytes: string;
+    /** list of hex-encoded fields */
+    fields: string[];
+    /** The hex-encoded hash. */
+    hash: string;
+  };
   /** The debug information, compressed and base64 encoded. */
   debug_symbols: string;
   /** The map of file ID to the source code and path of the file. */

package/src/p2p/block_attestation.ts

@@ -98,6 +98,10 @@ export class BlockAttestation extends Gossipable {
     return new BlockAttestation(0, ConsensusPayload.empty(), Signature.empty());
   }
 
+  static random(): BlockAttestation {
+    return new BlockAttestation(Math.floor(Math.random() * 1000) + 1, ConsensusPayload.random(), Signature.random());
+  }
+
   getSize(): number {
     return 4 /* blockNumber */ + this.payload.getSize() + this.signature.getSize();
   }

package/src/p2p/block_proposal.ts

@@ -5,7 +5,7 @@ import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import type { BlockInfo } from '../block/l2_block.js';
+import type { L2BlockInfo } from '../block/l2_block_info.js';
 import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
 import type { UInt32 } from '../types/index.js';
@@ -71,11 +71,13 @@ export class BlockProposal extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
-  toBlockInfo(): BlockInfo {
+  toBlockInfo(): L2BlockInfo {
     return {
       blockNumber: this.blockNumber,
       slotNumber: this.slotNumber.toNumber(),
-      archive: this.archive.toString(),
+      lastArchive: this.payload.header.lastArchiveRoot,
+      timestamp: this.payload.header.timestamp,
+      archive: this.archive,
       txCount: this.txHashes.length,
     };
   }

package/src/p2p/consensus_payload.ts

@@ -60,18 +60,17 @@ export class ConsensusPayload implements Signable {
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.header, this.archive, this.stateReference]);
-    this.size = buffer.length;
-    return buffer;
+    return serializeToBuffer([this.header, this.archive, this.stateReference]);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    return new ConsensusPayload(
+    const payload = new ConsensusPayload(
       reader.readObject(ProposedBlockHeader),
       reader.readObject(Fr),
       reader.readObject(StateReference),
     );
+    return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
@@ -86,6 +85,10 @@ export class ConsensusPayload implements Signable {
     return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty());
   }
 
+  static random(): ConsensusPayload {
+    return new ConsensusPayload(ProposedBlockHeader.random(), Fr.random(), StateReference.random());
+  }
+
   /**
    * Get the size of the consensus payload in bytes.
    * @returns The size of the consensus payload.

package/src/p2p/signature_utils.ts

@@ -4,6 +4,7 @@ import { keccak256, makeEthSignDigest } from '@aztec/foundation/crypto';
 export enum SignatureDomainSeparator {
   blockProposal = 0,
   blockAttestation = 1,
+  attestationsAndSigners = 2,
 }
 
 export interface Signable {

package/src/proofs/client_ivc_proof.ts

@@ -1,35 +1,33 @@
+import { CIVC_PROOF_LENGTH } from '@aztec/constants';
 import { randomBytes } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-const CLIENT_IVC_PROOF_LENGTH = 172052;
-
-/**
- * TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370) refactor this to
- * eventually we read all these VKs from the data tree instead of passing them
- */
 export class ClientIvcProof {
   constructor(
-    // produced by the sequencer when making the tube proof
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370): Need to precompute private kernel tail VK so we can verify this immediately in the tx pool
-    // which parts of these are needed to quickly verify that we have a correct IVC proof
-    public clientIvcProofBuffer: Buffer,
+    // The proof fields with public inputs.
+    // For recursive verification, the public inputs (at the front of the array) must be removed.
+    public proof: Fr[],
   ) {}
 
   public isEmpty() {
-    return this.clientIvcProofBuffer.length === 0;
+    return this.proof.length === 0;
   }
 
   static empty() {
-    return new ClientIvcProof(Buffer.from(''));
-  }
-
-  static fake(fill = Math.floor(Math.random() * 255)) {
-    return new ClientIvcProof(Buffer.alloc(1, fill));
+    return new ClientIvcProof([]);
   }
 
-  static random() {
-    return new ClientIvcProof(Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)));
+  static random(proofSize = CIVC_PROOF_LENGTH) {
+    // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
+    const reducedFrSize = Fr.SIZE_IN_BYTES - 1;
+    const randomFields = randomBytes(proofSize * reducedFrSize);
+    const proof = Array.from(
+      { length: proofSize },
+      (_, i) => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize)),
+    );
+    return new ClientIvcProof(proof);
   }
 
   static get schema() {
@@ -42,10 +40,18 @@ export class ClientIvcProof {
 
   static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProof {
     const reader = BufferReader.asReader(buffer);
-    return new ClientIvcProof(reader.readBuffer());
+    const proofLength = reader.readNumber();
+    const proof = reader.readArray(proofLength, Fr);
+    return new ClientIvcProof(proof);
   }
 
   public toBuffer() {
-    return serializeToBuffer(this.clientIvcProofBuffer.length, this.clientIvcProofBuffer);
+    return serializeToBuffer(this.proof.length, this.proof);
+  }
+
+  // Called when constructing a ClientIvcProof from proving results.
+  static fromBufferArray(fields: Uint8Array[]): ClientIvcProof {
+    const proof = fields.map(field => Fr.fromBuffer(Buffer.from(field)));
+    return new ClientIvcProof(proof);
   }
 }

package/src/proofs/index.ts

@@ -1,4 +1,5 @@
 export * from './recursive_proof.js';
 export * from './client_ivc_proof.js';
 export * from './proof.js';
+export * from './proof_data.js';
 export * from './proving_request_type.js';

package/src/proofs/proof_data.ts

@@ -0,0 +1,39 @@
+import type { CIVC_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { BufferReader, type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { VkData } from '../vks/index.js';
+
+/**
+ * Represents the data of a recursive proof.
+ */
+export class ProofData<T extends Bufferable, PROOF_LENGTH extends number> {
+  constructor(
+    public publicInputs: T,
+    public proof: RecursiveProof<PROOF_LENGTH>,
+    public vkData: VkData,
+  ) {}
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
+  }
+
+  public static fromBuffer<T extends Bufferable, PROOF_LENGTH extends number>(
+    buffer: Buffer | BufferReader,
+    publicInputs: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+    proofLength?: PROOF_LENGTH,
+  ): ProofData<T, PROOF_LENGTH> {
+    const reader = BufferReader.asReader(buffer);
+    return new ProofData(
+      reader.readObject(publicInputs),
+      RecursiveProof.fromBuffer(reader, proofLength),
+      reader.readObject(VkData),
+    );
+  }
+}
+
+export type CivcProofData<T extends Bufferable> = ProofData<T, typeof CIVC_PROOF_LENGTH>;
+
+export type RollupHonkProofData<T extends Bufferable> = ProofData<T, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;

package/src/proofs/proving_request_type.ts

@@ -1,6 +1,6 @@
 export enum ProvingRequestType {
   PUBLIC_VM,
-
+  PUBLIC_TUBE,
   PRIVATE_BASE_ROLLUP,
   PUBLIC_BASE_ROLLUP,
   MERGE_ROLLUP,
@@ -13,6 +13,4 @@ export enum ProvingRequestType {
 
   BASE_PARITY,
   ROOT_PARITY,
-  /** Recursive Client IVC verification to connect private to public or rollup */
-  TUBE_PROOF,
 }

package/src/rollup/index.ts

@@ -12,9 +12,7 @@ export * from './padding_block_root_rollup_inputs.js';
 export * from './previous_rollup_block_data.js';
 export * from './previous_rollup_data.js';
 export * from './private_base_rollup_inputs.js';
-export * from './private_tube_data.js';
 export * from './public_base_rollup_inputs.js';
-export * from './public_tube_data.js';
+export * from './public_tube_private_inputs.js';
 export * from './root_rollup.js';
 export * from './state_diff_hints.js';
-export * from './tube_inputs.js';

package/src/rollup/private_base_rollup_inputs.ts

@@ -3,12 +3,13 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
+import { type CivcProofData, ProofData } from '../proofs/proof_data.js';
 import { PrivateBaseRollupHints } from './base_rollup_hints.js';
-import { PrivateTubeData } from './private_tube_data.js';
 
 export class PrivateBaseRollupInputs {
   constructor(
-    public tubeData: PrivateTubeData,
+    public hidingKernelProofData: CivcProofData<PrivateToRollupKernelCircuitPublicInputs>,
     public hints: PrivateBaseRollupHints,
   ) {}
 
@@ -17,12 +18,15 @@ export class PrivateBaseRollupInputs {
   }
 
   static getFields(fields: FieldsOf<PrivateBaseRollupInputs>) {
-    return [fields.tubeData, fields.hints] as const;
+    return [fields.hidingKernelProofData, fields.hints] as const;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): PrivateBaseRollupInputs {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateBaseRollupInputs(reader.readObject(PrivateTubeData), reader.readObject(PrivateBaseRollupHints));
+    return new PrivateBaseRollupInputs(
+      ProofData.fromBuffer(reader, PrivateToRollupKernelCircuitPublicInputs),
+      reader.readObject(PrivateBaseRollupHints),
+    );
   }
 
   toBuffer() {
@@ -37,10 +41,6 @@ export class PrivateBaseRollupInputs {
     return bufferToHex(this.toBuffer());
   }
 
-  static empty() {
-    return new PrivateBaseRollupInputs(PrivateTubeData.empty(), PrivateBaseRollupHints.empty());
-  }
-
   /** Returns a buffer representation for JSON serialization. */
   toJSON() {
     return this.toBuffer();

package/src/rollup/public_base_rollup_inputs.ts

@@ -3,13 +3,14 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
 import { AvmProofData } from './avm_proof_data.js';
 import { PublicBaseRollupHints } from './base_rollup_hints.js';
-import { PublicTubeData } from './public_tube_data.js';
 
 export class PublicBaseRollupInputs {
   constructor(
-    public tubeData: PublicTubeData,
+    public publicTubeProofData: RollupHonkProofData<PrivateToPublicKernelCircuitPublicInputs>,
     public avmProofData: AvmProofData,
     public hints: PublicBaseRollupHints,
   ) {}
@@ -19,13 +20,13 @@ export class PublicBaseRollupInputs {
   }
 
   static getFields(fields: FieldsOf<PublicBaseRollupInputs>) {
-    return [fields.tubeData, fields.avmProofData, fields.hints] as const;
+    return [fields.publicTubeProofData, fields.avmProofData, fields.hints] as const;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): PublicBaseRollupInputs {
     const reader = BufferReader.asReader(buffer);
     return new PublicBaseRollupInputs(
-      reader.readObject(PublicTubeData),
+      ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs),
       reader.readObject(AvmProofData),
       reader.readObject(PublicBaseRollupHints),
     );
@@ -43,10 +44,6 @@ export class PublicBaseRollupInputs {
     return bufferToHex(this.toBuffer());
   }
 
-  static empty() {
-    return new PublicBaseRollupInputs(PublicTubeData.empty(), AvmProofData.empty(), PublicBaseRollupHints.empty());
-  }
-
   /** Returns a representation for JSON serialization. */
   toJSON() {
     return this.toBuffer();

package/src/rollup/public_tube_private_inputs.ts

@@ -0,0 +1,46 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
+import { type CivcProofData, ProofData } from '../proofs/proof_data.js';
+
+export class PublicTubePrivateInputs {
+  constructor(public hidingKernelProofData: CivcProofData<PrivateToPublicKernelCircuitPublicInputs>) {}
+
+  static from(fields: FieldsOf<PublicTubePrivateInputs>) {
+    return new PublicTubePrivateInputs(...PublicTubePrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PublicTubePrivateInputs>) {
+    return [fields.hidingKernelProofData] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicTubePrivateInputs(ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PublicTubePrivateInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PublicTubePrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(PublicTubePrivateInputs);
+  }
+}

package/src/stats/stats.ts

@@ -88,6 +88,7 @@ export type ClientCircuitName =
 export type ServerCircuitName =
   | 'base-parity'
   | 'root-parity'
+  | 'public-tube'
   | 'private-base-rollup'
   | 'public-base-rollup'
   | 'merge-rollup'
@@ -97,8 +98,7 @@ export type ServerCircuitName =
   | 'padding-block-root-rollup'
   | 'block-merge-rollup'
   | 'root-rollup'
-  | 'avm-circuit'
-  | 'tube-circuit';
+  | 'avm-circuit';
 
 export type CircuitName = ClientCircuitName | ServerCircuitName;
 

package/src/tests/factories.ts

@@ -5,6 +5,7 @@ import {
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   AZTEC_MAX_EPOCH_DURATION,
   BLOBS_PER_BLOCK,
+  CIVC_PROOF_LENGTH,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
   FIELDS_PER_BLOB,
   FIXED_DA_GAS,
@@ -41,7 +42,7 @@ import {
   PUBLIC_DATA_TREE_HEIGHT,
   PUBLIC_LOG_SIZE_IN_FIELDS,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
+  RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   VK_TREE_HEIGHT,
 } from '@aztec/constants';
 import { type FieldsOf, makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
@@ -131,6 +132,7 @@ import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import { RootParityInput } from '../parity/root_parity_input.js';
 import { RootParityInputs } from '../parity/root_parity_inputs.js';
 import { Proof } from '../proofs/proof.js';
+import { ProofData } from '../proofs/proof_data.js';
 import { ProvingRequestType } from '../proofs/proving_request_type.js';
 import { makeRecursiveProof } from '../proofs/recursive_proof.js';
 import { AvmProofData } from '../rollup/avm_proof_data.js';
@@ -151,9 +153,7 @@ import { MergeRollupInputs } from '../rollup/merge_rollup.js';
 import { PreviousRollupBlockData } from '../rollup/previous_rollup_block_data.js';
 import { PreviousRollupData } from '../rollup/previous_rollup_data.js';
 import { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
-import { PrivateTubeData } from '../rollup/private_tube_data.js';
 import { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
-import { PublicTubeData } from '../rollup/public_tube_data.js';
 import { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
 import { PrivateBaseStateDiffHints } from '../rollup/state_diff_hints.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
@@ -412,7 +412,7 @@ export function makePrivateKernelTailCircuitPublicInputs(
   );
 }
 
-function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
+export function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
   return new PrivateToPublicKernelCircuitPublicInputs(
     makeTxConstantData(seed),
     makePrivateToPublicAccumulatedData(seed + 0x200),
@@ -1083,10 +1083,14 @@ function makeVkData(seed = 1) {
   return new VkData(VerificationKeyData.makeFakeHonk(), seed, makeTuple(VK_TREE_HEIGHT, fr, seed + 0x100));
 }
 
-function makePrivateTubeData(seed = 1, kernelPublicInputs?: PrivateToRollupKernelCircuitPublicInputs) {
-  return new PrivateTubeData(
-    kernelPublicInputs ?? makePrivateToRollupKernelCircuitPublicInputs(seed, true),
-    makeRecursiveProof<typeof TUBE_PROOF_LENGTH>(TUBE_PROOF_LENGTH, seed + 0x100),
+export function makeProofData<T extends Bufferable, PROOF_LENGTH extends number>(
+  seed = 0,
+  makePublicInputs: (seed: number) => T,
+  proofSize: PROOF_LENGTH = NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH as PROOF_LENGTH,
+) {
+  return new ProofData(
+    makePublicInputs(seed),
+    makeRecursiveProof<PROOF_LENGTH>(proofSize, seed + 0x100),
     makeVkData(seed + 0x200),
   );
 }
@@ -1131,23 +1135,12 @@ function makePublicBaseRollupHints(seed = 1) {
 }
 
 export function makePrivateBaseRollupInputs(seed = 0) {
-  const tubeData = makePrivateTubeData(seed);
-  const hints = makePrivateBaseRollupHints(seed + 0x100);
-
   return PrivateBaseRollupInputs.from({
-    tubeData,
-    hints,
+    hidingKernelProofData: makeProofData(seed, makePrivateToRollupKernelCircuitPublicInputs, CIVC_PROOF_LENGTH),
+    hints: makePrivateBaseRollupHints(seed + 0x100),
   });
 }
 
-function makePublicTubeData(seed = 1) {
-  return new PublicTubeData(
-    makePrivateToPublicKernelCircuitPublicInputs(seed),
-    makeRecursiveProof<typeof TUBE_PROOF_LENGTH>(TUBE_PROOF_LENGTH, seed + 0x100),
-    makeVkData(seed + 0x200),
-  );
-}
-
 function makeAvmProofData(seed = 1) {
   return new AvmProofData(
     makeAvmCircuitPublicInputs(seed),
@@ -1157,12 +1150,16 @@ function makeAvmProofData(seed = 1) {
 }
 
 export function makePublicBaseRollupInputs(seed = 0) {
-  const tubeData = makePublicTubeData(seed);
+  const publicTubeProofData = makeProofData(
+    seed,
+    makePrivateToPublicKernelCircuitPublicInputs,
+    RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  );
   const avmProofData = makeAvmProofData(seed + 0x100);
   const hints = makePublicBaseRollupHints(seed + 0x200);
 
   return PublicBaseRollupInputs.from({
-    tubeData,
+    publicTubeProofData,
     avmProofData,
     hints,
   });

package/src/tests/mocks.ts

@@ -6,9 +6,10 @@ import { Fr } from '@aztec/foundation/fields';
 
 import type { ContractArtifact } from '../abi/abi.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { CommitteeAttestation } from '../block/index.js';
+import { CommitteeAttestation, L1PublishedData } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
-import type { PublishedL2Block } from '../block/published_l2_block.js';
+import type { CommitteeAttestationsAndSigners } from '../block/proposal/attestations_and_signers.js';
+import { 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';
@@ -88,7 +89,7 @@ export const mockTx = async (
     hasPublicTeardownCallRequest = false,
     publicCalldataSize = 2,
     feePayer,
-    clientIvcProof = ClientIvcProof.empty(),
+    clientIvcProof = ClientIvcProof.random(),
     maxPriorityFeesPerGas,
     chainId = Fr.ZERO,
     version = Fr.ZERO,
@@ -273,6 +274,17 @@ const makeAndSignConsensusPayload = (
   return { blockNumber: header.globalVariables.blockNumber, payload, signature };
 };
 
+export const makeAndSignCommitteeAttestationsAndSigners = (
+  attestationsAndSigners: CommitteeAttestationsAndSigners,
+  signer: Secp256k1Signer = Secp256k1Signer.random(),
+) => {
+  const hash = getHashedSignaturePayloadEthSignedMessage(
+    attestationsAndSigners,
+    SignatureDomainSeparator.attestationsAndSigners,
+  );
+  return signer.sign(hash);
+};
+
 export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockProposal => {
   const { blockNumber, payload, signature } = makeAndSignConsensusPayload(
     SignatureDomainSeparator.blockProposal,
@@ -306,16 +318,16 @@ export async function randomPublishedL2Block(
   opts: { signers?: Secp256k1Signer[] } = {},
 ): Promise<PublishedL2Block> {
   const block = await L2Block.random(l2BlockNumber);
-  const l1 = {
+  const l1 = L1PublishedData.fromFields({
     blockNumber: BigInt(block.number),
     timestamp: block.header.globalVariables.timestamp,
     blockHash: Buffer32.random().toString(),
-  };
+  });
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
   const atts = await Promise.all(signers.map(signer => makeBlockAttestationFromBlock(block, signer)));
   const attestations = atts.map(
     (attestation, i) => new CommitteeAttestation(signers[i].address, attestation.signature),
   );
-  return { block, l1, attestations };
+  return new PublishedL2Block(block, l1, attestations);
 }

package/src/tx/content_commitment.ts

@@ -75,6 +75,10 @@ export class ContentCommitment {
     return new ContentCommitment(reader.readField(), reader.readField(), reader.readField());
   }
 
+  static random(): ContentCommitment {
+    return new ContentCommitment(Fr.random(), Fr.random(), Fr.random());
+  }
+
   static empty(): ContentCommitment {
     return new ContentCommitment(Fr.zero(), Fr.zero(), Fr.zero());
   }

package/src/tx/partial_state_reference.ts

@@ -64,6 +64,14 @@ export class PartialStateReference {
     );
   }
 
+  static random(): PartialStateReference {
+    return new PartialStateReference(
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+    );
+  }
+
   toViem(): ViemPartialStateReference {
     return {
       noteHashTree: this.noteHashTree.toViem(),

package/src/tx/proposed_block_header.ts

@@ -116,6 +116,19 @@ export class ProposedBlockHeader {
     });
   }
 
+  static random(): ProposedBlockHeader {
+    return new ProposedBlockHeader(
+      Fr.random(),
+      ContentCommitment.random(),
+      new Fr(BigInt(Math.floor(Math.random() * 1000) + 1)),
+      BigInt(Math.floor(Date.now() / 1000)),
+      EthAddress.random(),
+      new AztecAddress(Fr.random()),
+      GasFees.random(),
+      new Fr(BigInt(Math.floor(Math.random() * 1000000))),
+    );
+  }
+
   isEmpty(): boolean {
     return (
       this.lastArchiveRoot.isZero() &&

package/src/tx/state_reference.ts

@@ -78,6 +78,10 @@ export class StateReference {
     return new StateReference(AppendOnlyTreeSnapshot.empty(), PartialStateReference.empty());
   }
 
+  static random(): StateReference {
+    return new StateReference(AppendOnlyTreeSnapshot.random(), PartialStateReference.random());
+  }
+
   toViem(): ViemStateReference {
     return {
       l1ToL2MessageTree: this.l1ToL2MessageTree.toViem(),