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

package/src/interfaces/server_circuit_prover.ts

@@ -3,10 +3,10 @@ import type {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 
 import type { AvmCircuitInputs } from '../avm/avm.js';
+import type { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import type { BaseParityInputs } from '../parity/base_parity_inputs.js';
 import type { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import type { RootParityInputs } from '../parity/root_parity_inputs.js';
@@ -15,12 +15,11 @@ import type { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
 import type { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
 import type { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
 import type { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
-import type { PaddingBlockRootRollupInputs } from '../rollup/index.js';
+import type { PaddingBlockRootRollupInputs, PublicTubePrivateInputs } from '../rollup/index.js';
 import type { MergeRollupInputs } from '../rollup/merge_rollup.js';
 import type { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
 import type { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
 import type { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
-import type { TubeInputs } from '../rollup/tube_inputs.js';
 import type { Tx } from '../tx/tx.js';
 import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from './proving-job.js';
 
@@ -48,6 +47,17 @@ export interface ServerCircuitProver {
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
 
+  getPublicTubeProof(
+    inputs: PublicTubePrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<
+      PrivateToPublicKernelCircuitPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >
+  >;
+
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
@@ -68,16 +78,6 @@ export interface ServerCircuitProver {
     PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
-  /**
-   * Get a recursively verified client IVC proof (making it a compatible honk proof for the rest of the rollup).
-   * @param input - Input to the circuit.
-   */
-  getTubeProof(
-    tubeInput: TubeInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>;
-
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.

package/src/interfaces/validator.ts

@@ -1,5 +1,6 @@
 import type { SecretValue } from '@aztec/foundation/config';
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import type { SequencerConfig, SlasherConfig } from '@aztec/stdlib/interfaces/server';
@@ -9,6 +10,8 @@ import type { ProposedBlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
 import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
 
+import type { CommitteeAttestationsAndSigners } from '../block/index.js';
+
 /**
  * Validator client configuration
  */
@@ -67,4 +70,8 @@ export interface Validator {
 
   broadcastBlockProposal(proposal: BlockProposal): Promise<void>;
   collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
+  signAttestationsAndSigners(
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    proposer: EthAddress,
+  ): Promise<Signature>;
 }

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/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

@@ -8,6 +8,7 @@ import type { ContractArtifact } from '../abi/abi.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { CommitteeAttestation } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
+import type { CommitteeAttestationsAndSigners } from '../block/proposal/attestations_and_signers.js';
 import type { PublishedL2Block } from '../block/published_l2_block.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.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,

package/src/tx/tx.ts

@@ -38,7 +38,6 @@ export class Tx extends Gossipable {
     public readonly data: PrivateKernelTailCircuitPublicInputs,
     /**
      * Proof from the private kernel circuit.
-     * TODO(#7368): This client IVC object currently contains various VKs that will eventually be more like static data.
      */
     public readonly clientIvcProof: ClientIvcProof,
     /**
@@ -238,7 +237,7 @@ export class Tx extends Gossipable {
       classPublishedCount: this.data.getNonEmptyContractClassLogsHashes().length,
       contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
 
-      proofSize: this.clientIvcProof.clientIvcProofBuffer.length,
+      proofSize: this.clientIvcProof.proof.length,
       size: this.toBuffer().length,
 
       feePaymentMethod:
@@ -250,7 +249,7 @@ export class Tx extends Gossipable {
   getSize() {
     return (
       this.data.getSize() +
-      this.clientIvcProof.clientIvcProofBuffer.length +
+      this.clientIvcProof.proof.length * Fr.SIZE_IN_BYTES +
       arraySerializedSizeOfNonEmpty(this.contractClassLogFields) +
       this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.getSize(), 0)
     );

package/dest/rollup/private_tube_data.d.ts

@@ -1,15 +0,0 @@
-import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
-import { BufferReader } from '@aztec/foundation/serialize';
-import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
-import { RecursiveProof } from '../proofs/recursive_proof.js';
-import { VkData } from '../vks/index.js';
-export declare class PrivateTubeData {
-    publicInputs: PrivateToRollupKernelCircuitPublicInputs;
-    proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
-    vkData: VkData;
-    constructor(publicInputs: PrivateToRollupKernelCircuitPublicInputs, proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>, vkData: VkData);
-    static empty(): PrivateTubeData;
-    static fromBuffer(buffer: Buffer | BufferReader): PrivateTubeData;
-    toBuffer(): Buffer<ArrayBufferLike>;
-}
-//# sourceMappingURL=private_tube_data.d.ts.map

package/dest/rollup/private_tube_data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"private_tube_data.d.ts","sourceRoot":"","sources":["../../src/rollup/private_tube_data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,wCAAwC,EAAE,MAAM,6DAA6D,CAAC;AACvH,OAAO,EAAE,cAAc,EAA2B,MAAM,8BAA8B,CAAC;AACvF,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,qBAAa,eAAe;IAEjB,YAAY,EAAE,wCAAwC;IACtD,KAAK,EAAE,cAAc,CAAC,OAAO,yCAAyC,CAAC;IACvE,MAAM,EAAE,MAAM;gBAFd,YAAY,EAAE,wCAAwC,EACtD,KAAK,EAAE,cAAc,CAAC,OAAO,yCAAyC,CAAC,EACvE,MAAM,EAAE,MAAM;IAGvB,MAAM,CAAC,KAAK;IAQZ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAS/C,QAAQ;CAGT"}

package/dest/rollup/private_tube_data.js

@@ -1,25 +0,0 @@
-import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
-import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
-import { VkData } from '../vks/index.js';
-export class PrivateTubeData {
-    publicInputs;
-    proof;
-    vkData;
-    constructor(publicInputs, proof, vkData){
-        this.publicInputs = publicInputs;
-        this.proof = proof;
-        this.vkData = vkData;
-    }
-    static empty() {
-        return new PrivateTubeData(PrivateToRollupKernelCircuitPublicInputs.empty(), makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VkData.empty());
-    }
-    static fromBuffer(buffer) {
-        const reader = BufferReader.asReader(buffer);
-        return new PrivateTubeData(reader.readObject(PrivateToRollupKernelCircuitPublicInputs), RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), reader.readObject(VkData));
-    }
-    toBuffer() {
-        return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
-    }
-}