@aztec/pxe 0.70.0 → 0.72.1

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,25 @@ 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,
+  PublicLog,
   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 +49,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';
 
@@ -318,7 +330,7 @@ export class SimulatorOracle implements DBOracle {
   async #calculateAppTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress) {
     const senderCompleteAddress = await this.getCompleteAddress(sender);
     const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
-    const secretPoint = computeTaggingSecretPoint(senderCompleteAddress, senderIvsk, recipient);
+    const secretPoint = await computeTaggingSecretPoint(senderCompleteAddress, senderIvsk, recipient);
     // Silo the secret so it can't be used to track other app's notes
     const appSecret = poseidon2Hash([secretPoint.x, secretPoint.y, contractAddress]);
     return appSecret;
@@ -345,10 +357,12 @@ export class SimulatorOracle implements DBOracle {
     const senders = [...(await this.db.getSenderAddresses()), ...(await this.keyStore.getAccounts())].filter(
       (address, index, self) => index === self.findIndex(otherAddress => otherAddress.equals(address)),
     );
-    const appTaggingSecrets = senders.map(contact => {
-      const sharedSecret = computeTaggingSecretPoint(recipientCompleteAddress, recipientIvsk, contact);
-      return poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
-    });
+    const appTaggingSecrets = await Promise.all(
+      senders.map(async contact => {
+        const sharedSecret = await computeTaggingSecretPoint(recipientCompleteAddress, recipientIvsk, contact);
+        return poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
+      }),
+    );
     const indexes = await this.db.getTaggingSecretsIndexesAsRecipient(appTaggingSecrets);
     return appTaggingSecrets.map((secret, i) => new IndexedTaggingSecret(secret, indexes[i]));
   }
@@ -431,6 +445,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
@@ -486,15 +502,31 @@ export class SimulatorOracle implements DBOracle {
 
         logsByTags.forEach((logsByTag, logIndex) => {
           if (logsByTag.length > 0) {
+            // Check that public logs have the correct contract address
+            const checkedLogsbyTag = logsByTag.filter(
+              l => !l.isFromPublic || PublicLog.fromBuffer(l.logData).contractAddress.equals(contractAddress),
+            );
+            if (checkedLogsbyTag.length < logsByTag.length) {
+              const discarded = logsByTag.filter(
+                log => checkedLogsbyTag.find(filteredLog => filteredLog.equals(log)) === undefined,
+              );
+              this.log.warn(
+                `Discarded ${
+                  logsByTag.length - checkedLogsbyTag.length
+                } public logs with mismatched contract address ${contractAddress}:`,
+                discarded.map(l => PublicLog.fromBuffer(l.logData)),
+              );
+            }
+
             // The logs for the given tag exist so we store them for later processing
-            logsForRecipient.push(...logsByTag);
+            logsForRecipient.push(...checkedLogsbyTag);
 
             // We retrieve the indexed tagging secret corresponding to the log as I need that to evaluate whether
             // a new largest index have been found.
             const secretCorrespondingToLog = secretsForTheWholeWindow[logIndex];
             const initialIndex = initialIndexesMap[secretCorrespondingToLog.appTaggingSecret.toString()];
 
-            this.log.debug(`Found ${logsByTag.length} logs as recipient ${recipient}`, {
+            this.log.debug(`Found ${checkedLogsbyTag.length} logs as recipient ${recipient}`, {
               recipient,
               secret: secretCorrespondingToLog.appTaggingSecret,
               contractName,
@@ -568,69 +600,41 @@ 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,
     );
-    const addressSecret = computeAddressSecret(recipientCompleteAddress.getPreaddress(), ivskM);
+    const addressSecret = await computeAddressSecret(recipientCompleteAddress.getPreaddress(), ivskM);
 
     // 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
-        ? L1NotePayload.decryptAsIncomingFromPublic(scopedLog.logData, addressSecret)
-        : L1NotePayload.decryptAsIncoming(PrivateLog.fromBuffer(scopedLog.logData), addressSecret);
-
-      if (notePayload) {
-        const payload = notePayload;
+      const payload = scopedLog.isFromPublic
+        ? await L1NotePayload.decryptAsIncomingFromPublic(PublicLog.fromBuffer(scopedLog.logData), addressSecret)
+        : await L1NotePayload.decryptAsIncoming(PrivateLog.fromBuffer(scopedLog.logData), addressSecret);
 
-        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 +647,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);
@@ -670,7 +722,7 @@ export class SimulatorOracle implements DBOracle {
         })
         .filter(nullifier => nullifier !== undefined) as InBlock<Fr>[];
 
-      const nullifiedNotes = await this.db.removeNullifiedNotes(foundNullifiers, recipient.toAddressPoint());
+      const nullifiedNotes = await this.db.removeNullifiedNotes(foundNullifiers, await recipient.toAddressPoint());
       nullifiedNotes.forEach(noteDao => {
         this.log.verbose(`Removed note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
           contract: noteDao.contractAddress,
@@ -681,25 +733,122 @@ 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> {
+    // We need to validate that the note does indeed exist in the world state to avoid adding notes that are then
+    // impossible to prove.
+
+    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`);
+    }
+
+    // Siloed and unique hashes are computed by us instead of relying on values sent by the contract to make sure
+    // we're not e.g. storing notes that belong to some other contract, which would constitute a security breach.
+    const uniqueNoteHash = computeUniqueNoteHash(nonce, siloNoteHash(contractAddress, noteHash));
+    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+
+    // We store notes by their index in the global note hash tree, which has the convenient side effect of validating
+    // note existence in said tree. Note that while this is technically a historical query, we perform it at the latest
+    // locally synced block number which *should* be recent enough to be available. We avoid querying at 'latest' since
+    // we want to avoid accidentally processing notes that only exist ahead in time of the locally synced state.
+    const syncedBlockNumber = await this.db.getBlockNumber();
+    const uniqueNoteHashTreeIndex = (
+      await this.aztecNode.findLeavesIndexes(syncedBlockNumber!, 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 ${syncedBlockNumber} (from tx ${txHash})`,
+      );
+    }
+
+    return new NoteDao(
+      new Note(content),
+      contractAddress,
+      storageSlot,
+      nonce,
+      noteHash,
+      siloedNullifier,
+      new TxHash(txHash),
+      receipt.blockNumber!,
+      receipt.blockHash!.toString(),
+      uniqueNoteHashTreeIndex,
+      await 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

package/dest/note_decryption_utils/produce_note_daos.d.ts

@@ -1,28 +0,0 @@
-import { type L1NotePayload, type PublicKey, type TxHash } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/foundation/fields';
-import { type Logger } from '@aztec/foundation/log';
-import { type AcirSimulator } from '@aztec/simulator/client';
-import { NoteDao } from '../database/note_dao.js';
-import { type PxeDatabase } from '../database/pxe_database.js';
-/**
- * Decodes a note from a transaction that we know was intended for us.
- * Throws if we do not yet have the contract corresponding to the note in our database.
- * Accepts a set of excluded indices, which are indices that have been assigned a note in the same tx.
- * Inserts the index of the note into the excludedIndices set if the note is successfully decoded.
- *
- * @param simulator - An instance of AcirSimulator.
- * @param db - An instance of PxeDatabase.
- * @param addressPoint - The public counterpart to the address secret, which is used in the decryption of incoming note logs.
- * @param payload - An instance of l1NotePayload.
- * @param txHash - The hash of the transaction that created the note. Equivalent to the first nullifier of the transaction.
- * @param noteHashes - New note hashes in this transaction, one of which belongs to this note.
- * @param dataStartIndexForTx - The next available leaf index for the note hash tree for this transaction.
- * @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 logger - An instance of Logger.
- * @param unencryptedLogs - Unencrypted logs for the transaction (used to complete partial notes).
- * @returns An object containing the incoming notes.
- */
-export declare function produceNoteDaos(simulator: AcirSimulator, db: PxeDatabase, addressPoint: PublicKey | undefined, payload: L1NotePayload, txHash: TxHash, firstNullifier: Fr, l2BlockNumber: number, l2BlockHash: string, noteHashes: Fr[], dataStartIndexForTx: number, excludedIndices: Set<number>, logger: Logger): Promise<{
-    note: NoteDao | undefined;
-}>;
-//# sourceMappingURL=produce_note_daos.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"produce_note_daos.d.ts","sourceRoot":"","sources":["../../src/note_decryption_utils/produce_note_daos.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACvF,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,aAAa,EACxB,EAAE,EAAE,WAAW,EACf,YAAY,EAAE,SAAS,GAAG,SAAS,EACnC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,EAAE,EAClB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,EAAE,EAAE,EAChB,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,CAAC,CA4BxC"}

package/dest/note_decryption_utils/produce_note_daos.js

@@ -1,33 +0,0 @@
-import { NoteDao } from '../database/note_dao.js';
-import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
-/**
- * Decodes a note from a transaction that we know was intended for us.
- * Throws if we do not yet have the contract corresponding to the note in our database.
- * Accepts a set of excluded indices, which are indices that have been assigned a note in the same tx.
- * Inserts the index of the note into the excludedIndices set if the note is successfully decoded.
- *
- * @param simulator - An instance of AcirSimulator.
- * @param db - An instance of PxeDatabase.
- * @param addressPoint - The public counterpart to the address secret, which is used in the decryption of incoming note logs.
- * @param payload - An instance of l1NotePayload.
- * @param txHash - The hash of the transaction that created the note. Equivalent to the first nullifier of the transaction.
- * @param noteHashes - New note hashes in this transaction, one of which belongs to this note.
- * @param dataStartIndexForTx - The next available leaf index for the note hash tree for this transaction.
- * @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 logger - An instance of Logger.
- * @param unencryptedLogs - Unencrypted logs for the transaction (used to complete partial notes).
- * @returns An object containing the incoming notes.
- */
-export async function produceNoteDaos(simulator, db, addressPoint, payload, txHash, firstNullifier, l2BlockNumber, l2BlockHash, noteHashes, dataStartIndexForTx, excludedIndices, logger) {
-    if (!addressPoint) {
-        throw new Error('addressPoint is undefined. Cannot create note.');
-    }
-    let note;
-    if (addressPoint) {
-        note = await produceNoteDaosForKey(simulator, db, addressPoint, payload, txHash, firstNullifier, l2BlockNumber, l2BlockHash, noteHashes, dataStartIndexForTx, excludedIndices, logger, NoteDao.fromPayloadAndNoteInfo);
-    }
-    return {
-        note,
-    };
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjZV9ub3RlX2Rhb3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZV9kZWNyeXB0aW9uX3V0aWxzL3Byb2R1Y2Vfbm90ZV9kYW9zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVsRCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUV2RTs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGVBQWUsQ0FDbkMsU0FBd0IsRUFDeEIsRUFBZSxFQUNmLFlBQW1DLEVBQ25DLE9BQXNCLEVBQ3RCLE1BQWMsRUFDZCxjQUFrQixFQUNsQixhQUFxQixFQUNyQixXQUFtQixFQUNuQixVQUFnQixFQUNoQixtQkFBMkIsRUFDM0IsZUFBNEIsRUFDNUIsTUFBYztJQUVkLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUNsQixNQUFNLElBQUksS0FBSyxDQUFDLGdEQUFnRCxDQUFDLENBQUM7SUFDcEUsQ0FBQztJQUVELElBQUksSUFBeUIsQ0FBQztJQUU5QixJQUFJLFlBQVksRUFBRSxDQUFDO1FBQ2pCLElBQUksR0FBRyxNQUFNLHFCQUFxQixDQUNoQyxTQUFTLEVBQ1QsRUFBRSxFQUNGLFlBQVksRUFDWixPQUFPLEVBQ1AsTUFBTSxFQUNOLGNBQWMsRUFDZCxhQUFhLEVBQ2IsV0FBVyxFQUNYLFVBQVUsRUFDVixtQkFBbUIsRUFDbkIsZUFBZSxFQUNmLE1BQU0sRUFDTixPQUFPLENBQUMsc0JBQXNCLENBQy9CLENBQUM7SUFDSixDQUFDO0lBRUQsT0FBTztRQUNMLElBQUk7S0FDTCxDQUFDO0FBQ0osQ0FBQyJ9

package/dest/note_decryption_utils/produce_note_daos_for_key.d.ts

@@ -1,8 +0,0 @@
-import { type L1NotePayload, type Note, type TxHash } from '@aztec/circuit-types';
-import { type Fr, type PublicKey } from '@aztec/circuits.js';
-import { type Logger } from '@aztec/foundation/log';
-import { type AcirSimulator } from '@aztec/simulator/client';
-import { type PxeDatabase } from '../database/pxe_database.js';
-import { type NoteInfo } from './brute_force_note_info.js';
-export declare function produceNoteDaosForKey<T>(simulator: AcirSimulator, db: PxeDatabase, pkM: PublicKey, payload: L1NotePayload, txHash: TxHash, firstNullifier: Fr, l2BlockNumber: number, l2BlockHash: string, noteHashes: Fr[], dataStartIndexForTx: number, excludedIndices: Set<number>, logger: Logger, daoConstructor: (note: Note, payload: L1NotePayload, noteInfo: NoteInfo, l2BlockNumber: number, l2BlockHash: string, dataStartIndexForTx: number, pkM: PublicKey) => T): Promise<T | undefined>;
-//# sourceMappingURL=produce_note_daos_for_key.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"produce_note_daos_for_key.d.ts","sourceRoot":"","sources":["../../src/note_decryption_utils/produce_note_daos_for_key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,KAAK,QAAQ,EAAsB,MAAM,4BAA4B,CAAC;AAE/E,wBAAsB,qBAAqB,CAAC,CAAC,EAC3C,SAAS,EAAE,aAAa,EACxB,EAAE,EAAE,WAAW,EACf,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,EAAE,EAClB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,EAAE,EAAE,EAChB,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,CACd,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,mBAAmB,EAAE,MAAM,EAC3B,GAAG,EAAE,SAAS,KACX,CAAC,GACL,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CA2BxB"}