@aztec/pxe 0.87.7 → 1.0.0-nightly.20250605

package/src/contract_function_simulator/pxe_oracle_interface.ts

@@ -18,9 +18,10 @@ import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
 import { computeAddressSecret, computeAppTaggingSecret } from '@aztec/stdlib/keys';
 import {
   IndexedTaggingSecret,
-  LogWithTxData,
   PendingTaggedLog,
+  PrivateLogWithTxData,
   PublicLog,
+  PublicLogWithTxData,
   TxScopedL2Log,
   deriveEcdhSharedSecret,
 } from '@aztec/stdlib/logs';
@@ -40,6 +41,8 @@ import type { NoteDataProvider } from '../storage/note_data_provider/note_data_p
 import type { PrivateEventDataProvider } from '../storage/private_event_data_provider/private_event_data_provider.js';
 import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
 import type { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
+import { EventValidationRequest } from './event_validation_request.js';
+import { NoteValidationRequest } from './note_validation_request.js';
 import type { ProxiedNode } from './proxied_node.js';
 import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
 
@@ -384,7 +387,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       });
 
       // We fetch the logs for the tags
-      const possibleLogs = await this.aztecNode.getLogsByTags(currentTags);
+      const possibleLogs = await this.#getPrivateLogsByTags(currentTags);
 
       // We find the index of the last log in the window that is not empty
       const indexOfLastLog = possibleLogs.findLastIndex(possibleLog => possibleLog.length !== 0);
@@ -421,8 +424,8 @@ export class PXEOracleInterface implements ExecutionDataProvider {
   }
 
   /**
-   * Synchronizes the logs tagged with scoped addresses and all the senders in the address book. Stores the found logs
-   * in CapsuleArray ready for a later retrieval in Aztec.nr.
+   * Synchronizes the private logs tagged with scoped addresses and all the senders in the address book. Stores the found
+   * logs in CapsuleArray ready for a later retrieval in Aztec.nr.
    * @param contractAddress - The address of the contract that the logs are tagged for.
    * @param pendingTaggedLogArrayBaseSlot - The base slot of the pending tagged logs capsule array in which
    * found logs will be stored.
@@ -482,20 +485,14 @@ export class PXEOracleInterface implements ExecutionDataProvider {
         // a new set of secrets and windows to fetch logs for.
         const newLargestIndexMapForIteration: { [k: string]: number } = {};
 
-        // Fetch the logs for the tags and iterate over them
-        const logsByTags = await this.aztecNode.getLogsByTags(tagsForTheWholeWindow);
+        // Fetch the private logs for the tags and iterate over them
+        const logsByTags = await this.#getPrivateLogsByTags(tagsForTheWholeWindow);
 
         for (let logIndex = 0; logIndex < logsByTags.length; logIndex++) {
           const logsByTag = logsByTags[logIndex];
           if (logsByTag.length > 0) {
-            // Discard public logs
-            const filteredLogsByTag = logsByTag.filter(l => !l.isFromPublic);
-            if (filteredLogsByTag.length < logsByTag.length) {
-              this.log.warn(`Discarded ${logsByTag.filter(l => l.isFromPublic).length} public logs with matching tags`);
-            }
-
             // We filter out the logs that are newer than the historical block number of the tx currently being constructed
-            const filteredLogsByBlockNumber = filteredLogsByTag.filter(l => l.blockNumber <= maxBlockNumber);
+            const filteredLogsByBlockNumber = logsByTag.filter(l => l.blockNumber <= maxBlockNumber);
 
             // We store the logs in capsules (to later be obtained in Noir)
             await this.#storePendingTaggedLogs(
@@ -510,7 +507,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
             const secretCorrespondingToLog = secretsForTheWholeWindow[logIndex];
             const initialIndex = initialIndexesMap[secretCorrespondingToLog.appTaggingSecret.toString()];
 
-            this.log.debug(`Found ${filteredLogsByTag.length} logs as recipient ${recipient}`, {
+            this.log.debug(`Found ${logsByTags.length} logs as recipient ${recipient}`, {
               recipient,
               secret: secretCorrespondingToLog.appTaggingSecret,
               contractName,
@@ -606,7 +603,55 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     return this.capsuleDataProvider.appendToCapsuleArray(contractAddress, capsuleArrayBaseSlot, pendingTaggedLogs);
   }
 
-  public async deliverNote(
+  public async validateEnqueuedNotesAndEvents(
+    contractAddress: AztecAddress,
+    noteValidationRequestsArrayBaseSlot: Fr,
+    eventValidationRequestsArrayBaseSlot: Fr,
+  ): Promise<void> {
+    // We read all note and event validation requests and process them all concurrently. This makes the process much
+    // faster as we don't need to wait for the network round-trip.
+    const noteValidationRequests = (
+      await this.capsuleDataProvider.readCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot)
+    ).map(NoteValidationRequest.fromFields);
+
+    const eventValidationRequests = (
+      await this.capsuleDataProvider.readCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot)
+    ).map(EventValidationRequest.fromFields);
+
+    const noteDeliveries = noteValidationRequests.map(request =>
+      this.deliverNote(
+        request.contractAddress,
+        request.storageSlot,
+        request.nonce,
+        request.content,
+        request.noteHash,
+        request.nullifier,
+        request.txHash,
+        request.recipient,
+      ),
+    );
+
+    const eventDeliveries = eventValidationRequests.map(request =>
+      this.deliverEvent(
+        request.contractAddress,
+        request.eventTypeId,
+        request.serializedEvent,
+        request.eventCommitment,
+        request.txHash,
+        request.logIndexInTx,
+        request.txIndexInBlock,
+        request.recipient,
+      ),
+    );
+
+    await Promise.all([...noteDeliveries, ...eventDeliveries]);
+
+    // Requests are cleared once we're done.
+    await this.capsuleDataProvider.resetCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, []);
+    await this.capsuleDataProvider.resetCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, []);
+  }
+
+  async deliverNote(
     contractAddress: AztecAddress,
     storageSlot: Fr,
     nonce: Fr,
@@ -633,6 +678,8 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     // in time of the locally synced state.
     // Note that while this technically results in historical queries, we perform it at the latest locally synced block
     // number which *should* be recent enough to be available, even for non-archive nodes.
+    // Also note that the note should never be ahead of the synced block here since `fetchTaggedLogs` only processes
+    // logs up to the synced block making this only an additional safety check.
     const syncedBlockNumber = await this.syncDataProvider.getBlockNumber();
 
     // By computing siloed and unique note hashes ourselves we prevent contracts from interfering with the note storage
@@ -690,18 +737,58 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     }
   }
 
-  public async getLogByTag(tag: Fr): Promise<LogWithTxData | null> {
-    const logs = await this.aztecNode.getLogsByTags([tag]);
+  async deliverEvent(
+    contractAddress: AztecAddress,
+    selector: EventSelector,
+    content: Fr[],
+    eventCommitment: Fr,
+    txHash: TxHash,
+    logIndexInTx: number,
+    txIndexInBlock: number,
+    recipient: AztecAddress,
+  ): Promise<void> {
+    // While using 'latest' block number would be fine for private events since they cannot be accessed from Aztec.nr
+    // (and thus we're less concerned about being ahead of the synced block), we use the synced block number to
+    // maintain consistent behavior in the PXE. Additionally, events should never be ahead of the synced block here
+    // since `fetchTaggedLogs` only processes logs up to the synced block.
+    const syncedBlockNumber = await this.syncDataProvider.getBlockNumber();
+
+    const siloedEventCommitment = await siloNullifier(contractAddress, eventCommitment);
+
+    const [nullifierIndex] = await this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [
+      siloedEventCommitment,
+    ]);
+
+    if (nullifierIndex === undefined) {
+      throw new Error(
+        `Event commitment ${eventCommitment} (siloed as ${siloedEventCommitment}) is not present on the nullifier tree at block ${syncedBlockNumber} (from tx ${txHash})`,
+      );
+    }
+
+    return this.privateEventDataProvider.storePrivateEventLog(
+      contractAddress,
+      recipient,
+      selector,
+      content,
+      txHash,
+      logIndexInTx,
+      txIndexInBlock,
+      nullifierIndex.l2BlockNumber, // Block in which the event was emitted
+    );
+  }
+
+  public async getPublicLogByTag(tag: Fr, contractAddress: AztecAddress): Promise<PublicLogWithTxData | null> {
+    const logs = await this.#getPublicLogsByTagsFromContract([tag], contractAddress);
     const logsForTag = logs[0];
 
-    this.log.debug(`Got ${logsForTag.length} logs for tag ${tag}`);
+    this.log.debug(`Got ${logsForTag.length} public logs for tag ${tag}`);
 
     if (logsForTag.length == 0) {
       return null;
     } else if (logsForTag.length > 1) {
       // TODO(#11627): handle this case
       throw new Error(
-        `Got ${logsForTag.length} logs for tag ${tag}. getLogByTag currently only supports a single log per tag`,
+        `Got ${logsForTag.length} logs for tag ${tag} and contract ${contractAddress.toString()}. getPublicLogByTag currently only supports a single log per tag`,
       );
     }
 
@@ -715,11 +802,45 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       throw new Error(`Unexpected: failed to retrieve tx effects for tx ${scopedLog.txHash} which is known to exist`);
     }
 
-    const logContent = (scopedLog.isFromPublic ? [(scopedLog.log as PublicLog).contractAddress.toField()] : []).concat(
-      scopedLog.log.getEmittedFields(),
+    return new PublicLogWithTxData(
+      scopedLog.log.getEmittedFieldsWithoutTag(),
+      scopedLog.txHash,
+      txEffect.data.noteHashes,
+      txEffect.data.nullifiers[0],
     );
+  }
 
-    return new LogWithTxData(logContent, scopedLog.txHash, txEffect.data.noteHashes, txEffect.data.nullifiers[0]);
+  public async getPrivateLogByTag(siloedTag: Fr): Promise<PrivateLogWithTxData | null> {
+    const logs = await this.#getPrivateLogsByTags([siloedTag]);
+    const logsForTag = logs[0];
+
+    this.log.debug(`Got ${logsForTag.length} private logs for tag ${siloedTag}`);
+
+    if (logsForTag.length == 0) {
+      return null;
+    } else if (logsForTag.length > 1) {
+      // TODO(#11627): handle this case
+      throw new Error(
+        `Got ${logsForTag.length} logs for tag ${siloedTag}. getPrivateLogByTag currently only supports a single log per tag`,
+      );
+    }
+
+    const scopedLog = logsForTag[0];
+
+    // getLogsByTag doesn't have all of the information that we need (notably note hashes and the first nullifier), so
+    // we need to make a second call to the node for `getTxEffect`.
+    // TODO(#9789): bundle this information in the `getLogsByTag` call.
+    const txEffect = await this.aztecNode.getTxEffect(scopedLog.txHash);
+    if (txEffect == undefined) {
+      throw new Error(`Unexpected: failed to retrieve tx effects for tx ${scopedLog.txHash} which is known to exist`);
+    }
+
+    return new PrivateLogWithTxData(
+      scopedLog.log.getEmittedFieldsWithoutTag(),
+      scopedLog.txHash,
+      txEffect.data.noteHashes,
+      txEffect.data.nullifiers[0],
+    );
   }
 
   public async removeNullifiedNotes(contractAddress: AztecAddress) {
@@ -791,35 +912,20 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     return deriveEcdhSharedSecret(addressSecret, ephPk);
   }
 
-  async storePrivateEventLog(
-    contractAddress: AztecAddress,
-    recipient: AztecAddress,
-    eventSelector: EventSelector,
-    msgContent: Fr[],
-    txHash: TxHash,
-    logIndexInTx: number,
-    txIndexInBlock: number,
-  ): Promise<void> {
-    const txReceipt = await this.aztecNode.getTxReceipt(txHash);
-    const blockNumber = txReceipt.blockNumber;
-    if (blockNumber === undefined) {
-      throw new Error(`Block number is undefined for tx ${txHash} in storePrivateEventLog`);
-    }
-    const historicalBlockNumber = await this.syncDataProvider.getBlockNumber();
-    if (blockNumber > historicalBlockNumber) {
-      throw new Error(
-        `Attempting to store private event log from a block newer than the historical block of the simulation. Log block number: ${blockNumber}, historical block number: ${historicalBlockNumber}`,
-      );
-    }
-    return this.privateEventDataProvider.storePrivateEventLog(
-      contractAddress,
-      recipient,
-      eventSelector,
-      msgContent,
-      txHash,
-      logIndexInTx,
-      txIndexInBlock,
-      blockNumber,
+  // TODO(#12656): Make this a public function on the AztecNode interface and remove the original getLogsByTags. This
+  // was not done yet as we were unsure about the API and we didn't want to introduce a breaking change.
+  async #getPrivateLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
+    const allLogs = await this.aztecNode.getLogsByTags(tags);
+    return allLogs.map(logs => logs.filter(log => !log.isFromPublic));
+  }
+
+  // TODO(#12656): Make this a public function on the AztecNode interface and remove the original getLogsByTags. This
+  // was not done yet as we were unsure about the API and we didn't want to introduce a breaking change.
+  async #getPublicLogsByTagsFromContract(tags: Fr[], contractAddress: AztecAddress): Promise<TxScopedL2Log[][]> {
+    const allLogs = await this.aztecNode.getLogsByTags(tags);
+    const allPublicLogs = allLogs.map(logs => logs.filter(log => log.isFromPublic));
+    return allPublicLogs.map(logs =>
+      logs.filter(log => (log.log as PublicLog).contractAddress.equals(contractAddress)),
     );
   }
 

package/src/private_kernel/hints/build_private_kernel_reset_private_inputs.ts

@@ -6,7 +6,6 @@ import {
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   MAX_PRIVATE_LOGS_PER_TX,
   NULLIFIER_TREE_HEIGHT,
-  VK_TREE_HEIGHT,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -16,6 +15,7 @@ import { MembershipWitness } from '@aztec/foundation/trees';
 import { privateKernelResetDimensionsConfig } from '@aztec/noir-protocol-circuits-types/client';
 import {
   KeyValidationHint,
+  PaddedSideEffects,
   type PrivateCircuitPublicInputs,
   type PrivateKernelCircuitPublicInputs,
   PrivateKernelData,
@@ -42,6 +42,7 @@ import {
   privateKernelResetDimensionNames,
 } from '@aztec/stdlib/kernel';
 import { type PrivateCallExecutionResult, collectNested } from '@aztec/stdlib/tx';
+import { VkData } from '@aztec/stdlib/vks';
 
 import type { PrivateKernelOracle } from '../private_kernel_oracle.js';
 
@@ -74,22 +75,17 @@ function getNullifierMembershipWitnessResolver(oracle: PrivateKernelOracle) {
 
 async function getMasterSecretKeysAndAppKeyGenerators(
   keyValidationRequests: Tuple<ScopedKeyValidationRequestAndGenerator, typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX>,
+  numRequestsToVerify: number,
   oracle: PrivateKernelOracle,
 ) {
-  const keysHints = [];
-  for (let i = 0; i < keyValidationRequests.length; ++i) {
-    const request = keyValidationRequests[i].request;
-    if (request.isEmpty()) {
-      break;
-    }
-    const secretKeys = await oracle.getMasterSecretKey(request.request.pkM);
-    keysHints.push(new KeyValidationHint(secretKeys, i));
-  }
-  return padArrayEnd(
-    keysHints,
-    KeyValidationHint.nada(MAX_KEY_VALIDATION_REQUESTS_PER_TX),
-    MAX_KEY_VALIDATION_REQUESTS_PER_TX,
+  const numRequests = countAccumulatedItems(keyValidationRequests);
+  const keysHints = await Promise.all(
+    keyValidationRequests.slice(0, Math.min(numRequests, numRequestsToVerify)).map(async ({ request }) => {
+      const secretKeys = await oracle.getMasterSecretKey(request.request.pkM);
+      return new KeyValidationHint(secretKeys);
+    }),
   );
+  return padArrayEnd(keysHints, KeyValidationHint.empty(), MAX_KEY_VALIDATION_REQUESTS_PER_TX);
 }
 
 export class PrivateKernelResetPrivateInputsBuilder {
@@ -166,26 +162,30 @@ export class PrivateKernelResetPrivateInputsBuilder {
     const previousVkMembershipWitness = await oracle.getVkMembershipWitness(
       this.previousKernelOutput.verificationKey.keyAsFields,
     );
-    const previousKernelData = new PrivateKernelData(
-      this.previousKernelOutput.publicInputs,
+    const vkData = new VkData(
       this.previousKernelOutput.verificationKey,
       Number(previousVkMembershipWitness.leafIndex),
-      assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
+      previousVkMembershipWitness.siblingPath,
     );
+    const previousKernelData = new PrivateKernelData(this.previousKernelOutput.publicInputs, vkData);
 
     this.reduceReadRequestStates(
       this.noteHashResetStates,
-      dimensions.NOTE_HASH_PENDING_AMOUNT,
-      dimensions.NOTE_HASH_SETTLED_AMOUNT,
+      dimensions.NOTE_HASH_PENDING_READ,
+      dimensions.NOTE_HASH_SETTLED_READ,
     );
     this.reduceReadRequestStates(
       this.nullifierResetStates,
-      dimensions.NULLIFIER_PENDING_AMOUNT,
-      dimensions.NULLIFIER_SETTLED_AMOUNT,
+      dimensions.NULLIFIER_PENDING_READ,
+      dimensions.NULLIFIER_SETTLED_READ,
     );
 
+    // TODO: Enable padding when we have a better idea what are the final amounts we should pad to.
+    const paddedSideEffects = PaddedSideEffects.empty();
+
     return new PrivateKernelResetCircuitPrivateInputs(
       previousKernelData,
+      paddedSideEffects,
       new PrivateKernelResetHints(
         await buildNoteHashReadRequestHintsFromResetStates(
           oracle,
@@ -201,6 +201,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
         ),
         await getMasterSecretKeysAndAppKeyGenerators(
           this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators,
+          dimensions.KEY_VALIDATION,
           oracle,
         ),
         this.transientDataIndexHints,
@@ -266,19 +267,19 @@ export class PrivateKernelResetPrivateInputsBuilder {
 
     if (!this.nextIteration) {
       this.noteHashResetStates = resetStates;
-      this.requestedDimensions.NOTE_HASH_PENDING_AMOUNT = numPendingReads;
-      this.requestedDimensions.NOTE_HASH_SETTLED_AMOUNT = numSettledReads;
+      this.requestedDimensions.NOTE_HASH_PENDING_READ = numPendingReads;
+      this.requestedDimensions.NOTE_HASH_SETTLED_READ = numSettledReads;
     } else {
       // Pick only one dimension to reset if next iteration is not empty.
       if (numPendingReads > numSettledReads) {
-        this.requestedDimensions.NOTE_HASH_PENDING_AMOUNT = numPendingReads;
+        this.requestedDimensions.NOTE_HASH_PENDING_READ = numPendingReads;
         this.noteHashResetStates.states = assertLength(
           resetStates.states.map(state => (state === ReadRequestState.PENDING ? state : ReadRequestState.NADA)),
           MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
         );
         this.noteHashResetStates.pendingReadHints = resetStates.pendingReadHints;
       } else {
-        this.requestedDimensions.NOTE_HASH_SETTLED_AMOUNT = numSettledReads;
+        this.requestedDimensions.NOTE_HASH_SETTLED_READ = numSettledReads;
         this.noteHashResetStates.states = assertLength(
           resetStates.states.map(state => (state === ReadRequestState.SETTLED ? state : ReadRequestState.NADA)),
           MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
@@ -318,19 +319,19 @@ export class PrivateKernelResetPrivateInputsBuilder {
 
     if (!this.nextIteration) {
       this.nullifierResetStates = resetStates;
-      this.requestedDimensions.NULLIFIER_PENDING_AMOUNT = numPendingReads;
-      this.requestedDimensions.NULLIFIER_SETTLED_AMOUNT = numSettledReads;
+      this.requestedDimensions.NULLIFIER_PENDING_READ = numPendingReads;
+      this.requestedDimensions.NULLIFIER_SETTLED_READ = numSettledReads;
     } else {
       // Pick only one dimension to reset if next iteration is not empty.
       if (numPendingReads > numSettledReads) {
-        this.requestedDimensions.NULLIFIER_PENDING_AMOUNT = numPendingReads;
+        this.requestedDimensions.NULLIFIER_PENDING_READ = numPendingReads;
         this.nullifierResetStates.states = assertLength(
           resetStates.states.map(state => (state === ReadRequestState.PENDING ? state : ReadRequestState.NADA)),
           MAX_NULLIFIER_READ_REQUESTS_PER_TX,
         );
         this.nullifierResetStates.pendingReadHints = resetStates.pendingReadHints;
       } else {
-        this.requestedDimensions.NULLIFIER_SETTLED_AMOUNT = numSettledReads;
+        this.requestedDimensions.NULLIFIER_SETTLED_READ = numSettledReads;
         this.nullifierResetStates.states = assertLength(
           resetStates.states.map(state => (state === ReadRequestState.SETTLED ? state : ReadRequestState.NADA)),
           MAX_NULLIFIER_READ_REQUESTS_PER_TX,
@@ -353,7 +354,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
       return false;
     }
 
-    this.requestedDimensions.NULLIFIER_KEYS = numCurr;
+    this.requestedDimensions.KEY_VALIDATION = numCurr;
 
     return true;
   }
@@ -430,7 +431,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
 
     this.numTransientData = numTransientData;
     this.transientDataIndexHints = transientDataIndexHints;
-    this.requestedDimensions.TRANSIENT_DATA_AMOUNT = numTransientData;
+    this.requestedDimensions.TRANSIENT_DATA_SQUASHING = numTransientData;
 
     return numTransientData > 0;
   }
@@ -442,7 +443,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
 
     const numNoteHashes = this.previousKernel.end.noteHashes.filter(n => !n.contractAddress.isZero()).length;
     const numToSilo = Math.max(0, numNoteHashes - this.numTransientData);
-    this.requestedDimensions.NOTE_HASH_SILOING_AMOUNT = numToSilo;
+    this.requestedDimensions.NOTE_HASH_SILOING = numToSilo;
 
     return numToSilo > 0;
   }
@@ -458,7 +459,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
     // The reset circuit checks that capped_size must be greater than or equal to all non-empty nullifiers.
     // Which includes the first nullifier, even though its contract address is always zero and doesn't need siloing.
     const cappedSize = numToSilo ? numToSilo + 1 : 0;
-    this.requestedDimensions.NULLIFIER_SILOING_AMOUNT = cappedSize;
+    this.requestedDimensions.NULLIFIER_SILOING = cappedSize;
 
     return numToSilo > 0;
   }
@@ -478,7 +479,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
     const numSquashedLogs = privateLogs.filter(l => squashedNoteHashCounters.includes(l.inner.noteHashCounter)).length;
 
     const numToSilo = numLogs - numSquashedLogs;
-    this.requestedDimensions.PRIVATE_LOG_SILOING_AMOUNT = numToSilo;
+    this.requestedDimensions.PRIVATE_LOG_SILOING = numToSilo;
 
     return numToSilo > 0;
   }

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -1,8 +1,6 @@
-import { VK_TREE_HEIGHT } from '@aztec/constants';
 import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { Timer } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
@@ -12,6 +10,7 @@ import { computeContractAddressFromInstance } from '@aztec/stdlib/contract';
 import { hashVK } from '@aztec/stdlib/hash';
 import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 import {
+  PaddedSideEffectAmounts,
   PrivateCallData,
   type PrivateExecutionStep,
   PrivateKernelCircuitPublicInputs,
@@ -33,7 +32,7 @@ import {
   collectNoteHashNullifierCounterMap,
   getFinalMinRevertibleSideEffectCounter,
 } from '@aztec/stdlib/tx';
-import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
+import { VerificationKeyAsFields, VerificationKeyData, VkData } from '@aztec/stdlib/vks';
 
 import { PrivateKernelResetPrivateInputsBuilder } from './hints/build_private_kernel_reset_private_inputs.js';
 import type { PrivateKernelOracle } from './private_kernel_oracle.js';
@@ -195,12 +194,12 @@ export class PrivateKernelExecutionProver {
         const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(
           output.verificationKey.keyAsFields,
         );
-        const previousKernelData = new PrivateKernelData(
-          output.publicInputs,
+        const vkData = new VkData(
           output.verificationKey,
           Number(previousVkMembershipWitness.leafIndex),
-          assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
+          previousVkMembershipWitness.siblingPath,
         );
+        const previousKernelData = new PrivateKernelData(output.publicInputs, vkData);
         const proofInput = new PrivateKernelInnerCircuitPrivateInputs(previousKernelData, privateCallData);
 
         pushTestData('private-kernel-inputs-inner', proofInput);
@@ -261,18 +260,20 @@ export class PrivateKernelExecutionProver {
     }
     // Private tail.
     const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey.keyAsFields);
-    const previousKernelData = new PrivateKernelData(
-      output.publicInputs,
+    const vkData = new VkData(
       output.verificationKey,
       Number(previousVkMembershipWitness.leafIndex),
-      assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
+      previousVkMembershipWitness.siblingPath,
     );
+    const previousKernelData = new PrivateKernelData(output.publicInputs, vkData);
 
     this.log.debug(
       `Calling private kernel tail with hwm ${previousKernelData.publicInputs.minRevertibleSideEffectCounter}`,
     );
 
-    const privateInputs = new PrivateKernelTailCircuitPrivateInputs(previousKernelData);
+    // TODO: Enable padding when we have a better what are the final amounts we should pad to.
+    const paddedSideEffectAmounts = PaddedSideEffectAmounts.empty();
+    const privateInputs = new PrivateKernelTailCircuitPrivateInputs(previousKernelData, paddedSideEffectAmounts);
 
     pushTestData('private-kernel-inputs-ordering', privateInputs);
 

package/src/pxe_service/pxe_service.ts

@@ -49,7 +49,7 @@ import type {
 } from '@aztec/stdlib/interfaces/client';
 import type { PrivateKernelExecutionProofOutput, PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import type { LogFilter } from '@aztec/stdlib/logs';
-import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
+import { computeL2ToL1MembershipWitness, getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { type NotesFilter, UniqueNote } from '@aztec/stdlib/note';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
@@ -196,8 +196,15 @@ export class PXEService implements PXE {
     return this.node.isL1ToL2MessageSynced(l1ToL2Message);
   }
 
-  public getL2ToL1MembershipWitness(blockNumber: number, l2Tol1Message: Fr): Promise<[bigint, SiblingPath<number>]> {
-    return this.node.getL2ToL1MessageMembershipWitness(blockNumber, l2Tol1Message);
+  public async getL2ToL1MembershipWitness(
+    blockNumber: number,
+    l2Tol1Message: Fr,
+  ): Promise<[bigint, SiblingPath<number>]> {
+    const result = await computeL2ToL1MembershipWitness(this.node, blockNumber, l2Tol1Message);
+    if (!result) {
+      throw new Error(`L2 to L1 message not found in block ${blockNumber}`);
+    }
+    return [result.l2MessageIndex, result.siblingPath];
   }
 
   public getTxReceipt(txHash: TxHash): Promise<TxReceipt> {

package/src/storage/capsule_data_provider/capsule_data_provider.ts

@@ -75,26 +75,71 @@ export class CapsuleDataProvider implements DataProvider {
    * All operations are performed in a single transaction.
    * @param contractAddress - The contract address that owns the capsule array
    * @param baseSlot - The slot where the array length is stored
-   * @param capsules - Array of capsule data to append
+   * @param content - Array of capsule data to append
    */
-  appendToCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, capsules: Fr[][]): Promise<void> {
+  appendToCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][]): Promise<void> {
     return this.#store.transactionAsync(async () => {
       // Load current length, defaulting to 0 if not found
       const lengthData = await this.loadCapsule(contractAddress, baseSlot);
-      const currentLength = lengthData ? lengthData[0].toBigInt() : 0n;
+      const currentLength = lengthData ? lengthData[0].toNumber() : 0;
 
       // Store each capsule at consecutive slots after baseSlot + 1 + currentLength
-      for (let i = 0; i < capsules.length; i++) {
-        const nextSlot = baseSlot.add(new Fr(1)).add(new Fr(currentLength + BigInt(i)));
-        await this.storeCapsule(contractAddress, nextSlot, capsules[i]);
+      for (let i = 0; i < content.length; i++) {
+        const nextSlot = arraySlot(baseSlot, currentLength + i);
+        await this.storeCapsule(contractAddress, nextSlot, content[i]);
       }
 
       // Update length to include all new capsules
-      const newLength = currentLength + BigInt(capsules.length);
+      const newLength = currentLength + content.length;
       await this.storeCapsule(contractAddress, baseSlot, [new Fr(newLength)]);
     });
   }
 
+  readCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr): Promise<Fr[][]> {
+    return this.#store.transactionAsync(async () => {
+      // Load length, defaulting to 0 if not found
+      const maybeLength = await this.loadCapsule(contractAddress, baseSlot);
+      const length = maybeLength ? maybeLength[0].toBigInt() : 0n;
+
+      const values: Fr[][] = [];
+
+      // Read each capsule at consecutive slots after baseSlot
+      for (let i = 0; i < length; i++) {
+        const currentValue = await this.loadCapsule(contractAddress, arraySlot(baseSlot, i));
+        if (currentValue == undefined) {
+          throw new Error(
+            `Expected non-empty value at capsule array in base slot ${baseSlot} at index ${i} for contract ${contractAddress}`,
+          );
+        }
+
+        values.push(currentValue);
+      }
+
+      return values;
+    });
+  }
+
+  resetCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][]) {
+    return this.#store.transactionAsync(async () => {
+      // Load current length, defaulting to 0 if not found
+      const maybeLength = await this.loadCapsule(contractAddress, baseSlot);
+      const originalLength = maybeLength ? maybeLength[0].toNumber() : 0;
+
+      // Set the new length
+      await this.storeCapsule(contractAddress, baseSlot, [new Fr(content.length)]);
+
+      // Store the new content, possibly overwriting existing values
+      for (let i = 0; i < content.length; i++) {
+        await this.storeCapsule(contractAddress, arraySlot(baseSlot, i), content[i]);
+      }
+
+      // Clear any stragglers
+      for (let i = content.length; i < originalLength; i++) {
+        await this.deleteCapsule(contractAddress, arraySlot(baseSlot, i));
+      }
+    });
+  }
+
   public async getSize() {
     return (await toArray(this.#capsules.valuesAsync())).reduce(
       (sum, value) => sum + value.length * Fr.SIZE_IN_BYTES,
@@ -106,3 +151,7 @@ export class CapsuleDataProvider implements DataProvider {
 function dbSlotToKey(contractAddress: AztecAddress, slot: Fr): string {
   return `${contractAddress.toString()}:${slot.toString()}`;
 }
+
+function arraySlot(baseSlot: Fr, index: number) {
+  return baseSlot.add(new Fr(1)).add(new Fr(index));
+}