@aztec/pxe 0.70.0 → 0.71.0

package/src/database/pxe_database_test_suite.ts

@@ -406,7 +406,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
     });
 
-    describe('contract store', () => {
+    describe('contract non-volatile database', () => {
       let contract: AztecAddress;
 
       beforeEach(() => {
@@ -415,56 +415,155 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('stores and loads a single value', async () => {
-        const key = new Fr(1);
+        const slot = new Fr(1);
         const values = [new Fr(42)];
 
-        await database.store(contract, key, values);
-        const result = await database.load(contract, key);
+        await database.dbStore(contract, slot, values);
+        const result = await database.dbLoad(contract, slot);
         expect(result).toEqual(values);
       });
 
       it('stores and loads multiple values', async () => {
-        const key = new Fr(1);
+        const slot = new Fr(1);
         const values = [new Fr(42), new Fr(43), new Fr(44)];
 
-        await database.store(contract, key, values);
-        const result = await database.load(contract, key);
+        await database.dbStore(contract, slot, values);
+        const result = await database.dbLoad(contract, slot);
         expect(result).toEqual(values);
       });
 
       it('overwrites existing values', async () => {
-        const key = new Fr(1);
+        const slot = new Fr(1);
         const initialValues = [new Fr(42)];
         const newValues = [new Fr(100)];
 
-        await database.store(contract, key, initialValues);
-        await database.store(contract, key, newValues);
+        await database.dbStore(contract, slot, initialValues);
+        await database.dbStore(contract, slot, newValues);
 
-        const result = await database.load(contract, key);
+        const result = await database.dbLoad(contract, slot);
         expect(result).toEqual(newValues);
       });
 
       it('stores values for different contracts independently', async () => {
         const anotherContract = AztecAddress.random();
-        const key = new Fr(1);
+        const slot = new Fr(1);
         const values1 = [new Fr(42)];
         const values2 = [new Fr(100)];
 
-        await database.store(contract, key, values1);
-        await database.store(anotherContract, key, values2);
+        await database.dbStore(contract, slot, values1);
+        await database.dbStore(anotherContract, slot, values2);
 
-        const result1 = await database.load(contract, key);
-        const result2 = await database.load(anotherContract, key);
+        const result1 = await database.dbLoad(contract, slot);
+        const result2 = await database.dbLoad(anotherContract, slot);
 
         expect(result1).toEqual(values1);
         expect(result2).toEqual(values2);
       });
 
-      it('returns null for non-existent keys', async () => {
-        const key = Fr.random();
-        const result = await database.load(contract, key);
+      it('returns null for non-existent slots', async () => {
+        const slot = Fr.random();
+        const result = await database.dbLoad(contract, slot);
         expect(result).toBeNull();
       });
+
+      it('deletes a slot', async () => {
+        const slot = new Fr(1);
+        const values = [new Fr(42)];
+
+        await database.dbStore(contract, slot, values);
+        await database.dbDelete(contract, slot);
+
+        expect(await database.dbLoad(contract, slot)).toBeNull();
+      });
+
+      it('deletes an empty slot', async () => {
+        const slot = new Fr(1);
+        await database.dbDelete(contract, slot);
+
+        expect(await database.dbLoad(contract, slot)).toBeNull();
+      });
+
+      it('copies a single value', async () => {
+        const slot = new Fr(1);
+        const values = [new Fr(42)];
+
+        await database.dbStore(contract, slot, values);
+
+        const dstSlot = new Fr(5);
+        await database.dbCopy(contract, slot, dstSlot, 1);
+
+        expect(await database.dbLoad(contract, dstSlot)).toEqual(values);
+      });
+
+      it('copies multiple non-overlapping values', async () => {
+        const src = new Fr(1);
+        const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
+
+        await database.dbStore(contract, src, valuesArray[0]);
+        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+
+        const dst = new Fr(5);
+        await database.dbCopy(contract, src, dst, 3);
+
+        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+      });
+
+      it('copies overlapping values with src ahead', async () => {
+        const src = new Fr(1);
+        const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
+
+        await database.dbStore(contract, src, valuesArray[0]);
+        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+
+        const dst = new Fr(2);
+        await database.dbCopy(contract, src, dst, 3);
+
+        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+
+        // Slots 2 and 3 (src[1] and src[2]) should have been overwritten since they are also dst[0] and dst[1]
+        expect(await database.dbLoad(contract, src)).toEqual(valuesArray[0]); // src[0] (unchanged)
+        expect(await database.dbLoad(contract, src.add(new Fr(1)))).toEqual(valuesArray[0]); // dst[0]
+        expect(await database.dbLoad(contract, src.add(new Fr(2)))).toEqual(valuesArray[1]); // dst[1]
+      });
+
+      it('copies overlapping values with dst ahead', async () => {
+        const src = new Fr(5);
+        const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
+
+        await database.dbStore(contract, src, valuesArray[0]);
+        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+
+        const dst = new Fr(4);
+        await database.dbCopy(contract, src, dst, 3);
+
+        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+
+        // Slots 5 and 6 (src[0] and src[1]) should have been overwritten since they are also dst[1] and dst[2]
+        expect(await database.dbLoad(contract, src)).toEqual(valuesArray[1]); // dst[1]
+        expect(await database.dbLoad(contract, src.add(new Fr(1)))).toEqual(valuesArray[2]); // dst[2]
+        expect(await database.dbLoad(contract, src.add(new Fr(2)))).toEqual(valuesArray[2]); // src[2] (unchanged)
+      });
+
+      it('copying fails if any value is empty', async () => {
+        const src = new Fr(1);
+        const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
+
+        await database.dbStore(contract, src, valuesArray[0]);
+        // We skip src[1]
+        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+
+        const dst = new Fr(5);
+        await expect(database.dbCopy(contract, src, dst, 3)).rejects.toThrow('Attempted to copy empty slot');
+      });
     });
   });
 }

package/src/note_decryption_utils/add_public_values_to_payload.ts

@@ -41,7 +41,7 @@ export async function getOrderedNoteItems(
   noteFields.sort((a, b) => a.index - b.index);
 
   // Now we insert the public fields into the note based on its indices defined in the ABI.
-  const modifiedNoteItems = privateNoteValues;
+  const modifiedNoteItems = [...privateNoteValues];
   let indexInPublicValues = 0;
   for (let i = 0; i < noteFields.length; i++) {
     const noteField = noteFields[i];

package/src/simulator_oracle/index.ts

@@ -1,14 +1,16 @@
 import {
   type AztecNode,
+  type FunctionCall,
   type InBlock,
   L1NotePayload,
   type L2Block,
   type L2BlockNumber,
   MerkleTreeId,
+  Note,
   type NoteStatus,
   type NullifierMembershipWitness,
   type PublicDataWitness,
-  type TxEffect,
+  TxHash,
   type TxScopedL2Log,
   getNonNullifiedL1ToL2MessageWitness,
 } from '@aztec/circuit-types';
@@ -18,15 +20,24 @@ import {
   type CompleteAddress,
   type ContractInstance,
   Fr,
-  type FunctionSelector,
+  FunctionSelector,
   IndexedTaggingSecret,
   type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
+  MAX_NOTE_HASHES_PER_TX,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
   PrivateLog,
   computeAddressSecret,
   computeTaggingSecretPoint,
 } from '@aztec/circuits.js';
-import { type FunctionArtifact, getFunctionArtifact } from '@aztec/foundation/abi';
+import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
+import {
+  type FunctionArtifact,
+  FunctionType,
+  NoteSelector,
+  encodeArguments,
+  getFunctionArtifact,
+} from '@aztec/foundation/abi';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
 import { type KeyStore } from '@aztec/key-store';
@@ -37,10 +48,10 @@ import {
   type SimulationProvider,
 } from '@aztec/simulator/client';
 
-import { type ContractDataOracle } from '../contract_data_oracle/index.js';
+import { ContractDataOracle } from '../contract_data_oracle/index.js';
 import { type PxeDatabase } from '../database/index.js';
-import { type NoteDao } from '../database/note_dao.js';
-import { produceNoteDaos } from '../note_decryption_utils/produce_note_daos.js';
+import { NoteDao } from '../database/note_dao.js';
+import { getOrderedNoteItems } from '../note_decryption_utils/add_public_values_to_payload.js';
 import { getAcirSimulator } from '../simulator/index.js';
 import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
 
@@ -431,6 +442,8 @@ export class SimulatorOracle implements DBOracle {
     maxBlockNumber: number,
     scopes?: AztecAddress[],
   ): Promise<Map<string, TxScopedL2Log[]>> {
+    this.log.verbose('Searching for tagged logs', { contract: contractAddress });
+
     // Ideally this algorithm would be implemented in noir, exposing its building blocks as oracles.
     // However it is impossible at the moment due to the language not supporting nested slices.
     // This nesting is necessary because for a given set of tags we don't
@@ -568,10 +581,9 @@ export class SimulatorOracle implements DBOracle {
    * Decrypts logs tagged for a recipient and returns them.
    * @param scopedLogs - The logs to decrypt.
    * @param recipient - The recipient of the logs.
-   * @param simulator - The simulator to use for decryption.
    * @returns The decrypted notes.
    */
-  async #decryptTaggedLogs(scopedLogs: TxScopedL2Log[], recipient: AztecAddress, simulator?: AcirSimulator) {
+  async #decryptTaggedLogs(scopedLogs: TxScopedL2Log[], recipient: AztecAddress) {
     const recipientCompleteAddress = await this.getCompleteAddress(recipient);
     const ivskM = await this.keyStore.getMasterSecretKey(
       recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey,
@@ -581,56 +593,29 @@ export class SimulatorOracle implements DBOracle {
     // Since we could have notes with the same index for different txs, we need
     // to keep track of them scoping by txHash
     const excludedIndices: Map<string, Set<number>> = new Map();
-    const notes: NoteDao[] = [];
-
-    const txEffectsCache = new Map<string, InBlock<TxEffect> | undefined>();
+    const decrypted = [];
 
     for (const scopedLog of scopedLogs) {
-      const notePayload = scopedLog.isFromPublic
+      const payload = scopedLog.isFromPublic
         ? L1NotePayload.decryptAsIncomingFromPublic(scopedLog.logData, addressSecret)
         : L1NotePayload.decryptAsIncoming(PrivateLog.fromBuffer(scopedLog.logData), addressSecret);
 
-      if (notePayload) {
-        const payload = notePayload;
-
-        const txEffect =
-          txEffectsCache.get(scopedLog.txHash.toString()) ?? (await this.aztecNode.getTxEffect(scopedLog.txHash));
-
-        if (!txEffect) {
-          this.log.warn(`No tx effect found for ${scopedLog.txHash} while decrypting tagged logs`);
-          continue;
-        }
+      if (!payload) {
+        this.log.verbose('Unable to decrypt log');
+        continue;
+      }
 
-        txEffectsCache.set(scopedLog.txHash.toString(), txEffect);
+      if (!excludedIndices.has(scopedLog.txHash.toString())) {
+        excludedIndices.set(scopedLog.txHash.toString(), new Set());
+      }
 
-        if (!excludedIndices.has(scopedLog.txHash.toString())) {
-          excludedIndices.set(scopedLog.txHash.toString(), new Set());
-        }
-        const { note } = await produceNoteDaos(
-          // I don't like this at all, but we need a simulator to run `computeNoteHashAndOptionallyANullifier`. This generates
-          // a chicken-and-egg problem due to this oracle requiring a simulator, which in turn requires this oracle. Furthermore, since jest doesn't allow
-          // mocking ESM exports, we have to pollute the method even more by providing a simulator parameter so tests can inject a fake one.
-          simulator ??
-            getAcirSimulator(this.db, this.aztecNode, this.keyStore, this.simulationProvider, this.contractDataOracle),
-          this.db,
-          notePayload ? recipient.toAddressPoint() : undefined,
-          payload!,
-          txEffect.data.txHash,
-          txEffect.data.nullifiers[0],
-          txEffect.l2BlockNumber,
-          txEffect.l2BlockHash,
-          txEffect.data.noteHashes,
-          scopedLog.dataStartIndexForTx,
-          excludedIndices.get(scopedLog.txHash.toString())!,
-          this.log,
-        );
+      const note = await getOrderedNoteItems(this.db, payload);
+      const plaintext = [payload.storageSlot, payload.noteTypeId.toField(), ...note.items];
 
-        if (note) {
-          notes.push(note);
-        }
-      }
+      decrypted.push({ plaintext, txHash: scopedLog.txHash, contractAddress: payload.contractAddress });
     }
-    return { notes };
+
+    return decrypted;
   }
 
   /**
@@ -643,20 +628,68 @@ export class SimulatorOracle implements DBOracle {
     recipient: AztecAddress,
     simulator?: AcirSimulator,
   ): Promise<void> {
-    const { notes } = await this.#decryptTaggedLogs(logs, recipient, simulator);
-    if (notes.length) {
-      await this.db.addNotes(notes, recipient);
-      notes.forEach(noteDao => {
-        this.log.verbose(`Added incoming note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
-          contract: noteDao.contractAddress,
-          slot: noteDao.storageSlot,
-          nullifier: noteDao.siloedNullifier.toString(),
-        });
-      });
+    const decryptedLogs = await this.#decryptTaggedLogs(logs, recipient);
+
+    // We've produced the full NoteDao, which we'd be able to simply insert into the database. However, this is
+    // only a temporary measure as we migrate from the PXE-driven discovery into the new contract-driven approach. We
+    // discard most of the work done up to this point and reconstruct the note plaintext to then hand over to the
+    // contract for further processing.
+    for (const decryptedLog of decryptedLogs) {
+      // Log processing requires the note hashes in the tx in which the note was created. We are now assuming that the
+      // note was included in the same block in which the log was delivered - note that partial notes will not work this
+      // way.
+      const txEffect = await this.aztecNode.getTxEffect(decryptedLog.txHash);
+      if (!txEffect) {
+        throw new Error(`Could not find tx effect for tx hash ${decryptedLog.txHash}`);
+      }
+
+      // This will trigger calls to the deliverNote oracle
+      await this.callProcessLog(
+        decryptedLog.contractAddress,
+        decryptedLog.plaintext,
+        decryptedLog.txHash,
+        txEffect.data.noteHashes,
+        txEffect.data.nullifiers[0],
+        recipient,
+        simulator,
+      );
     }
+    return;
+  }
+
+  // Called when notes are delivered, usually as a result to a call to the process_log contract function
+  public async deliverNote(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    nonce: Fr,
+    content: Fr[],
+    noteHash: Fr,
+    nullifier: Fr,
+    txHash: Fr,
+    recipient: AztecAddress,
+  ): Promise<void> {
+    const noteDao = await this.produceNoteDao(
+      contractAddress,
+      storageSlot,
+      nonce,
+      content,
+      noteHash,
+      nullifier,
+      txHash,
+      recipient,
+    );
+
+    await this.db.addNotes([noteDao], recipient);
+    this.log.verbose('Added note', {
+      contract: noteDao.contractAddress,
+      slot: noteDao.storageSlot,
+      nullifier: noteDao.siloedNullifier.toString,
+    });
   }
 
   public async removeNullifiedNotes(contractAddress: AztecAddress) {
+    this.log.verbose('Removing nullified notes', { contract: contractAddress });
+
     for (const recipient of await this.keyStore.getAccounts()) {
       const currentNotesForRecipient = await this.db.getNotes({ contractAddress, owner: recipient });
       const nullifiersToCheck = currentNotesForRecipient.map(note => note.siloedNullifier);
@@ -681,25 +714,113 @@ export class SimulatorOracle implements DBOracle {
     }
   }
 
-  /**
-   * Used by contracts during execution to store arbitrary data in the local PXE database. The data is siloed/scoped
-   * to a specific `contract`.
-   * @param contract - An address of a contract that is requesting to store the data.
-   * @param key - A field element representing the key to store the data under.
-   * @param values - An array of field elements representing the data to store.
-   */
-  store(contract: AztecAddress, key: Fr, values: Fr[]): Promise<void> {
-    return this.db.store(contract, key, values);
+  async produceNoteDao(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    nonce: Fr,
+    content: Fr[],
+    noteHash: Fr,
+    nullifier: Fr,
+    txHash: Fr,
+    recipient: AztecAddress,
+  ): Promise<NoteDao> {
+    const receipt = await this.aztecNode.getTxReceipt(new TxHash(txHash));
+    if (receipt === undefined) {
+      throw new Error(`Failed to fetch tx receipt for tx hash ${txHash} when searching for note hashes`);
+    }
+    const { blockNumber, blockHash } = receipt;
+
+    const uniqueNoteHash = computeUniqueNoteHash(nonce, siloNoteHash(contractAddress, noteHash));
+    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+
+    const uniqueNoteHashTreeIndex = (
+      await this.aztecNode.findLeavesIndexes(blockNumber!, MerkleTreeId.NOTE_HASH_TREE, [uniqueNoteHash])
+    )[0];
+    if (uniqueNoteHashTreeIndex === undefined) {
+      throw new Error(
+        `Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present on the tree at block ${blockNumber} (from tx ${txHash})`,
+      );
+    }
+
+    return new NoteDao(
+      new Note(content),
+      contractAddress,
+      storageSlot,
+      nonce,
+      noteHash,
+      siloedNullifier,
+      new TxHash(txHash),
+      blockNumber!,
+      blockHash!.toString(),
+      uniqueNoteHashTreeIndex,
+      recipient.toAddressPoint(),
+      NoteSelector.empty(), // todo: remove
+    );
   }
 
-  /**
-   * Used by contracts during execution to load arbitrary data from the local PXE database. The data is siloed/scoped
-   * to a specific `contract`.
-   * @param contract - An address of a contract that is requesting to load the data.
-   * @param key - A field element representing the key under which to load the data..
-   * @returns An array of field elements representing the stored data or `null` if no data is stored under the key.
-   */
-  load(contract: AztecAddress, key: Fr): Promise<Fr[] | null> {
-    return this.db.load(contract, key);
+  async callProcessLog(
+    contractAddress: AztecAddress,
+    logPlaintext: Fr[],
+    txHash: TxHash,
+    noteHashes: Fr[],
+    firstNullifier: Fr,
+    recipient: AztecAddress,
+    simulator?: AcirSimulator,
+  ) {
+    const artifact: FunctionArtifact | undefined = await new ContractDataOracle(this.db).getFunctionArtifactByName(
+      contractAddress,
+      'process_log',
+    );
+    if (!artifact) {
+      throw new Error(
+        `Mandatory implementation of "process_log" missing in noir contract ${contractAddress.toString()}.`,
+      );
+    }
+
+    const execRequest: FunctionCall = {
+      name: artifact.name,
+      to: contractAddress,
+      selector: FunctionSelector.fromNameAndParameters(artifact),
+      type: FunctionType.UNCONSTRAINED,
+      isStatic: artifact.isStatic,
+      args: encodeArguments(artifact, [
+        toBoundedVec(logPlaintext, PRIVATE_LOG_SIZE_IN_FIELDS),
+        txHash.toString(),
+        toBoundedVec(noteHashes, MAX_NOTE_HASHES_PER_TX),
+        firstNullifier,
+        recipient,
+      ]),
+      returnTypes: artifact.returnTypes,
+    };
+
+    await (
+      simulator ??
+      getAcirSimulator(this.db, this.aztecNode, this.keyStore, this.simulationProvider, this.contractDataOracle)
+    ).runUnconstrained(
+      execRequest,
+      artifact,
+      contractAddress,
+      [], // empty scope as this call should not require access to private information
+    );
   }
+
+  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void> {
+    return this.db.dbStore(contractAddress, slot, values);
+  }
+
+  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+    return this.db.dbLoad(contractAddress, slot);
+  }
+
+  dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+    return this.db.dbDelete(contractAddress, slot);
+  }
+
+  dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
+    return this.db.dbCopy(contractAddress, srcSlot, dstSlot, numEntries);
+  }
+}
+
+function toBoundedVec(array: Fr[], maxLength: number) {
+  return { storage: array.concat(Array(maxLength - array.length).fill(new Fr(0))), len: array.length };
 }

package/dest/note_decryption_utils/brute_force_note_info.d.ts

@@ -1,31 +0,0 @@
-import { type Note, type TxHash } from '@aztec/circuit-types';
-import { type AztecAddress } from '@aztec/circuits.js';
-import { type NoteSelector } from '@aztec/foundation/abi';
-import { Fr } from '@aztec/foundation/fields';
-import { type AcirSimulator } from '@aztec/simulator/client';
-export interface NoteInfo {
-    noteHashIndex: number;
-    nonce: Fr;
-    noteHash: Fr;
-    siloedNullifier: Fr;
-    txHash: TxHash;
-}
-/**
- * Finds nonce, index, inner hash and siloed nullifier for a given note.
- * @dev Finds the index in the note hash tree by computing the note hash with different nonce and see which hash for
- * the current tx matches this value.
- * @remarks This method assists in identifying spent notes in the note hash tree.
- * @param uniqueNoteHashes - Note hashes in the tx. One of them should correspond to the note we are looking for
- * @param txHash - Hash of a tx the note was emitted in.
- * @param contractAddress - Address of the contract the note was emitted in.
- * @param storageSlot - Storage slot of the note.
- * @param noteTypeId - Type of the note.
- * @param note - Note items.
- * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same
- * l1NotePayload. We need to find a different index for each replicate.
- * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
- * @returns Nonce, index, inner hash and siloed nullifier for a given note.
- * @throws If cannot find the nonce for the note.
- */
-export declare function bruteForceNoteInfo(simulator: AcirSimulator, uniqueNoteHashes: Fr[], txHash: TxHash, firstNullifier: Fr, contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: NoteSelector, note: Note, excludedIndices: Set<number>, computeNullifier: boolean): Promise<NoteInfo>;
-//# sourceMappingURL=brute_force_note_info.d.ts.map

package/dest/note_decryption_utils/brute_force_note_info.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"brute_force_note_info.d.ts","sourceRoot":"","sources":["../../src/note_decryption_utils/brute_force_note_info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,MAAM,WAAW,QAAQ;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,EAAE,CAAC;IACV,QAAQ,EAAE,EAAE,CAAC;IACb,eAAe,EAAE,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,aAAa,EACxB,gBAAgB,EAAE,EAAE,EAAE,EACtB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,EAAE,EAClB,eAAe,EAAE,YAAY,EAC7B,WAAW,EAAE,EAAE,EACf,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,IAAI,EACV,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,EAC5B,gBAAgB,EAAE,OAAO,GACxB,OAAO,CAAC,QAAQ,CAAC,CA8CnB"}

package/dest/note_decryption_utils/brute_force_note_info.js

@@ -1,54 +0,0 @@
-import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
-import { Fr } from '@aztec/foundation/fields';
-/**
- * Finds nonce, index, inner hash and siloed nullifier for a given note.
- * @dev Finds the index in the note hash tree by computing the note hash with different nonce and see which hash for
- * the current tx matches this value.
- * @remarks This method assists in identifying spent notes in the note hash tree.
- * @param uniqueNoteHashes - Note hashes in the tx. One of them should correspond to the note we are looking for
- * @param txHash - Hash of a tx the note was emitted in.
- * @param contractAddress - Address of the contract the note was emitted in.
- * @param storageSlot - Storage slot of the note.
- * @param noteTypeId - Type of the note.
- * @param note - Note items.
- * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same
- * l1NotePayload. We need to find a different index for each replicate.
- * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
- * @returns Nonce, index, inner hash and siloed nullifier for a given note.
- * @throws If cannot find the nonce for the note.
- */
-export async function bruteForceNoteInfo(simulator, uniqueNoteHashes, txHash, firstNullifier, contractAddress, storageSlot, noteTypeId, note, excludedIndices, computeNullifier) {
-    let noteHashIndex = 0;
-    let nonce;
-    let noteHash;
-    let uniqueNoteHash;
-    let innerNullifier;
-    for (; noteHashIndex < uniqueNoteHashes.length; ++noteHashIndex) {
-        if (excludedIndices.has(noteHashIndex)) {
-            continue;
-        }
-        const uniqueNoteHashFromTxEffect = uniqueNoteHashes[noteHashIndex];
-        if (uniqueNoteHashFromTxEffect.equals(Fr.ZERO)) {
-            break;
-        }
-        const expectedNonce = computeNoteHashNonce(firstNullifier, noteHashIndex);
-        ({ noteHash, uniqueNoteHash, innerNullifier } = await simulator.computeNoteHashAndOptionallyANullifier(contractAddress, expectedNonce, storageSlot, noteTypeId, computeNullifier, note));
-        if (uniqueNoteHashFromTxEffect.equals(uniqueNoteHash)) {
-            nonce = expectedNonce;
-            break;
-        }
-    }
-    if (!nonce) {
-        // NB: this used to warn the user that a decrypted log didn't match any notes.
-        // This was previously fine as we didn't chop transient note logs, but now we do (#1641 complete).
-        throw new Error('Cannot find a matching note hash for the note.');
-    }
-    return {
-        noteHashIndex,
-        nonce,
-        noteHash: noteHash,
-        siloedNullifier: siloNullifier(contractAddress, innerNullifier),
-        txHash,
-    };
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJ1dGVfZm9yY2Vfbm90ZV9pbmZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL25vdGVfZGVjcnlwdGlvbl91dGlscy9icnV0ZV9mb3JjZV9ub3RlX2luZm8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLGFBQWEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRTlFLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQVc5Qzs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsa0JBQWtCLENBQ3RDLFNBQXdCLEVBQ3hCLGdCQUFzQixFQUN0QixNQUFjLEVBQ2QsY0FBa0IsRUFDbEIsZUFBNkIsRUFDN0IsV0FBZSxFQUNmLFVBQXdCLEVBQ3hCLElBQVUsRUFDVixlQUE0QixFQUM1QixnQkFBeUI7SUFFekIsSUFBSSxhQUFhLEdBQUcsQ0FBQyxDQUFDO0lBQ3RCLElBQUksS0FBcUIsQ0FBQztJQUMxQixJQUFJLFFBQXdCLENBQUM7SUFDN0IsSUFBSSxjQUE4QixDQUFDO0lBQ25DLElBQUksY0FBOEIsQ0FBQztJQUVuQyxPQUFPLGFBQWEsR0FBRyxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsRUFBRSxhQUFhLEVBQUUsQ0FBQztRQUNoRSxJQUFJLGVBQWUsQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDLEVBQUUsQ0FBQztZQUN2QyxTQUFTO1FBQ1gsQ0FBQztRQUVELE1BQU0sMEJBQTBCLEdBQUcsZ0JBQWdCLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDbkUsSUFBSSwwQkFBMEIsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDL0MsTUFBTTtRQUNSLENBQUM7UUFFRCxNQUFNLGFBQWEsR0FBRyxvQkFBb0IsQ0FBQyxjQUFjLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFDMUUsQ0FBQyxFQUFFLFFBQVEsRUFBRSxjQUFjLEVBQUUsY0FBYyxFQUFFLEdBQUcsTUFBTSxTQUFTLENBQUMsc0NBQXNDLENBQ3BHLGVBQWUsRUFDZixhQUFhLEVBQ2IsV0FBVyxFQUNYLFVBQVUsRUFDVixnQkFBZ0IsRUFDaEIsSUFBSSxDQUNMLENBQUMsQ0FBQztRQUVILElBQUksMEJBQTBCLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxFQUFFLENBQUM7WUFDdEQsS0FBSyxHQUFHLGFBQWEsQ0FBQztZQUN0QixNQUFNO1FBQ1IsQ0FBQztJQUNILENBQUM7SUFFRCxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDWCw4RUFBOEU7UUFDOUUsa0dBQWtHO1FBQ2xHLE1BQU0sSUFBSSxLQUFLLENBQUMsZ0RBQWdELENBQUMsQ0FBQztJQUNwRSxDQUFDO0lBRUQsT0FBTztRQUNMLGFBQWE7UUFDYixLQUFLO1FBQ0wsUUFBUSxFQUFFLFFBQVM7UUFDbkIsZUFBZSxFQUFFLGFBQWEsQ0FBQyxlQUFlLEVBQUUsY0FBZSxDQUFDO1FBQ2hFLE1BQU07S0FDUCxDQUFDO0FBQ0osQ0FBQyJ9

package/dest/note_decryption_utils/index.d.ts

@@ -1,3 +0,0 @@
-export { produceNoteDaos } from './produce_note_daos.js';
-export { NoteInfo } from './brute_force_note_info.js';
-//# sourceMappingURL=index.d.ts.map

package/dest/note_decryption_utils/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/note_decryption_utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC"}

package/dest/note_decryption_utils/index.js

@@ -1,2 +0,0 @@
-export { produceNoteDaos } from './produce_note_daos.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZV9kZWNyeXB0aW9uX3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQyJ9