@aztec/pxe 5.0.0-rc.2 → 5.0.0

package/src/entrypoints/client/lazy/utils.ts

@@ -1,6 +1,6 @@
 import { BBLazyPrivateKernelProver } from '@aztec/bb-prover/client/lazy';
 import { createLogger } from '@aztec/foundation/log';
-import { createStore } from '@aztec/kv-store/indexeddb';
+import { createStore } from '@aztec/kv-store/sqlite-opfs';
 import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/providers/lazy';
 import { WASMSimulator } from '@aztec/simulator/client';
 import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry/lazy';
@@ -37,7 +37,7 @@ export async function createPXE(
 
   const loggers = options.loggers ?? {};
 
-  const storeLogger = loggers.store ?? createLogger('pxe:data:idb', { actor });
+  const storeLogger = loggers.store ?? createLogger('pxe:data', { actor });
 
   const store =
     options.store ?? (await createStore('pxe_data', configWithContracts, PXE_DATA_SCHEMA_VERSION, storeLogger));

package/src/entrypoints/server/index.ts

@@ -1,3 +1,5 @@
+export { type AccountPrivacyKeys, type AccountPrivacySecretKeys } from '@aztec/key-store';
+
 export * from '../../notes_filter.js';
 export * from '../../pxe.js';
 export * from '../../config/index.js';
@@ -8,4 +10,6 @@ export { NoteService } from '../../notes/note_service.js';
 export { ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR } from '../../oracle_version.js';
 export { type PXECreationOptions } from '../pxe_creation_options.js';
 export { JobCoordinator } from '../../job_coordinator/job_coordinator.js';
-export { ContractSyncService } from '../../contract_sync/contract_sync_service.js';
+export { ContractSyncService } from '../../contract/contract_sync_service.js';
+export { ContractClassService } from '../../contract/contract_class_service.js';
+export { AnchoredContractData } from '../../contract_function_simulator/anchored_contract_data.js';

package/src/error_enriching.ts

@@ -3,7 +3,9 @@ import { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '@
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type SimulationError, isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 
+import type { ContractClassService } from './contract/contract_class_service.js';
 import type { ContractStore } from './storage/contract_store/contract_store.js';
 
 /**
@@ -11,7 +13,13 @@ import type { ContractStore } from './storage/contract_store/contract_store.js';
  * can be found in the PXE database
  * @param err - The error to enrich.
  */
-export async function enrichSimulationError(err: SimulationError, contractStore: ContractStore, logger: Logger) {
+export async function enrichSimulationError(
+  err: SimulationError,
+  contractStore: ContractStore,
+  contractClassService: ContractClassService,
+  anchorHeader: BlockHeader,
+  logger: Logger,
+) {
   // Maps contract addresses to the set of function selectors that were in error.
   // Map and Set do reference equality for their keys instead of value equality, so we store the string
   // representation to get e.g. different contract address objects with the same address value to match.
@@ -30,13 +38,14 @@ export async function enrichSimulationError(err: SimulationError, contractStore:
   await Promise.all(
     [...mentionedFunctions.entries()].map(async ([contractAddress, fnSelectors]) => {
       const parsedContractAddress = AztecAddress.fromStringUnsafe(contractAddress);
-      const contract = await contractStore.getContract(parsedContractAddress);
-      if (contract) {
-        err.enrichWithContractName(parsedContractAddress, contract.name);
+      const classId = await contractClassService.getCurrentClassId(parsedContractAddress, anchorHeader);
+      const artifact = classId && (await contractStore.getContractArtifact(classId));
+      if (artifact) {
+        err.enrichWithContractName(parsedContractAddress, artifact.name);
         // Map from function selector to function name. It uses a stringified key for the same reason as mentionedFunctions.
         const selectorToNameMap: Map<string, string> = new Map();
         await Promise.all(
-          contract.functions.map(async fn => {
+          artifact.functions.map(async fn => {
             const selector = await FunctionSelector.fromNameAndParameters(fn);
             selectorToNameMap.set(selector.toString(), fn.name);
           }),
@@ -51,7 +60,7 @@ export async function enrichSimulationError(err: SimulationError, contractStore:
             );
           } else {
             logger.warn(
-              `Could not find function artifact in contract ${contract.name} for function '${fnSelector}' when enriching error callstack`,
+              `Could not find function artifact in contract ${artifact.name} for function '${fnSelector}' when enriching error callstack`,
             );
           }
         }
@@ -64,7 +73,13 @@ export async function enrichSimulationError(err: SimulationError, contractStore:
   );
 }
 
-export async function enrichPublicSimulationError(err: SimulationError, contractStore: ContractStore, logger: Logger) {
+export async function enrichPublicSimulationError(
+  err: SimulationError,
+  contractStore: ContractStore,
+  contractClassService: ContractClassService,
+  anchorHeader: BlockHeader,
+  logger: Logger,
+) {
   const callStack = err.getCallStack();
   const originalFailingFunction = callStack[callStack.length - 1];
 
@@ -72,7 +87,8 @@ export async function enrichPublicSimulationError(err: SimulationError, contract
     throw new Error(`Original failing function not found when enriching public simulation, missing callstack`);
   }
 
-  const artifact = await contractStore.getPublicFunctionArtifact(originalFailingFunction.contractAddress);
+  const classId = await contractClassService.getCurrentClassId(originalFailingFunction.contractAddress, anchorHeader);
+  const artifact = classId && (await contractStore.getPublicFunctionArtifact(classId));
   if (!artifact) {
     throw new Error(
       `Artifact not found when enriching public simulation error. Contract address: ${originalFailingFunction.contractAddress}.`,
@@ -84,7 +100,7 @@ export async function enrichPublicSimulationError(err: SimulationError, contract
     err.setOriginalMessage(err.getOriginalMessage() + `${assertionMessage}`);
   }
 
-  const debugInfo = await contractStore.getPublicFunctionDebugMetadata(originalFailingFunction.contractAddress);
+  const debugInfo = await contractStore.getPublicFunctionDebugMetadata(classId);
 
   const noirCallStack = err.getNoirCallStack();
   if (debugInfo) {
@@ -102,6 +118,6 @@ export async function enrichPublicSimulationError(err: SimulationError, contract
         );
       }
     }
-    await enrichSimulationError(err, contractStore, logger);
+    await enrichSimulationError(err, contractStore, contractClassService, anchorHeader, logger);
   }
 }

package/src/hooks/execution_hooks.ts

@@ -1,4 +1,5 @@
 import type { AuthorizeUtilityCall } from './authorize_utility_call.js';
+import type { ResolveCustomRequest } from './resolve_custom_request.js';
 import type { ResolveTaggingSecretStrategy } from './resolve_tagging_secret_strategy.js';
 
 /**
@@ -28,8 +29,12 @@ import type { ResolveTaggingSecretStrategy } from './resolve_tagging_secret_stra
  *         ? { authorized: true }
  *         : { authorized: false, reason: 'Unknown target' };
  *     },
- *     // When there's no established way to reach the recipient, fall back to a non-interactive handshake.
- *     resolveTaggingSecretStrategy: async () => ({ type: 'non-interactive-handshake' }),
+ *     // Apply per-recipient policy: reach a known contact via their address keys (no onchain trace) and use a
+ *     // non-interactive handshake for everyone else.
+ *     resolveTaggingSecretStrategy: async ({ recipient }) =>
+ *       knownContacts.has(recipient.toString())
+ *         ? { type: 'address-derived' }
+ *         : { type: 'non-interactive-handshake' },
  *   },
  * });
  * ```
@@ -39,10 +44,16 @@ export interface ExecutionHooks {
   authorizeUtilityCall?: AuthorizeUtilityCall;
   /**
    * Resolves a message's tagging secret when none is already established for the sender/recipient pair, letting the
-   * wallet apply per-recipient policy. PXE applies a privacy-safe default when absent.
+   * wallet apply per-recipient policy. PXE applies a default when absent.
    * See {@link ResolveTaggingSecretStrategy} for the request shape and defaults.
    */
   resolveTaggingSecretStrategy?: ResolveTaggingSecretStrategy;
+  /**
+   * Resolves a custom, caller-defined request a circuit cannot serve from local state. Any contract can issue one, so
+   * an implementor should verify both the request `kind` and the issuing contract (its address and class ID) before
+   * fulfilling it. Rejected when absent; see {@link ResolveCustomRequest}.
+   */
+  resolveCustomRequest?: ResolveCustomRequest;
 }
 
 /**

package/src/hooks/index.ts

@@ -4,7 +4,9 @@ export type {
   UtilityCallAuthorizationResponse,
 } from './authorize_utility_call.js';
 export { type ExecutionHooks, composeHooks } from './execution_hooks.js';
+export { type CustomRequest, type ResolveCustomRequest } from './resolve_custom_request.js';
 export {
+  DEFAULT_TAGGING_SECRET_STRATEGY,
   type ResolveTaggingSecretStrategy,
   type TaggingSecretStrategy,
   type TaggingSecretStrategyRequest,

package/src/hooks/resolve_custom_request.ts

@@ -0,0 +1,24 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/**
+ * A custom, caller-defined request resolved via the {@link ResolveCustomRequest} hook. It carries no fixed meaning:
+ * `kind` selects the request type so one hook can serve many such types, and `payload` holds the opaque,
+ * request-specific arguments. The resolver answers by whatever means it needs (local state, a third party,
+ * offchain data).
+ */
+export type CustomRequest = {
+  /** The address of the contract issuing the request. */
+  contractAddress: AztecAddress;
+  /** The issuing contract's class ID, so resolvers can apply class-level (not just per-address) policy. */
+  contractClassId: Fr;
+  /** Discriminates the request type, letting one hook serve many such types. */
+  kind: Fr;
+  /** Opaque, request-specific arguments. */
+  payload: Fr[];
+};
+
+/**
+ * Hook resolving a {@link CustomRequest}. The resolver produces the response however it needs to.
+ */
+export type ResolveCustomRequest = (request: CustomRequest) => Promise<Fr[]>;

package/src/hooks/resolve_tagging_secret_strategy.ts

@@ -3,6 +3,9 @@ import type { Point } from '@aztec/foundation/curves/grumpkin';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { AppTaggingSecretKind } from '@aztec/stdlib/logs';
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- only referenced by a {@link} doc tag
+import type { ResolveCustomRequest } from './resolve_custom_request.js';
+
 /**
  * How a message's tagging secret is chosen: the wallet's strategy, returned by the `resolveTaggingSecretStrategy` hook
  * when no onchain handshake has been registered for the sender/recipient pair. This is intent (plus, for an arbitrary
@@ -13,6 +16,14 @@ export type TaggingSecretStrategy =
       /** Establish a fresh non-interactive handshake via the onchain registry; reveals the recipient onchain. */
       type: 'non-interactive-handshake';
     }
+  | {
+      /**
+       * Establish a fresh interactive handshake via the onchain registry. Reveals nothing about the recipient
+       * onchain, but requires the recipient to answer the registry's signed-authorization request (served through
+       * the {@link ResolveCustomRequest} hook), so the send fails when it cannot be served.
+       */
+      type: 'interactive-handshake';
+    }
   | {
       /** Derive the secret from the sender's and recipient's address keys via ECDH. PXE computes and silos it. */
       type: 'address-derived';
@@ -28,6 +39,9 @@ export type TaggingSecretStrategy =
       secret: Point;
     };
 
+/** The strategy PXE applies to both delivery modes when no `resolveTaggingSecretStrategy` hook is configured. */
+export const DEFAULT_TAGGING_SECRET_STRATEGY: TaggingSecretStrategy = { type: 'non-interactive-handshake' };
+
 /** Information about the message delivery requesting a tagging secret strategy. */
 export type TaggingSecretStrategyRequest = {
   contractAddress: AztecAddress;

package/src/logs/log_service.ts

@@ -9,8 +9,8 @@ import type { CompleteAddress } from '@aztec/stdlib/contract';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import {
   AppTaggingSecret,
+  AppTaggingSecretKind,
   type LogResult,
-  type PendingTaggedLog,
   SiloedTag,
   computeSharedTaggingSecret,
 } from '@aztec/stdlib/logs';
@@ -21,6 +21,8 @@ import {
   LogSource,
 } from '../contract_function_simulator/noir-structs/log_retrieval_request.js';
 import type { LogRetrievalResponse } from '../contract_function_simulator/noir-structs/log_retrieval_response.js';
+import type { PendingTaggedLog } from '../contract_function_simulator/noir-structs/pending_tagged_log.js';
+import { ResolvedTx } from '../contract_function_simulator/noir-structs/resolved_tx.js';
 import { AddressStore } from '../storage/address_store/address_store.js';
 import type { RecipientTaggingStore } from '../storage/tagging_store/recipient_tagging_store.js';
 import type { TaggingSecretSourcesStore } from '../storage/tagging_store/tagging_secret_sources_store.js';
@@ -176,6 +178,9 @@ export class LogService {
       txHash: log.txHash,
       uniqueNoteHashesInTx: noteHashes,
       firstNullifierInTx: nullifiers[0],
+      blockNumber: log.blockNumber,
+      blockTimestamp: log.blockTimestamp,
+      blockHash: log.blockHash,
     };
   }
 
@@ -216,17 +221,17 @@ export class LogService {
       }
       return {
         log: log.logData,
-        context: { txHash: log.txHash, uniqueNoteHashesInTx: noteHashes, firstNullifierInTx: nullifiers[0] },
+        context: new ResolvedTx(log.txHash, noteHashes, nullifiers[0], log.blockNumber, log.blockHash.toFr()),
       };
     });
   }
 
   /**
    * Computes the tagging secrets PXE can enumerate for a recipient: one per known sender (via ECDH) plus any
-   * pre-shared secret points registered directly for the recipient, each siloed to `contractAddress` and directed to
-   * `recipient`. These require knowing the recipient's address preimage and keys, so returns an empty array when those
-   * are unavailable. App-supplied secrets (e.g. handshake-derived) are handled separately by the caller and do not go
-   * through here.
+   * pre-shared secrets registered directly for the recipient. Each registered secret is scanned under the tag
+   * streams its kind can back. Deriving the sender-based secrets requires the recipient's address preimage and keys,
+   * so returns an empty array when those are unavailable. App-supplied secrets (e.g. derived from discovered
+   * handshakes) are handled separately by the caller and do not go through here.
    */
   async #getPointDerivedSecrets(contractAddress: AztecAddress, recipient: AztecAddress): Promise<AppTaggingSecret[]> {
     const recipientCompleteAddress = await this.addressStore.getCompleteAddress(recipient);
@@ -238,11 +243,26 @@ export class LogService {
     }
     const recipientIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
 
-    const points = [
-      ...(await this.#getSecretsForSenders(recipientCompleteAddress, recipientIvsk)),
-      ...(await this.taggingSecretSourcesStore.getSharedSecretsForRecipient(recipient)),
-    ];
-    return Promise.all(points.map(secret => AppTaggingSecret.compute(secret, contractAddress, recipient)));
+    const [senderPoints, registeredSecrets] = await Promise.all([
+      this.#getSecretsForSenders(recipientCompleteAddress, recipientIvsk),
+      this.taggingSecretSourcesStore.getSharedSecretsForRecipient(recipient),
+    ]);
+    return Promise.all([
+      ...senderPoints.map(secret => AppTaggingSecret.computeDirectional(secret, contractAddress, recipient)),
+      ...registeredSecrets.flatMap(({ kind, secret }) => {
+        switch (kind) {
+          case 'arbitrary-secret':
+            return [AppTaggingSecret.computeDirectional(secret, contractAddress, recipient)];
+          case 'handshake':
+            // A handshake-backed sender tags messages with the bare app-siloed secret, one tag domain per delivery
+            // mode.
+            return [
+              AppTaggingSecret.computeAppSiloed(secret, contractAddress, AppTaggingSecretKind.UNCONSTRAINED),
+              AppTaggingSecret.computeAppSiloed(secret, contractAddress, AppTaggingSecretKind.CONSTRAINED),
+            ];
+        }
+      }),
+    ]);
   }
 
   async #getSecretsForSenders(

package/src/oracle_version.ts

@@ -11,7 +11,7 @@
 /// if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency without actually
 /// using any of the new oracles then there is no reason to throw.
 export const ORACLE_VERSION_MAJOR = 30;
-export const ORACLE_VERSION_MINOR = 1;
+export const ORACLE_VERSION_MINOR = 7;
 
 /// This hash is computed from the `ORACLE_REGISTRY` declaration (each oracle's name, ordered parameter names and
 /// types, and return type) and is used to detect when the oracle interface changes. When it does, you need to either:
@@ -19,4 +19,4 @@ export const ORACLE_VERSION_MINOR = 1;
 /// - increment only `ORACLE_VERSION_MINOR` if the change is additive (a new oracle was added).
 ///
 /// These constants must be kept in sync between this file and `noir-projects/aztec-nr/aztec/src/oracle/version.nr`.
-export const ORACLE_INTERFACE_HASH = '2a441f29ab01b252bc74b91b07fc2514891c28bffdfa0042d80494271b75edee';
+export const ORACLE_INTERFACE_HASH = '416b0e7d3e6dca5803ebe2a65ea93f1e79759dc39ef8ec4c52eeba5e2b0f3fca';

package/src/private_kernel/hints/private_kernel_reset_private_inputs_builder.ts

@@ -35,6 +35,7 @@ import {
   findPrivateKernelResetDimensions,
   getNoteHashReadRequestResetActions,
   getNullifierReadRequestResetActions,
+  kernelStateIsForPublic,
   privateKernelResetDimensionNames,
 } from '@aztec/stdlib/kernel';
 import { type PrivateCallExecutionResult, collectNested } from '@aztec/stdlib/tx';
@@ -138,10 +139,19 @@ export class PrivateKernelResetPrivateInputsBuilder {
     // The dimensions found must be big enough to reset all values, i.e. empty remainder.
     const allowRemainder = isInner;
 
+    // Terminal reset picks from the finalTail / finalTailToPublic catalogs; mid-tx resets always
+    // use the inner catalog. The public/private decision must match `kernelStateIsForPublic` - the
+    // same predicate the circuit inputs and the orchestrator use.
+    const mode = isInner
+      ? ('inner' as const)
+      : kernelStateIsForPublic(this.previousKernel)
+        ? ('finalTailToPublic' as const)
+        : ('finalTail' as const);
+
     const dimensions = findPrivateKernelResetDimensions(
       this.requestedDimensions,
       privateKernelResetDimensionsConfig,
-      isInner,
+      mode,
       allowRemainder,
     );
 

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -24,8 +24,8 @@ import {
   PrivateKernelInner2CircuitPrivateInputs,
   PrivateKernelInner3CircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
+  PrivateKernelResetTailCircuitPrivateInputs,
   type PrivateKernelSimulateOutput,
-  PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
   PrivateVerificationKeyHints,
   type UpdatedClassIdHints,
@@ -170,7 +170,6 @@ export class PrivateKernelExecutionProver {
         previousOutput: output,
         txRequest,
         isPrivateOnlyTx,
-        firstNullifierHint: executionResult.firstNullifier,
         minRevertibleSideEffectCounter,
         executionSteps,
         generateWitnesses,
@@ -179,7 +178,8 @@ export class PrivateKernelExecutionProver {
       firstIteration = false;
     }
 
-    // Final reset: include siloing of note hashes, nullifiers and private logs.
+    // Terminal reset+tail. The final reset must be performed exactly once because each tx has at
+    // least one nullifier that requires siloing, and siloing cannot be done multiple times.
     const finalResetBuilder = new PrivateKernelResetPrivateInputsBuilder(
       output,
       [],
@@ -187,29 +187,9 @@ export class PrivateKernelExecutionProver {
       splitCounter,
     );
     if (!finalResetBuilder.needsReset()) {
-      // The final reset must be performed exactly once, because each tx has at least one nullifier that requires
-      // siloing, and siloing cannot be done multiple times.
-      // While, in theory, it might be possible to silo note hashes first and then run another reset to silo nullifiers
-      // and/or private logs, we currently don't have standalone dimensions for the arrays that require siloing. As a
-      // result, all necessary siloing must be done together in a single reset.
+      // Siloing for note hashes, nullifiers, and private logs is dimensioned as one terminal reset.
       // Refer to the possible combinations of dimensions in private_kernel_reset_config.json.
       throw new Error('Nothing to reset for the final reset.');
-    } else {
-      const witgenTimer = new Timer();
-      const privateInputs = await finalResetBuilder.build(this.oracle);
-      output = generateWitnesses
-        ? await this.proofCreator.generateResetOutput(privateInputs)
-        : await this.proofCreator.simulateReset(privateInputs);
-
-      executionSteps.push({
-        functionName: 'private_kernel_reset',
-        bytecode: output.bytecode,
-        witness: output.outputWitness,
-        vk: output.verificationKey.keyAsBytes,
-        timings: {
-          witgen: witgenTimer.ms(),
-        },
-      });
     }
 
     if (output.publicInputs.feePayer.isZero() && skipFeeEnforcement) {
@@ -218,34 +198,35 @@ export class PrivateKernelExecutionProver {
       }
       output.publicInputs.feePayer = new AztecAddress(Fr.MAX_FIELD_VALUE);
     }
-    // Private tail.
-    const vkData = await this.getVkData(output.verificationKey);
-    const previousKernelData = new PrivateKernelData(output.publicInputs, vkData);
-
-    this.log.debug(
-      `Calling private kernel tail with hwm ${previousKernelData.publicInputs.minRevertibleSideEffectCounter}`,
-    );
 
     // TODO: Enable padding once we better understand the final amounts to pad to.
     const paddedSideEffectAmounts = PaddedSideEffectAmounts.empty();
 
     // Round the aggregated expirationTimestamp down to reduce precision and avoid leaking which private
     // functions were called via their exact expiration offsets.
-    const expirationTimestampUpperBound = computeTxExpirationTimestamp(previousKernelData.publicInputs);
-
-    const privateInputs = new PrivateKernelTailCircuitPrivateInputs(
-      previousKernelData,
+    const expirationTimestampUpperBound = computeTxExpirationTimestamp(output.publicInputs);
+
+    const resetInputs = await finalResetBuilder.build(this.oracle);
+    const mergedInputs = new PrivateKernelResetTailCircuitPrivateInputs(
+      resetInputs.previousKernel,
+      resetInputs.paddedSideEffects,
+      resetInputs.hints,
+      resetInputs.dimensions,
       paddedSideEffectAmounts,
       expirationTimestampUpperBound,
     );
 
+    this.log.debug(
+      `Calling terminal private kernel reset+tail (${mergedInputs.isForPublic() ? 'to-public' : 'to-rollup'}) with hwm ${output.publicInputs.minRevertibleSideEffectCounter}`,
+    );
+
     const witgenTimer = new Timer();
     const tailOutput = generateWitnesses
-      ? await this.proofCreator.generateTailOutput(privateInputs)
-      : await this.proofCreator.simulateTail(privateInputs);
+      ? await this.proofCreator.generateResetTailOutput(mergedInputs)
+      : await this.proofCreator.simulateResetTail(mergedInputs);
 
     executionSteps.push({
-      functionName: 'private_kernel_tail',
+      functionName: mergedInputs.isForPublic() ? 'private_kernel_reset_tail_to_public' : 'private_kernel_reset_tail',
       bytecode: tailOutput.bytecode,
       witness: tailOutput.outputWitness,
       vk: tailOutput.verificationKey.keyAsBytes,
@@ -457,7 +438,6 @@ export class PrivateKernelExecutionProver {
     previousOutput: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>;
     txRequest: TxRequest;
     isPrivateOnlyTx: boolean;
-    firstNullifierHint: Fr;
     minRevertibleSideEffectCounter: number;
     executionSteps: PrivateExecutionStep[];
     generateWitnesses: boolean;
@@ -468,7 +448,6 @@ export class PrivateKernelExecutionProver {
       previousOutput,
       txRequest,
       isPrivateOnlyTx,
-      firstNullifierHint,
       minRevertibleSideEffectCounter,
       executionSteps,
       generateWitnesses,
@@ -488,12 +467,9 @@ export class PrivateKernelExecutionProver {
             ProtocolContractsList,
             apps[0],
             isPrivateOnlyTx,
-            firstNullifierHint,
             minRevertibleSideEffectCounter,
           );
-          this.log.debug(
-            `Calling private kernel init with isPrivateOnly ${isPrivateOnlyTx} and firstNullifierHint ${proofInput.firstNullifierHint}`,
-          );
+          this.log.debug(`Calling private kernel init with isPrivateOnly ${isPrivateOnlyTx}`);
           pushTestData('private-kernel-inputs-init', proofInput);
           output = generateWitnesses
             ? await this.proofCreator.generateInitOutput(proofInput)
@@ -509,12 +485,9 @@ export class PrivateKernelExecutionProver {
             apps[0],
             apps[1],
             isPrivateOnlyTx,
-            firstNullifierHint,
             minRevertibleSideEffectCounter,
           );
-          this.log.debug(
-            `Calling private kernel init_2 with isPrivateOnly ${isPrivateOnlyTx} and firstNullifierHint ${proofInput.firstNullifierHint}`,
-          );
+          this.log.debug(`Calling private kernel init_2 with isPrivateOnly ${isPrivateOnlyTx}`);
           pushTestData('private-kernel-inputs-init-2', proofInput);
           output = generateWitnesses
             ? await this.proofCreator.generateInit2Output(proofInput)
@@ -531,12 +504,9 @@ export class PrivateKernelExecutionProver {
             apps[1],
             apps[2],
             isPrivateOnlyTx,
-            firstNullifierHint,
             minRevertibleSideEffectCounter,
           );
-          this.log.debug(
-            `Calling private kernel init_3 with isPrivateOnly ${isPrivateOnlyTx} and firstNullifierHint ${proofInput.firstNullifierHint}`,
-          );
+          this.log.debug(`Calling private kernel init_3 with isPrivateOnly ${isPrivateOnlyTx}`);
           pushTestData('private-kernel-inputs-init-3', proofInput);
           output = generateWitnesses
             ? await this.proofCreator.generateInit3Output(proofInput)

package/src/private_kernel/private_kernel_oracle.ts

@@ -22,30 +22,45 @@ import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import { AnchoredContractData } from '../contract_function_simulator/anchored_contract_data.js';
 import type { ContractStore } from '../storage/contract_store/contract_store.js';
 
 /**
  * Provides functionality needed by the private kernel for interacting with our state trees.
  */
 export class PrivateKernelOracle {
+  private readonly anchoredContractData: AnchoredContractData;
+
   constructor(
     private contractStore: ContractStore,
+    contractClassService: ContractClassService,
     private keyStore: KeyStore,
     private node: AztecNode,
     private blockHeader: BlockHeader,
-  ) {}
+  ) {
+    // Kernels never use contract overrides (those are confined to simulations, which skip proving), so this view is
+    // built without them.
+    this.anchoredContractData = new AnchoredContractData(contractStore, contractClassService, blockHeader);
+  }
 
   /** Retrieves the preimage of a contract address from the registered contract instances db. */
   public async getContractAddressPreimage(
     address: AztecAddress,
   ): Promise<ContractInstanceWithAddress & { saltedInitializationHash: Fr }> {
-    const instance = await this.contractStore.getContractInstance(address);
+    const instance = await this.anchoredContractData.getContractInstance(address);
     if (!instance) {
       throw new Error(`Contract instance not found when getting address preimage. Contract address: ${address}.`);
     }
+    // Local instance existence was checked above, so resolution below cannot come back empty.
+    const currentContractClassId = await this.anchoredContractData.getCurrentClassId(address);
+    if (!currentContractClassId) {
+      throw new Error(`Could not resolve the current class id for registered contract ${address}.`);
+    }
     return {
       saltedInitializationHash: await computeSaltedInitializationHash(instance),
       ...instance,
+      currentContractClassId,
     };
   }
 
@@ -114,8 +129,12 @@ export class PrivateKernelOracle {
   }
 
   /** Use debug data to get the function name corresponding to a selector. */
-  public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    return this.contractStore.getDebugFunctionName(contractAddress, selector);
+  public async getDebugFunctionName(
+    contractAddress: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<string | undefined> {
+    const classId = await this.anchoredContractData.getCurrentClassId(contractAddress);
+    return classId ? this.contractStore.getDebugFunctionName(classId, selector) : undefined;
   }
 
   /**