@aztec/pxe 0.0.1-commit.24de95ac → 0.0.1-commit.5daedc8

package/src/contract_function_simulator/pxe_oracle_interface.ts

@@ -3,12 +3,7 @@ import { timesParallel } from '@aztec/foundation/collection';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import type { KeyStore } from '@aztec/key-store';
-import {
-  EventSelector,
-  type FunctionArtifactWithContractName,
-  FunctionSelector,
-  getFunctionArtifact,
-} from '@aztec/stdlib/abi';
+import { EventSelector, type FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { InBlock, L2Block, L2BlockNumber } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
@@ -26,6 +21,7 @@ import {
 } from '@aztec/stdlib/logs';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { Note, type NoteStatus } from '@aztec/stdlib/note';
+import { NoteDao } from '@aztec/stdlib/note';
 import { MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import { TxHash } from '@aztec/stdlib/tx';
@@ -36,7 +32,6 @@ import { ORACLE_VERSION } from '../oracle_version.js';
 import type { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
 import type { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
 import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
-import { NoteDao } from '../storage/note_data_provider/note_dao.js';
 import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
 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';
@@ -102,16 +97,19 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       status,
       scopes,
     });
-    return noteDaos.map(({ contractAddress, storageSlot, noteNonce, note, noteHash, siloedNullifier, index }) => ({
-      contractAddress,
-      storageSlot,
-      noteNonce,
-      note,
-      noteHash,
-      siloedNullifier,
-      // PXE can use this index to get full MembershipWitness
-      index,
-    }));
+    return noteDaos.map(
+      ({ contractAddress, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier, index }) => ({
+        contractAddress,
+        storageSlot,
+        randomness,
+        noteNonce,
+        note,
+        noteHash,
+        siloedNullifier,
+        // PXE can use this index to get full MembershipWitness
+        index,
+      }),
+    );
   }
 
   async getFunctionArtifact(
@@ -129,18 +127,6 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     };
   }
 
-  async getFunctionArtifactByName(
-    contractAddress: AztecAddress,
-    functionName: string,
-  ): Promise<FunctionArtifactWithContractName | undefined> {
-    const instance = await this.contractDataProvider.getContractInstance(contractAddress);
-    if (!instance) {
-      return;
-    }
-    const artifact = await this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
-    return artifact && getFunctionArtifact(artifact, functionName);
-  }
-
   /**
    * Fetches a message from the db, given its key.
    * @param contractAddress - Address of a contract by which the message was emitted.
@@ -614,6 +600,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       this.deliverNote(
         request.contractAddress,
         request.storageSlot,
+        request.randomness,
         request.noteNonce,
         request.content,
         request.noteHash,
@@ -644,6 +631,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
   async deliverNote(
     contractAddress: AztecAddress,
     storageSlot: Fr,
+    randomness: Fr,
     noteNonce: Fr,
     content: Fr[],
     noteHash: Fr,
@@ -695,6 +683,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       new Note(content),
       contractAddress,
       storageSlot,
+      randomness,
       noteNonce,
       noteHash,
       siloedNullifier,
@@ -702,9 +691,9 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       uniqueNoteHashTreeIndexInBlock?.l2BlockNumber,
       uniqueNoteHashTreeIndexInBlock?.l2BlockHash.toString(),
       uniqueNoteHashTreeIndexInBlock?.data,
-      recipient,
     );
 
+    // The note was found by `recipient`, so we use that as the scope when storing the note.
     await this.noteDataProvider.addNotes([noteDao], recipient);
     this.log.verbose('Added note', {
       index: noteDao.index,
@@ -767,7 +756,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
             privateLog.firstNullifierInTx,
           );
         } else {
-          null;
+          return null;
         }
       }),
     );

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

@@ -1,4 +1,4 @@
-import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
@@ -49,7 +49,7 @@ export async function createPXE(
     ? loggers.prover
     : createLogger('pxe:bb:wasm:bundle' + (logSuffix ? `:${logSuffix}` : ''));
 
-  const prover = options.prover ?? new BBWASMBundlePrivateKernelProver(simulator, 16, proverLogger);
+  const prover = options.prover ?? new BBBundlePrivateKernelProver(simulator, proverLogger);
   const protocolContractsProvider = new BundledProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));

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

@@ -1,4 +1,4 @@
-import { BBWASMLazyPrivateKernelProver } from '@aztec/bb-prover/client/wasm/lazy';
+import { BBLazyPrivateKernelProver } from '@aztec/bb-prover/client/lazy';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
@@ -48,7 +48,7 @@ export async function createPXE(
     ? loggers.prover
     : createLogger('pxe:bb:wasm:bundle' + (logSuffix ? `:${logSuffix}` : ''));
 
-  const prover = options.prover ?? new BBWASMLazyPrivateKernelProver(simulator, 16, proverLogger);
+  const prover = options.prover ?? new BBLazyPrivateKernelProver(simulator, proverLogger);
 
   const protocolContractsProvider = new LazyProtocolContractsProvider();
 

package/src/entrypoints/server/utils.ts

@@ -1,5 +1,4 @@
-import { BBNativePrivateKernelProver } from '@aztec/bb-prover/client/native';
-import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
@@ -59,7 +58,7 @@ export async function createPXE(
     ? loggers.prover
     : createLogger('pxe:bb:native' + (logSuffix ? `:${logSuffix}` : ''));
 
-  const prover = options.prover ?? (await createProver(config, simulator, proverLogger));
+  const prover = options.prover ?? createProver(simulator, proverLogger);
   const protocolContractsProvider = new BundledProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
@@ -75,19 +74,6 @@ export async function createPXE(
   return pxe;
 }
 
-function createProver(
-  config: Pick<PXEConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>,
-  simulator: CircuitSimulator,
-  logger?: Logger,
-) {
-  if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return new BBWASMBundlePrivateKernelProver(simulator, 16, logger);
-  } else {
-    const bbConfig = config as Required<Pick<PXEConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> & PXEConfig;
-    return BBNativePrivateKernelProver.new(
-      { bbSkipCleanup: false, numConcurrentIVCVerifiers: 1, bbIVCConcurrency: 1, ...bbConfig },
-      simulator,
-      logger,
-    );
-  }
+function createProver(simulator: CircuitSimulator, logger?: Logger) {
+  return new BBBundlePrivateKernelProver(simulator, logger);
 }

package/src/oracle_version.ts

@@ -4,8 +4,8 @@
 ///
 /// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called
 /// and if the oracle version is incompatible an error is thrown.
-export const ORACLE_VERSION = 3;
+export const ORACLE_VERSION = 4;
 
 /// This hash is computed as by hashing the Oracle interface and it is used to detect when the Oracle interface changes,
 /// which in turn implies that you need to update the ORACLE_VERSION constant.
-export const ORACLE_INTERFACE_HASH = 'f9168ceb5a2227c148c5021ebffd4e2ca0da99885b87c5be3ee5ac0d8dd3d67c';
+export const ORACLE_INTERFACE_HASH = 'd1496df59c0b51a481d5ef93f218b5c35ddfce6242da28d60bb5c66386940eac';

package/src/private_kernel/hints/build_private_kernel_reset_private_inputs.ts

@@ -24,7 +24,6 @@ import {
   PrivateKernelResetDimensions,
   PrivateKernelResetHints,
   type PrivateKernelSimulateOutput,
-  type ReadRequest,
   ReadRequestActionEnum,
   ReadRequestResetActions,
   type ScopedKeyValidationRequestAndGenerator,
@@ -47,12 +46,10 @@ import type { PrivateKernelOracle } from '../private_kernel_oracle.js';
 
 function collectNestedReadRequests<N extends number>(
   executionStack: PrivateCallExecutionResult[],
-  extractReadRequests: (execution: PrivateCallExecutionResult) => ClaimedLengthArray<ReadRequest, N>,
+  extractReadRequests: (execution: PrivateCallExecutionResult) => ClaimedLengthArray<ScopedReadRequest, N>,
 ): ScopedReadRequest[] {
   return collectNested(executionStack, executionResult => {
-    return extractReadRequests(executionResult)
-      .getActiveItems()
-      .map(readRequest => new ScopedReadRequest(readRequest, executionResult.publicInputs.callContext.contractAddress));
+    return extractReadRequests(executionResult).getActiveItems();
   });
 }
 
@@ -104,7 +101,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
     private previousKernelOutput: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>,
     private executionStack: PrivateCallExecutionResult[],
     private noteHashNullifierCounterMap: Map<number, number>,
-    private validationRequestsSplitCounter: number,
+    private splitCounter: number,
   ) {
     this.previousKernel = previousKernelOutput.publicInputs;
     this.requestedDimensions = PrivateKernelResetDimensions.empty();
@@ -206,7 +203,6 @@ export class PrivateKernelResetPrivateInputsBuilder {
           oracle,
         ),
         this.transientDataSquashingHints,
-        this.validationRequestsSplitCounter,
       ),
       dimensions,
     );
@@ -403,7 +399,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
       futureNoteHashReads,
       futureNullifierReads,
       this.noteHashNullifierCounterMap,
-      this.validationRequestsSplitCounter,
+      this.splitCounter,
     );
 
     if (this.nextIteration && !numTransientData) {

package/src/private_kernel/hints/compute_side_effect_uniqueness_hints.ts

@@ -0,0 +1,173 @@
+import {
+  GLOBAL_INDEX_CONTRACT_CLASS_LOG_HASH_OFFSET,
+  GLOBAL_INDEX_L2_TO_L1_MSG_OFFSET,
+  GLOBAL_INDEX_NOTE_HASH_OFFSET,
+  GLOBAL_INDEX_NOTE_HASH_READ_REQUEST_OFFSET,
+  GLOBAL_INDEX_NULLIFIER_OFFSET,
+  GLOBAL_INDEX_NULLIFIER_READ_REQUEST_OFFSET,
+  GLOBAL_INDEX_PRIVATE_CALL_REQUEST_OFFSET,
+  GLOBAL_INDEX_PRIVATE_LOG_OFFSET,
+  GLOBAL_INDEX_PUBLIC_CALL_REQUEST_OFFSET,
+  MAX_CONTRACT_CLASS_LOGS_PER_CALL,
+  MAX_ENQUEUED_CALLS_PER_CALL,
+  MAX_L2_TO_L1_MSGS_PER_CALL,
+  MAX_NOTE_HASHES_PER_CALL,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIERS_PER_CALL,
+  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+  MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+  MAX_PRIVATE_LOGS_PER_CALL,
+  TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL,
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import type { Serializable } from '@aztec/foundation/serialize';
+import {
+  ClaimedLengthArray,
+  PrivateCallRequest,
+  type PrivateCircuitPublicInputs,
+  SideEffectCounterRange,
+  SideEffectUniquenessHints,
+} from '@aztec/stdlib/kernel';
+
+export function computeSideEffectUniquenessHints(publicInputs: PrivateCircuitPublicInputs): SideEffectUniquenessHints {
+  let sideEffectRanges: SideEffectCounterRange[] = [];
+
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.noteHashReadRequests,
+      GLOBAL_INDEX_NOTE_HASH_READ_REQUEST_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.nullifierReadRequests,
+      GLOBAL_INDEX_NULLIFIER_READ_REQUEST_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.noteHashes,
+      GLOBAL_INDEX_NOTE_HASH_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.nullifiers,
+      GLOBAL_INDEX_NULLIFIER_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.privateCallRequests,
+      GLOBAL_INDEX_PRIVATE_CALL_REQUEST_OFFSET,
+      createRangeFromPrivateCallRequest,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.publicCallRequests,
+      GLOBAL_INDEX_PUBLIC_CALL_REQUEST_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.l2ToL1Msgs,
+      GLOBAL_INDEX_L2_TO_L1_MSG_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.privateLogs,
+      GLOBAL_INDEX_PRIVATE_LOG_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.contractClassLogsHashes,
+      GLOBAL_INDEX_CONTRACT_CLASS_LOG_HASH_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+
+  sideEffectRanges.sort((a, b) => a.start - b.start);
+
+  const sideEffectRangeIndices = makeTuple(TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL, () => 0);
+  for (let i = 0; i < sideEffectRanges.length; i++) {
+    const range = sideEffectRanges[i];
+    sideEffectRangeIndices[range.sideEffectGlobalIndex] = i;
+  }
+
+  const hints = SideEffectUniquenessHints.from({
+    sideEffectRanges: padArrayEnd(
+      sideEffectRanges,
+      SideEffectCounterRange.empty(),
+      TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL,
+    ),
+    noteHashReadRequestIndices: makeTuple(
+      MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_NOTE_HASH_READ_REQUEST_OFFSET],
+    ),
+    nullifierReadRequestIndices: makeTuple(
+      MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_NULLIFIER_READ_REQUEST_OFFSET],
+    ),
+    noteHashesIndices: makeTuple(
+      MAX_NOTE_HASHES_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_NOTE_HASH_OFFSET],
+    ),
+    nullifiersIndices: makeTuple(
+      MAX_NULLIFIERS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_NULLIFIER_OFFSET],
+    ),
+    privateCallRequestsIndices: makeTuple(
+      MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_PRIVATE_CALL_REQUEST_OFFSET],
+    ),
+    publicCallRequestsIndices: makeTuple(
+      MAX_ENQUEUED_CALLS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_PUBLIC_CALL_REQUEST_OFFSET],
+    ),
+    l2ToL1MsgsIndices: makeTuple(
+      MAX_L2_TO_L1_MSGS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_L2_TO_L1_MSG_OFFSET],
+    ),
+    privateLogsIndices: makeTuple(
+      MAX_PRIVATE_LOGS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_PRIVATE_LOG_OFFSET],
+    ),
+    contractClassLogsHashesIndices: makeTuple(
+      MAX_CONTRACT_CLASS_LOGS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_CONTRACT_CLASS_LOG_HASH_OFFSET],
+    ),
+  });
+
+  return hints;
+}
+
+function createRangesFromClaimedLengthArray<T extends Serializable, N extends number>(
+  array: ClaimedLengthArray<T, N>,
+  globalIndexOffset: number,
+  rangeConstructor: (item: T, globalIndex: number) => SideEffectCounterRange,
+): SideEffectCounterRange[] {
+  const ranges = [];
+  for (let i = 0; i < array.claimedLength; i++) {
+    ranges.push(rangeConstructor(array.array[i], globalIndexOffset + i));
+  }
+  return ranges;
+}
+
+function createRangeFromCountedItem(item: { counter: number }, globalIndex: number): SideEffectCounterRange {
+  return new SideEffectCounterRange(item.counter, item.counter, globalIndex);
+}
+
+function createRangeFromPrivateCallRequest(item: PrivateCallRequest, globalIndex: number): SideEffectCounterRange {
+  return new SideEffectCounterRange(item.startSideEffectCounter, item.endSideEffectCounter, globalIndex);
+}

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -35,6 +35,7 @@ import {
 import { VerificationKeyAsFields, VerificationKeyData, VkData } from '@aztec/stdlib/vks';
 
 import { PrivateKernelResetPrivateInputsBuilder } from './hints/build_private_kernel_reset_private_inputs.js';
+import { computeSideEffectUniquenessHints } from './hints/compute_side_effect_uniqueness_hints.js';
 import type { PrivateKernelOracle } from './private_kernel_oracle.js';
 
 const NULL_SIMULATE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs> = {
@@ -103,9 +104,8 @@ export class PrivateKernelExecutionProver {
 
     const noteHashLeafIndexMap = collectNoteHashLeafIndexMap(executionResult);
     const noteHashNullifierCounterMap = collectNoteHashNullifierCounterMap(executionResult);
-    const validationRequestsSplitCounter = isPrivateOnlyTx
-      ? 0
-      : getFinalMinRevertibleSideEffectCounter(executionResult);
+    const minRevertibleSideEffectCounter = getFinalMinRevertibleSideEffectCounter(executionResult);
+    const splitCounter = isPrivateOnlyTx ? 0 : minRevertibleSideEffectCounter;
 
     while (executionStack.length) {
       if (!firstIteration) {
@@ -113,7 +113,7 @@ export class PrivateKernelExecutionProver {
           output,
           executionStack,
           noteHashNullifierCounterMap,
-          validationRequestsSplitCounter,
+          splitCounter,
         );
         while (resetBuilder.needsReset()) {
           const witgenTimer = new Timer();
@@ -134,7 +134,7 @@ export class PrivateKernelExecutionProver {
             output,
             executionStack,
             noteHashNullifierCounterMap,
-            validationRequestsSplitCounter,
+            splitCounter,
           );
         }
       }
@@ -171,6 +171,7 @@ export class PrivateKernelExecutionProver {
           privateCallData,
           isPrivateOnlyTx,
           executionResult.firstNullifier,
+          minRevertibleSideEffectCounter,
         );
         this.log.debug(
           `Calling private kernel init with isPrivateOnly ${isPrivateOnlyTx} and firstNullifierHint ${proofInput.firstNullifierHint}`,
@@ -220,7 +221,7 @@ export class PrivateKernelExecutionProver {
       output,
       [],
       noteHashNullifierCounterMap,
-      validationRequestsSplitCounter,
+      splitCounter,
     );
     while (resetBuilder.needsReset()) {
       const witgenTimer = new Timer();
@@ -239,12 +240,7 @@ export class PrivateKernelExecutionProver {
         },
       });
 
-      resetBuilder = new PrivateKernelResetPrivateInputsBuilder(
-        output,
-        [],
-        noteHashNullifierCounterMap,
-        validationRequestsSplitCounter,
-      );
+      resetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, [], noteHashNullifierCounterMap, splitCounter);
     }
 
     if (output.publicInputs.feePayer.isZero() && skipFeeEnforcement) {
@@ -420,6 +416,9 @@ export class PrivateKernelExecutionProver {
       await this.oracle.getContractClassIdPreimage(currentContractClassId);
 
     const updatedClassIdHints = await this.oracle.getUpdatedClassIdHints(contractAddress);
+
+    const sideEffectUniquenessHints = computeSideEffectUniquenessHints(publicInputs);
+
     return PrivateCallData.from({
       publicInputs,
       vk,
@@ -431,6 +430,7 @@ export class PrivateKernelExecutionProver {
         functionLeafMembershipWitness,
         updatedClassIdHints,
       }),
+      sideEffectUniquenessHints,
     });
   }
 }