@aztec/stdlib 0.87.7 → 1.0.0-nightly.20250604

package/src/interfaces/p2p.ts

@@ -44,7 +44,7 @@ export interface P2PApiWithoutAttestations {
   getPeers(includePending?: boolean): Promise<PeerInfo[]>;
 }
 
-export interface P2PClient extends P2PApiWithoutAttestations {
+export interface P2PApiWithAttestations extends P2PApiWithoutAttestations {
   /**
    * Queries the Attestation pool for attestations for the given slot
    *
@@ -53,13 +53,19 @@ export interface P2PClient extends P2PApiWithoutAttestations {
    * @returns BlockAttestations
    */
   getAttestationsForSlot(slot: bigint, proposalId?: string): Promise<BlockAttestation[]>;
+}
 
+export interface P2PClient extends P2PApiWithAttestations {
   /** Manually adds an attestation to the p2p client attestation pool. */
-  addAttestation(attestation: BlockAttestation): Promise<void>;
+  addAttestations(attestations: BlockAttestation[]): Promise<void>;
 }
 
 export type P2PApi<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
-  ? P2PClient & P2PApiWithoutAttestations
+  ? P2PApiWithAttestations
+  : P2PApiWithoutAttestations;
+
+export type P2PApiFull<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
+  ? P2PApiWithAttestations & P2PClient
   : P2PApiWithoutAttestations;
 
 export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
@@ -71,5 +77,4 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
   getPendingTxCount: z.function().returns(schemas.Integer),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
-  addAttestation: z.function().args(BlockAttestation.schema).returns(z.void()),
 };

package/src/interfaces/proving-job.ts

@@ -1,5 +1,5 @@
 import {
-  AVM_PROOF_LENGTH_IN_FIELDS,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -179,7 +179,7 @@ export type ProvingJobInputsMap = {
 export const ProvingJobResult = z.discriminatedUnion('type', [
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_VM),
-    result: schemaForRecursiveProofAndVerificationKey(AVM_PROOF_LENGTH_IN_FIELDS),
+    result: schemaForRecursiveProofAndVerificationKey(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
   }),
   z.object({
     type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP),
@@ -249,7 +249,7 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
 ]);
 export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
-  [ProvingRequestType.PUBLIC_VM]: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>;
+  [ProvingRequestType.PUBLIC_VM]: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
   [ProvingRequestType.PRIVATE_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
     BaseOrMergeRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH

package/src/interfaces/server_circuit_prover.ts

@@ -1,5 +1,5 @@
 import type {
-  AVM_PROOF_LENGTH_IN_FIELDS,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -149,9 +149,10 @@ export interface ServerCircuitProver {
    */
   getAvmProof(
     inputs: AvmCircuitInputs,
+    skipPublicInputsValidation?: boolean, // TODO(#14234)[Unconditional PIs validation]: Remove.
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>>;
+  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;
 }
 
 /**

package/src/kernel/hints/find_private_kernel_reset_dimensions.ts

@@ -148,9 +148,9 @@ export function findPrivateKernelResetDimensions(
     ? isEnough
     : // If isInner is true, it's a reset to prevent overflow. The following must be zero because siloing can't be done at the moment.
       (dimensions: PrivateKernelResetDimensions) =>
-        dimensions.NOTE_HASH_SILOING_AMOUNT === 0 &&
-        dimensions.NULLIFIER_SILOING_AMOUNT === 0 &&
-        dimensions.PRIVATE_LOG_SILOING_AMOUNT === 0 &&
+        dimensions.NOTE_HASH_SILOING === 0 &&
+        dimensions.NULLIFIER_SILOING === 0 &&
+        dimensions.PRIVATE_LOG_SILOING === 0 &&
         isEnough(dimensions);
 
   const options = [

package/src/kernel/hints/key_validation_hint.ts

@@ -5,20 +5,18 @@ export class KeyValidationHint {
   constructor(
     /** Master secret key used to derive sk_app and pk_m. */
     public skM: GrumpkinScalar,
-    /** Index of the request in the array of hints. */
-    public requestIndex: number,
   ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new KeyValidationHint(reader.readObject(GrumpkinScalar), reader.readNumber());
+    return new KeyValidationHint(reader.readObject(GrumpkinScalar));
   }
 
   toBuffer() {
-    return serializeToBuffer(this.skM, this.requestIndex);
+    return serializeToBuffer(this.skM);
   }
 
-  static nada(keyValidationRequestLen: number) {
-    return new KeyValidationHint(GrumpkinScalar.zero(), keyValidationRequestLen);
+  static empty() {
+    return new KeyValidationHint(GrumpkinScalar.zero());
   }
 }

package/src/kernel/hints/private_kernel_reset_hints.ts

@@ -10,8 +10,8 @@ export class PrivateKernelResetHints<
   NH_RR_SETTLED extends number,
   NLL_RR_PENDING extends number,
   NLL_RR_SETTLED extends number,
-  KEY_VALIDATION_REQUESTS extends number,
-  NUM_TRANSIENT_DATA_INDEX_HINTS extends number,
+  KEY_VALIDATION_HINTS_LEN extends number,
+  TRANSIENT_DATA_HINTS_LEN extends number,
 > {
   constructor(
     /**
@@ -25,11 +25,11 @@ export class PrivateKernelResetHints<
     /**
      * Contains hints for key validation request.
      */
-    public keyValidationHints: Tuple<KeyValidationHint, KEY_VALIDATION_REQUESTS>,
+    public keyValidationHints: Tuple<KeyValidationHint, KEY_VALIDATION_HINTS_LEN>,
     /**
      * Contains hints for the transient note hashes to locate corresponding nullifiers.
      */
-    public transientDataIndexHints: Tuple<TransientDataIndexHint, NUM_TRANSIENT_DATA_INDEX_HINTS>,
+    public transientDataIndexHints: Tuple<TransientDataIndexHint, TRANSIENT_DATA_HINTS_LEN>,
     /**
      * The "final" minRevertibleSideEffectCounter of a tx, to split the data for squashing.
      * Not the minRevertibleSideEffectCounter at the point the reset circuit is run.
@@ -47,39 +47,30 @@ export class PrivateKernelResetHints<
     );
   }
 
-  trimToSizes<
-    NEW_NH_RR_PENDING extends number,
-    NEW_NH_RR_SETTLED extends number,
-    NEW_NLL_RR_PENDING extends number,
-    NEW_NLL_RR_SETTLED extends number,
-    NEW_KEY_VALIDATION_REQUESTS extends number,
-    NUM_TRANSIENT_DATA_INDEX_HINTS extends number,
-  >(
-    numNoteHashReadRequestPending: NEW_NH_RR_PENDING,
-    numNoteHashReadRequestSettled: NEW_NH_RR_SETTLED,
-    numNullifierReadRequestPending: NEW_NLL_RR_PENDING,
-    numNullifierReadRequestSettled: NEW_NLL_RR_SETTLED,
-    numKeyValidationRequests: NEW_KEY_VALIDATION_REQUESTS,
-    numTransientDataIndexHints: NUM_TRANSIENT_DATA_INDEX_HINTS,
-  ): PrivateKernelResetHints<
-    NEW_NH_RR_PENDING,
-    NEW_NH_RR_SETTLED,
-    NEW_NLL_RR_PENDING,
-    NEW_NLL_RR_SETTLED,
-    NEW_KEY_VALIDATION_REQUESTS,
-    NUM_TRANSIENT_DATA_INDEX_HINTS
-  > {
+  trimToSizes(
+    numNoteHashReadRequestPending: number,
+    numNoteHashReadRequestSettled: number,
+    numNullifierReadRequestPending: number,
+    numNullifierReadRequestSettled: number,
+    numKeyValidationHints: number,
+    numTransientDataIndexHints: number,
+  ) {
+    // Noir does not allow empty arrays. So we make the minimum array size 1.
+    // There is a constant for each dimension, coded in the circuit that indicates how many hints should be applied.
+    // The circuit is selected based on the dimension sizes, not the hint array sizes created here.
+    const useSize = (num: number) => Math.max(num, 1);
+
     return new PrivateKernelResetHints(
-      this.noteHashReadRequestHints.trimToSizes(numNoteHashReadRequestPending, numNoteHashReadRequestSettled),
-      this.nullifierReadRequestHints.trimToSizes(numNullifierReadRequestPending, numNullifierReadRequestSettled),
-      this.keyValidationHints.slice(0, numKeyValidationRequests) as Tuple<
-        KeyValidationHint,
-        NEW_KEY_VALIDATION_REQUESTS
-      >,
-      this.transientDataIndexHints.slice(0, numTransientDataIndexHints) as Tuple<
-        TransientDataIndexHint,
-        NUM_TRANSIENT_DATA_INDEX_HINTS
-      >,
+      this.noteHashReadRequestHints.trimToSizes(
+        useSize(numNoteHashReadRequestPending),
+        useSize(numNoteHashReadRequestSettled),
+      ),
+      this.nullifierReadRequestHints.trimToSizes(
+        useSize(numNullifierReadRequestPending),
+        useSize(numNullifierReadRequestSettled),
+      ),
+      this.keyValidationHints.slice(0, useSize(numKeyValidationHints)),
+      this.transientDataIndexHints.slice(0, useSize(numTransientDataIndexHints)),
       this.validationRequestsSplitCounter,
     );
   }
@@ -93,23 +84,23 @@ export class PrivateKernelResetHints<
     NH_RR_SETTLED extends number,
     NLL_RR_PENDING extends number,
     NLL_RR_SETTLED extends number,
-    KEY_VALIDATION_REQUESTS extends number,
-    NUM_TRANSIENT_DATA_INDEX_HINTS extends number,
+    KEY_VALIDATION_HINTS_LEN extends number,
+    TRANSIENT_DATA_HINTS_LEN extends number,
   >(
     buffer: Buffer | BufferReader,
     numNoteHashReadRequestPending: NH_RR_PENDING,
     numNoteHashReadRequestSettled: NH_RR_SETTLED,
     numNullifierReadRequestPending: NLL_RR_PENDING,
     numNullifierReadRequestSettled: NLL_RR_SETTLED,
-    numNullifierKeys: KEY_VALIDATION_REQUESTS,
-    numTransientDataIndexHints: NUM_TRANSIENT_DATA_INDEX_HINTS,
+    numKeyValidationHints: KEY_VALIDATION_HINTS_LEN,
+    numTransientDataIndexHints: TRANSIENT_DATA_HINTS_LEN,
   ): PrivateKernelResetHints<
     NH_RR_PENDING,
     NH_RR_SETTLED,
     NLL_RR_PENDING,
     NLL_RR_SETTLED,
-    KEY_VALIDATION_REQUESTS,
-    NUM_TRANSIENT_DATA_INDEX_HINTS
+    KEY_VALIDATION_HINTS_LEN,
+    TRANSIENT_DATA_HINTS_LEN
   > {
     const reader = BufferReader.asReader(buffer);
     return new PrivateKernelResetHints(
@@ -121,7 +112,7 @@ export class PrivateKernelResetHints<
         fromBuffer: buf =>
           nullifierReadRequestHintsFromBuffer(buf, numNullifierReadRequestPending, numNullifierReadRequestSettled),
       }),
-      reader.readArray(numNullifierKeys, KeyValidationHint),
+      reader.readArray(numKeyValidationHints, KeyValidationHint),
       reader.readArray(numTransientDataIndexHints, TransientDataIndexHint),
       reader.readNumber(),
     );

package/src/kernel/hints/read_request_hints.ts

@@ -94,8 +94,8 @@ export class SettledReadHint<TREE_HEIGHT extends number, LEAF_PREIMAGE extends B
  */
 export class ReadRequestResetHints<
   READ_REQUEST_LEN extends number,
-  NUM_PENDING_READS extends number,
-  NUM_SETTLED_READS extends number,
+  PENDING_READ_HINTS_LEN extends number,
+  SETTLED_READ_HINTS_LEN extends number,
   TREE_HEIGHT extends number,
   LEAF_PREIMAGE extends Bufferable,
 > {
@@ -104,23 +104,29 @@ export class ReadRequestResetHints<
     /**
      * The hints for read requests reading pending values.
      */
-    public pendingReadHints: Tuple<PendingReadHint, NUM_PENDING_READS>,
+    public pendingReadHints: Tuple<PendingReadHint, PENDING_READ_HINTS_LEN>,
     /**
      * The hints for read requests reading settled values.
      */
-    public settledReadHints: Tuple<SettledReadHint<TREE_HEIGHT, LEAF_PREIMAGE>, NUM_SETTLED_READS>,
+    public settledReadHints: Tuple<SettledReadHint<TREE_HEIGHT, LEAF_PREIMAGE>, SETTLED_READ_HINTS_LEN>,
   ) {}
 
-  trimToSizes<NEW_NUM_PENDING_READS extends number, NEW_NUM_SETTLED_READS extends number>(
-    numPendingReads: NEW_NUM_PENDING_READS,
-    numSettledReads: NEW_NUM_SETTLED_READS,
-  ): ReadRequestResetHints<READ_REQUEST_LEN, NEW_NUM_PENDING_READS, NEW_NUM_SETTLED_READS, TREE_HEIGHT, LEAF_PREIMAGE> {
+  trimToSizes<NEW_PENDING_READ_HINTS_LEN extends number, NEW_SETTLED_READ_HINTS_LEN extends number>(
+    numPendingReads: NEW_PENDING_READ_HINTS_LEN,
+    numSettledReads: NEW_SETTLED_READ_HINTS_LEN,
+  ): ReadRequestResetHints<
+    READ_REQUEST_LEN,
+    NEW_PENDING_READ_HINTS_LEN,
+    NEW_SETTLED_READ_HINTS_LEN,
+    TREE_HEIGHT,
+    LEAF_PREIMAGE
+  > {
     return new ReadRequestResetHints(
       this.readRequestStatuses,
-      this.pendingReadHints.slice(0, numPendingReads) as Tuple<PendingReadHint, NEW_NUM_PENDING_READS>,
+      this.pendingReadHints.slice(0, numPendingReads) as Tuple<PendingReadHint, NEW_PENDING_READ_HINTS_LEN>,
       this.settledReadHints.slice(0, numSettledReads) as Tuple<
         SettledReadHint<TREE_HEIGHT, LEAF_PREIMAGE>,
-        NEW_NUM_SETTLED_READS
+        NEW_SETTLED_READ_HINTS_LEN
       >,
     );
   }
@@ -132,18 +138,24 @@ export class ReadRequestResetHints<
    */
   static fromBuffer<
     READ_REQUEST_LEN extends number,
-    NUM_PENDING_READS extends number,
-    NUM_SETTLED_READS extends number,
+    PENDING_READ_HINTS_LEN extends number,
+    SETTLED_READ_HINTS_LEN extends number,
     TREE_HEIGHT extends number,
     LEAF_PREIMAGE extends Bufferable,
   >(
     buffer: Buffer | BufferReader,
     readRequestLen: READ_REQUEST_LEN,
-    numPendingReads: NUM_PENDING_READS,
-    numSettledReads: NUM_SETTLED_READS,
+    numPendingReads: PENDING_READ_HINTS_LEN,
+    numSettledReads: SETTLED_READ_HINTS_LEN,
     treeHeight: TREE_HEIGHT,
     leafPreimageFromBuffer: { fromBuffer: (buffer: BufferReader) => LEAF_PREIMAGE },
-  ): ReadRequestResetHints<READ_REQUEST_LEN, NUM_PENDING_READS, NUM_SETTLED_READS, TREE_HEIGHT, LEAF_PREIMAGE> {
+  ): ReadRequestResetHints<
+    READ_REQUEST_LEN,
+    PENDING_READ_HINTS_LEN,
+    SETTLED_READ_HINTS_LEN,
+    TREE_HEIGHT,
+    LEAF_PREIMAGE
+  > {
     const reader = BufferReader.asReader(buffer);
     return new ReadRequestResetHints(
       reader.readArray(readRequestLen, ReadRequestStatus),

package/src/kernel/index.ts

@@ -28,3 +28,4 @@ export * from './private_call_request.js';
 export * from './private_validation_requests.js';
 export * from './private_kernel_simulated_output.js';
 export * from './private_kernel_prover_output.js';
+export * from './padded_side_effects.js';

package/src/kernel/padded_side_effects.ts

@@ -0,0 +1,73 @@
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { PrivateLog } from '../logs/index.js';
+
+export class PaddedSideEffects {
+  constructor(
+    public noteHashes: Tuple<Fr, typeof MAX_NOTE_HASHES_PER_TX>,
+    public nullifiers: Tuple<Fr, typeof MAX_NULLIFIERS_PER_TX>,
+    public privateLogs: Tuple<PrivateLog, typeof MAX_PRIVATE_LOGS_PER_TX>,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.noteHashes, this.nullifiers, this.privateLogs);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PaddedSideEffects(
+      reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
+      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readArray(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
+    );
+  }
+
+  static empty() {
+    return new PaddedSideEffects(
+      makeTuple(MAX_NOTE_HASHES_PER_TX, Fr.zero),
+      makeTuple(MAX_NULLIFIERS_PER_TX, Fr.zero),
+      makeTuple(MAX_PRIVATE_LOGS_PER_TX, PrivateLog.empty),
+    );
+  }
+}
+
+export class PaddedSideEffectAmounts {
+  constructor(
+    public nonRevertibleNoteHashes: number,
+    public revertibleNoteHashes: number,
+    public nonRevertibleNullifiers: number,
+    public revertibleNullifiers: number,
+    public nonRevertiblePrivateLogs: number,
+    public revertiblePrivateLogs: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.nonRevertibleNoteHashes,
+      this.revertibleNoteHashes,
+      this.nonRevertibleNullifiers,
+      this.revertibleNullifiers,
+      this.nonRevertiblePrivateLogs,
+      this.revertiblePrivateLogs,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PaddedSideEffectAmounts(
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+    );
+  }
+
+  static empty() {
+    return new PaddedSideEffectAmounts(0, 0, 0, 0, 0, 0);
+  }
+}

package/src/kernel/private_kernel_data.ts

@@ -1,10 +1,6 @@
-import { VK_TREE_HEIGHT } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import type { UInt32 } from '../types/shared.js';
-import { VerificationKeyData } from '../vks/verification_key.js';
+import { VkData } from '../vks/index.js';
 import { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_public_inputs.js';
 
 /**
@@ -19,17 +15,9 @@ export class PrivateKernelData {
      */
     public publicInputs: PrivateKernelCircuitPublicInputs,
     /**
-     * Verification key of the previous kernel.
+     * The verification key and the witness of the vk in the vk tree.
      */
-    public verificationKey: VerificationKeyData,
-    /**
-     * Index of the previous kernel's vk in a tree of vks.
-     */
-    public vkIndex: UInt32,
-    /**
-     * Sibling path of the previous kernel's vk in a tree of vks.
-     */
-    public vkPath: Tuple<Fr, typeof VK_TREE_HEIGHT>,
+    public vkData: VkData,
   ) {}
 
   /**
@@ -37,25 +25,15 @@ export class PrivateKernelData {
    * @returns The buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.publicInputs, this.verificationKey, this.vkIndex, this.vkPath);
+    return serializeToBuffer(this.publicInputs, this.vkData);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelData {
     const reader = BufferReader.asReader(buffer);
-    return new this(
-      reader.readObject(PrivateKernelCircuitPublicInputs),
-      reader.readObject(VerificationKeyData),
-      reader.readNumber(),
-      reader.readArray(VK_TREE_HEIGHT, Fr),
-    );
+    return new this(reader.readObject(PrivateKernelCircuitPublicInputs), reader.readObject(VkData));
   }
 
   static empty(): PrivateKernelData {
-    return new PrivateKernelData(
-      PrivateKernelCircuitPublicInputs.empty(),
-      VerificationKeyData.empty(),
-      0,
-      makeTuple(VK_TREE_HEIGHT, Fr.zero),
-    );
+    return new PrivateKernelData(PrivateKernelCircuitPublicInputs.empty(), VkData.empty());
   }
 }

package/src/kernel/private_kernel_reset_circuit_private_inputs.ts

@@ -7,6 +7,7 @@ import type {
 import { serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { PrivateKernelResetHints } from './hints/private_kernel_reset_hints.js';
+import type { PaddedSideEffects } from './padded_side_effects.js';
 import type { PrivateKernelData } from './private_kernel_data.js';
 import type { PrivateKernelResetDimensions } from './private_kernel_reset_dimensions.js';
 
@@ -15,23 +16,24 @@ export class PrivateKernelResetCircuitPrivateInputsVariants<
   NH_RR_SETTLED extends number,
   NLL_RR_PENDING extends number,
   NLL_RR_SETTLED extends number,
-  KEY_VALIDATION_REQUESTS extends number,
-  NUM_TRANSIENT_DATA_INDEX_HINTS extends number,
+  KEY_VALIDATION_HINTS_LEN extends number,
+  TRANSIENT_DATA_HINTS_LEN extends number,
 > {
   constructor(
     public previousKernel: PrivateKernelData,
+    public paddedSideEffects: PaddedSideEffects,
     public hints: PrivateKernelResetHints<
       NH_RR_PENDING,
       NH_RR_SETTLED,
       NLL_RR_PENDING,
       NLL_RR_SETTLED,
-      KEY_VALIDATION_REQUESTS,
-      NUM_TRANSIENT_DATA_INDEX_HINTS
+      KEY_VALIDATION_HINTS_LEN,
+      TRANSIENT_DATA_HINTS_LEN
     >,
   ) {}
 
   toBuffer() {
-    return serializeToBuffer(this.previousKernel, this.hints);
+    return serializeToBuffer(this.previousKernel, this.paddedSideEffects, this.hints);
   }
 }
 
@@ -44,6 +46,7 @@ export class PrivateKernelResetCircuitPrivateInputs {
      * The previous kernel data
      */
     public previousKernel: PrivateKernelData,
+    public paddedSideEffects: PaddedSideEffects,
     public hints: PrivateKernelResetHints<
       typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
       typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
@@ -60,18 +63,18 @@ export class PrivateKernelResetCircuitPrivateInputs {
    * @returns The buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.previousKernel, this.hints, this.dimensions);
+    return serializeToBuffer(this.previousKernel, this.paddedSideEffects, this.hints, this.dimensions);
   }
 
   trimToSizes() {
     const hints = this.hints.trimToSizes(
-      this.dimensions.NOTE_HASH_PENDING_AMOUNT,
-      this.dimensions.NOTE_HASH_SETTLED_AMOUNT,
-      this.dimensions.NULLIFIER_PENDING_AMOUNT,
-      this.dimensions.NULLIFIER_SETTLED_AMOUNT,
-      this.dimensions.NULLIFIER_KEYS,
-      this.dimensions.TRANSIENT_DATA_AMOUNT,
+      this.dimensions.NOTE_HASH_PENDING_READ,
+      this.dimensions.NOTE_HASH_SETTLED_READ,
+      this.dimensions.NULLIFIER_PENDING_READ,
+      this.dimensions.NULLIFIER_SETTLED_READ,
+      this.dimensions.KEY_VALIDATION,
+      this.dimensions.TRANSIENT_DATA_SQUASHING,
     );
-    return new PrivateKernelResetCircuitPrivateInputsVariants(this.previousKernel, hints);
+    return new PrivateKernelResetCircuitPrivateInputsVariants(this.previousKernel, this.paddedSideEffects, hints);
   }
 }

package/src/kernel/private_kernel_reset_dimensions.ts

@@ -3,28 +3,28 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 export class PrivateKernelResetDimensions {
   constructor(
-    public NOTE_HASH_PENDING_AMOUNT: number,
-    public NOTE_HASH_SETTLED_AMOUNT: number,
-    public NULLIFIER_PENDING_AMOUNT: number,
-    public NULLIFIER_SETTLED_AMOUNT: number,
-    public NULLIFIER_KEYS: number,
-    public TRANSIENT_DATA_AMOUNT: number,
-    public NOTE_HASH_SILOING_AMOUNT: number,
-    public NULLIFIER_SILOING_AMOUNT: number,
-    public PRIVATE_LOG_SILOING_AMOUNT: number,
+    public NOTE_HASH_PENDING_READ: number,
+    public NOTE_HASH_SETTLED_READ: number,
+    public NULLIFIER_PENDING_READ: number,
+    public NULLIFIER_SETTLED_READ: number,
+    public KEY_VALIDATION: number,
+    public TRANSIENT_DATA_SQUASHING: number,
+    public NOTE_HASH_SILOING: number,
+    public NULLIFIER_SILOING: number,
+    public PRIVATE_LOG_SILOING: number,
   ) {}
 
   toBuffer() {
     return serializeToBuffer(
-      this.NOTE_HASH_PENDING_AMOUNT,
-      this.NOTE_HASH_SETTLED_AMOUNT,
-      this.NULLIFIER_PENDING_AMOUNT,
-      this.NULLIFIER_SETTLED_AMOUNT,
-      this.NULLIFIER_KEYS,
-      this.TRANSIENT_DATA_AMOUNT,
-      this.NOTE_HASH_SILOING_AMOUNT,
-      this.NULLIFIER_SILOING_AMOUNT,
-      this.PRIVATE_LOG_SILOING_AMOUNT,
+      this.NOTE_HASH_PENDING_READ,
+      this.NOTE_HASH_SETTLED_READ,
+      this.NULLIFIER_PENDING_READ,
+      this.NULLIFIER_SETTLED_READ,
+      this.KEY_VALIDATION,
+      this.TRANSIENT_DATA_SQUASHING,
+      this.NOTE_HASH_SILOING,
+      this.NULLIFIER_SILOING,
+      this.PRIVATE_LOG_SILOING,
     );
   }
 
@@ -57,15 +57,15 @@ export class PrivateKernelResetDimensions {
 export type DimensionName = keyof FieldsOf<PrivateKernelResetDimensions>;
 
 export const privateKernelResetDimensionNames: DimensionName[] = [
-  'NOTE_HASH_PENDING_AMOUNT',
-  'NOTE_HASH_SETTLED_AMOUNT',
-  'NULLIFIER_PENDING_AMOUNT',
-  'NULLIFIER_SETTLED_AMOUNT',
-  'NULLIFIER_KEYS',
-  'TRANSIENT_DATA_AMOUNT',
-  'NOTE_HASH_SILOING_AMOUNT',
-  'NULLIFIER_SILOING_AMOUNT',
-  'PRIVATE_LOG_SILOING_AMOUNT',
+  'NOTE_HASH_PENDING_READ',
+  'NOTE_HASH_SETTLED_READ',
+  'NULLIFIER_PENDING_READ',
+  'NULLIFIER_SETTLED_READ',
+  'KEY_VALIDATION',
+  'TRANSIENT_DATA_SQUASHING',
+  'NOTE_HASH_SILOING',
+  'NULLIFIER_SILOING',
+  'PRIVATE_LOG_SILOING',
 ];
 
 export interface DimensionConfig {

package/src/kernel/private_kernel_tail_circuit_private_inputs.ts

@@ -1,5 +1,6 @@
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import { PaddedSideEffectAmounts } from './padded_side_effects.js';
 import { PrivateKernelData } from './private_kernel_data.js';
 import { countAccumulatedItems } from './utils/order_and_comparison.js';
 
@@ -12,6 +13,10 @@ export class PrivateKernelTailCircuitPrivateInputs {
      * The previous kernel data
      */
     public previousKernel: PrivateKernelData,
+    /**
+     * The number of the padded side effects.
+     */
+    public paddedSideEffectAmounts: PaddedSideEffectAmounts,
   ) {}
 
   isForPublic() {
@@ -26,7 +31,7 @@ export class PrivateKernelTailCircuitPrivateInputs {
    * @returns The buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.previousKernel);
+    return serializeToBuffer(this.previousKernel, this.paddedSideEffectAmounts);
   }
 
   /**
@@ -36,6 +41,9 @@ export class PrivateKernelTailCircuitPrivateInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelTailCircuitPrivateInputs {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateKernelTailCircuitPrivateInputs(reader.readObject(PrivateKernelData));
+    return new PrivateKernelTailCircuitPrivateInputs(
+      reader.readObject(PrivateKernelData),
+      reader.readObject(PaddedSideEffectAmounts),
+    );
   }
 }