@aztec/pxe 0.67.1-devnet → 0.68.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.67.1-devnet",
+  "version": "0.68.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -23,7 +23,7 @@
     "clean": "rm -rf ./dest .tsbuildinfo ./src/config/package_info.ts",
     "formatting": "run -T prettier --check ./src && run -T eslint ./src",
     "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
-    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests",
+    "test": "HARDWARE_CONCURRENCY=16 RAYON_NUM_THREADS=4 NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=8",
     "start": "LOG_LEVEL=${LOG_LEVEL:-debug} && node ./dest/bin/index.js",
     "generate": "node ./scripts/generate_package_info.js"
   },
@@ -59,9 +59,9 @@
     ],
     "reporters": [
       [
-        "default",
+        "jest-silent-reporter",
         {
-          "summaryThreshold": 9999
+          "useDots": true
         }
       ]
     ],
@@ -71,19 +71,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.67.1-devnet",
-    "@aztec/bb.js": "0.67.1-devnet",
-    "@aztec/builder": "0.67.1-devnet",
-    "@aztec/circuit-types": "0.67.1-devnet",
-    "@aztec/circuits.js": "0.67.1-devnet",
-    "@aztec/ethereum": "0.67.1-devnet",
-    "@aztec/foundation": "0.67.1-devnet",
-    "@aztec/key-store": "0.67.1-devnet",
-    "@aztec/kv-store": "0.67.1-devnet",
-    "@aztec/noir-protocol-circuits-types": "0.67.1-devnet",
-    "@aztec/protocol-contracts": "0.67.1-devnet",
-    "@aztec/simulator": "0.67.1-devnet",
-    "@aztec/types": "0.67.1-devnet",
+    "@aztec/bb-prover": "0.68.0",
+    "@aztec/bb.js": "0.68.0",
+    "@aztec/builder": "0.68.0",
+    "@aztec/circuit-types": "0.68.0",
+    "@aztec/circuits.js": "0.68.0",
+    "@aztec/ethereum": "0.68.0",
+    "@aztec/foundation": "0.68.0",
+    "@aztec/key-store": "0.68.0",
+    "@aztec/kv-store": "0.68.0",
+    "@aztec/noir-protocol-circuits-types": "0.68.0",
+    "@aztec/protocol-contracts": "0.68.0",
+    "@aztec/simulator": "0.68.0",
+    "@aztec/types": "0.68.0",
     "@msgpack/msgpack": "^3.0.0-beta2",
     "@noir-lang/noirc_abi": "portal:../../noir/packages/noirc_abi",
     "@noir-lang/types": "workspace:*",

package/src/database/kv_pxe_database.ts

@@ -538,7 +538,7 @@ export class KVPxeDatabase implements PxeDatabase {
     return (await toArray(this.#completeAddresses.valuesAsync())).map(v => CompleteAddress.fromBuffer(v));
   }
 
-  async addContactAddress(address: AztecAddress): Promise<boolean> {
+  async addSenderAddress(address: AztecAddress): Promise<boolean> {
     if (await this.#addressBook.hasAsync(address.toString())) {
       return false;
     }
@@ -548,11 +548,11 @@ export class KVPxeDatabase implements PxeDatabase {
     return true;
   }
 
-  async getContactAddresses(): Promise<AztecAddress[]> {
+  async getSenderAddresses(): Promise<AztecAddress[]> {
     return (await toArray(this.#addressBook.entriesAsync())).map(AztecAddress.fromString);
   }
 
-  async removeContactAddress(address: AztecAddress): Promise<boolean> {
+  async removeSenderAddress(address: AztecAddress): Promise<boolean> {
     if (!this.#addressBook.hasAsync(address.toString())) {
       return false;
     }

package/src/database/pxe_database.ts

@@ -119,24 +119,24 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
   setHeader(header: BlockHeader): Promise<void>;
 
   /**
-   * Adds contact address to the database.
+   * Adds sender address to the database.
    * @param address - The address to add to the address book.
    * @returns A promise resolving to true if the address was added, false if it already exists.
    */
-  addContactAddress(address: AztecAddress): Promise<boolean>;
+  addSenderAddress(address: AztecAddress): Promise<boolean>;
 
   /**
-   * Retrieves the list of contact addresses in the address book.
+   * Retrieves the list of sender addresses in the address book.
    * @returns An array of Aztec addresses.
    */
-  getContactAddresses(): Promise<AztecAddress[]>;
+  getSenderAddresses(): Promise<AztecAddress[]>;
 
   /**
-   * Removes a contact address from the database.
+   * Removes a sender address from the database.
    * @param address - The address to remove from the address book.
    * @returns A promise resolving to true if the address was removed, false if it does not exist.
    */
-  removeContactAddress(address: AztecAddress): Promise<boolean>;
+  removeSenderAddress(address: AztecAddress): Promise<boolean>;
 
   /**
    * Adds complete address to the database.

package/src/pxe_service/error_enriching.ts

@@ -1,5 +1,8 @@
 import { type SimulationError, isNoirCallStackUnresolved } from '@aztec/circuit-types';
-import { AztecAddress, Fr, FunctionSelector, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js/constants';
+import { FunctionSelector } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
 import { type Logger } from '@aztec/foundation/log';
 import { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '@aztec/simulator/errors';
 
@@ -39,7 +42,7 @@ export async function enrichSimulationError(err: SimulationError, db: PxeDatabas
             );
           } else {
             logger.warn(
-              `Could not function artifact in contract ${contract.name} for function '${fnName}' when enriching error callstack`,
+              `Could not find function artifact in contract ${contract.name} for function '${fnName}' when enriching error callstack`,
             );
           }
         });

package/src/pxe_service/pxe_service.ts

@@ -31,29 +31,32 @@ import {
   UniqueNote,
   getNonNullifiedL1ToL2MessageWitness,
 } from '@aztec/circuit-types';
+import type {
+  CompleteAddress,
+  ContractClassWithId,
+  ContractInstanceWithAddress,
+  GasFees,
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  NodeInfo,
+  PartialAddress,
+  PrivateKernelTailCircuitPublicInputs,
+} from '@aztec/circuits.js';
 import {
-  type AztecAddress,
-  type CompleteAddress,
-  type ContractClassWithId,
-  type ContractInstanceWithAddress,
-  type GasFees,
-  type L1_TO_L2_MSG_TREE_HEIGHT,
-  type NodeInfo,
-  type PartialAddress,
-  type PrivateKernelTailCircuitPublicInputs,
-  computeAddressSecret,
   computeContractAddressFromInstance,
   computeContractClassId,
   getContractClassFromArtifact,
-} from '@aztec/circuits.js';
+} from '@aztec/circuits.js/contract';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
+import { computeAddressSecret } from '@aztec/circuits.js/keys';
 import {
   type AbiDecoded,
   type ContractArtifact,
   EventSelector,
   FunctionSelector,
+  FunctionType,
   encodeArguments,
 } from '@aztec/foundation/abi';
+import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, type Point } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -163,37 +166,37 @@ export class PXEService implements PXE {
     return accountCompleteAddress;
   }
 
-  public async registerContact(address: AztecAddress): Promise<AztecAddress> {
+  public async registerSender(address: AztecAddress): Promise<AztecAddress> {
     const accounts = await this.keyStore.getAccounts();
     if (accounts.includes(address)) {
-      this.log.info(`Account:\n "${address.toString()}"\n already registered.`);
+      this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
       return address;
     }
 
-    const wasAdded = await this.db.addContactAddress(address);
+    const wasAdded = await this.db.addSenderAddress(address);
 
     if (wasAdded) {
-      this.log.info(`Added contact:\n ${address.toString()}`);
+      this.log.info(`Added sender:\n ${address.toString()}`);
     } else {
-      this.log.info(`Contact:\n "${address.toString()}"\n already registered.`);
+      this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
     }
 
     return address;
   }
 
-  public getContacts(): Promise<AztecAddress[]> {
-    const contacts = this.db.getContactAddresses();
+  public getSenders(): Promise<AztecAddress[]> {
+    const senders = this.db.getSenderAddresses();
 
-    return Promise.resolve(contacts);
+    return Promise.resolve(senders);
   }
 
-  public async removeContact(address: AztecAddress): Promise<void> {
-    const wasRemoved = await this.db.removeContactAddress(address);
+  public async removeSender(address: AztecAddress): Promise<void> {
+    const wasRemoved = await this.db.removeSenderAddress(address);
 
     if (wasRemoved) {
-      this.log.info(`Removed contact:\n ${address.toString()}`);
+      this.log.info(`Removed sender:\n ${address.toString()}`);
     } else {
-      this.log.info(`Contact:\n "${address.toString()}"\n not in address book.`);
+      this.log.info(`Sender:\n "${address.toString()}"\n not in address book.`);
     }
 
     return Promise.resolve();
@@ -240,8 +243,14 @@ export class PXEService implements PXE {
 
       await this.db.addContractArtifact(contractClassId, artifact);
 
-      // TODO: PXE may not want to broadcast the artifact to the network
-      await this.node.addContractArtifact(instance.address, artifact);
+      const functionNames: Record<string, string> = {};
+      for (const fn of artifact.functions) {
+        if (fn.functionType === FunctionType.PUBLIC) {
+          functionNames[FunctionSelector.fromNameAndParameters(fn.name, fn.parameters).toString()] = fn.name;
+        }
+      }
+
+      await this.node.registerContractFunctionNames(instance.address, functionNames);
 
       // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
       await this.node.addContractClass({ ...contractClass, privateFunctions: [], unconstrainedFunctions: [] });
@@ -479,6 +488,7 @@ export class PXEService implements PXE {
     simulatePublic: boolean,
     msgSender: AztecAddress | undefined = undefined,
     skipTxValidation: boolean = false,
+    enforceFeePayment: boolean = true,
     profile: boolean = false,
     scopes?: AztecAddress[],
   ): Promise<TxSimulationResult> {
@@ -516,7 +526,7 @@ export class PXEService implements PXE {
       const simulatedTx = privateSimulationResult.toSimulatedTx();
       let publicOutput: PublicSimulationOutput | undefined;
       if (simulatePublic) {
-        publicOutput = await this.#simulatePublicCalls(simulatedTx);
+        publicOutput = await this.#simulatePublicCalls(simulatedTx, enforceFeePayment);
       }
 
       if (!skipTxValidation) {
@@ -773,11 +783,11 @@ export class PXEService implements PXE {
    * It can also be used for estimating gas in the future.
    * @param tx - The transaction to be simulated.
    */
-  async #simulatePublicCalls(tx: Tx) {
+  async #simulatePublicCalls(tx: Tx, enforceFeePayment: boolean) {
     // Simulating public calls can throw if the TX fails in a phase that doesn't allow reverts (setup)
     // Or return as reverted if it fails in a phase that allows reverts (app logic, teardown)
     try {
-      const result = await this.node.simulatePublicCalls(tx);
+      const result = await this.node.simulatePublicCalls(tx, enforceFeePayment);
       if (result.revertReason) {
         throw result.revertReason;
       }

package/src/simulator_oracle/index.ts

@@ -38,7 +38,7 @@ import { type IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
 import { produceNoteDaos } from '../note_decryption_utils/produce_note_daos.js';
 import { getAcirSimulator } from '../simulator/index.js';
-import { getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
+import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
 
 /**
  * A data oracle that provides information needed for simulating a transaction.
@@ -253,8 +253,8 @@ export class SimulatorOracle implements DBOracle {
    * 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(): Promise<AztecAddress[]> {
-    return this.db.getContactAddresses();
+  public getSenders(): Promise<AztecAddress[]> {
+    return this.db.getSenderAddresses();
   }
 
   /**
@@ -321,18 +321,19 @@ export class SimulatorOracle implements DBOracle {
    * @param recipient - The address receiving the notes
    * @returns A list of indexed tagging secrets
    */
-  async #getIndexedTaggingSecretsForContacts(
+  async #getIndexedTaggingSecretsForSenders(
     contractAddress: AztecAddress,
     recipient: AztecAddress,
   ): Promise<IndexedTaggingSecret[]> {
     const recipientCompleteAddress = await this.getCompleteAddress(recipient);
     const recipientIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
 
-    // We implicitly add all PXE accounts as contacts, this helps us decrypt tags on notes that we send to ourselves (recipient = us, sender = us)
-    const contacts = [...(await this.db.getContactAddresses()), ...(await this.keyStore.getAccounts())].filter(
+    // We implicitly add all PXE accounts as senders, this helps us decrypt tags on notes that we send to ourselves
+    // (recipient = us, sender = us)
+    const senders = [...(await this.db.getSenderAddresses()), ...(await this.keyStore.getAccounts())].filter(
       (address, index, self) => index === self.findIndex(otherAddress => otherAddress.equals(address)),
     );
-    const appTaggingSecrets = contacts.map(contact => {
+    const appTaggingSecrets = senders.map(contact => {
       const sharedSecret = computeTaggingSecretPoint(recipientCompleteAddress, recipientIvsk, contact);
       return poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
     });
@@ -353,59 +354,56 @@ export class SimulatorOracle implements DBOracle {
     recipient: AztecAddress,
   ): Promise<void> {
     const appTaggingSecret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
-    let [currentIndex] = await this.db.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
-
-    const INDEX_OFFSET = 10;
-
-    let previousEmptyBack = 0;
-    let currentEmptyBack = 0;
-    let currentEmptyFront: number;
-
-    // The below code is trying to find the index of the start of the first window in which for all elements of window, we do not see logs.
-    // We take our window size, and fetch the node for these logs. We store both the amount of empty consecutive slots from the front and the back.
-    // We use our current empty consecutive slots from the front, as well as the previous consecutive empty slots from the back to see if we ever hit a time where there
-    // is a window in which we see the combination of them to be greater than the window's size. If true, we rewind current index to the start of said window and use it.
-    // Assuming two windows of 5:
-    // [0, 1, 0, 1, 0], [0, 0, 0, 0, 0]
-    // We can see that when processing the second window, the previous amount of empty slots from the back of the window (1), added with the empty elements from the front of the window (5)
-    // is greater than 5 (6) and therefore we have found a window to use.
-    // We simply need to take the number of elements (10) - the size of the window (5) - the number of consecutive empty elements from the back of the last window (1) = 4;
-    // This is the first index of our desired window.
-    // Note that if we ever see a situation like so:
-    // [0, 1, 0, 1, 0], [0, 0, 0, 0, 1]
-    // This also returns the correct index (4), but this is indicative of a problem / desync. i.e. we should never have a window that has a log that exists after the window.
+    const [oldIndex] = await this.db.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
 
+    // This algorithm works such that:
+    // 1. If we find minimum consecutive empty logs in a window of logs we set the index to the index of the last log
+    // we found and quit.
+    // 2. If we don't find minimum consecutive empty logs in a window of logs we slide the window to latest log index
+    // and repeat the process.
+    const MIN_CONSECUTIVE_EMPTY_LOGS = 10;
+    const WINDOW_SIZE = MIN_CONSECUTIVE_EMPTY_LOGS * 2;
+
+    let [numConsecutiveEmptyLogs, currentIndex] = [0, oldIndex];
     do {
-      const currentTags = [...new Array(INDEX_OFFSET)].map((_, i) => {
+      // We compute the tags for the current window of indexes
+      const currentTags = [...new Array(WINDOW_SIZE)].map((_, i) => {
         const indexedAppTaggingSecret = new IndexedTaggingSecret(appTaggingSecret, currentIndex + i);
         return indexedAppTaggingSecret.computeSiloedTag(recipient, contractAddress);
       });
-      previousEmptyBack = currentEmptyBack;
 
+      // We fetch the logs for the tags
       const possibleLogs = await this.aztecNode.getLogsByTags(currentTags);
 
-      const indexOfFirstLog = possibleLogs.findIndex(possibleLog => possibleLog.length !== 0);
-      currentEmptyFront = indexOfFirstLog === -1 ? INDEX_OFFSET : indexOfFirstLog;
-
+      // We find the index of the last log in the window that is not empty
       const indexOfLastLog = possibleLogs.findLastIndex(possibleLog => possibleLog.length !== 0);
-      currentEmptyBack = indexOfLastLog === -1 ? INDEX_OFFSET : INDEX_OFFSET - 1 - indexOfLastLog;
 
-      currentIndex += INDEX_OFFSET;
-    } while (currentEmptyFront + previousEmptyBack < INDEX_OFFSET);
+      if (indexOfLastLog === -1) {
+        // We haven't found any logs in the current window so we stop looking
+        break;
+      }
 
-    // We unwind the entire current window and the amount of consecutive empty slots from the previous window
-    const newIndex = currentIndex - (INDEX_OFFSET + previousEmptyBack);
+      // We move the current index to that of the last log we found
+      currentIndex += indexOfLastLog + 1;
 
-    await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(appTaggingSecret, newIndex)]);
+      // We compute the number of consecutive empty logs we found and repeat the process if we haven't found enough.
+      numConsecutiveEmptyLogs = WINDOW_SIZE - indexOfLastLog - 1;
+    } while (numConsecutiveEmptyLogs < MIN_CONSECUTIVE_EMPTY_LOGS);
 
     const contractName = await this.contractDataOracle.getDebugContractName(contractAddress);
-    this.log.debug(`Syncing logs for sender ${sender} at contract ${contractName}(${contractAddress})`, {
-      sender,
-      secret: appTaggingSecret,
-      index: currentIndex,
-      contractName,
-      contractAddress,
-    });
+    if (currentIndex !== oldIndex) {
+      await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(appTaggingSecret, currentIndex)]);
+
+      this.log.debug(`Syncing logs for sender ${sender} at contract ${contractName}(${contractAddress})`, {
+        sender,
+        secret: appTaggingSecret,
+        index: currentIndex,
+        contractName,
+        contractAddress,
+      });
+    } else {
+      this.log.debug(`No new logs found for sender ${sender} at contract ${contractName}(${contractAddress})`);
+    }
   }
 
   /**
@@ -421,9 +419,6 @@ export class SimulatorOracle implements DBOracle {
     maxBlockNumber: number,
     scopes?: AztecAddress[],
   ): Promise<Map<string, TxScopedL2Log[]>> {
-    // Half the size of the window we slide over the tagging secret indexes.
-    const WINDOW_HALF_SIZE = 10;
-
     // 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
@@ -440,7 +435,7 @@ export class SimulatorOracle implements DBOracle {
       const logsForRecipient: TxScopedL2Log[] = [];
 
       // Get all the secrets for the recipient and sender pairs (#9365)
-      const secrets = await this.#getIndexedTaggingSecretsForContacts(contractAddress, recipient);
+      const secrets = await this.#getIndexedTaggingSecretsForSenders(contractAddress, recipient);
 
       // We fetch logs for a window of indexes in a range:
       //    <latest_log_index - WINDOW_HALF_SIZE, latest_log_index + WINDOW_HALF_SIZE>.

package/src/simulator_oracle/tagging_utils.ts

@@ -1,5 +1,8 @@
 import { type Fr, IndexedTaggingSecret } from '@aztec/circuits.js';
 
+// Half the size of the window we slide over the tagging secret indexes.
+export const WINDOW_HALF_SIZE = 10;
+
 export function getIndexedTaggingSecretsForTheWindow(
   secretsAndWindows: { appTaggingSecret: Fr; leftMostIndex: number; rightMostIndex: number }[],
 ): IndexedTaggingSecret[] {