@aztec/stdlib 0.87.6 → 1.0.0-nightly.20250604

package/src/kernel/private_to_avm_accumulated_data.ts

@@ -22,6 +22,7 @@ import { z } from 'zod';
 
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import type { UInt32 } from '../types/shared.js';
+import { countAccumulatedItems } from './utils/index.js';
 
 export class PrivateToAvmAccumulatedData {
   constructor(
@@ -55,6 +56,14 @@ export class PrivateToAvmAccumulatedData {
     );
   }
 
+  getArrayLengths() {
+    return new PrivateToAvmAccumulatedDataArrayLengths(
+      countAccumulatedItems(this.noteHashes),
+      countAccumulatedItems(this.nullifiers),
+      countAccumulatedItems(this.l2ToL1Msgs),
+    );
+  }
+
   static getFields(fields: FieldsOf<PrivateToAvmAccumulatedData>) {
     return [fields.noteHashes, fields.nullifiers, fields.l2ToL1Msgs] as const;
   }

package/src/kernel/public_call_request.ts

@@ -123,6 +123,72 @@ export class PublicCallRequest {
   }
 }
 
+/**
+ * Represents lengths of arrays of public call requests.
+ */
+export class PublicCallRequestArrayLengths {
+  constructor(
+    /**
+     * Number of setup call requests
+     */
+    public setupCalls: number,
+    /**
+     * Number of app logic call requests
+     */
+    public appLogicCalls: number,
+    /**
+     * Whether there is a teardown call request
+     */
+    public teardownCall: boolean,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        setupCalls: z.number(),
+        appLogicCalls: z.number(),
+        teardownCall: z.boolean(),
+      })
+      .transform(({ setupCalls, appLogicCalls, teardownCall }) => {
+        return new PublicCallRequestArrayLengths(setupCalls, appLogicCalls, teardownCall);
+      });
+  }
+
+  static getFields(fields: FieldsOf<PublicCallRequestArrayLengths>) {
+    return [fields.setupCalls, fields.appLogicCalls, fields.teardownCall] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): PublicCallRequestArrayLengths {
+    const reader = FieldReader.asReader(fields);
+    return new PublicCallRequestArrayLengths(reader.readU32(), reader.readU32(), reader.readBoolean());
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...PublicCallRequestArrayLengths.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicCallRequestArrayLengths(reader.readNumber(), reader.readNumber(), reader.readBoolean());
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PublicCallRequestArrayLengths.getFields(this));
+  }
+
+  static empty() {
+    return new PublicCallRequestArrayLengths(0, 0, false);
+  }
+
+  [inspect.custom]() {
+    return `PublicCallRequestArrayLengths {
+      setupCalls: ${this.setupCalls}
+      appLogicCalls: ${this.appLogicCalls}
+      teardownCall: ${this.teardownCall}
+    }`;
+  }
+}
+
 export class CountedPublicCallRequest {
   constructor(
     public inner: PublicCallRequest,

package/src/logs/contract_class_log.ts

@@ -96,8 +96,6 @@ export class ContractClassLogFields {
 
 export class ContractClassLog {
   static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_LENGTH;
-  // Keeps original first field pre-siloing. Only set by silo().
-  public unsiloedFirstField?: Fr | undefined;
 
   constructor(
     public contractAddress: AztecAddress,
@@ -180,40 +178,6 @@ export class ContractClassLog {
     );
   }
 
-  setUnsiloedFirstField(field: Fr) {
-    this.unsiloedFirstField = field;
-  }
-
-  toUnsiloed() {
-    if (this.contractAddress.isZero()) {
-      return this;
-    }
-    if (this.unsiloedFirstField) {
-      return new ContractClassLog(
-        this.contractAddress,
-        new ContractClassLogFields([this.unsiloedFirstField].concat(this.fields.fields.slice(1))),
-        this.emittedLength,
-      );
-    } else {
-      return this;
-    }
-  }
-
-  // TODO(#13914): Don't need to silo the contract class logs.
-  async silo() {
-    if (this.contractAddress.isZero()) {
-      return this;
-    }
-
-    const fields = this.fields.clone();
-    const unsiloedField = fields.fields[0];
-    const siloedField = await poseidon2Hash([this.contractAddress, unsiloedField]);
-    fields.fields[0] = siloedField;
-    const cloned = new ContractClassLog(this.contractAddress, fields, this.emittedLength);
-    cloned.setUnsiloedFirstField(unsiloedField);
-    return cloned;
-  }
-
   async hash() {
     return await this.fields.hash();
   }

package/src/logs/log_with_tx_data.ts

@@ -1,33 +1,47 @@
-import { MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN, PUBLIC_LOG_PLAINTEXT_LEN } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { TxHash } from '@aztec/stdlib/tx';
 
-// TypeScript representation of the Noir aztec::oracle::message_discovery::LogWithTxData struct. This is used as a
-// response for PXE's custom getLogByTag oracle.
-export class LogWithTxData {
+// TypeScript representation of the Noir aztec::oracle::message_processing::LogWithTxData<N> struct. This is used as a
+// response for PXE's custom getPublicLogByTag and getPrivateLogByTag oracles.
+class LogWithTxData<N extends number> {
   constructor(
-    // The emitted fields of a log.
-    // For public logs, the contract address is prepended to the content.
-    public logContent: Fr[],
+    public logPayload: Fr[],
     public txHash: TxHash,
     public uniqueNoteHashesInTx: Fr[],
     public firstNullifierInTx: Fr,
+    private maxLogContentLength: N,
   ) {}
 
   toNoirSerialization(): (Fr | Fr[])[] {
     return [
-      // The log fields length is PUBLIC_LOG_SIZE_IN_FIELDS. + 1 because the contract address is prepended to the content.
-      // This is only used for public logs currently, so the maxLength is PUBLIC_LOG_SIZE_IN_FIELDS + 1.
-      // TODO(#11639): this could also be used for private logs.
-      ...toBoundedVecSerialization(this.logContent, PUBLIC_LOG_SIZE_IN_FIELDS + 1),
+      ...toBoundedVecSerialization(this.logPayload, this.maxLogContentLength),
       this.txHash.hash,
       ...toBoundedVecSerialization(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
       this.firstNullifierInTx,
     ];
   }
+}
+
+// This is used as a response for PXE's custom getPublicLogByTag oracle.
+export class PublicLogWithTxData extends LogWithTxData<typeof PUBLIC_LOG_PLAINTEXT_LEN> {
+  constructor(logContent: Fr[], txHash: TxHash, uniqueNoteHashesInTx: Fr[], firstNullifierInTx: Fr) {
+    super(logContent, txHash, uniqueNoteHashesInTx, firstNullifierInTx, PUBLIC_LOG_PLAINTEXT_LEN);
+  }
+
+  static noirSerializationOfEmpty(): (Fr | Fr[])[] {
+    return new PublicLogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();
+  }
+}
+
+// This is used as a response for PXE's custom getPrivateLogByTag oracle.
+export class PrivateLogWithTxData extends LogWithTxData<typeof PRIVATE_LOG_CIPHERTEXT_LEN> {
+  constructor(logContent: Fr[], txHash: TxHash, uniqueNoteHashesInTx: Fr[], firstNullifierInTx: Fr) {
+    super(logContent, txHash, uniqueNoteHashesInTx, firstNullifierInTx, PRIVATE_LOG_CIPHERTEXT_LEN);
+  }
 
   static noirSerializationOfEmpty(): (Fr | Fr[])[] {
-    return new LogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();
+    return new PrivateLogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();
   }
 }
 

package/src/logs/private_log.ts

@@ -44,6 +44,10 @@ export class PrivateLog {
     return this.fields.slice(0, this.emittedLength);
   }
 
+  getEmittedFieldsWithoutTag() {
+    return this.fields.slice(1, this.emittedLength);
+  }
+
   toBlobFields(): Fr[] {
     return [new Fr(this.emittedLength)].concat(this.getEmittedFields());
   }

package/src/logs/public_log.ts

@@ -50,6 +50,10 @@ export class PublicLog {
     return this.fields.slice(0, this.emittedLength);
   }
 
+  getEmittedFieldsWithoutTag() {
+    return this.fields.slice(1, this.emittedLength);
+  }
+
   toBlobFields(): Fr[] {
     return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
   }

package/src/logs/tx_scoped_l2_log.ts

@@ -6,6 +6,7 @@ import { TxHash } from '../tx/tx_hash.js';
 import { PrivateLog } from './private_log.js';
 import { PublicLog } from './public_log.js';
 
+// TODO(#14460): Split to private and public versions instead of having this weird mix.
 export class TxScopedL2Log {
   constructor(
     /*

package/src/messaging/index.ts

@@ -4,3 +4,4 @@ export * from './l1_to_l2_message_source.js';
 export * from './l1_actor.js';
 export * from './l2_actor.js';
 export * from './l2_to_l1_message.js';
+export * from './l2_to_l1_membership.js';

package/src/messaging/l2_to_l1_membership.ts

@@ -0,0 +1,113 @@
+import { SHA256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { MerkleTreeCalculator, SiblingPath, UnbalancedMerkleTreeCalculator } from '@aztec/foundation/trees';
+
+export interface MessageRetrieval {
+  getL2ToL1Messages(l2BlockNumber: number): Promise<Fr[][] | undefined>;
+}
+
+export type L2ToL1MembershipWitness = {
+  l2MessageIndex: bigint;
+  siblingPath: SiblingPath<number>;
+};
+
+export async function computeL2ToL1MembershipWitness(
+  messageRetriever: MessageRetrieval,
+  l2BlockNumber: number,
+  message: Fr,
+): Promise<L2ToL1MembershipWitness | undefined> {
+  const messagesPerTx = await messageRetriever.getL2ToL1Messages(l2BlockNumber);
+  if (!messagesPerTx) {
+    return undefined;
+  }
+
+  // Find index of message in subtree and index of tx in a block
+  let messageIndexInTx = -1,
+    txIndex = -1;
+  {
+    txIndex = messagesPerTx.findIndex(messages => {
+      const idx = messages.findIndex(msg => msg.equals(message));
+      messageIndexInTx = Math.max(messageIndexInTx, idx);
+      return idx !== -1;
+    });
+  }
+
+  if (txIndex === -1) {
+    throw new Error('The L2ToL1Message you are trying to prove inclusion of does not exist');
+  }
+
+  const hasher = new SHA256Trunc();
+
+  // Get the message path in subtree and message subtree height
+  let messagePathInSubtree: SiblingPath<number>;
+  let messageSubtreeHeight: number;
+  {
+    const txMessages = messagesPerTx[txIndex];
+    messageSubtreeHeight = txMessages.length <= 1 ? 1 : Math.ceil(Math.log2(txMessages.length));
+    const calculator: MerkleTreeCalculator = await MerkleTreeCalculator.create(
+      messageSubtreeHeight,
+      Buffer.alloc(32, 0), // Zero leaf
+      (lhs: Buffer, rhs: Buffer) => Promise.resolve(hasher.hash(lhs, rhs)),
+    );
+
+    const tree = await calculator.computeTree(txMessages.map(msg => msg.toBuffer()));
+    const tempPath = tree.getSiblingPath(messageIndexInTx);
+    messagePathInSubtree = new SiblingPath(tempPath.length, tempPath);
+  }
+
+  // If the number of txs is 1 we are dealing with a special case where the tx subtree itself is the whole block's
+  // l2 to l1 message tree.
+  const numTransactions = messagesPerTx.length;
+  if (numTransactions === 1) {
+    return {
+      l2MessageIndex: BigInt(messageIndexInTx),
+      siblingPath: messagePathInSubtree,
+    };
+  }
+
+  // Calculate roots for all tx subtrees
+  const txSubtreeRoots = await Promise.all(
+    messagesPerTx.map(async (messages, _) => {
+      // For a tx with no messages, we have to set an out hash of 0 to match what the circuit does.
+      if (messages.length === 0) {
+        return Fr.ZERO;
+      }
+
+      const txTreeHeight = messages.length <= 1 ? 1 : Math.ceil(Math.log2(messages.length));
+      const calculator: MerkleTreeCalculator = await MerkleTreeCalculator.create(
+        txTreeHeight,
+        Buffer.alloc(32, 0), // Zero leaf
+        (lhs: Buffer, rhs: Buffer) => Promise.resolve(hasher.hash(lhs, rhs)),
+      );
+
+      const root = await calculator.computeTreeRoot(messages.map(msg => msg.toBuffer()));
+      return Fr.fromBuffer(root);
+    }),
+  );
+
+  // Construct the top tree and compute the combined path
+  let combinedPath: Buffer[];
+  {
+    const topTreeHeight = Math.ceil(Math.log2(txSubtreeRoots.length));
+    // The root of this tree is the out_hash calculated in Noir => we truncate to match Noir's SHA
+    const topTree = UnbalancedMerkleTreeCalculator.create(topTreeHeight, (lhs: Buffer, rhs: Buffer) =>
+      Promise.resolve(hasher.hash(lhs, rhs)),
+    );
+    await topTree.appendLeaves(txSubtreeRoots.map(f => f.toBuffer()));
+
+    const txPathInTopTree = await topTree.getSiblingPath(txSubtreeRoots[txIndex].toBigInt());
+    // Append subtree path to top tree path
+    combinedPath = messagePathInSubtree.toBufferArray().concat(txPathInTopTree.toBufferArray());
+  }
+
+  // Append binary index of subtree path to binary index of top tree path
+  const combinedIndex = parseInt(
+    txIndex.toString(2).concat(messageIndexInTx.toString(2).padStart(messageSubtreeHeight, '0')),
+    2,
+  );
+
+  return {
+    l2MessageIndex: BigInt(combinedIndex),
+    siblingPath: new SiblingPath(combinedPath.length, combinedPath),
+  };
+}

package/src/p2p/consensus_payload.ts

@@ -107,6 +107,8 @@ export class ConsensusPayload implements Signable {
   }
 
   toString() {
-    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}, txHashes: ${this.txHashes.join(', ')}`;
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}, txHashes: ${this.txHashes.join(
+      ', ',
+    )}`;
   }
 }

package/src/rollup/avm_proof_data.ts

@@ -1,15 +1,16 @@
-import { AVM_PROOF_LENGTH_IN_FIELDS } from '@aztec/constants';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
 import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
-import { VkWitnessData } from '../vks/vk_witness_data.js';
+import { VkData } from '../vks/vk_data.js';
 
 export class AvmProofData {
   constructor(
     public publicInputs: AvmCircuitPublicInputs,
-    public proof: RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>,
-    public vkData: VkWitnessData,
+    public proof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>,
+    public vkData: VkData,
   ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -17,7 +18,7 @@ export class AvmProofData {
     return new AvmProofData(
       reader.readObject(AvmCircuitPublicInputs),
       RecursiveProof.fromBuffer(reader),
-      reader.readObject(VkWitnessData),
+      reader.readObject(VkData),
     );
   }
 
@@ -28,8 +29,14 @@ export class AvmProofData {
   static empty() {
     return new AvmProofData(
       AvmCircuitPublicInputs.empty(),
-      makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
-      VkWitnessData.empty(),
+      makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
+      VkData.empty(),
     );
   }
 }
+
+// TODO(#14234)[Unconditional PIs validation]: remove this function.
+export function enhanceProofWithPiValidationFlag(proof: Fr[], skipPublicInputsValidation: boolean): Fr[] {
+  const skipPublicInputsField = skipPublicInputsValidation ? new Fr(1) : new Fr(0);
+  return [skipPublicInputsField].concat(proof).slice(0, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
+}

package/src/rollup/base_rollup_hints.ts

@@ -39,7 +39,7 @@ export class PrivateBaseRollupHints {
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
-    public contractClassLogsPreimages: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsFields: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Data which is not modified by the base rollup circuit.
      */
@@ -57,7 +57,7 @@ export class PrivateBaseRollupHints {
       fields.stateDiffHints,
       fields.feePayerFeeJuiceBalanceReadHint,
       fields.archiveRootMembershipWitness,
-      fields.contractClassLogsPreimages,
+      fields.contractClassLogsFields,
       fields.constants,
     ] as const;
   }
@@ -121,7 +121,7 @@ export class PublicBaseRollupHints {
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
-    public contractClassLogsPreimages: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsFields: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Data which is not modified by the base rollup circuit.
      */
@@ -136,7 +136,7 @@ export class PublicBaseRollupHints {
     return [
       fields.startSpongeBlob,
       fields.archiveRootMembershipWitness,
-      fields.contractClassLogsPreimages,
+      fields.contractClassLogsFields,
       fields.constants,
     ] as const;
   }

package/src/rollup/previous_rollup_block_data.ts

@@ -1,9 +1,8 @@
-import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { MembershipWitness } from '@aztec/foundation/trees';
 
 import { RecursiveProof } from '../proofs/recursive_proof.js';
-import { VerificationKeyAsFields } from '../vks/verification_key.js';
+import { VkData } from '../vks/index.js';
 import { BlockRootOrBlockMergePublicInputs } from './block_root_or_block_merge_public_inputs.js';
 
 /**
@@ -20,13 +19,9 @@ export class PreviousRollupBlockData {
      */
     public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
     /**
-     * The verification key of the block merge or block root rollup circuit.
+     * The verification key and the witness of the vk in the vk tree.
      */
-    public vk: VerificationKeyAsFields,
-    /**
-     * Sibling path of the rollup circuit's vk in a big tree of rollup circuit vks.
-     */
-    public vkWitness: MembershipWitness<typeof VK_TREE_HEIGHT>,
+    public vkData: VkData,
   ) {}
 
   /**
@@ -34,7 +29,7 @@ export class PreviousRollupBlockData {
    * @returns The buffer of the serialized previous rollup data.
    */
   public toBuffer(): Buffer {
-    return serializeToBuffer(this.blockRootOrBlockMergePublicInputs, this.proof, this.vk, this.vkWitness);
+    return serializeToBuffer(this.blockRootOrBlockMergePublicInputs, this.proof, this.vkData);
   }
 
   /**
@@ -47,8 +42,7 @@ export class PreviousRollupBlockData {
     return new PreviousRollupBlockData(
       reader.readObject(BlockRootOrBlockMergePublicInputs),
       RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      reader.readObject(VerificationKeyAsFields),
-      MembershipWitness.fromBuffer(reader, VK_TREE_HEIGHT),
+      reader.readObject(VkData),
     );
   }
 }

package/src/rollup/previous_rollup_data.ts

@@ -1,9 +1,8 @@
-import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { MembershipWitness } from '@aztec/foundation/trees';
 
 import { RecursiveProof } from '../proofs/recursive_proof.js';
-import { VerificationKeyAsFields } from '../vks/verification_key.js';
+import { VkData } from '../vks/index.js';
 import { BaseOrMergeRollupPublicInputs } from './base_or_merge_rollup_public_inputs.js';
 
 /**
@@ -20,13 +19,9 @@ export class PreviousRollupData {
      */
     public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
     /**
-     * The verification key of the base or merge rollup circuit.
+     * The verification key and the witness of the vk in the vk tree.
      */
-    public vk: VerificationKeyAsFields,
-    /**
-     * Sibling path of the rollup circuit's vk in a big tree of rollup circuit vks.
-     */
-    public vkWitness: MembershipWitness<typeof VK_TREE_HEIGHT>,
+    public vkData: VkData,
   ) {}
 
   /**
@@ -34,7 +29,7 @@ export class PreviousRollupData {
    * @returns The buffer of the serialized previous rollup data.
    */
   public toBuffer(): Buffer {
-    return serializeToBuffer(this.baseOrMergeRollupPublicInputs, this.proof, this.vk, this.vkWitness);
+    return serializeToBuffer(this.baseOrMergeRollupPublicInputs, this.proof, this.vkData);
   }
 
   /**
@@ -47,8 +42,7 @@ export class PreviousRollupData {
     return new PreviousRollupData(
       reader.readObject(BaseOrMergeRollupPublicInputs),
       RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      reader.readObject(VerificationKeyAsFields),
-      MembershipWitness.fromBuffer(reader, VK_TREE_HEIGHT),
+      reader.readObject(VkData),
     );
   }
 }

package/src/rollup/private_tube_data.ts

@@ -3,20 +3,20 @@ 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 { VkWitnessData } from '../vks/vk_witness_data.js';
+import { VkData } from '../vks/index.js';
 
 export class PrivateTubeData {
   constructor(
     public publicInputs: PrivateToRollupKernelCircuitPublicInputs,
     public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
-    public vkData: VkWitnessData,
+    public vkData: VkData,
   ) {}
 
   static empty() {
     return new PrivateTubeData(
       PrivateToRollupKernelCircuitPublicInputs.empty(),
       makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      VkWitnessData.empty(),
+      VkData.empty(),
     );
   }
 
@@ -25,7 +25,7 @@ export class PrivateTubeData {
     return new PrivateTubeData(
       reader.readObject(PrivateToRollupKernelCircuitPublicInputs),
       RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      reader.readObject(VkWitnessData),
+      reader.readObject(VkData),
     );
   }
 

package/src/rollup/public_tube_data.ts

@@ -3,20 +3,20 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
-import { VkWitnessData } from '../vks/vk_witness_data.js';
+import { VkData } from '../vks/index.js';
 
 export class PublicTubeData {
   constructor(
     public publicInputs: PrivateToPublicKernelCircuitPublicInputs,
     public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
-    public vkData: VkWitnessData,
+    public vkData: VkData,
   ) {}
 
   static empty() {
     return new PublicTubeData(
       PrivateToPublicKernelCircuitPublicInputs.empty(),
       makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      VkWitnessData.empty(),
+      VkData.empty(),
     );
   }
 
@@ -25,7 +25,7 @@ export class PublicTubeData {
     return new PublicTubeData(
       reader.readObject(PrivateToPublicKernelCircuitPublicInputs),
       RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      reader.readObject(VkWitnessData),
+      reader.readObject(VkData),
     );
   }
 

package/src/rollup/root_rollup.ts

@@ -7,7 +7,6 @@ import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { FeeRecipient } from './block_root_or_block_merge_public_inputs.js';
 import { PreviousRollupBlockData } from './previous_rollup_block_data.js';
 
@@ -100,13 +99,10 @@ export class RootRollupInputs {
  */
 export class RootRollupPublicInputs {
   constructor(
-    /** Snapshot of archive tree before/after this rollup been processed */
-    public previousArchive: AppendOnlyTreeSnapshot,
-    public endArchive: AppendOnlyTreeSnapshot,
-    // This is a u64 in nr, but GlobalVariables contains this as a u64 and is mapped to ts as a field, so I'm doing the same here
-    public endTimestamp: Fr,
-    public endBlockNumber: Fr,
-    public outHash: Fr,
+    /** Root of the archive tree before this rollup is processed */
+    public previousArchiveRoot: Fr,
+    /** Root of the archive tree after this rollup is processed */
+    public endArchiveRoot: Fr,
     public proposedBlockHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
     public chainId: Fr,
@@ -119,11 +115,8 @@ export class RootRollupPublicInputs {
 
   static getFields(fields: FieldsOf<RootRollupPublicInputs>) {
     return [
-      fields.previousArchive,
-      fields.endArchive,
-      fields.endTimestamp,
-      fields.endBlockNumber,
-      fields.outHash,
+      fields.previousArchiveRoot,
+      fields.endArchiveRoot,
       fields.proposedBlockHeaderHashes,
       fields.fees,
       fields.chainId,
@@ -155,9 +148,6 @@ export class RootRollupPublicInputs {
   public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new RootRollupPublicInputs(
-      reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(AppendOnlyTreeSnapshot),
-      Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
@@ -192,9 +182,6 @@ export class RootRollupPublicInputs {
   /** Creates a random instance. */
   static random() {
     return new RootRollupPublicInputs(
-      AppendOnlyTreeSnapshot.random(),
-      AppendOnlyTreeSnapshot.random(),
-      Fr.random(),
       Fr.random(),
       Fr.random(),
       makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),