@aztec/pxe 0.61.0 → 0.62.0

package/src/pxe_service/pxe_service.ts

@@ -1,7 +1,7 @@
 import {
   type AuthWitness,
   type AztecNode,
-  type EventMetadata,
+  EventMetadata,
   EventType,
   type ExtendedNote,
   type FunctionCall,
@@ -44,11 +44,13 @@ import {
   computeAddressSecret,
   computeContractAddressFromInstance,
   computeContractClassId,
+  computePoint,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
 import {
   type AbiDecoded,
+  type AbiType,
   type ContractArtifact,
   EventSelector,
   FunctionSelector,
@@ -124,19 +126,18 @@ export class PXEService implements PXE {
 
   private async restoreNoteProcessors() {
     const accounts = await this.keyStore.getAccounts();
-    const publicKeys = accounts.map(async account => await this.keyStore.getMasterIncomingViewingPublicKey(account));
-    const publicKeysSet = new Set(publicKeys.map(k => k.toString()));
+    const accountsSet = new Set(accounts.map(k => k.toString()));
 
     const registeredAddresses = await this.db.getCompleteAddresses();
 
     let count = 0;
-    for (const address of registeredAddresses) {
-      if (!publicKeysSet.has(address.publicKeys.masterIncomingViewingPublicKey.toString())) {
+    for (const completeAddress of registeredAddresses) {
+      if (!accountsSet.has(completeAddress.address.toString())) {
         continue;
       }
 
       count++;
-      this.synchronizer.addAccount(address, this.keyStore, this.config.l2StartingBlock);
+      this.synchronizer.addAccount(completeAddress, this.keyStore, this.config.l2StartingBlock);
     }
 
     if (count > 0) {
@@ -204,47 +205,56 @@ export class PXEService implements PXE {
     return accountCompleteAddress;
   }
 
-  public async getRegisteredAccounts(): Promise<CompleteAddress[]> {
-    // Get complete addresses of both the recipients and the accounts
-    const completeAddresses = await this.db.getCompleteAddresses();
-    // Filter out the addresses not corresponding to accounts
+  public async registerContact(address: AztecAddress): Promise<AztecAddress> {
     const accounts = await this.keyStore.getAccounts();
-    return completeAddresses.filter(completeAddress =>
-      accounts.find(address => address.equals(completeAddress.address)),
-    );
+    if (accounts.includes(address)) {
+      this.log.info(`Account:\n "${address.toString()}"\n already registered.`);
+      return address;
+    }
+
+    const wasAdded = await this.db.addContactAddress(address);
+
+    if (wasAdded) {
+      this.log.info(`Added contact:\n ${address.toString()}`);
+    } else {
+      this.log.info(`Contact:\n "${address.toString()}"\n already registered.`);
+    }
+
+    return address;
   }
 
-  public async getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    const result = await this.getRegisteredAccounts();
-    const account = result.find(r => r.address.equals(address));
-    return Promise.resolve(account);
+  public getContacts(): Promise<AztecAddress[]> {
+    const contacts = this.db.getContactAddresses();
+
+    return Promise.resolve(contacts);
   }
 
-  public async registerRecipient(recipient: CompleteAddress): Promise<void> {
-    const wasAdded = await this.db.addCompleteAddress(recipient);
+  public async removeContact(address: AztecAddress): Promise<void> {
+    const wasRemoved = await this.db.removeContactAddress(address);
 
-    if (wasAdded) {
-      this.log.info(`Added recipient:\n ${recipient.toReadableString()}`);
+    if (wasRemoved) {
+      this.log.info(`Removed contact:\n ${address.toString()}`);
     } else {
-      this.log.info(`Recipient:\n "${recipient.toReadableString()}"\n already registered.`);
+      this.log.info(`Contact:\n "${address.toString()}"\n not in address book.`);
     }
+
+    return Promise.resolve();
   }
 
-  public async getRecipients(): Promise<CompleteAddress[]> {
+  public async getRegisteredAccounts(): Promise<CompleteAddress[]> {
     // Get complete addresses of both the recipients and the accounts
     const completeAddresses = await this.db.getCompleteAddresses();
-    // Filter out the addresses corresponding to accounts
+    // Filter out the addresses not corresponding to accounts
     const accounts = await this.keyStore.getAccounts();
-    const recipients = completeAddresses.filter(
-      completeAddress => !accounts.find(account => account.equals(completeAddress.address)),
+    return completeAddresses.filter(completeAddress =>
+      accounts.find(address => address.equals(completeAddress.address)),
     );
-    return recipients;
   }
 
-  public async getRecipient(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    const result = await this.getRecipients();
-    const recipient = result.find(r => r.address.equals(address));
-    return Promise.resolve(recipient);
+  public async getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
+    const result = await this.getRegisteredAccounts();
+    const account = result.find(r => r.address.equals(address));
+    return Promise.resolve(account);
   }
 
   public async registerContractClass(artifact: ContractArtifact): Promise<void> {
@@ -306,11 +316,11 @@ export class PXEService implements PXE {
     const extendedNotes = noteDaos.map(async dao => {
       let owner = filter.owner;
       if (owner === undefined) {
-        const completeAddresses = (await this.db.getCompleteAddresses()).find(address =>
-          address.publicKeys.masterIncomingViewingPublicKey.equals(dao.ivpkM),
+        const completeAddresses = (await this.db.getCompleteAddresses()).find(completeAddress =>
+          computePoint(completeAddress.address).equals(dao.addressPoint),
         );
         if (completeAddresses === undefined) {
-          throw new Error(`Cannot find complete address for IvpkM ${dao.ivpkM.toString()}`);
+          throw new Error(`Cannot find complete address for addressPoint ${dao.addressPoint.toString()}`);
         }
         owner = completeAddresses.address;
       }
@@ -405,7 +415,7 @@ export class PXEService implements PXE {
           noteHash,
           siloedNullifier,
           index,
-          owner.publicKeys.masterIncomingViewingPublicKey,
+          computePoint(owner.address),
         ),
         scope,
       );
@@ -413,11 +423,6 @@ export class PXEService implements PXE {
   }
 
   public async addNullifiedNote(note: ExtendedNote) {
-    const owner = await this.db.getCompleteAddress(note.owner);
-    if (!owner) {
-      throw new Error(`Unknown account: ${note.owner.toString()}`);
-    }
-
     const nonces = await this.#getNoteNonces(note);
     if (nonces.length === 0) {
       throw new Error(`Cannot find the note in tx: ${note.txHash}.`);
@@ -453,7 +458,7 @@ export class PXEService implements PXE {
           noteHash,
           Fr.ZERO, // We are not able to derive
           index,
-          owner.publicKeys.masterIncomingViewingPublicKey,
+          computePoint(note.owner),
         ),
       );
     }
@@ -830,24 +835,25 @@ export class PXEService implements PXE {
 
   public getEvents<T>(
     type: EventType.Encrypted,
-    eventMetadata: EventMetadata<T>,
+    event: { eventSelector: EventSelector; abiType: AbiType; fieldNames: string[] },
     from: number,
     limit: number,
     vpks: Point[],
   ): Promise<T[]>;
   public getEvents<T>(
     type: EventType.Unencrypted,
-    eventMetadata: EventMetadata<T>,
+    event: { eventSelector: EventSelector; abiType: AbiType; fieldNames: string[] },
     from: number,
     limit: number,
   ): Promise<T[]>;
   public getEvents<T>(
     type: EventType,
-    eventMetadata: EventMetadata<T>,
+    event: { eventSelector: EventSelector; abiType: AbiType; fieldNames: string[] },
     from: number,
     limit: number,
     vpks: Point[] = [],
   ): Promise<T[]> {
+    const eventMetadata = new EventMetadata<T>(type, event);
     if (type.includes(EventType.Encrypted)) {
       return this.getEncryptedEvents(from, limit, eventMetadata, vpks);
     }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -4,15 +4,7 @@ import {
   randomContractInstanceWithAddress,
   randomDeployedContract,
 } from '@aztec/circuit-types';
-import {
-  AztecAddress,
-  CompleteAddress,
-  Fr,
-  INITIAL_L2_BLOCK_NUM,
-  Point,
-  PublicKeys,
-  getContractClassFromArtifact,
-} from '@aztec/circuits.js';
+import { AztecAddress, Fr, INITIAL_L2_BLOCK_NUM, getContractClassFromArtifact } from '@aztec/circuits.js';
 
 export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) => {
   describe(testName, () => {
@@ -29,33 +21,11 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
 
       // Check that the account is correctly registered using the getAccounts and getRecipients methods
       const accounts = await pxe.getRegisteredAccounts();
-      const recipients = await pxe.getRecipients();
       expect(accounts).toContainEqual(completeAddress);
-      expect(recipients).not.toContainEqual(completeAddress);
 
       // Check that the account is correctly registered using the getAccount and getRecipient methods
       const account = await pxe.getRegisteredAccount(completeAddress.address);
-      const recipient = await pxe.getRecipient(completeAddress.address);
       expect(account).toEqual(completeAddress);
-      expect(recipient).toBeUndefined();
-    });
-
-    it('registers a recipient and returns it as a recipient only and not as an account', async () => {
-      const completeAddress = CompleteAddress.random();
-
-      await pxe.registerRecipient(completeAddress);
-
-      // Check that the recipient is correctly registered using the getAccounts and getRecipients methods
-      const accounts = await pxe.getRegisteredAccounts();
-      const recipients = await pxe.getRecipients();
-      expect(accounts).not.toContainEqual(completeAddress);
-      expect(recipients).toContainEqual(completeAddress);
-
-      // Check that the recipient is correctly registered using the getAccount and getRecipient methods
-      const account = await pxe.getRegisteredAccount(completeAddress.address);
-      const recipient = await pxe.getRecipient(completeAddress.address);
-      expect(account).toBeUndefined();
-      expect(recipient).toEqual(completeAddress);
     });
 
     it('does not throw when registering the same account twice (just ignores the second attempt)', async () => {
@@ -66,28 +36,6 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       await pxe.registerAccount(randomSecretKey, randomPartialAddress);
     });
 
-    // Disabled as CompleteAddress constructor now performs preimage validation.
-    it.skip('cannot register a recipient with the same aztec address but different pub key or partial address', async () => {
-      const recipient1 = CompleteAddress.random();
-      const recipient2 = new CompleteAddress(
-        recipient1.address,
-        new PublicKeys(Point.random(), Point.random(), Point.random(), Point.random()),
-        Fr.random(),
-      );
-
-      await pxe.registerRecipient(recipient1);
-      await expect(() => pxe.registerRecipient(recipient2)).rejects.toThrow(
-        `Complete address with aztec address ${recipient1.address}`,
-      );
-    });
-
-    it('does not throw when registering the same recipient twice (just ignores the second attempt)', async () => {
-      const completeAddress = CompleteAddress.random();
-
-      await pxe.registerRecipient(completeAddress);
-      await pxe.registerRecipient(completeAddress);
-    });
-
     it('successfully adds a contract', async () => {
       const contracts = [randomDeployedContract(), randomDeployedContract()];
       for (const contract of contracts) {

package/src/simulator_oracle/index.ts

@@ -1,5 +1,6 @@
 import {
   type AztecNode,
+  type EncryptedL2NoteLog,
   type L2Block,
   MerkleTreeId,
   type NoteStatus,
@@ -17,6 +18,7 @@ import {
   IndexedTaggingSecret,
   type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
+  TaggingSecret,
   computeTaggingSecret,
 } from '@aztec/circuits.js';
 import { type FunctionArtifact, getFunctionArtifact } from '@aztec/foundation/abi';
@@ -49,7 +51,7 @@ export class SimulatorOracle implements DBOracle {
     if (!completeAddress) {
       throw new Error(
         `No public key registered for address ${account}.
-        Register it by calling pxe.registerRecipient(...) or pxe.registerAccount(...).\nSee docs for context: https://docs.aztec.network/reference/common_errors/aztecnr-errors#simulation-error-no-public-key-registered-for-address-0x0-register-it-by-calling-pxeregisterrecipient-or-pxeregisteraccount`,
+        Register it by calling pxe.registerAccount(...).\nSee docs for context: https://docs.aztec.network/reference/common_errors/aztecnr-errors#simulation-error-no-public-key-registered-for-address-0x0-register-it-by-calling-pxeregisterrecipient-or-pxeregisteraccount`,
       );
     }
     return completeAddress;
@@ -230,6 +232,16 @@ export class SimulatorOracle implements DBOracle {
     return this.contractDataOracle.getDebugFunctionName(contractAddress, selector);
   }
 
+  /**
+   * Returns the full contents of your address book.
+   * This is used when calculating tags for incoming notes by deriving the shared secret, the contract-siloed tagging secret, and
+   * finally the index specified tag. We will then query the node with this tag for each address in the address book.
+   * @returns The full list of the users contact addresses.
+   */
+  public getContacts(): AztecAddress[] {
+    return this.db.getContactAddresses();
+  }
+
   /**
    * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
    * Includes the last known index used for tagging with this secret.
@@ -243,13 +255,35 @@ export class SimulatorOracle implements DBOracle {
     sender: AztecAddress,
     recipient: AztecAddress,
   ): Promise<IndexedTaggingSecret> {
+    const directionalSecret = await this.#calculateDirectionalSecret(contractAddress, sender, recipient);
+    const [index] = await this.db.getTaggingSecretsIndexes([directionalSecret]);
+    return IndexedTaggingSecret.fromTaggingSecret(directionalSecret, index);
+  }
+
+  /**
+   * Increments the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * @param contractAddress - The contract address to silo the secret for
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   */
+  public async incrementAppTaggingSecret(
+    contractAddress: AztecAddress,
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<void> {
+    const directionalSecret = await this.#calculateDirectionalSecret(contractAddress, sender, recipient);
+    await this.db.incrementTaggingSecretsIndexes([directionalSecret]);
+  }
+
+  async #calculateDirectionalSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress) {
     const senderCompleteAddress = await this.getCompleteAddress(sender);
     const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
     const sharedSecret = computeTaggingSecret(senderCompleteAddress, senderIvsk, recipient);
     // Silo the secret to the app so it can't be used to track other app's notes
-    const secret = poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
-    const [index] = await this.db.getTaggingSecretsIndexes([secret]);
-    return new IndexedTaggingSecret(secret, index);
+    const siloedSecret = poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
+    // Get the index of the secret, ensuring the directionality (sender -> recipient)
+    const directionalSecret = new TaggingSecret(siloedSecret, recipient);
+    return directionalSecret;
   }
 
   /**
@@ -263,18 +297,63 @@ export class SimulatorOracle implements DBOracle {
     recipient: AztecAddress,
   ): Promise<IndexedTaggingSecret[]> {
     const recipientCompleteAddress = await this.getCompleteAddress(recipient);
-    const completeAddresses = await this.db.getCompleteAddresses();
-    // Filter out the addresses corresponding to accounts
-    const accounts = await this.keyStore.getAccounts();
-    const senders = completeAddresses.filter(
-      completeAddress => !accounts.find(account => account.equals(completeAddress.address)),
-    );
     const recipientIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
-    const secrets = senders.map(({ address: sender }) => {
-      const sharedSecret = computeTaggingSecret(recipientCompleteAddress, recipientIvsk, sender);
+
+    // We implicitly add the recipient as a contact, this helps us decrypt tags on notes that we send to ourselves (recipient = us, sender = us)
+    const contacts = [...this.db.getContactAddresses(), recipient];
+    const appTaggingSecrets = contacts.map(contact => {
+      const sharedSecret = computeTaggingSecret(recipientCompleteAddress, recipientIvsk, contact);
       return poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
     });
-    const indexes = await this.db.getTaggingSecretsIndexes(secrets);
-    return secrets.map((secret, i) => new IndexedTaggingSecret(secret, indexes[i]));
+    // Ensure the directionality (sender -> recipient)
+    const directionalSecrets = appTaggingSecrets.map(secret => new TaggingSecret(secret, recipient));
+    const indexes = await this.db.getTaggingSecretsIndexes(directionalSecrets);
+    return directionalSecrets.map((directionalSecret, i) =>
+      IndexedTaggingSecret.fromTaggingSecret(directionalSecret, indexes[i]),
+    );
+  }
+
+  /**
+   * Synchronizes the logs tagged with the recipient's address and all the senders in the addressbook.
+   * Returns the unsynched logs and updates the indexes of the secrets used to tag them until there are no more logs to sync.
+   * @param contractAddress - The address of the contract that the logs are tagged for
+   * @param recipient - The address of the recipient
+   * @returns A list of encrypted logs tagged with the recipient's address
+   */
+  public async syncTaggedLogs(contractAddress: AztecAddress, recipient: AztecAddress): Promise<EncryptedL2NoteLog[]> {
+    // 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
+    // know how many logs we will get back. Furthermore, these logs are of undetermined
+    // length, since we don't really know the note they correspond to until we decrypt them.
+
+    // 1. Get all the secrets for the recipient and sender pairs (#9365)
+    let appTaggingSecrets = await this.getAppTaggingSecretsForSenders(contractAddress, recipient);
+
+    const logs: EncryptedL2NoteLog[] = [];
+    while (appTaggingSecrets.length > 0) {
+      // 2. Compute tags using the secrets, recipient and index. Obtain logs for each tag (#9380)
+      const currentTags = appTaggingSecrets.map(({ secret, recipient, index }) =>
+        poseidon2Hash([secret, recipient, index]),
+      );
+      const logsByTags = await this.aztecNode.getLogsByTags(currentTags);
+      const newTaggingSecrets: IndexedTaggingSecret[] = [];
+      logsByTags.forEach((logsByTag, index) => {
+        // 3.1. Append logs to the list and increment the index for the tags that have logs (#9380)
+        if (logsByTag.length > 0) {
+          logs.push(...logsByTag);
+          // 3.2. Increment the index for the tags that have logs (#9380)
+          newTaggingSecrets.push(
+            new IndexedTaggingSecret(appTaggingSecrets[index].secret, recipient, appTaggingSecrets[index].index + 1),
+          );
+        }
+      });
+      // 4. Consolidate in db and replace initial appTaggingSecrets with the new ones (updated indexes)
+      await this.db.incrementTaggingSecretsIndexes(
+        newTaggingSecrets.map(secret => new TaggingSecret(secret.secret, recipient)),
+      );
+      appTaggingSecrets = newTaggingSecrets;
+    }
+    return logs;
   }
 }

package/src/synchronizer/synchronizer.ts

@@ -371,15 +371,15 @@ export class Synchronizer {
 
   async #removeNullifiedNotes(notes: IncomingNoteDao[]) {
     // now group the decoded incoming notes by public key
-    const publicKeyToIncomingNotes: Map<PublicKey, IncomingNoteDao[]> = new Map();
+    const addressPointToIncomingNotes: Map<PublicKey, IncomingNoteDao[]> = new Map();
     for (const noteDao of notes) {
-      const notesForPublicKey = publicKeyToIncomingNotes.get(noteDao.ivpkM) ?? [];
-      notesForPublicKey.push(noteDao);
-      publicKeyToIncomingNotes.set(noteDao.ivpkM, notesForPublicKey);
+      const notesForAddressPoint = addressPointToIncomingNotes.get(noteDao.addressPoint) ?? [];
+      notesForAddressPoint.push(noteDao);
+      addressPointToIncomingNotes.set(noteDao.addressPoint, notesForAddressPoint);
     }
 
     // now for each group, look for the nullifiers in the nullifier tree
-    for (const [publicKey, notes] of publicKeyToIncomingNotes.entries()) {
+    for (const [publicKey, notes] of addressPointToIncomingNotes.entries()) {
       const nullifiers = notes.map(n => n.siloedNullifier);
       const relevantNullifiers: Fr[] = [];
       for (const nullifier of nullifiers) {