@aztec/pxe 0.55.1 → 0.57.0

package/src/note_processor/utils/produce_note_daos_for_key.ts

@@ -0,0 +1,157 @@
+import { type L1NotePayload, type TxHash, UnencryptedTxL2Logs } from '@aztec/circuit-types';
+import { Fr, type PublicKey } from '@aztec/circuits.js';
+import { type Logger } from '@aztec/foundation/log';
+import { type AcirSimulator, ContractNotFoundError } from '@aztec/simulator';
+
+import { DeferredNoteDao } from '../../database/deferred_note_dao.js';
+import { type PxeDatabase } from '../../database/pxe_database.js';
+import { addNullableFieldsToPayload } from './add_nullable_field_to_payload.js';
+import { type NoteInfo, bruteForceNoteInfo } from './brute_force_note_info.js';
+
+export async function produceNoteDaosForKey<T>(
+  simulator: AcirSimulator,
+  db: PxeDatabase,
+  pkM: PublicKey,
+  payload: L1NotePayload,
+  txHash: TxHash,
+  noteHashes: Fr[],
+  dataStartIndexForTx: number,
+  excludedIndices: Set<number>,
+  logger: Logger,
+  unencryptedLogs: UnencryptedTxL2Logs,
+  daoConstructor: (payload: L1NotePayload, noteInfo: NoteInfo, dataStartIndexForTx: number, pkM: PublicKey) => T,
+): Promise<[T | undefined, DeferredNoteDao | undefined]> {
+  let noteDao: T | undefined;
+  let deferredNoteDao: DeferredNoteDao | undefined;
+
+  try {
+    const noteInfo = await bruteForceNoteInfo(
+      simulator,
+      noteHashes,
+      txHash,
+      payload,
+      excludedIndices,
+      true, // For incoming we compute a nullifier (recipient of incoming is the party that nullifies).
+    );
+    excludedIndices?.add(noteInfo.noteHashIndex);
+
+    noteDao = daoConstructor(payload, noteInfo, dataStartIndexForTx, pkM);
+  } catch (e) {
+    if (e instanceof ContractNotFoundError) {
+      logger.warn(e.message);
+
+      deferredNoteDao = new DeferredNoteDao(
+        pkM,
+        payload.note,
+        payload.contractAddress,
+        payload.storageSlot,
+        payload.noteTypeId,
+        txHash,
+        noteHashes,
+        dataStartIndexForTx,
+        unencryptedLogs,
+      );
+    } else if (
+      (e as any).message.includes('failed to solve blackbox function: embedded_curve_add') ||
+      (e as any).message.includes('Could not find key prefix.')
+    ) {
+      // TODO(#8769): This branch is a temporary partial notes delivery solution that should be eventually replaced.
+      // Both error messages above occur only when we are dealing with a partial note and are thrown when calling
+      // `note.compute_note_hash()` or `note.compute_nullifier_without_context()`
+      // in `compute_note_hash_and_optionally_a_nullifier` function. It occurs with partial notes because in the
+      // partial flow we receive a note log of a note that is missing some fields here and then we try to compute
+      // the note hash with MSM while some of the fields are zeroed out (or get a nsk for zero npk_m_hash).
+      noteDao = await handlePartialNote(
+        simulator,
+        db,
+        pkM,
+        payload,
+        txHash,
+        noteHashes,
+        dataStartIndexForTx,
+        excludedIndices,
+        logger,
+        unencryptedLogs,
+        daoConstructor,
+      );
+    } else {
+      logger.error(`Could not process note because of "${e}". Discarding note...`);
+    }
+  }
+
+  return [noteDao, deferredNoteDao];
+}
+
+async function handlePartialNote<T>(
+  simulator: AcirSimulator,
+  db: PxeDatabase,
+  pkM: PublicKey,
+  payload: L1NotePayload,
+  txHash: TxHash,
+  noteHashes: Fr[],
+  dataStartIndexForTx: number,
+  excludedIndices: Set<number>,
+  logger: Logger,
+  unencryptedLogs: UnencryptedTxL2Logs,
+  daoConstructor: (payload: L1NotePayload, noteInfo: NoteInfo, dataStartIndexForTx: number, pkM: PublicKey) => T,
+): Promise<T | undefined> {
+  let noteDao: T | undefined;
+
+  for (const functionLogs of unencryptedLogs.functionLogs) {
+    for (const log of functionLogs.logs) {
+      const { data } = log;
+      // It is the expectation that partial notes will have the corresponding unencrypted log be multiple
+      // of Fr.SIZE_IN_BYTES as the nullable fields should be simply concatenated.
+      if (data.length % Fr.SIZE_IN_BYTES === 0) {
+        const nullableFields = [];
+        for (let i = 0; i < data.length; i += Fr.SIZE_IN_BYTES) {
+          const chunk = data.subarray(i, i + Fr.SIZE_IN_BYTES);
+          nullableFields.push(Fr.fromBuffer(chunk));
+        }
+
+        // We insert the nullable fields into the note and then we try to produce the note dao again
+        const payloadWithNullableFields = await addNullableFieldsToPayload(db, payload, nullableFields);
+
+        let deferredNoteDao: DeferredNoteDao | undefined;
+        try {
+          [noteDao, deferredNoteDao] = await produceNoteDaosForKey(
+            simulator,
+            db,
+            pkM,
+            payloadWithNullableFields,
+            txHash,
+            noteHashes,
+            dataStartIndexForTx,
+            excludedIndices,
+            logger,
+            UnencryptedTxL2Logs.empty(), // We set unencrypted logs to empty to prevent infinite recursion.
+            daoConstructor,
+          );
+        } catch (e) {
+          // We ignore the key prefix error because that is expected to be triggered when an incorrect value
+          // is inserted at the position of `npk_m_hash`. This happens commonly because we are brute forcing
+          // the unencrypted logs.
+          if (!(e as any).message.includes('Could not find key prefix.')) {
+            throw e;
+          }
+        }
+
+        if (deferredNoteDao) {
+          // This should not happen as we should first get contract not found error before the blackbox func error.
+          throw new Error('Partial notes should never be deferred.');
+        }
+
+        if (noteDao) {
+          // We managed to complete the partial note so we terminate the search.
+          break;
+        }
+      }
+    }
+  }
+
+  if (!noteDao) {
+    logger.error(`Partial note note found. Discarding note...`);
+  }
+
+  return noteDao;
+}

package/src/pxe_http/pxe_http_server.ts

@@ -1,6 +1,10 @@
 import {
   AuthWitness,
   CompleteAddress,
+  CountedNoteLog,
+  CountedPublicExecutionRequest,
+  EncryptedL2Log,
+  EncryptedL2NoteLog,
   EncryptedNoteL2BlockL2Logs,
   ExtendedNote,
   ExtendedUnencryptedL2Log,
@@ -9,17 +13,20 @@ import {
   Note,
   NullifierMembershipWitness,
   type PXE,
+  PrivateExecutionResult,
   SiblingPath,
-  SimulatedTx,
   Tx,
   TxEffect,
   TxExecutionRequest,
   TxHash,
+  TxProvingResult,
   TxReceipt,
+  TxSimulationResult,
   UnencryptedL2BlockL2Logs,
+  UnencryptedL2Log,
   UniqueNote,
 } from '@aztec/circuit-types';
-import { FunctionSelector } from '@aztec/circuits.js';
+import { FunctionSelector, PrivateCallStackItem } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Buffer32 } from '@aztec/foundation/buffer';
@@ -59,9 +66,17 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
     },
     {
       EncryptedNoteL2BlockL2Logs,
+      EncryptedL2NoteLog,
+      EncryptedL2Log,
+      UnencryptedL2Log,
       NoteSelector,
       NullifierMembershipWitness,
-      SimulatedTx,
+      TxSimulationResult,
+      TxProvingResult,
+      PrivateExecutionResult,
+      PrivateCallStackItem,
+      CountedPublicExecutionRequest,
+      CountedNoteLog,
       Tx,
       TxReceipt,
       UnencryptedL2BlockL2Logs,

package/src/pxe_service/create_pxe_service.ts

@@ -8,7 +8,6 @@ import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registr
 import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
-import { getCanonicalKeyRegistry } from '@aztec/protocol-contracts/key-registry';
 import { getCanonicalMultiCallEntrypointContract } from '@aztec/protocol-contracts/multi-call-entrypoint';
 import { getCanonicalRouter } from '@aztec/protocol-contracts/router';
 
@@ -51,7 +50,6 @@ export async function createPXEService(
     getCanonicalInstanceDeployer(),
     getCanonicalMultiCallEntrypointContract(),
     getCanonicalFeeJuice(),
-    getCanonicalKeyRegistry(),
     getCanonicalAuthRegistry(),
     getCanonicalRouter(),
   ]) {

package/src/pxe_service/pxe_service.ts

@@ -1,8 +1,6 @@
 import {
   type AuthWitness,
   type AztecNode,
-  EncryptedNoteTxL2Logs,
-  EncryptedTxL2Logs,
   type EventMetadata,
   EventType,
   type ExtendedNote,
@@ -16,59 +14,53 @@ import {
   type OutgoingNotesFilter,
   type PXE,
   type PXEInfo,
+  type PrivateExecutionResult,
   type PrivateKernelProver,
+  type PrivateKernelSimulateOutput,
+  PrivateSimulationResult,
+  type PublicSimulationOutput,
   type SiblingPath,
-  SimulatedTx,
   SimulationError,
-  TaggedLog,
-  Tx,
+  type Tx,
   type TxEffect,
   type TxExecutionRequest,
   type TxHash,
+  TxProvingResult,
   type TxReceipt,
-  UnencryptedTxL2Logs,
+  TxSimulationResult,
   UniqueNote,
   getNonNullifiedL1ToL2MessageWitness,
   isNoirCallStackUnresolved,
 } from '@aztec/circuit-types';
+import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
 import {
   AztecAddress,
   type CompleteAddress,
   type L1_TO_L2_MSG_TREE_HEIGHT,
+  PUBLIC_DISPATCH_SELECTOR,
   type PartialAddress,
+  type PrivateKernelTailCircuitPublicInputs,
   computeContractAddressFromInstance,
   computeContractClassId,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
 import {
+  type AbiDecoded,
   type ContractArtifact,
-  type DecodedReturn,
   EventSelector,
   FunctionSelector,
   encodeArguments,
 } from '@aztec/foundation/abi';
-import { type Fq, Fr, type Point } from '@aztec/foundation/fields';
+import { Fr, type Point } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { type KeyStore } from '@aztec/key-store';
 import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
-import { getCanonicalKeyRegistryAddress } from '@aztec/protocol-contracts/key-registry';
 import { getCanonicalMultiCallEntrypointAddress } from '@aztec/protocol-contracts/multi-call-entrypoint';
-import {
-  type AcirSimulator,
-  type ExecutionResult,
-  accumulateReturnValues,
-  collectEnqueuedPublicFunctionCalls,
-  collectPublicTeardownFunctionCall,
-  collectSortedEncryptedLogs,
-  collectSortedNoteEncryptedLogs,
-  collectSortedUnencryptedLogs,
-  resolveAssertionMessage,
-  resolveOpcodeLocations,
-} from '@aztec/simulator';
+import { type AcirSimulator, resolveAssertionMessage, resolveOpcodeLocations } from '@aztec/simulator';
 import { type ContractClassWithId, type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type NodeInfo } from '@aztec/types/interfaces';
 
@@ -176,10 +168,6 @@ export class PXEService implements PXE {
     return this.db.getAuthWitness(messageHash);
   }
 
-  async rotateNskM(account: AztecAddress, secretKey: Fq): Promise<void> {
-    await this.keyStore.rotateMasterNullifierKey(account, secretKey);
-  }
-
   public addCapsule(capsule: Fr[]) {
     return this.db.addCapsule(capsule);
   }
@@ -312,8 +300,6 @@ export class PXEService implements PXE {
   public async getIncomingNotes(filter: IncomingNotesFilter): Promise<UniqueNote[]> {
     const noteDaos = await this.db.getIncomingNotes(filter);
 
-    // TODO(#6531): Refactor --> This type conversion is ugly but I decided to keep it this way for now because
-    // key rotation will affect this
     const extendedNotes = noteDaos.map(async dao => {
       let owner = filter.owner;
       if (owner === undefined) {
@@ -341,8 +327,6 @@ export class PXEService implements PXE {
   public async getOutgoingNotes(filter: OutgoingNotesFilter): Promise<UniqueNote[]> {
     const noteDaos = await this.db.getOutgoingNotes(filter);
 
-    // TODO(#6532): Refactor --> This type conversion is ugly but I decided to keep it this way for now because
-    // key rotation will affect this
     const extendedNotes = noteDaos.map(async dao => {
       let owner = filter.owner;
       if (owner === undefined) {
@@ -518,13 +502,21 @@ export class PXEService implements PXE {
     return await this.node.getBlock(blockNumber);
   }
 
-  public proveTx(txRequest: TxExecutionRequest, simulatePublic: boolean, scopes?: AztecAddress[]): Promise<Tx> {
+  async #simulateKernels(
+    txRequest: TxExecutionRequest,
+    privateExecutionResult: PrivateExecutionResult,
+  ): Promise<PrivateKernelTailCircuitPublicInputs> {
+    const result = await this.#prove(txRequest, new TestPrivateKernelProver(), privateExecutionResult);
+    return result.publicInputs;
+  }
+
+  public proveTx(
+    txRequest: TxExecutionRequest,
+    privateExecutionResult: PrivateExecutionResult,
+  ): Promise<TxProvingResult> {
     return this.jobQueue.put(async () => {
-      const simulatedTx = await this.#simulateAndProve(txRequest, this.proofCreator, undefined, scopes);
-      if (simulatePublic) {
-        simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
-      }
-      return simulatedTx.tx;
+      const { publicInputs, clientIvcProof } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult);
+      return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
     });
   }
 
@@ -535,15 +527,19 @@ export class PXEService implements PXE {
     msgSender: AztecAddress | undefined = undefined,
     skipTxValidation: boolean = false,
     scopes?: AztecAddress[],
-  ): Promise<SimulatedTx> {
+  ): Promise<TxSimulationResult> {
     return await this.jobQueue.put(async () => {
-      const simulatedTx = await this.#simulateAndProve(txRequest, this.fakeProofCreator, msgSender, scopes);
+      const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
+      const publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
+      const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
+      const simulatedTx = privateSimulationResult.toSimulatedTx();
+      let publicOutput: PublicSimulationOutput | undefined;
       if (simulatePublic) {
-        simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
+        publicOutput = await this.#simulatePublicCalls(simulatedTx);
       }
 
       if (!skipTxValidation) {
-        if (!(await this.node.isValidTx(simulatedTx.tx, true))) {
+        if (!(await this.node.isValidTx(simulatedTx, true))) {
           throw new Error('The simulated transaction is unable to be added to state and is invalid.');
         }
       }
@@ -553,9 +549,9 @@ export class PXEService implements PXE {
       // Meaning that it will not necessarily have produced a nullifier (and thus have no TxHash)
       // If we log, the `getTxHash` function will throw.
       if (!msgSender) {
-        this.log.info(`Executed local simulation for ${simulatedTx.tx.getTxHash()}`);
+        this.log.info(`Executed local simulation for ${simulatedTx.getTxHash()}`);
       }
-      return simulatedTx;
+      return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput);
     });
   }
 
@@ -576,7 +572,7 @@ export class PXEService implements PXE {
     to: AztecAddress,
     _from?: AztecAddress,
     scopes?: AztecAddress[],
-  ): Promise<DecodedReturn> {
+  ): Promise<AbiDecoded> {
     // all simulations must be serialized w.r.t. the synchronizer
     return await this.jobQueue.put(async () => {
       // TODO - Should check if `from` has the permission to call the view function.
@@ -667,7 +663,6 @@ export class PXEService implements PXE {
         classRegisterer: ClassRegistererAddress,
         feeJuice: getCanonicalFeeJuice().address,
         instanceDeployer: getCanonicalInstanceDeployer().address,
-        keyRegistry: getCanonicalKeyRegistryAddress(),
         multiCallEntrypoint: getCanonicalMultiCallEntrypointAddress(),
       },
     });
@@ -696,11 +691,11 @@ export class PXEService implements PXE {
     };
   }
 
-  async #simulate(
+  async #executePrivate(
     txRequest: TxExecutionRequest,
     msgSender?: AztecAddress,
     scopes?: AztecAddress[],
-  ): Promise<ExecutionResult> {
+  ): Promise<PrivateExecutionResult> {
     // TODO - Pause syncing while simulating.
 
     const { contractAddress, functionArtifact } = await this.#getSimulationParameters(txRequest);
@@ -758,9 +753,13 @@ export class PXEService implements PXE {
       if (err instanceof SimulationError) {
         const callStack = err.getCallStack();
         const originalFailingFunction = callStack[callStack.length - 1];
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Properly fix this.
+        // To be able to resolve the assertion message, we need to use the information from the public dispatch function,
+        // no matter what the call stack selector points to (since we've modified it to point to the target function).
+        // We should remove this because the AVM (or public protocol) shouldn't be aware of the public dispatch calling convention.
         const debugInfo = await this.contractDataOracle.getFunctionDebugMetadata(
           originalFailingFunction.contractAddress,
-          originalFailingFunction.functionSelector,
+          FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
         );
         const noirCallStack = err.getNoirCallStack();
         if (debugInfo) {
@@ -803,40 +802,15 @@ export class PXEService implements PXE {
    * A private transaction object containing the proof, public inputs, and encrypted logs.
    * The return values of the private execution
    */
-  async #simulateAndProve(
+  async #prove(
     txExecutionRequest: TxExecutionRequest,
     proofCreator: PrivateKernelProver,
-    msgSender?: AztecAddress,
-    scopes?: AztecAddress[],
-  ): Promise<SimulatedTx> {
-    // Get values that allow us to reconstruct the block hash
-    const executionResult = await this.#simulate(txExecutionRequest, msgSender, scopes);
-
+    privateExecutionResult: PrivateExecutionResult,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
     const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node);
     const kernelProver = new KernelProver(kernelOracle, proofCreator);
     this.log.debug(`Executing kernel prover...`);
-    const { clientIvcProof, publicInputs } = await kernelProver.prove(
-      txExecutionRequest.toTxRequest(),
-      executionResult,
-    );
-
-    const noteEncryptedLogs = new EncryptedNoteTxL2Logs([collectSortedNoteEncryptedLogs(executionResult)]);
-    const unencryptedLogs = new UnencryptedTxL2Logs([collectSortedUnencryptedLogs(executionResult)]);
-    const encryptedLogs = new EncryptedTxL2Logs([collectSortedEncryptedLogs(executionResult)]);
-    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(executionResult);
-    const teardownPublicFunction = collectPublicTeardownFunctionCall(executionResult);
-
-    const tx = new Tx(
-      publicInputs,
-      clientIvcProof!,
-      noteEncryptedLogs,
-      encryptedLogs,
-      unencryptedLogs,
-      enqueuedPublicFunctions,
-      teardownPublicFunction,
-    );
-
-    return new SimulatedTx(tx, accumulateReturnValues(executionResult));
+    return await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult);
   }
 
   /**
@@ -888,7 +862,7 @@ export class PXEService implements PXE {
     return Promise.resolve(this.synchronizer.getSyncStatus());
   }
 
-  public getSyncStats() {
+  public getSyncStats(): Promise<{ [address: string]: NoteProcessorStats }> {
     return Promise.resolve(this.synchronizer.getSyncStats());
   }
 
@@ -953,11 +927,10 @@ export class PXEService implements PXE {
 
     const visibleEvents = encryptedLogs.flatMap(encryptedLog => {
       for (const sk of vsks) {
-        const decryptedLog =
-          TaggedLog.decryptAsIncoming(encryptedLog, sk, L1EventPayload) ??
-          TaggedLog.decryptAsOutgoing(encryptedLog, sk, L1EventPayload);
-        if (decryptedLog !== undefined) {
-          return [decryptedLog];
+        const decryptedEvent =
+          L1EventPayload.decryptAsIncoming(encryptedLog, sk) ?? L1EventPayload.decryptAsOutgoing(encryptedLog, sk);
+        if (decryptedEvent !== undefined) {
+          return [decryptedEvent];
         }
       }
 
@@ -966,25 +939,19 @@ export class PXEService implements PXE {
 
     const decodedEvents = visibleEvents
       .map(visibleEvent => {
-        if (visibleEvent.payload === undefined) {
+        if (visibleEvent === undefined) {
           return undefined;
         }
-        if (!visibleEvent.payload.eventTypeId.equals(eventMetadata.eventSelector)) {
+        if (!visibleEvent.eventTypeId.equals(eventMetadata.eventSelector)) {
           return undefined;
         }
-        if (visibleEvent.payload.event.items.length !== eventMetadata.fieldNames.length) {
+        if (visibleEvent.event.items.length !== eventMetadata.fieldNames.length) {
           throw new Error(
-            'Something is weird here, we have matching FunctionSelectors, but the actual payload has mismatched length',
+            'Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length',
           );
         }
 
-        return eventMetadata.fieldNames.reduce(
-          (acc, curr, i) => ({
-            ...acc,
-            [curr]: visibleEvent.payload.event.items[i],
-          }),
-          {} as T,
-        );
+        return eventMetadata.decode(visibleEvent);
       })
       .filter(visibleEvent => visibleEvent !== undefined) as T[];
 
@@ -1011,17 +978,11 @@ export class PXEService implements PXE {
 
         if (unencryptedLogBuf.byteLength !== eventMetadata.fieldNames.length * 32 + 32) {
           throw new Error(
-            'Something is weird here, we have matching FunctionSelectors, but the actual payload has mismatched length',
+            'Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length',
           );
         }
 
-        return eventMetadata.fieldNames.reduce(
-          (acc, curr, i) => ({
-            ...acc,
-            [curr]: new Fr(unencryptedLogBuf.subarray(i * 32, i * 32 + 32)),
-          }),
-          {} as T,
-        );
+        return eventMetadata.decode(unencryptedLog.log);
       })
       .filter(unencryptedLog => unencryptedLog !== undefined) as T[];
 

package/dest/kernel_prover/hints/build_private_kernel_reset_hints.d.ts

@@ -1,5 +0,0 @@
-import { type PrivateKernelData, type PrivateKernelResetCircuitPrivateInputsVariants } from '@aztec/circuits.js';
-import type { ExecutionResult } from '@aztec/simulator';
-import { type ProvingDataOracle } from '../proving_data_oracle.js';
-export declare function buildPrivateKernelResetInputs(executionStack: ExecutionResult[], previousKernelData: PrivateKernelData, noteHashLeafIndexMap: Map<bigint, bigint>, noteHashNullifierCounterMap: Map<number, number>, validationRequestsSplitCounter: number, shouldSilo: boolean, oracle: ProvingDataOracle): Promise<PrivateKernelResetCircuitPrivateInputsVariants>;
-//# sourceMappingURL=build_private_kernel_reset_hints.d.ts.map

package/dest/kernel_prover/hints/build_private_kernel_reset_hints.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build_private_kernel_reset_hints.d.ts","sourceRoot":"","sources":["../../../src/kernel_prover/hints/build_private_kernel_reset_hints.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,KAAK,iBAAiB,EAEtB,KAAK,8CAA8C,EAYpD,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAyDnE,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,eAAe,EAAE,EACjC,kBAAkB,EAAE,iBAAiB,EACrC,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,8BAA8B,EAAE,MAAM,EACtC,UAAU,EAAE,OAAO,EACnB,MAAM,EAAE,iBAAiB,2DA+H1B"}