@aztec/pxe 4.0.0-nightly.20260113 → 4.0.0-nightly.20260114

package/dest/storage/private_event_store/private_event_store.js

@@ -8,10 +8,10 @@ import { TxHash } from '@aztec/stdlib/tx';
  * Stores decrypted private event logs.
  */ export class PrivateEventStore {
     #store;
-    /** Map storing the actual private event log entries, keyed by eventCommitmentIndex */ #eventLogs;
-    /** Map from contractAddress_scope_eventSelector to eventCommitmentIndex[] for efficient lookup */ #eventsByContractScopeSelector;
-    /** Map from block number to eventCommitmentIndex[] for rollback support */ #eventsByBlockNumber;
-    /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */ #seenLogs;
+    /** Map storing the actual private event log entries, keyed by siloedEventCommitment */ #eventLogs;
+    /** Map from contractAddress_scope_eventSelector to siloedEventCommitment[] for efficient lookup */ #eventsByContractScopeSelector;
+    /** Map from block number to siloedEventCommitment[] for rollback support */ #eventsByBlockNumber;
+    /** Map from siloedEventCommitment to boolean indicating if log has been seen. */ #seenLogs;
     logger = createLogger('private_event_store');
     constructor(store){
         this.#store = store;
@@ -26,23 +26,26 @@ import { TxHash } from '@aztec/stdlib/tx';
     /**
    * Store a private event log.
    * @param eventSelector - The event selector of the event.
+   * @param randomness - The randomness used for the event commitment.
    * @param msgContent - The content of the event.
-   * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
+   * @param siloedEventCommitment - The siloed event commitment (used as unique identifier).
    * @param metadata
    *  contractAddress - The address of the contract that emitted the event.
    *  scope - The address to which the event is scoped.
    *  txHash - The transaction hash of the event log.
    *  blockNumber - The block number in which the event was emitted.
-   */ storePrivateEventLog(eventSelector, randomness, msgContent, eventCommitmentIndex, metadata) {
-        const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash } = metadata;
+   */ storePrivateEventLog(eventSelector, randomness, msgContent, siloedEventCommitment, metadata) {
+        const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
         return this.#store.transactionAsync(async ()=>{
             const key = this.#keyFor(contractAddress, scope, eventSelector);
-            // Check if this exact log has already been stored using eventCommitmentIndex as unique identifier
-            const hasBeenSeen = await this.#seenLogs.getAsync(eventCommitmentIndex);
+            // The siloed event commitment is guaranteed to be unique as it's inserted into the nullifier tree. For this
+            // reason we use it as id.
+            const eventId = siloedEventCommitment.toString();
+            const hasBeenSeen = await this.#seenLogs.getAsync(eventId);
             if (hasBeenSeen) {
                 this.logger.verbose('Ignoring duplicate event log', {
                     txHash: txHash.toString(),
-                    eventCommitmentIndex
+                    siloedEventCommitment
                 });
                 return;
             }
@@ -52,27 +55,28 @@ import { TxHash } from '@aztec/stdlib/tx';
                 msgContent,
                 l2BlockNumber
             });
-            await this.#eventLogs.set(eventCommitmentIndex, {
+            await this.#eventLogs.set(eventId, {
                 randomness,
                 msgContent: serializeToBuffer(msgContent),
                 l2BlockNumber,
                 l2BlockHash: l2BlockHash.toBuffer(),
-                eventCommitmentIndex,
                 txHash: txHash.toBuffer(),
+                txIndexInBlock,
+                eventIndexInTx,
                 lookupKey: key
             });
-            const existingIndices = await this.#eventsByContractScopeSelector.getAsync(key) || [];
+            const existingIds = await this.#eventsByContractScopeSelector.getAsync(key) || [];
             await this.#eventsByContractScopeSelector.set(key, [
-                ...existingIndices,
-                eventCommitmentIndex
+                ...existingIds,
+                eventId
             ]);
-            const existingBlockIndices = await this.#eventsByBlockNumber.getAsync(l2BlockNumber) || [];
+            const existingBlockIds = await this.#eventsByBlockNumber.getAsync(l2BlockNumber) || [];
             await this.#eventsByBlockNumber.set(l2BlockNumber, [
-                ...existingBlockIndices,
-                eventCommitmentIndex
+                ...existingBlockIds,
+                eventId
             ]);
-            // Mark this log as seen using eventCommitmentIndex
-            await this.#seenLogs.set(eventCommitmentIndex, true);
+            // Mark this log as seen
+            await this.#seenLogs.set(eventId, true);
         });
     }
     /**
@@ -83,15 +87,15 @@ import { TxHash } from '@aztec/stdlib/tx';
    *  fromBlock: The block number to search from (inclusive).
    *  toBlock: The block number to search upto (exclusive).
    *  scope: - The addresses that decrypted the logs.
-   * @returns - The event log contents, augmented with metadata about
-   *  the transaction and block it the event was included in .
+   * @returns - The event log contents, augmented with metadata about the transaction and block in which the event was
+   * included.
    */ async getPrivateEvents(eventSelector, filter) {
         const events = [];
         for (const scope of filter.scopes){
             const key = this.#keyFor(filter.contractAddress, scope, eventSelector);
-            const eventCommitmentIndices = await this.#eventsByContractScopeSelector.getAsync(key) || [];
-            for (const eventCommitmentIndex of eventCommitmentIndices){
-                const entry = await this.#eventLogs.getAsync(eventCommitmentIndex);
+            const eventIds = await this.#eventsByContractScopeSelector.getAsync(key) || [];
+            for (const eventId of eventIds){
+                const entry = await this.#eventLogs.getAsync(eventId);
                 if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
                     continue;
                 }
@@ -105,7 +109,9 @@ import { TxHash } from '@aztec/stdlib/tx';
                     continue;
                 }
                 events.push({
-                    eventCommitmentIndex: entry.eventCommitmentIndex,
+                    l2BlockNumber: entry.l2BlockNumber,
+                    txIndexInBlock: entry.txIndexInBlock,
+                    eventIndexInTx: entry.eventIndexInTx,
                     event: {
                         packedEvent: msgContent,
                         l2BlockNumber: BlockNumber(entry.l2BlockNumber),
@@ -116,8 +122,16 @@ import { TxHash } from '@aztec/stdlib/tx';
                 });
             }
         }
-        // Sort by eventCommitmentIndex only
-        events.sort((a, b)=>a.eventCommitmentIndex - b.eventCommitmentIndex);
+        // Sort by block number, then by tx index within block, then by event index within tx
+        events.sort((a, b)=>{
+            if (a.l2BlockNumber !== b.l2BlockNumber) {
+                return a.l2BlockNumber - b.l2BlockNumber;
+            }
+            if (a.txIndexInBlock !== b.txIndexInBlock) {
+                return a.txIndexInBlock - b.txIndexInBlock;
+            }
+            return a.eventIndexInTx - b.eventIndexInTx;
+        });
         return events.map((ev)=>ev.event);
     }
     /**
@@ -128,26 +142,26 @@ import { TxHash } from '@aztec/stdlib/tx';
    */ async rollback(blockNumber, synchedBlockNumber) {
         let removedCount = 0;
         for(let block = blockNumber + 1; block <= synchedBlockNumber; block++){
-            const indices = await this.#eventsByBlockNumber.getAsync(block);
-            if (indices) {
+            const eventIds = await this.#eventsByBlockNumber.getAsync(block);
+            if (eventIds) {
                 await this.#eventsByBlockNumber.delete(block);
-                for (const eventCommitmentIndex of indices){
-                    const entry = await this.#eventLogs.getAsync(eventCommitmentIndex);
+                for (const eventId of eventIds){
+                    const entry = await this.#eventLogs.getAsync(eventId);
                     if (!entry) {
-                        throw new Error(`Event log not found for eventCommitmentIndex ${eventCommitmentIndex}`);
+                        throw new Error(`Event log not found for eventId ${eventId}`);
                     }
-                    await this.#eventLogs.delete(eventCommitmentIndex);
-                    await this.#seenLogs.delete(eventCommitmentIndex);
+                    await this.#eventLogs.delete(eventId);
+                    await this.#seenLogs.delete(eventId);
                     // Update #eventsByContractScopeSelector using the stored lookupKey
-                    const existingIndices = await this.#eventsByContractScopeSelector.getAsync(entry.lookupKey);
-                    if (!existingIndices || existingIndices.length === 0) {
-                        throw new Error(`No indices found in #eventsByContractScopeSelector for key ${entry.lookupKey}`);
+                    const existingIds = await this.#eventsByContractScopeSelector.getAsync(entry.lookupKey);
+                    if (!existingIds || existingIds.length === 0) {
+                        throw new Error(`No ids found in #eventsByContractScopeSelector for key ${entry.lookupKey}`);
                     }
-                    const filteredIndices = existingIndices.filter((idx)=>idx !== eventCommitmentIndex);
-                    if (filteredIndices.length === 0) {
+                    const filteredIds = existingIds.filter((id)=>id !== eventId);
+                    if (filteredIds.length === 0) {
                         await this.#eventsByContractScopeSelector.delete(entry.lookupKey);
                     } else {
-                        await this.#eventsByContractScopeSelector.set(entry.lookupKey, filteredIndices);
+                        await this.#eventsByContractScopeSelector.set(entry.lookupKey, filteredIds);
                     }
                     removedCount++;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "4.0.0-nightly.20260113",
+  "version": "4.0.0-nightly.20260114",
   "type": "module",
   "exports": {
     "./server": "./dest/entrypoints/server/index.js",
@@ -61,19 +61,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "4.0.0-nightly.20260113",
-    "@aztec/bb.js": "4.0.0-nightly.20260113",
-    "@aztec/builder": "4.0.0-nightly.20260113",
-    "@aztec/constants": "4.0.0-nightly.20260113",
-    "@aztec/ethereum": "4.0.0-nightly.20260113",
-    "@aztec/foundation": "4.0.0-nightly.20260113",
-    "@aztec/key-store": "4.0.0-nightly.20260113",
-    "@aztec/kv-store": "4.0.0-nightly.20260113",
-    "@aztec/noir-protocol-circuits-types": "4.0.0-nightly.20260113",
-    "@aztec/noir-types": "4.0.0-nightly.20260113",
-    "@aztec/protocol-contracts": "4.0.0-nightly.20260113",
-    "@aztec/simulator": "4.0.0-nightly.20260113",
-    "@aztec/stdlib": "4.0.0-nightly.20260113",
+    "@aztec/bb-prover": "4.0.0-nightly.20260114",
+    "@aztec/bb.js": "4.0.0-nightly.20260114",
+    "@aztec/builder": "4.0.0-nightly.20260114",
+    "@aztec/constants": "4.0.0-nightly.20260114",
+    "@aztec/ethereum": "4.0.0-nightly.20260114",
+    "@aztec/foundation": "4.0.0-nightly.20260114",
+    "@aztec/key-store": "4.0.0-nightly.20260114",
+    "@aztec/kv-store": "4.0.0-nightly.20260114",
+    "@aztec/noir-protocol-circuits-types": "4.0.0-nightly.20260114",
+    "@aztec/noir-types": "4.0.0-nightly.20260114",
+    "@aztec/protocol-contracts": "4.0.0-nightly.20260114",
+    "@aztec/simulator": "4.0.0-nightly.20260114",
+    "@aztec/stdlib": "4.0.0-nightly.20260114",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "lodash.omit": "^4.5.0",
@@ -82,8 +82,8 @@
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/merkle-tree": "4.0.0-nightly.20260113",
-    "@aztec/noir-test-contracts.js": "4.0.0-nightly.20260113",
+    "@aztec/merkle-tree": "4.0.0-nightly.20260114",
+    "@aztec/noir-test-contracts.js": "4.0.0-nightly.20260114",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",

package/src/contract_function_simulator/oracle/interfaces.ts

@@ -32,10 +32,10 @@ export interface NoteData {
   noteNonce: Fr;
   /** A hash of the note as it gets stored in the note hash tree. */
   noteHash: Fr;
+  /** True if the note is pending, false if settled. */
+  isPending: boolean;
   /** The corresponding nullifier of the note. Undefined for pending notes. */
   siloedNullifier?: Fr;
-  /** The note's leaf index in the note hash tree. Undefined for pending notes. */
-  index?: bigint;
 }
 
 // These interfaces contain the list of oracles required by aztec-nr in order to simulate and execute transactions, i.e.

package/src/contract_function_simulator/oracle/note_packing_utils.ts

@@ -28,7 +28,7 @@ function fromRawData(nonzeroNoteHashCounter: boolean, maybeNoteNonce: Fr): { sta
  * @param randomness - The randomness injected into the note to get the hiding property of commitments
  * @param storageSlot - The storage slot of the note
  * @param noteNonce - The nonce injected into the note hash preimage by kernels.
- * @param index - Optional index in the note hash tree. If undefined, indicates a transient note
+ * @param isPending - True if the note is pending, false if settled
  * @param note - The note content containing the actual note data
  * @returns The packed note as an array of field elements
  */
@@ -38,7 +38,7 @@ export function packAsRetrievedNote({
   randomness,
   storageSlot,
   noteNonce,
-  index,
+  isPending,
   note,
 }: {
   contractAddress: AztecAddress;
@@ -46,14 +46,14 @@ export function packAsRetrievedNote({
   randomness: Fr;
   storageSlot: Fr;
   noteNonce: Fr;
-  index?: bigint;
+  isPending: boolean;
   note: Note;
 }) {
-  // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
-  const nonzeroNoteHashCounter = index === undefined;
+  // If the note is pending it means it has a non-zero note hash counter associated with it.
+  const nonZeroNoteHashCounter = isPending;
 
   // To pack the note as retrieved note we first need to reconstruct the note metadata.
-  const noteMetadata = fromRawData(nonzeroNoteHashCounter, noteNonce);
+  const noteMetadata = fromRawData(nonZeroNoteHashCounter, noteNonce);
 
   // Pack in order: note, contract_address, owner, randomness, storage_slot, metadata (stage, maybe_note_nonce)
   return [

package/src/contract_function_simulator/oracle/oracle.ts

@@ -286,7 +286,7 @@ export class Oracle {
         randomness: noteData.randomness,
         storageSlot: noteData.storageSlot,
         noteNonce: noteData.noteNonce,
-        index: noteData.index,
+        isPending: noteData.isPending,
         note: noteData.note,
       }),
     );

package/src/contract_function_simulator/oracle/private_execution_oracle.ts

@@ -428,6 +428,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
         note,
         siloedNullifier: undefined, // Siloed nullifier cannot be known for newly created note.
         noteHash,
+        isPending: true, // This note has just been created and hence is not settled yet.
       },
       counter,
     );

package/src/events/event_service.ts

@@ -3,7 +3,6 @@ import type { EventSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { TxHash } from '@aztec/stdlib/tx';
 
 import { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
@@ -45,35 +44,22 @@ export class EventService {
       throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${syncedBlockNumber}`);
     }
 
-    const eventInTx = txEffect.data.nullifiers.some(n => n.equals(siloedEventCommitment));
-    if (!eventInTx) {
+    // Find the index of the event commitment in the nullifiers array to determine event ordering within the tx
+    const eventIndexInTx = txEffect.data.nullifiers.findIndex(n => n.equals(siloedEventCommitment));
+    if (eventIndexInTx === -1) {
       throw new Error(
         `Event commitment ${eventCommitment} (siloed as ${siloedEventCommitment}) is not present in tx ${txHash}`,
       );
     }
 
-    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.privateEventStore.storePrivateEventLog(
-      selector,
-      randomness,
-      content,
-      Number(nullifierIndex.data), // Index of the event commitment in the nullifier tree
-      {
-        contractAddress,
-        scope,
-        txHash,
-        l2BlockNumber: nullifierIndex.l2BlockNumber, // Block number in which the event was emitted
-        l2BlockHash: nullifierIndex.l2BlockHash, // Block hash in which the event was emitted
-      },
-    );
+    return this.privateEventStore.storePrivateEventLog(selector, randomness, content, siloedEventCommitment, {
+      contractAddress,
+      scope,
+      txHash,
+      l2BlockNumber: txEffect.l2BlockNumber,
+      l2BlockHash: txEffect.l2BlockHash,
+      txIndexInBlock: txEffect.txIndexInBlock,
+      eventIndexInTx,
+    });
   }
 }

package/src/notes/note_service.ts

@@ -41,7 +41,7 @@ export class NoteService {
       scopes,
     });
     return noteDaos.map(
-      ({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier, index }) => ({
+      ({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier }) => ({
         contractAddress,
         owner,
         storageSlot,
@@ -49,9 +49,8 @@ export class NoteService {
         noteNonce,
         note,
         noteHash,
+        isPending: false, // Note service deals only with settled notes
         siloedNullifier,
-        // PXE can use this index to get full MembershipWitness
-        index,
       }),
     );
   }
@@ -146,7 +145,10 @@ export class NoteService {
     const uniqueNoteHash = await computeUniqueNoteHash(noteNonce, await siloNoteHash(contractAddress, noteHash));
     const siloedNullifier = await siloNullifier(contractAddress, nullifier);
 
-    const txEffect = await this.aztecNode.getTxEffect(txHash);
+    const [txEffect, [nullifierIndex]] = await Promise.all([
+      this.aztecNode.getTxEffect(txHash),
+      this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [siloedNullifier]),
+    ]);
     if (!txEffect) {
       throw new Error(`Could not find tx effect for tx hash ${txHash}`);
     }
@@ -155,25 +157,12 @@ export class NoteService {
       throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${syncedBlockNumber}`);
     }
 
-    const noteInTx = txEffect.data.noteHashes.some(nh => nh.equals(uniqueNoteHash));
-    if (!noteInTx) {
+    // Find the index of the note hash in the noteHashes array to determine note ordering within the tx
+    const noteIndexInTx = txEffect.data.noteHashes.findIndex(nh => nh.equals(uniqueNoteHash));
+    if (noteIndexInTx === -1) {
       throw new Error(`Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present in tx ${txHash}`);
     }
 
-    // We store notes by their index in the global note hash tree, which has the convenient side effect of validating
-    // note existence in said tree. We concurrently also check if the note's nullifier exists, performing all node
-    // queries in a single round-trip.
-    const [[uniqueNoteHashTreeIndexInBlock], [nullifierIndex]] = await Promise.all([
-      this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NOTE_HASH_TREE, [uniqueNoteHash]),
-      this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [siloedNullifier]),
-    ]);
-
-    if (uniqueNoteHashTreeIndexInBlock === undefined) {
-      throw new Error(
-        `Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present on the tree at block ${syncedBlockNumber} (from tx ${txHash})`,
-      );
-    }
-
     const noteDao = new NoteDao(
       new Note(content),
       contractAddress,
@@ -184,15 +173,17 @@ export class NoteService {
       noteHash,
       siloedNullifier,
       txHash,
-      uniqueNoteHashTreeIndexInBlock.l2BlockNumber,
-      uniqueNoteHashTreeIndexInBlock.l2BlockHash.toString(),
-      uniqueNoteHashTreeIndexInBlock.data,
+      txEffect.l2BlockNumber,
+      txEffect.l2BlockHash.toString(),
+      txEffect.txIndexInBlock,
+      noteIndexInTx,
     );
 
     // The note was found by `recipient`, so we use that as the scope when storing the note.
     await this.noteStore.addNotes([noteDao], recipient);
 
     if (nullifierIndex !== undefined) {
+      // We found nullifier index which implies that the note has already been nullified.
       const { data: _, ...blockHashAndNum } = nullifierIndex;
       await this.noteStore.applyNullifiers([{ data: siloedNullifier, ...blockHashAndNum }]);
     }

package/src/private_kernel/private_kernel_oracle.ts

@@ -1,73 +1,155 @@
-import { FUNCTION_TREE_HEIGHT, NOTE_HASH_TREE_HEIGHT, VK_TREE_HEIGHT } from '@aztec/constants';
+import { FUNCTION_TREE_HEIGHT, NOTE_HASH_TREE_HEIGHT, PUBLIC_DATA_TREE_HEIGHT, VK_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 import { MembershipWitness } from '@aztec/foundation/trees';
+import type { KeyStore } from '@aztec/key-store';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockParameter } from '@aztec/stdlib/block';
+import {
+  type ContractInstanceWithAddress,
+  computeContractClassIdPreimage,
+  computeSaltedInitializationHash,
+} from '@aztec/stdlib/contract';
+import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
-import type { PublicKeys } from '@aztec/stdlib/keys';
 import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+// TODO: Block number should not be "latest".
+// It should be fixed at the time the proof is being simulated. I.e., it should be the same as the value defined in the constant data.
+
 /**
  * Provides functionality needed by the private kernel for interacting with our state trees.
- * This is either PrivateKernelOracleImpl, or a mocked test implementation.
  */
-export interface PrivateKernelOracle {
+export class PrivateKernelOracle {
+  constructor(
+    private contractStore: ContractStore,
+    private keyStore: KeyStore,
+    private node: AztecNode,
+    private blockNumber: BlockParameter = 'latest',
+  ) {}
+
   /** Retrieves the preimage of a contract address from the registered contract instances db. */
-  getContractAddressPreimage(address: AztecAddress): Promise<{
-    saltedInitializationHash: Fr;
-    publicKeys: PublicKeys;
-    currentContractClassId: Fr;
-    originalContractClassId: Fr;
-  }>;
+  public async getContractAddressPreimage(
+    address: AztecAddress,
+  ): Promise<ContractInstanceWithAddress & { saltedInitializationHash: Fr }> {
+    const instance = await this.contractStore.getContractInstance(address);
+    if (!instance) {
+      throw new Error(`Contract instance not found when getting address preimage. Contract address: ${address}.`);
+    }
+    return {
+      saltedInitializationHash: await computeSaltedInitializationHash(instance),
+      ...instance,
+    };
+  }
 
   /** Retrieves the preimage of a contract class id from the contract classes db. */
-  getContractClassIdPreimage(
-    contractClassId: Fr,
-  ): Promise<{ artifactHash: Fr; publicBytecodeCommitment: Fr; privateFunctionsRoot: Fr }>;
+  public async getContractClassIdPreimage(contractClassId: Fr) {
+    const contractClass = await this.contractStore.getContractClass(contractClassId);
+    if (!contractClass) {
+      throw new Error(`Contract class not found when getting class id preimage. Class id: ${contractClassId}.`);
+    }
+    return computeContractClassIdPreimage(contractClass);
+  }
 
-  /**
-   * Returns a membership witness with the sibling path and leaf index in our private functions tree.
-   */
-  getFunctionMembershipWitness(
+  /** Returns a membership witness with the sibling path and leaf index in our private functions tree. */
+  public async getFunctionMembershipWitness(
     contractClassId: Fr,
     selector: FunctionSelector,
-  ): Promise<MembershipWitness<typeof FUNCTION_TREE_HEIGHT>>;
+  ): Promise<MembershipWitness<typeof FUNCTION_TREE_HEIGHT>> {
+    const membershipWitness = await this.contractStore.getFunctionMembershipWitness(contractClassId, selector);
+    if (!membershipWitness) {
+      throw new Error(
+        `Membership witness not found for contract class id ${contractClassId} and selector ${selector}.`,
+      );
+    }
+    return membershipWitness;
+  }
 
   /**
    * Returns a membership witness with the sibling path and leaf index in our protocol VK indexed merkle tree.
    * Used to validate the previous kernel's verification key.
    */
-  getVkMembershipWitness(vk: VerificationKeyAsFields): Promise<MembershipWitness<typeof VK_TREE_HEIGHT>>;
+  public getVkMembershipWitness(vk: VerificationKeyAsFields): Promise<MembershipWitness<typeof VK_TREE_HEIGHT>> {
+    const leafIndex = getVKIndex(vk);
+    return Promise.resolve(new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
+  }
 
-  /**
-   * Returns a membership witness with the sibling path and leaf index in our private function indexed merkle tree.
-   */
-  getNoteHashMembershipWitness(noteHash: Fr): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT> | undefined>;
+  /** Returns a membership witness with the sibling path and leaf index in our note hash tree. */
+  getNoteHashMembershipWitness(noteHash: Fr): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT> | undefined> {
+    return this.node.getNoteHashMembershipWitness(this.blockNumber, noteHash);
+  }
 
-  /**
-   * Returns a membership witness with the sibling path and leaf index in our nullifier indexed merkle tree.
-   */
-  getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-  /**
-   * Returns the root of our note hash merkle tree.
-   */
-  getNoteHashTreeRoot(): Promise<Fr>;
+  /** Returns a membership witness with the sibling path and leaf index in our nullifier indexed merkle tree. */
+  getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined> {
+    return this.node.getNullifierMembershipWitness(this.blockNumber, nullifier);
+  }
+
+  /** Returns the root of our note hash merkle tree. */
+  async getNoteHashTreeRoot(): Promise<Fr> {
+    const header = await this.node.getBlockHeader(this.blockNumber);
+    if (!header) {
+      throw new Error(`No block header found for block number ${this.blockNumber}`);
+    }
+    return header.state.partial.noteHashTree.root;
+  }
 
   /**
    * Retrieves the sk_m corresponding to the pk_m.
    * @throws If the provided public key is not associated with any of the registered accounts.
-   * @param pkM - The master public key to get secret key for.
+   * @param masterPublicKey - The master public key to get secret key for.
    * @returns A Promise that resolves to sk_m.
    * @dev Used when feeding the sk_m to the kernel circuit for keys verification.
    */
-  getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinScalar>;
+  public getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinScalar> {
+    return this.keyStore.getMasterSecretKey(masterPublicKey);
+  }
 
   /** Use debug data to get the function name corresponding to a selector. */
-  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+  public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    return this.contractStore.getDebugFunctionName(contractAddress, selector);
+  }
+
+  /**
+   * Returns a membership witness and leaf index to our public data indexed merkle tree,
+   * along with an associated DelayedPublicMutable containing the class ID to update.
+   */
+  public async getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints> {
+    const { delayedPublicMutableSlot, delayedPublicMutableHashSlot } =
+      await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
+
+    const hashLeafSlot = await computePublicDataTreeLeafSlot(
+      ProtocolContractAddress.ContractInstanceRegistry,
+      delayedPublicMutableHashSlot,
+    );
+    const updatedClassIdWitness = await this.node.getPublicDataWitness(this.blockNumber, hashLeafSlot);
+
+    if (!updatedClassIdWitness) {
+      throw new Error(`No public data tree witness found for ${hashLeafSlot}`);
+    }
+
+    const readStorage = (storageSlot: Fr) =>
+      this.node.getPublicStorageAt(this.blockNumber, ProtocolContractAddress.ContractInstanceRegistry, storageSlot);
+    const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(
+      delayedPublicMutableSlot,
+      readStorage,
+    );
 
-  /** Returns a membership witness and leaf index to our public data indexed merkle tree,
-   * along with an associated DelayedPublicMutable containing the class ID to update. */
-  getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints>;
+    return new UpdatedClassIdHints(
+      new MembershipWitness(
+        PUBLIC_DATA_TREE_HEIGHT,
+        updatedClassIdWitness.index,
+        updatedClassIdWitness.siblingPath.toTuple(),
+      ),
+      updatedClassIdWitness.leafPreimage,
+      delayedPublicMutableValues,
+    );
+  }
 }