@aztec/pxe 0.24.0 → 0.26.2

package/src/pxe_service/pxe_service.ts

@@ -10,18 +10,17 @@ import {
   GetUnencryptedLogsResponse,
   KeyStore,
   L2Block,
-  L2Tx,
   LogFilter,
   MerkleTreeId,
   NoteFilter,
   PXE,
   SimulationError,
   Tx,
+  TxEffect,
   TxExecutionRequest,
   TxHash,
   TxL2Logs,
   TxReceipt,
-  TxStatus,
   getNewContractPublicFunctions,
   isNoirCallStackUnresolved,
 } from '@aztec/circuit-types';
@@ -32,7 +31,8 @@ import {
   CompleteAddress,
   FunctionData,
   GrumpkinPrivateKey,
-  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+  MAX_NON_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+  MAX_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   PartialAddress,
   PrivateKernelTailCircuitPublicInputs,
   PublicCallRequest,
@@ -41,9 +41,9 @@ import {
   computeSaltedInitializationHash,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
-import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/abis';
+import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/hash';
 import { DecodedReturn, encodeArguments } from '@aztec/foundation/abi';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
@@ -56,7 +56,7 @@ import {
   collectUnencryptedLogs,
   resolveOpcodeLocations,
 } from '@aztec/simulator';
-import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+import { ContractClassWithId, ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { NodeInfo } from '@aztec/types/interfaces';
 
 import { PXEServiceConfig, getPackageInfo } from '../config/index.js';
@@ -162,6 +162,11 @@ export class PXEService implements PXE {
     return this.db.getContractInstance(address);
   }
 
+  public async getContractClass(id: Fr): Promise<ContractClassWithId | undefined> {
+    const artifact = await this.db.getContractArtifact(id);
+    return artifact && getContractClassFromArtifact(artifact);
+  }
+
   public async registerAccount(privKey: GrumpkinPrivateKey, partialAddress: PartialAddress): Promise<CompleteAddress> {
     const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(privKey, partialAddress);
     const wasAdded = await this.db.addCompleteAddress(completeAddress);
@@ -330,17 +335,17 @@ export class PXEService implements PXE {
    * @remarks More than a single nonce may be returned since there might be more than one nonce for a given note.
    */
   private async getNoteNonces(note: ExtendedNote): Promise<Fr[]> {
-    const tx = await this.node.getTx(note.txHash);
+    const tx = await this.node.getTxEffect(note.txHash);
     if (!tx) {
       throw new Error(`Unknown tx: ${note.txHash}`);
     }
 
     const nonces: Fr[] = [];
-    const firstNullifier = tx.newNullifiers[0];
-    const commitments = tx.newCommitments;
-    for (let i = 0; i < commitments.length; ++i) {
-      const commitment = commitments[i];
-      if (commitment.equals(Fr.ZERO)) {
+    const firstNullifier = tx.nullifiers[0];
+    const hashes = tx.noteHashes;
+    for (let i = 0; i < hashes.length; ++i) {
+      const hash = hashes[i];
+      if (hash.equals(Fr.ZERO)) {
         break;
       }
 
@@ -354,11 +359,11 @@ export class PXEService implements PXE {
       );
       // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)
       // Remove this once notes added from public also include nonces.
-      if (commitment.equals(siloedNoteHash)) {
+      if (hash.equals(siloedNoteHash)) {
         nonces.push(Fr.ZERO);
         break;
       }
-      if (commitment.equals(uniqueSiloedNoteHash)) {
+      if (hash.equals(uniqueSiloedNoteHash)) {
         nonces.push(nonce);
       }
     }
@@ -391,7 +396,7 @@ export class PXEService implements PXE {
 
       const timer = new Timer();
       const tx = await this.#simulateAndProve(txRequest, newContract);
-      this.log(`Processed private part of ${tx.data.end.newNullifiers[0]}`, {
+      this.log(`Processed private part of ${tx.getTxHash()}`, {
         eventName: 'tx-pxe-processing',
         duration: timer.ms(),
         ...tx.getStats(),
@@ -399,15 +404,15 @@ export class PXEService implements PXE {
       if (simulatePublic) {
         await this.#simulatePublicCalls(tx);
       }
-      this.log.info(`Executed local simulation for ${await tx.getTxHash()}`);
+      this.log.info(`Executed local simulation for ${tx.getTxHash()}`);
 
       return tx;
     });
   }
 
   public async sendTx(tx: Tx): Promise<TxHash> {
-    const txHash = await tx.getTxHash();
-    if (await this.node.getTx(txHash)) {
+    const txHash = tx.getTxHash();
+    if (await this.node.getTxEffect(txHash)) {
       throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
     }
     this.log.info(`Sending transaction ${txHash}`);
@@ -432,38 +437,12 @@ export class PXEService implements PXE {
     });
   }
 
-  public async getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    let txReceipt = new TxReceipt(txHash, TxStatus.DROPPED, 'Tx dropped by P2P node.');
-
-    // We first check if the tx is in pending (instead of first checking if it is mined) because if we first check
-    // for mined and then for pending there could be a race condition where the tx is mined between the two checks
-    // and we would incorrectly return a TxReceipt with status DROPPED
-    const pendingTx = await this.node.getPendingTxByHash(txHash);
-    if (pendingTx) {
-      txReceipt = new TxReceipt(txHash, TxStatus.PENDING, '');
-    }
-
-    const settledTx = await this.node.getTx(txHash);
-    if (settledTx) {
-      const deployedContractAddress = settledTx.newContractData.find(
-        c => !c.contractAddress.equals(AztecAddress.ZERO),
-      )?.contractAddress;
-
-      txReceipt = new TxReceipt(
-        txHash,
-        TxStatus.MINED,
-        '',
-        settledTx.blockHash.toBuffer(),
-        settledTx.blockNumber,
-        deployedContractAddress,
-      );
-    }
-
-    return txReceipt;
+  public getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
+    return this.node.getTxReceipt(txHash);
   }
 
-  public async getTx(txHash: TxHash): Promise<L2Tx | undefined> {
-    return await this.node.getTx(txHash);
+  public getTxEffect(txHash: TxHash): Promise<TxEffect | undefined> {
+    return this.node.getTxEffect(txHash);
   }
 
   async getBlockNumber(): Promise<number> {
@@ -647,6 +626,9 @@ export class PXEService implements PXE {
     const kernelProver = new KernelProver(kernelOracle);
     this.log(`Executing kernel prover...`);
     const { proof, publicInputs } = await kernelProver.prove(txExecutionRequest.toTxRequest(), executionResult);
+    this.log(
+      `Needs setup: ${publicInputs.needsSetup}, needs app logic: ${publicInputs.needsAppLogic}, needs teardown: ${publicInputs.needsTeardown}`,
+    );
 
     const encryptedLogs = new TxL2Logs(collectEncryptedLogs(executionResult));
     const unencryptedLogs = new TxL2Logs(collectUnencryptedLogs(executionResult));
@@ -714,27 +696,54 @@ export class PXEService implements PXE {
     enqueuedPublicCalls: PublicCallRequest[],
   ) {
     const enqueuedPublicCallStackItems = await Promise.all(enqueuedPublicCalls.map(c => c.toCallRequest()));
-    const { publicCallStack } = publicInputs.end;
 
     // Validate all items in enqueued public calls are in the kernel emitted stack
-    const areEqual = enqueuedPublicCallStackItems.reduce(
-      (accum, enqueued) => accum && !!publicCallStack.find(item => item.equals(enqueued)),
-      true,
+    const enqueuedRevertiblePublicCallStackItems = enqueuedPublicCallStackItems.filter(enqueued =>
+      publicInputs.end.publicCallStack.find(item => item.equals(enqueued)),
     );
 
-    if (!areEqual) {
+    const revertibleStackSize = arrayNonEmptyLength(publicInputs.end.publicCallStack, item => item.isEmpty());
+
+    if (enqueuedRevertiblePublicCallStackItems.length !== revertibleStackSize) {
       throw new Error(
-        `Enqueued public function calls and public call stack do not match.\nEnqueued calls: ${enqueuedPublicCallStackItems
+        `Enqueued revertible public function calls and revertible public call stack do not match.\nEnqueued calls: ${enqueuedRevertiblePublicCallStackItems
           .map(h => h.hash.toString())
-          .join(', ')}\nPublic call stack: ${publicCallStack.map(i => i.toString()).join(', ')}`,
+          .join(', ')}\nPublic call stack: ${publicInputs.end.publicCallStack.map(i => i.toString()).join(', ')}`,
       );
     }
 
     // Override kernel output
     publicInputs.end.publicCallStack = padArrayEnd(
-      enqueuedPublicCallStackItems,
+      enqueuedRevertiblePublicCallStackItems,
+      CallRequest.empty(),
+      MAX_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+    );
+
+    // Do the same for non-revertible
+
+    const enqueuedNonRevertiblePublicCallStackItems = enqueuedPublicCallStackItems.filter(enqueued =>
+      publicInputs.endNonRevertibleData.publicCallStack.find(item => item.equals(enqueued)),
+    );
+
+    const nonRevertibleStackSize = arrayNonEmptyLength(publicInputs.endNonRevertibleData.publicCallStack, item =>
+      item.isEmpty(),
+    );
+
+    if (enqueuedNonRevertiblePublicCallStackItems.length !== nonRevertibleStackSize) {
+      throw new Error(
+        `Enqueued non-revertible public function calls and non-revertible public call stack do not match.\nEnqueued calls: ${enqueuedNonRevertiblePublicCallStackItems
+          .map(h => h.hash.toString())
+          .join(', ')}\nPublic call stack: ${publicInputs.endNonRevertibleData.publicCallStack
+          .map(i => i.toString())
+          .join(', ')}`,
+      );
+    }
+
+    // Override kernel output
+    publicInputs.endNonRevertibleData.publicCallStack = padArrayEnd(
+      enqueuedNonRevertiblePublicCallStackItems,
       CallRequest.empty(),
-      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+      MAX_NON_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
     );
   }
 
@@ -753,4 +762,8 @@ export class PXEService implements PXE {
   public getKeyStore() {
     return this.keyStore;
   }
+
+  public async isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
+    return !!(await this.node.getContractClass(id));
+  }
 }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -1,11 +1,13 @@
+import { DeployedContract, PXE, TxExecutionRequest, randomDeployedContract } from '@aztec/circuit-types';
 import {
-  DeployedContract,
+  AztecAddress,
+  CompleteAddress,
+  Fr,
+  FunctionData,
   INITIAL_L2_BLOCK_NUM,
-  PXE,
-  TxExecutionRequest,
-  randomDeployedContract,
-} from '@aztec/circuit-types';
-import { AztecAddress, CompleteAddress, Fr, FunctionData, Point, TxContext } from '@aztec/circuits.js';
+  Point,
+  TxContext,
+} from '@aztec/circuits.js';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { ConstantKeyPair } from '@aztec/key-store';
 

package/src/simulator_oracle/index.ts

@@ -19,6 +19,7 @@ import {
 import { FunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { DBOracle, KeyPair, MessageLoadOracleInputs } from '@aztec/simulator';
+import { ContractInstance } from '@aztec/types/contracts';
 
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
 import { PxeDatabase } from '../database/index.js';
@@ -52,6 +53,14 @@ export class SimulatorOracle implements DBOracle {
     return completeAddress;
   }
 
+  async getContractInstance(address: AztecAddress): Promise<ContractInstance> {
+    const instance = await this.db.getContractInstance(address);
+    if (!instance) {
+      throw new Error(`No contract instance found for address ${address.toString()}`);
+    }
+    return instance;
+  }
+
   async getAuthWitness(messageHash: Fr): Promise<Fr[]> {
     const witness = await this.db.getAuthWitness(messageHash);
     if (!witness) {
@@ -119,19 +128,18 @@ export class SimulatorOracle implements DBOracle {
   }
 
   /**
-   * Retrieves the L1ToL2Message associated with a specific message key
-   * Throws an error if the message key is not found
+   * Retrieves the L1ToL2Message associated with a specific entry key
+   * Throws an error if the entry key is not found
    *
-   * @param msgKey - The key of the message to be retrieved
+   * @param entryKey - The key of the message to be retrieved
    * @returns A promise that resolves to the message data, a sibling path and the
    *          index of the message in the l1ToL2MessageTree
    */
-  async getL1ToL2Message(msgKey: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
-    const messageAndIndex = await this.aztecNode.getL1ToL2MessageAndIndex(msgKey);
-    const message = messageAndIndex.message;
+  async getL1ToL2MembershipWitness(entryKey: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
+    const messageAndIndex = await this.aztecNode.getL1ToL2MessageAndIndex(entryKey);
     const index = messageAndIndex.index;
     const siblingPath = await this.aztecNode.getL1ToL2MessageSiblingPath('latest', index);
-    return new MessageLoadOracleInputs(message, index, siblingPath);
+    return new MessageLoadOracleInputs(index, siblingPath);
   }
 
   /**
@@ -168,6 +176,10 @@ export class SimulatorOracle implements DBOracle {
     }
   }
 
+  public async getNullifierMembershipWitnessAtLatestBlock(nullifier: Fr) {
+    return this.getNullifierMembershipWitness(await this.getBlockNumber(), nullifier);
+  }
+
   public getNullifierMembershipWitness(
     blockNumber: number,
     nullifier: Fr,

package/src/synchronizer/synchronizer.ts

@@ -1,15 +1,6 @@
-import {
-  AztecNode,
-  INITIAL_L2_BLOCK_NUM,
-  KeyStore,
-  L2BlockContext,
-  L2BlockL2Logs,
-  LogType,
-  MerkleTreeId,
-  TxHash,
-} from '@aztec/circuit-types';
+import { AztecNode, KeyStore, L2BlockContext, L2BlockL2Logs, MerkleTreeId, TxHash } from '@aztec/circuit-types';
 import { NoteProcessorCaughtUpStats } from '@aztec/circuit-types/stats';
-import { AztecAddress, Fr, PublicKey } from '@aztec/circuits.js';
+import { AztecAddress, Fr, INITIAL_L2_BLOCK_NUM, PublicKey } from '@aztec/circuits.js';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -102,38 +93,12 @@ export class Synchronizer {
   protected async work(limit = 1): Promise<boolean> {
     const from = this.getSynchedBlockNumber() + 1;
     try {
-      // Possibly improve after https://github.com/AztecProtocol/aztec-packages/issues/3870
-      let encryptedLogs = await this.node.getLogs(from, limit, LogType.ENCRYPTED);
-      if (!encryptedLogs.length) {
+      const blocks = await this.node.getBlocks(from, limit);
+      if (blocks.length === 0) {
         return false;
       }
 
-      let unencryptedLogs = await this.node.getLogs(from, limit, LogType.UNENCRYPTED);
-      if (!unencryptedLogs.length) {
-        return false;
-      }
-
-      // Note: If less than `limit` encrypted logs is returned, then we fetch only that number of blocks.
-      const blocks = await this.node.getBlocks(from, encryptedLogs.length);
-      if (!blocks.length) {
-        return false;
-      }
-
-      if (blocks.length !== encryptedLogs.length) {
-        // "Trim" the encrypted logs to match the number of blocks.
-        encryptedLogs = encryptedLogs.slice(0, blocks.length);
-      }
-
-      if (blocks.length !== unencryptedLogs.length) {
-        // "Trim" the unencrypted logs to match the number of blocks.
-        unencryptedLogs = unencryptedLogs.slice(0, blocks.length);
-      }
-
-      // attach logs to blocks
-      blocks.forEach((block, i) => {
-        block.attachLogs(encryptedLogs[i], LogType.ENCRYPTED);
-        block.attachLogs(unencryptedLogs[i], LogType.UNENCRYPTED);
-      });
+      const encryptedLogs = blocks.flatMap(block => block.body.encryptedLogs);
 
       // Wrap blocks in block contexts & only keep those that match our query
       const blockContexts = blocks.filter(block => block.number >= from).map(block => new L2BlockContext(block));
@@ -166,15 +131,19 @@ export class Synchronizer {
 
     // filter out note processors that are already caught up
     // and sort them by the block number they are lagging behind in ascending order
-    this.noteProcessorsToCatchUp = this.noteProcessorsToCatchUp.filter(noteProcessor => {
+    const noteProcessorsToCatchUp: NoteProcessor[] = [];
+
+    this.noteProcessorsToCatchUp.forEach(noteProcessor => {
       if (noteProcessor.status.syncedToBlock >= toBlockNumber) {
         // Note processor is ahead of main sync, nothing to do
         this.noteProcessors.push(noteProcessor);
-        return false;
+      } else {
+        noteProcessorsToCatchUp.push(noteProcessor);
       }
-      return true;
     });
 
+    this.noteProcessorsToCatchUp = noteProcessorsToCatchUp;
+
     if (!this.noteProcessorsToCatchUp.length) {
       // No note processors to catch up, nothing to do here,
       // but we return true to continue with the normal flow.
@@ -200,25 +169,14 @@ export class Synchronizer {
     }
 
     try {
-      let encryptedLogs = await this.node.getLogs(from, limit, LogType.ENCRYPTED);
-      if (!encryptedLogs.length) {
-        // This should never happen because this function should only be called when the note processor is lagging
-        // behind main sync.
-        throw new Error('No encrypted logs in processor catch up mode');
-      }
-
-      // Note: If less than `limit` encrypted logs is returned, then we fetch only that number of blocks.
-      const blocks = await this.node.getBlocks(from, encryptedLogs.length);
+      const blocks = await this.node.getBlocks(from, limit);
       if (!blocks.length) {
         // This should never happen because this function should only be called when the note processor is lagging
         // behind main sync.
         throw new Error('No blocks in processor catch up mode');
       }
 
-      if (blocks.length !== encryptedLogs.length) {
-        // "Trim" the encrypted logs to match the number of blocks.
-        encryptedLogs = encryptedLogs.slice(0, blocks.length);
-      }
+      const encryptedLogs = blocks.flatMap(block => block.body.encryptedLogs);
 
       const blockContexts = blocks.map(block => new L2BlockContext(block));