@aztec/pxe 0.72.1 → 0.74.0

package/src/pxe_service/pxe_service.ts

@@ -100,10 +100,13 @@ export class PXEService implements PXE {
     private proofCreator: PrivateKernelProver,
     private simulationProvider: SimulationProvider,
     config: PXEServiceConfig,
-    logSuffix?: string,
+    loggerOrSuffix?: string | Logger,
   ) {
-    this.log = createLogger(logSuffix ? `pxe:service:${logSuffix}` : `pxe:service`);
-    this.synchronizer = new Synchronizer(node, db, tipsStore, config, logSuffix);
+    this.log =
+      !loggerOrSuffix || typeof loggerOrSuffix === 'string'
+        ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`)
+        : loggerOrSuffix;
+    this.synchronizer = new Synchronizer(node, db, tipsStore, config, loggerOrSuffix);
     this.contractDataOracle = new ContractDataOracle(db);
     this.simulator = getAcirSimulator(db, node, keyStore, this.simulationProvider, this.contractDataOracle);
     this.packageVersion = getPackageInfo().version;
@@ -146,13 +149,33 @@ export class PXEService implements PXE {
     return this.db.getContractInstance(address);
   }
 
-  public async getContractClass(id: Fr): Promise<ContractClassWithId | undefined> {
+  public async getContractClassMetadata(
+    id: Fr,
+    includeArtifact: boolean = false,
+  ): Promise<{
+    contractClass: ContractClassWithId | undefined;
+    isContractClassPubliclyRegistered: boolean;
+    artifact: ContractArtifact | undefined;
+  }> {
     const artifact = await this.db.getContractArtifact(id);
-    return artifact && getContractClassFromArtifact(artifact);
+
+    return {
+      contractClass: artifact && (await getContractClassFromArtifact(artifact)),
+      isContractClassPubliclyRegistered: await this.#isContractClassPubliclyRegistered(id),
+      artifact: includeArtifact ? artifact : undefined,
+    };
   }
 
-  public getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
-    return this.db.getContractArtifact(id);
+  public async getContractMetadata(address: AztecAddress): Promise<{
+    contractInstance: ContractInstanceWithAddress | undefined;
+    isContractInitialized: boolean;
+    isContractPubliclyDeployed: boolean;
+  }> {
+    return {
+      contractInstance: await this.db.getContractInstance(address),
+      isContractInitialized: await this.#isContractInitialized(address),
+      isContractPubliclyDeployed: await this.#isContractPubliclyDeployed(address),
+    };
   }
 
   public async registerAccount(secretKey: Fr, partialAddress: PartialAddress): Promise<CompleteAddress> {
@@ -217,7 +240,7 @@ export class PXEService implements PXE {
   }
 
   public async registerContractClass(artifact: ContractArtifact): Promise<void> {
-    const contractClassId = computeContractClassId(getContractClassFromArtifact(artifact));
+    const contractClassId = await computeContractClassId(await getContractClassFromArtifact(artifact));
     await this.db.addContractArtifact(contractClassId, artifact);
     this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
   }
@@ -228,8 +251,8 @@ export class PXEService implements PXE {
 
     if (artifact) {
       // If the user provides an artifact, validate it against the expected class id and register it
-      const contractClass = getContractClassFromArtifact(artifact);
-      const contractClassId = computeContractClassId(contractClass);
+      const contractClass = await getContractClassFromArtifact(artifact);
+      const contractClassId = await computeContractClassId(contractClass);
       if (!contractClassId.equals(instance.contractClassId)) {
         throw new Error(
           `Artifact does not match expected class id (computed ${contractClassId} but instance refers to ${instance.contractClassId})`,
@@ -341,7 +364,7 @@ export class PXEService implements PXE {
         throw new Error('Note does not exist.');
       }
 
-      const siloedNullifier = siloNullifier(note.contractAddress, innerNullifier!);
+      const siloedNullifier = await siloNullifier(note.contractAddress, innerNullifier!);
       const [nullifierIndex] = await this.node.findLeavesIndexes('latest', MerkleTreeId.NULLIFIER_TREE, [
         siloedNullifier,
       ]);
@@ -434,7 +457,7 @@ export class PXEService implements PXE {
         break;
       }
 
-      const nonce = computeNoteHashNonce(firstNullifier, i);
+      const nonce = await computeNoteHashNonce(firstNullifier, i);
       const { uniqueNoteHash } = await this.simulator.computeNoteHashAndOptionallyANullifier(
         note.contractAddress,
         nonce,
@@ -526,8 +549,9 @@ export class PXEService implements PXE {
         }
       }
 
-      this.log.info(`Simulation completed for ${simulatedTx.getTxHash()} in ${timer.ms()}ms`, {
-        txHash: simulatedTx.getTxHash(),
+      const txHash = await simulatedTx.getTxHash();
+      this.log.info(`Simulation completed for ${txHash.toString()} in ${timer.ms()}ms`, {
+        txHash,
         ...txInfo,
         ...(profileResult ? { gateCounts: profileResult.gateCounts } : {}),
         ...(publicOutput
@@ -558,7 +582,7 @@ export class PXEService implements PXE {
   }
 
   public async sendTx(tx: Tx): Promise<TxHash> {
-    const txHash = tx.getTxHash();
+    const txHash = await tx.getTxHash();
     if (await this.node.getTxEffect(txHash)) {
       throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
     }
@@ -645,7 +669,7 @@ export class PXEService implements PXE {
     return {
       name: functionDao.name,
       args: encodeArguments(functionDao, args),
-      selector: FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
+      selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
       type: functionDao.functionType,
       to,
       isStatic: functionDao.isStatic,
@@ -824,16 +848,16 @@ export class PXEService implements PXE {
     });
   }
 
-  public async isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
+  async #isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
     return !!(await this.node.getContractClass(id));
   }
 
-  public async isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
+  async #isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
     return !!(await this.node.getContract(address));
   }
 
-  public async isContractInitialized(address: AztecAddress): Promise<boolean> {
-    const initNullifier = siloNullifier(address, address.toField());
+  async #isContractInitialized(address: AztecAddress): Promise<boolean> {
+    const initNullifier = await siloNullifier(address, address.toField());
     return !!(await this.node.getNullifierMembershipWitness('latest', initNullifier));
   }
 
@@ -866,7 +890,7 @@ export class PXEService implements PXE {
             throw new Error('No registered account');
           }
 
-          const preaddress = registeredAccount.getPreaddress();
+          const preaddress = await registeredAccount.getPreaddress();
 
           secretKey = await computeAddressSecret(preaddress, secretKey);
         }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -47,22 +47,22 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
 
     it('registers a class and adds a contract for it', async () => {
       const artifact = randomContractArtifact();
-      const contractClass = getContractClassFromArtifact(artifact);
+      const contractClass = await getContractClassFromArtifact(artifact);
       const contractClassId = contractClass.id;
       const instance = await randomContractInstanceWithAddress({ contractClassId });
 
       await pxe.registerContractClass(artifact);
-      expect(await pxe.getContractClass(contractClassId)).toMatchObject(
+      expect((await pxe.getContractClassMetadata(contractClassId)).contractClass).toMatchObject(
         omit(contractClass, 'privateFunctionsRoot', 'publicBytecodeCommitment'),
       );
 
       await pxe.registerContract({ instance });
-      expect(await pxe.getContractInstance(instance.address)).toEqual(instance);
+      expect((await pxe.getContractMetadata(instance.address)).contractInstance).toEqual(instance);
     });
 
     it('refuses to register a class with a mismatched address', async () => {
       const artifact = randomContractArtifact();
-      const contractClass = getContractClassFromArtifact(artifact);
+      const contractClass = await getContractClassFromArtifact(artifact);
       const contractClassId = contractClass.id;
       const instance = await randomContractInstanceWithAddress({ contractClassId });
       await expect(

package/src/simulator_oracle/index.ts

@@ -39,6 +39,7 @@ import {
   encodeArguments,
   getFunctionArtifact,
 } from '@aztec/foundation/abi';
+import { timesParallel } from '@aztec/foundation/collection';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
 import { type KeyStore } from '@aztec/key-store';
@@ -393,7 +394,7 @@ export class SimulatorOracle implements DBOracle {
     let [numConsecutiveEmptyLogs, currentIndex] = [0, oldIndex];
     do {
       // We compute the tags for the current window of indexes
-      const currentTags = [...new Array(WINDOW_SIZE)].map((_, i) => {
+      const currentTags = await timesParallel(WINDOW_SIZE, i => {
         const indexedAppTaggingSecret = new IndexedTaggingSecret(appTaggingSecret, currentIndex + i);
         return indexedAppTaggingSecret.computeSiloedTag(recipient, contractAddress);
       });
@@ -489,8 +490,8 @@ export class SimulatorOracle implements DBOracle {
 
       while (secretsAndWindows.length > 0) {
         const secretsForTheWholeWindow = getIndexedTaggingSecretsForTheWindow(secretsAndWindows);
-        const tagsForTheWholeWindow = secretsForTheWholeWindow.map(secret =>
-          secret.computeSiloedTag(recipient, contractAddress),
+        const tagsForTheWholeWindow = await Promise.all(
+          secretsForTheWholeWindow.map(secret => secret.computeSiloedTag(recipient, contractAddress)),
         );
 
         // We store the new largest indexes we find in the iteration in the following map to later on construct
@@ -607,7 +608,7 @@ export class SimulatorOracle implements DBOracle {
     const ivskM = await this.keyStore.getMasterSecretKey(
       recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey,
     );
-    const addressSecret = await computeAddressSecret(recipientCompleteAddress.getPreaddress(), ivskM);
+    const addressSecret = await computeAddressSecret(await 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
@@ -753,8 +754,8 @@ export class SimulatorOracle implements DBOracle {
 
     // 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);
+    const uniqueNoteHash = await computeUniqueNoteHash(nonce, await siloNoteHash(contractAddress, noteHash));
+    const siloedNullifier = await 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
@@ -808,7 +809,7 @@ export class SimulatorOracle implements DBOracle {
     const execRequest: FunctionCall = {
       name: artifact.name,
       to: contractAddress,
-      selector: FunctionSelector.fromNameAndParameters(artifact),
+      selector: await FunctionSelector.fromNameAndParameters(artifact),
       type: FunctionType.UNCONSTRAINED,
       isStatic: artifact.isStatic,
       args: encodeArguments(artifact, [

package/src/synchronizer/synchronizer.ts

@@ -27,9 +27,12 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     private db: PxeDatabase,
     private l2TipsStore: L2TipsStore,
     config: Partial<Pick<PXEConfig, 'l2StartingBlock'>> = {},
-    logSuffix?: string,
+    loggerOrSuffix?: string | Logger,
   ) {
-    this.log = createLogger(logSuffix ? `pxe:synchronizer:${logSuffix}` : 'pxe:synchronizer');
+    this.log =
+      !loggerOrSuffix || typeof loggerOrSuffix === 'string'
+        ? createLogger(loggerOrSuffix ? `pxe:synchronizer:${loggerOrSuffix}` : `pxe:synchronizer`)
+        : loggerOrSuffix;
     this.blockStream = this.createBlockStream(config);
   }