@aztec/pxe 0.22.0 → 0.24.0

package/src/pxe_service/test/pxe_test_suite.ts

@@ -0,0 +1,138 @@
+import {
+  DeployedContract,
+  INITIAL_L2_BLOCK_NUM,
+  PXE,
+  TxExecutionRequest,
+  randomDeployedContract,
+} from '@aztec/circuit-types';
+import { AztecAddress, CompleteAddress, Fr, FunctionData, Point, TxContext } from '@aztec/circuits.js';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import { ConstantKeyPair } from '@aztec/key-store';
+
+export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) => {
+  describe(testName, () => {
+    let pxe: PXE;
+
+    beforeAll(async () => {
+      pxe = await pxeSetup();
+    }, 120_000);
+
+    it('registers an account and returns it as an account only and not as a recipient', async () => {
+      const keyPair = ConstantKeyPair.random(new Grumpkin());
+      const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(keyPair.getPrivateKey(), Fr.random());
+
+      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
+
+      // 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 () => {
+      const keyPair = ConstantKeyPair.random(new Grumpkin());
+      const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(keyPair.getPrivateKey(), Fr.random());
+
+      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
+      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
+    });
+
+    it('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, 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: DeployedContract[] = [randomDeployedContract(), randomDeployedContract()];
+      await pxe.addContracts(contracts);
+
+      const expectedContractAddresses = contracts.map(contract => contract.instance.address);
+      const contractAddresses = await pxe.getContracts();
+
+      // check if all the contracts were returned
+      expect(contractAddresses).toEqual(expect.arrayContaining(expectedContractAddresses));
+    });
+
+    it('throws when simulating a tx targeting public entrypoint', async () => {
+      const functionData = FunctionData.empty();
+      functionData.isPrivate = false;
+      const txExecutionRequest = TxExecutionRequest.from({
+        origin: AztecAddress.random(),
+        argsHash: new Fr(0),
+        functionData,
+        txContext: TxContext.empty(),
+        packedArguments: [],
+        authWitnesses: [],
+      });
+
+      await expect(async () => await pxe.simulateTx(txExecutionRequest, false)).rejects.toThrow(
+        'Public entrypoints are not allowed',
+      );
+    });
+
+    // Note: Not testing a successful run of `simulateTx`, `sendTx`, `getTxReceipt` and `viewTx` here as it requires
+    //       a larger setup and it's sufficiently tested in the e2e tests.
+
+    it('throws when getting public storage for non-existent contract', async () => {
+      const contract = AztecAddress.random();
+      await expect(async () => await pxe.getPublicStorageAt(contract, new Fr(0n))).rejects.toThrow(
+        `Contract ${contract.toString()} is not deployed`,
+      );
+    });
+
+    // Note: Not testing `getExtendedContractData`, `getContractData` and `getUnencryptedLogs` here as these
+    //       functions only call AztecNode and these methods are frequently used by the e2e tests.
+
+    it('successfully gets a block number', async () => {
+      const blockNum = await pxe.getBlockNumber();
+      expect(blockNum).toBeGreaterThanOrEqual(INITIAL_L2_BLOCK_NUM);
+    });
+
+    it('successfully gets node info', async () => {
+      const nodeInfo = await pxe.getNodeInfo();
+      expect(typeof nodeInfo.protocolVersion).toEqual('number');
+      expect(typeof nodeInfo.chainId).toEqual('number');
+      expect(nodeInfo.l1ContractAddresses.rollupAddress.toString()).toMatch(/0x[a-fA-F0-9]+/);
+    });
+
+    // Note: Not testing `isGlobalStateSynchronized`, `isAccountStateSynchronized` and `getSyncStatus` as these methods
+    //       only call synchronizer.
+  });
+};

package/src/simulator/index.ts

@@ -0,0 +1,24 @@
+import { AztecNode, KeyStore } from '@aztec/circuit-types';
+import { AcirSimulator } from '@aztec/simulator';
+
+import { ContractDataOracle } from '../contract_data_oracle/index.js';
+import { PxeDatabase } from '../database/pxe_database.js';
+import { SimulatorOracle } from '../simulator_oracle/index.js';
+
+/**
+ * Helper method to create an instance of the acir simulator.
+ */
+export function getAcirSimulator(
+  db: PxeDatabase,
+  aztecNode: AztecNode,
+  keyStore: KeyStore,
+  contractDataOracle?: ContractDataOracle,
+) {
+  const simulatorOracle = new SimulatorOracle(
+    contractDataOracle ?? new ContractDataOracle(db),
+    db,
+    keyStore,
+    aztecNode,
+  );
+  return new AcirSimulator(simulatorOracle, aztecNode);
+}

package/src/simulator_oracle/index.ts

@@ -0,0 +1,210 @@
+import {
+  AztecNode,
+  KeyStore,
+  L2Block,
+  MerkleTreeId,
+  NoteStatus,
+  NullifierMembershipWitness,
+  PublicDataWitness,
+} from '@aztec/circuit-types';
+import {
+  AztecAddress,
+  CompleteAddress,
+  EthAddress,
+  Fr,
+  FunctionSelector,
+  Header,
+  L1_TO_L2_MSG_TREE_HEIGHT,
+} from '@aztec/circuits.js';
+import { FunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { DBOracle, KeyPair, MessageLoadOracleInputs } from '@aztec/simulator';
+
+import { ContractDataOracle } from '../contract_data_oracle/index.js';
+import { PxeDatabase } from '../database/index.js';
+
+/**
+ * A data oracle that provides information needed for simulating a transaction.
+ */
+export class SimulatorOracle implements DBOracle {
+  constructor(
+    private contractDataOracle: ContractDataOracle,
+    private db: PxeDatabase,
+    private keyStore: KeyStore,
+    private aztecNode: AztecNode,
+    private log = createDebugLogger('aztec:pxe:simulator_oracle'),
+  ) {}
+
+  async getNullifierKeyPair(accountAddress: AztecAddress, contractAddress: AztecAddress): Promise<KeyPair> {
+    const accountPublicKey = (await this.db.getCompleteAddress(accountAddress))!.publicKey;
+    const publicKey = await this.keyStore.getNullifierPublicKey(accountPublicKey);
+    const secretKey = await this.keyStore.getSiloedNullifierSecretKey(accountPublicKey, contractAddress);
+    return { publicKey, secretKey };
+  }
+
+  async getCompleteAddress(address: AztecAddress): Promise<CompleteAddress> {
+    const completeAddress = await this.db.getCompleteAddress(address);
+    if (!completeAddress) {
+      throw new Error(
+        `No public key registered for address ${address.toString()}. Register it by calling pxe.registerRecipient(...) or pxe.registerAccount(...).\nSee docs for context: https://docs.aztec.network/developers/debugging/aztecnr-errors#simulation-error-No-public-key-registered-for-address-0x0-Register-it-by-calling-pxeregisterRecipient-or-pxeregisterAccount`,
+      );
+    }
+    return completeAddress;
+  }
+
+  async getAuthWitness(messageHash: Fr): Promise<Fr[]> {
+    const witness = await this.db.getAuthWitness(messageHash);
+    if (!witness) {
+      throw new Error(`Unknown auth witness for message hash ${messageHash.toString()}`);
+    }
+    return witness;
+  }
+
+  async popCapsule(): Promise<Fr[]> {
+    const capsule = await this.db.popCapsule();
+    if (!capsule) {
+      throw new Error(`No capsules available`);
+    }
+    return capsule;
+  }
+
+  async getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus) {
+    const noteDaos = await this.db.getNotes({
+      contractAddress,
+      storageSlot,
+      status,
+    });
+    return noteDaos.map(({ contractAddress, storageSlot, nonce, note, innerNoteHash, siloedNullifier, index }) => ({
+      contractAddress,
+      storageSlot,
+      nonce,
+      note,
+      innerNoteHash,
+      siloedNullifier,
+      // PXE can use this index to get full MembershipWitness
+      index,
+    }));
+  }
+
+  async getFunctionArtifact(
+    contractAddress: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithDebugMetadata> {
+    const artifact = await this.contractDataOracle.getFunctionArtifact(contractAddress, selector);
+    const debug = await this.contractDataOracle.getFunctionDebugMetadata(contractAddress, selector);
+    return {
+      ...artifact,
+      debug,
+    };
+  }
+
+  async getFunctionArtifactByName(
+    contractAddress: AztecAddress,
+    functionName: string,
+  ): Promise<FunctionArtifactWithDebugMetadata | undefined> {
+    const artifact = await this.contractDataOracle.getFunctionArtifactByName(contractAddress, functionName);
+    if (!artifact) {
+      return;
+    }
+
+    const debug = await this.contractDataOracle.getFunctionDebugMetadata(contractAddress, artifact.selector);
+    return {
+      ...artifact,
+      debug,
+    };
+  }
+
+  async getPortalContractAddress(contractAddress: AztecAddress): Promise<EthAddress> {
+    return await this.contractDataOracle.getPortalContractAddress(contractAddress);
+  }
+
+  /**
+   * Retrieves the L1ToL2Message associated with a specific message key
+   * Throws an error if the message key is not found
+   *
+   * @param msgKey - 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;
+    const index = messageAndIndex.index;
+    const siblingPath = await this.aztecNode.getL1ToL2MessageSiblingPath('latest', index);
+    return new MessageLoadOracleInputs(message, index, siblingPath);
+  }
+
+  /**
+   * Gets the index of a commitment in the note hash tree.
+   * @param commitment - The commitment.
+   * @returns - The index of the commitment. Undefined if it does not exist in the tree.
+   */
+  async getCommitmentIndex(commitment: Fr) {
+    return await this.aztecNode.findLeafIndex('latest', MerkleTreeId.NOTE_HASH_TREE, commitment);
+  }
+
+  async getNullifierIndex(nullifier: Fr) {
+    return await this.aztecNode.findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
+  }
+
+  public async findLeafIndex(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<bigint | undefined> {
+    return await this.aztecNode.findLeafIndex(blockNumber, treeId, leafValue);
+  }
+
+  public async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: bigint): Promise<Fr[]> {
+    switch (treeId) {
+      case MerkleTreeId.CONTRACT_TREE:
+        return (await this.aztecNode.getContractSiblingPath(blockNumber, leafIndex)).toFields();
+      case MerkleTreeId.NULLIFIER_TREE:
+        return (await this.aztecNode.getNullifierSiblingPath(blockNumber, leafIndex)).toFields();
+      case MerkleTreeId.NOTE_HASH_TREE:
+        return (await this.aztecNode.getNoteHashSiblingPath(blockNumber, leafIndex)).toFields();
+      case MerkleTreeId.PUBLIC_DATA_TREE:
+        return (await this.aztecNode.getPublicDataSiblingPath(blockNumber, leafIndex)).toFields();
+      case MerkleTreeId.ARCHIVE:
+        return (await this.aztecNode.getArchiveSiblingPath(blockNumber, leafIndex)).toFields();
+      default:
+        throw new Error('Not implemented');
+    }
+  }
+
+  public getNullifierMembershipWitness(
+    blockNumber: number,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    return this.aztecNode.getNullifierMembershipWitness(blockNumber, nullifier);
+  }
+
+  public getLowNullifierMembershipWitness(
+    blockNumber: number,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    return this.aztecNode.getLowNullifierMembershipWitness(blockNumber, nullifier);
+  }
+
+  public async getBlock(blockNumber: number): Promise<L2Block | undefined> {
+    return await this.aztecNode.getBlock(blockNumber);
+  }
+
+  public async getPublicDataTreeWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    return await this.aztecNode.getPublicDataTreeWitness(blockNumber, leafSlot);
+  }
+
+  /**
+   * Retrieve the databases view of the Block Header object.
+   * This structure is fed into the circuits simulator and is used to prove against certain historical roots.
+   *
+   * @returns A Promise that resolves to a Header object.
+   */
+  getHeader(): Promise<Header> {
+    return Promise.resolve(this.db.getHeader());
+  }
+
+  /**
+   * Fetches the current block number.
+   * @returns The block number.
+   */
+  public async getBlockNumber(): Promise<number> {
+    return await this.aztecNode.getBlockNumber();
+  }
+}

package/src/synchronizer/index.ts

@@ -0,0 +1 @@
+export * from './synchronizer.js';