@aztec/pxe 0.8.6

package/src/kernel_prover/proof_creator.ts

@@ -0,0 +1,176 @@
+import {
+  CircuitError,
+  CircuitsWasm,
+  KernelCircuitPublicInputs,
+  KernelCircuitPublicInputsFinal,
+  PrivateCircuitPublicInputs,
+  PrivateKernelInputsInit,
+  PrivateKernelInputsInner,
+  PrivateKernelInputsOrdering,
+  Proof,
+  makeEmptyProof,
+  privateKernelSimInit,
+  privateKernelSimInner,
+  privateKernelSimOrdering,
+} from '@aztec/circuits.js';
+import { siloCommitment } from '@aztec/circuits.js/abis';
+import { Fr } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
+
+/**
+ * Represents the output of the proof creation process for init and inner private kernel circuit.
+ * Contains the public inputs required for the init and inner private kernel circuit and the generated proof.
+ */
+export interface ProofOutput {
+  /**
+   * The public inputs required for the proof generation process.
+   * Note: C++ side does not define the specific data structure PrivateKernelPublicInputs and therefore
+   * would not generate a binding in circuits.gen.ts.
+   */
+  publicInputs: KernelCircuitPublicInputs;
+  /**
+   * The zk-SNARK proof for the kernel execution.
+   */
+  proof: Proof;
+}
+
+/**
+ * Represents the output of the proof creation process for final ordering private kernel circuit.
+ * Contains the public inputs required for the final ordering private kernel circuit and the generated proof.
+ */
+export interface ProofOutputFinal {
+  /**
+   * The public inputs required for the proof generation process.
+   * Note: C++ side does not define the specific data structure PrivateKernelPublicInputsFinal and therefore
+   * would not generate a binding in circuits.gen.ts.
+   */
+  publicInputs: KernelCircuitPublicInputsFinal;
+  /**
+   * The zk-SNARK proof for the kernel execution.
+   */
+  proof: Proof;
+}
+
+/**
+ * ProofCreator provides functionality to create and validate proofs, and retrieve
+ * siloed commitments necessary for maintaining transaction privacy and security on the network.
+ */
+export interface ProofCreator {
+  /**
+   * Computes the siloed commitments for a given set of public inputs.
+   *
+   * @param publicInputs - The public inputs containing the contract address and new commitments to be used in generating siloed commitments.
+   * @returns An array of Fr (finite field) elements representing the siloed commitments.
+   */
+  getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs): Promise<Fr[]>;
+
+  /**
+   * Creates a proof output for a given signed transaction request and private call data for the first iteration.
+   *
+   * @param privateKernelInputsInit - The private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  createProofInit(privateKernelInputsInit: PrivateKernelInputsInit): Promise<ProofOutput>;
+
+  /**
+   * Creates a proof output for a given previous kernel data and private call data for an inner iteration.
+   *
+   * @param privateKernelInputsInner - The private input data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  createProofInner(privateKernelInputsInner: PrivateKernelInputsInner): Promise<ProofOutput>;
+
+  /**
+   * Creates a proof output based on the last inner kernel iteration kernel data for the final ordering iteration.
+   *
+   * @param privateKernelInputsOrdering - The private input data structure for the final ordering iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  createProofOrdering(privateKernelInputsOrdering: PrivateKernelInputsOrdering): Promise<ProofOutputFinal>;
+}
+
+/**
+ * The KernelProofCreator class is responsible for generating siloed commitments and zero-knowledge proofs
+ * for private kernel circuit. It leverages Barretenberg and Circuits Wasm libraries
+ * to perform cryptographic operations and proof creation. The class provides methods to compute commitments
+ * based on the given public inputs and to generate proofs based on signed transaction requests, previous kernel
+ * data, private call data, and a flag indicating whether it's the first iteration or not.
+ */
+export class KernelProofCreator implements ProofCreator {
+  constructor(private log = createDebugLogger('aztec:kernel_proof_creator')) {}
+
+  public async getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs) {
+    const wasm = await CircuitsWasm.get();
+    const contractAddress = publicInputs.callContext.storageContractAddress;
+
+    return publicInputs.newCommitments.map(commitment => siloCommitment(wasm, contractAddress, commitment));
+  }
+
+  public async createProofInit(privateInputs: PrivateKernelInputsInit): Promise<ProofOutput> {
+    const wasm = await CircuitsWasm.get();
+    const [time, result] = await elapsed(() => privateKernelSimInit(wasm, privateInputs));
+    if (result instanceof CircuitError) {
+      throw new CircuitError(result.code, result.message);
+    }
+    this.log(`Simulated private kernel init`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'private-kernel-init',
+      duration: time.ms(),
+      inputSize: privateInputs.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    });
+    this.log('Skipping private kernel init proving...');
+    const proof = makeEmptyProof();
+
+    return {
+      publicInputs: result,
+      proof: proof,
+    };
+  }
+
+  public async createProofInner(privateInputs: PrivateKernelInputsInner): Promise<ProofOutput> {
+    const wasm = await CircuitsWasm.get();
+    const [time, result] = await elapsed(() => privateKernelSimInner(wasm, privateInputs));
+    if (result instanceof CircuitError) {
+      throw new CircuitError(result.code, result.message);
+    }
+    this.log(`Simulated private kernel inner`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'private-kernel-inner',
+      duration: time.ms(),
+      inputSize: privateInputs.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    });
+    this.log('Skipping private kernel inner proving...');
+    const proof = makeEmptyProof();
+
+    return {
+      publicInputs: result,
+      proof: proof,
+    };
+  }
+
+  public async createProofOrdering(privateInputs: PrivateKernelInputsOrdering): Promise<ProofOutputFinal> {
+    const wasm = await CircuitsWasm.get();
+    this.log('Executing private kernel simulation ordering...');
+    const [time, result] = await elapsed(() => privateKernelSimOrdering(wasm, privateInputs));
+    if (result instanceof CircuitError) {
+      throw new CircuitError(result.code, result.message);
+    }
+    this.log(`Simulated private kernel ordering`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'private-kernel-ordering',
+      duration: time.ms(),
+      inputSize: privateInputs.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    });
+    this.log('Skipping private kernel ordering proving...');
+    const proof = makeEmptyProof();
+
+    return {
+      publicInputs: result,
+      proof: proof,
+    };
+  }
+}

package/src/kernel_prover/proving_data_oracle.ts

@@ -0,0 +1,69 @@
+import {
+  CONTRACT_TREE_HEIGHT,
+  FUNCTION_TREE_HEIGHT,
+  Fr,
+  FunctionSelector,
+  MembershipWitness,
+  PRIVATE_DATA_TREE_HEIGHT,
+  VK_TREE_HEIGHT,
+  VerificationKey,
+} from '@aztec/circuits.js';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+
+/**
+ * Provides functionality to fetch membership witnesses for verification keys,
+ * contract addresses, and function selectors in their respective merkle trees.
+ */
+export interface ProvingDataOracle {
+  /**
+   * Retrieves the contract membership witness for a given contract address.
+   * A contract membership witness is a cryptographic proof that the contract exists in the Aztec network.
+   * This function will search for an existing contract tree associated with the contract address and obtain its
+   * membership witness. If no such contract tree exists, it will throw an error.
+   *
+   * @param contractAddress - The contract address.
+   * @returns A promise that resolves to a MembershipWitness instance representing the contract membership witness.
+   * @throws Error if the contract address is unknown or not found.
+   */
+  getContractMembershipWitness(contractAddress: AztecAddress): Promise<MembershipWitness<typeof CONTRACT_TREE_HEIGHT>>;
+
+  /**
+   * Retrieve the function membership witness for the given contract address and function selector.
+   * The function membership witness represents a proof that the function belongs to the specified contract.
+   * Throws an error if the contract address or function selector is unknown.
+   *
+   * @param contractAddress - The contract address.
+   * @param selector - The function selector.
+   * @returns A promise that resolves with the MembershipWitness instance for the specified contract's function.
+   */
+  getFunctionMembershipWitness(
+    contractAddress: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<MembershipWitness<typeof FUNCTION_TREE_HEIGHT>>;
+
+  /**
+   * Retrieve the membership witness corresponding to a verification key.
+   * This function currently returns a random membership witness of the specified height,
+   * which is a placeholder implementation until a concrete membership witness calculation
+   * is implemented.
+   *
+   * @param vk - The VerificationKey for which the membership witness is needed.
+   * @returns A Promise that resolves to the MembershipWitness instance.
+   */
+  getVkMembershipWitness(vk: VerificationKey): Promise<MembershipWitness<typeof VK_TREE_HEIGHT>>;
+
+  /**
+   * Get the note membership witness for a note in the private data tree at the given leaf index.
+   *
+   * @param leafIndex - The leaf index of the note in the private data tree.
+   * @returns the MembershipWitness for the note.
+   */
+  getNoteMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof PRIVATE_DATA_TREE_HEIGHT>>;
+
+  /**
+   * Get the root of the private data tree.
+   *
+   * @returns the root of the private data tree.
+   */
+  getPrivateDataRoot(): Promise<Fr>;
+}

package/src/note_processor/index.ts

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

package/src/note_processor/note_processor.ts

@@ -0,0 +1,267 @@
+import { CircuitsWasm, MAX_NEW_COMMITMENTS_PER_TX, MAX_NEW_NULLIFIERS_PER_TX } from '@aztec/circuits.js';
+import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/abis';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import { Fr } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { AztecNode, KeyStore, L2BlockContext, L2BlockL2Logs, NoteSpendingInfo, PublicKey } from '@aztec/types';
+
+import { Database, NoteSpendingInfoDao } from '../database/index.js';
+import { getAcirSimulator } from '../simulator/index.js';
+
+/**
+ * Contains all the decrypted data in this array so that we can later batch insert it all into the database.
+ */
+interface ProcessedData {
+  /**
+   * Holds L2 block data and associated context.
+   */
+  blockContext: L2BlockContext;
+  /**
+   * A collection of data access objects for note spending info.
+   */
+  noteSpendingInfoDaos: NoteSpendingInfoDao[];
+}
+
+/**
+ * NoteProcessor is responsible for decrypting logs and converting them to notes via their originating contracts
+ * before storing them against their owner.
+ */
+export class NoteProcessor {
+  /**
+   * The latest L2 block number that the note processor has synchronized to.
+   */
+  private syncedToBlock = 0;
+
+  constructor(
+    /**
+     * The public counterpart to the private key to be used in note decryption.
+     */
+    public readonly publicKey: PublicKey,
+    private keyStore: KeyStore,
+    private db: Database,
+    private node: AztecNode,
+    private simulator = getAcirSimulator(db, node, keyStore),
+    private log = createDebugLogger('aztec:aztec_note_processor'),
+  ) {}
+
+  /**
+   * Check if the NoteProcessor is synchronized with the remote block number.
+   * The function queries the remote block number from the AztecNode and compares it with the syncedToBlock value in the NoteProcessor.
+   * If the values are equal, then the NoteProcessor is considered to be synchronized, otherwise not.
+   *
+   * @returns A boolean indicating whether the NoteProcessor is synchronized with the remote block number or not.
+   */
+  public async isSynchronized() {
+    const remoteBlockNumber = await this.node.getBlockNumber();
+    return this.syncedToBlock === remoteBlockNumber;
+  }
+
+  /**
+   * Returns synchronisation status (ie up to which block has been synced ) for this note processor.
+   */
+  public get status() {
+    return { syncedToBlock: this.syncedToBlock };
+  }
+
+  /**
+   * Process the given L2 block contexts and encrypted logs to update the note processor.
+   * It synchronizes the user's account by decrypting the encrypted logs and processing
+   * the transactions and auxiliary data associated with them.
+   * Throws an error if the number of block contexts and encrypted logs do not match.
+   *
+   * @param l2BlockContexts - An array of L2 block contexts to be processed.
+   * @param encryptedL2BlockLogs - An array of encrypted logs associated with the L2 block contexts.
+   * @returns A promise that resolves once the processing is completed.
+   */
+  public async process(l2BlockContexts: L2BlockContext[], encryptedL2BlockLogs: L2BlockL2Logs[]): Promise<void> {
+    if (l2BlockContexts.length !== encryptedL2BlockLogs.length) {
+      throw new Error(
+        `Number of blocks and EncryptedLogs is not equal. Received ${l2BlockContexts.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`,
+      );
+    }
+    if (!l2BlockContexts.length) {
+      return;
+    }
+
+    const blocksAndNoteSpendingInfo: ProcessedData[] = [];
+    const curve = await Grumpkin.new();
+
+    // Iterate over both blocks and encrypted logs.
+    for (let blockIndex = 0; blockIndex < encryptedL2BlockLogs.length; ++blockIndex) {
+      const { txLogs } = encryptedL2BlockLogs[blockIndex];
+      const block = l2BlockContexts[blockIndex].block;
+      const dataStartIndexForBlock = block.startPrivateDataTreeSnapshot.nextAvailableLeafIndex;
+
+      // We are using set for `userPertainingTxIndices` to avoid duplicates. This would happen in case there were
+      // multiple encrypted logs in a tx pertaining to a user.
+      const noteSpendingInfoDaos: NoteSpendingInfoDao[] = [];
+      const privateKey = await this.keyStore.getAccountPrivateKey(this.publicKey);
+
+      // Iterate over all the encrypted logs and try decrypting them. If successful, store the note spending info.
+      for (let indexOfTxInABlock = 0; indexOfTxInABlock < txLogs.length; ++indexOfTxInABlock) {
+        const dataStartIndexForTx = dataStartIndexForBlock + indexOfTxInABlock * MAX_NEW_COMMITMENTS_PER_TX;
+        const newCommitments = block.newCommitments.slice(
+          indexOfTxInABlock * MAX_NEW_COMMITMENTS_PER_TX,
+          (indexOfTxInABlock + 1) * MAX_NEW_COMMITMENTS_PER_TX,
+        );
+        const newNullifiers = block.newNullifiers.slice(
+          indexOfTxInABlock * MAX_NEW_NULLIFIERS_PER_TX,
+          (indexOfTxInABlock + 1) * MAX_NEW_NULLIFIERS_PER_TX,
+        );
+        // Note: Each tx generates a `TxL2Logs` object and for this reason we can rely on its index corresponding
+        //       to the index of a tx in a block.
+        const txFunctionLogs = txLogs[indexOfTxInABlock].functionLogs;
+        const excludedIndices: Set<number> = new Set();
+        for (const functionLogs of txFunctionLogs) {
+          for (const logs of functionLogs.logs) {
+            const noteSpendingInfo = NoteSpendingInfo.fromEncryptedBuffer(logs, privateKey, curve);
+            if (noteSpendingInfo) {
+              // We have successfully decrypted the data.
+              try {
+                const { commitmentIndex, nonce, innerNoteHash, siloedNullifier } = await this.findNoteIndexAndNullifier(
+                  newCommitments,
+                  newNullifiers[0],
+                  noteSpendingInfo,
+                  excludedIndices,
+                );
+                const index = BigInt(dataStartIndexForTx + commitmentIndex);
+                excludedIndices.add(commitmentIndex);
+                noteSpendingInfoDaos.push({
+                  ...noteSpendingInfo,
+                  nonce,
+                  innerNoteHash,
+                  siloedNullifier,
+                  index,
+                  publicKey: this.publicKey,
+                });
+              } catch (e) {
+                this.log.warn(`Could not process note because of "${e}". Skipping note...`);
+              }
+            }
+          }
+        }
+      }
+
+      blocksAndNoteSpendingInfo.push({
+        blockContext: l2BlockContexts[blockIndex],
+        noteSpendingInfoDaos,
+      });
+    }
+
+    await this.processBlocksAndNoteSpendingInfo(blocksAndNoteSpendingInfo);
+
+    this.syncedToBlock = l2BlockContexts[l2BlockContexts.length - 1].block.number;
+    this.log(`Synched block ${this.syncedToBlock}`);
+  }
+
+  /**
+   * Find the index of the note in the private data tree by computing the note hash with different nonce and see which
+   * commitment for the current tx matches this value.
+   * Compute the nullifier for a given transaction auxiliary data.
+   * The nullifier is calculated using the private key of the account,
+   * contract address, and note preimage associated with the noteSpendingInfo.
+   * This method assists in identifying spent commitments in the private state.
+   * @param commitments - Commitments in the tx. One of them should be the note's commitment.
+   * @param firstNullifier - First nullifier in the tx.
+   * @param noteSpendingInfo - An instance of NoteSpendingInfo containing transaction details.
+   * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same
+   * NoteSpendingInfo. We need to find a different index for each replicate.
+   * @returns Information for a decrypted note, including the index of its commitment, nonce, inner note
+   * hash, and the siloed nullifier. Throw if cannot find the nonce for the note.
+   */
+  private async findNoteIndexAndNullifier(
+    commitments: Fr[],
+    firstNullifier: Fr,
+    { contractAddress, storageSlot, notePreimage }: NoteSpendingInfo,
+    excludedIndices: Set<number>,
+  ) {
+    const wasm = await CircuitsWasm.get();
+    let commitmentIndex = 0;
+    let nonce: Fr | undefined;
+    let innerNoteHash: Fr | undefined;
+    let siloedNoteHash: Fr | undefined;
+    let uniqueSiloedNoteHash: Fr | undefined;
+    let innerNullifier: Fr | undefined;
+    for (; commitmentIndex < commitments.length; ++commitmentIndex) {
+      if (excludedIndices.has(commitmentIndex)) continue;
+
+      const commitment = commitments[commitmentIndex];
+      if (commitment.equals(Fr.ZERO)) break;
+
+      const expectedNonce = computeCommitmentNonce(wasm, firstNullifier, commitmentIndex);
+      ({ innerNoteHash, siloedNoteHash, uniqueSiloedNoteHash, innerNullifier } =
+        await this.simulator.computeNoteHashAndNullifier(
+          contractAddress,
+          expectedNonce,
+          storageSlot,
+          notePreimage.items,
+        ));
+      if (commitment.equals(uniqueSiloedNoteHash)) {
+        nonce = expectedNonce;
+        break;
+      }
+    }
+
+    if (!nonce) {
+      let errorString;
+      if (siloedNoteHash == undefined) {
+        errorString = 'Cannot find a matching commitment for the note.';
+      } else {
+        errorString = `We decrypted a log, but couldn't find a corresponding note in the tree.
+This might be because the note was nullified in the same tx which created it.
+In that case, everything is fine. To check whether this is the case, look back through
+the logs for a notification
+'important: chopped commitment for siloed inner hash note
+${siloedNoteHash.toString()}'.
+If you can see that notification. Everything's fine.
+If that's not the case, and you can't find such a notification, something has gone wrong.
+There could be a problem with the way you've defined a custom note, or with the way you're
+serialising / deserialising / hashing / encrypting / decrypting that note.
+Please see the following github issue to track an improvement that we're working on:
+https://github.com/AztecProtocol/aztec-packages/issues/1641`;
+      }
+
+      throw new Error(errorString);
+    }
+
+    return {
+      commitmentIndex,
+      nonce,
+      innerNoteHash: innerNoteHash!,
+      siloedNullifier: siloNullifier(wasm, contractAddress, innerNullifier!),
+    };
+  }
+
+  /**
+   * Process the given blocks and their associated transaction auxiliary data.
+   * This function updates the database with information about new transactions,
+   * user-pertaining transaction indices, and auxiliary data. It also removes nullified
+   * transaction auxiliary data from the database. This function keeps track of new nullifiers
+   * and ensures all other transactions are updated with newly settled block information.
+   *
+   * @param blocksAndNoteSpendingInfo - Array of objects containing L2BlockContexts, user-pertaining transaction indices, and NoteSpendingInfoDaos.
+   */
+  private async processBlocksAndNoteSpendingInfo(blocksAndNoteSpendingInfo: ProcessedData[]) {
+    const noteSpendingInfoDaosBatch = blocksAndNoteSpendingInfo.flatMap(b => b.noteSpendingInfoDaos);
+    if (noteSpendingInfoDaosBatch.length) {
+      await this.db.addNoteSpendingInfoBatch(noteSpendingInfoDaosBatch);
+      noteSpendingInfoDaosBatch.forEach(noteSpendingInfo => {
+        this.log(
+          `Added note spending info for contract ${noteSpendingInfo.contractAddress} at slot ${
+            noteSpendingInfo.storageSlot
+          } with nullifier ${noteSpendingInfo.siloedNullifier.toString()}`,
+        );
+      });
+    }
+
+    const newNullifiers: Fr[] = blocksAndNoteSpendingInfo.flatMap(b => b.blockContext.block.newNullifiers);
+    const removedNoteSpendingInfo = await this.db.removeNullifiedNoteSpendingInfo(newNullifiers, this.publicKey);
+    removedNoteSpendingInfo.forEach(noteSpendingInfo => {
+      this.log(
+        `Removed note spending info for contract ${noteSpendingInfo.contractAddress} at slot ${
+          noteSpendingInfo.storageSlot
+        } with nullifier ${noteSpendingInfo.siloedNullifier.toString()}`,
+      );
+    });
+  }
+}

package/src/pxe_http/index.ts

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

package/src/pxe_http/pxe_http_server.ts

@@ -0,0 +1,70 @@
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { JsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import {
+  AuthWitness,
+  CompleteAddress,
+  ContractData,
+  ExtendedContractData,
+  L2Block,
+  L2BlockL2Logs,
+  L2Tx,
+  NotePreimage,
+  PXE,
+  Tx,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+} from '@aztec/types';
+
+import http from 'http';
+import { foundry } from 'viem/chains';
+
+import { EthAddress } from '../index.js';
+
+export const localAnvil = foundry;
+
+/**
+ * Wraps an instance of Private eXecution Environment (PXE) implementation to a JSON RPC HTTP interface.
+ * @returns A new instance of the HTTP server.
+ */
+export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
+  return new JsonRpcServer(
+    pxeService,
+    {
+      CompleteAddress,
+      AztecAddress,
+      TxExecutionRequest,
+      ContractData,
+      ExtendedContractData,
+      TxHash,
+      EthAddress,
+      Point,
+      Fr,
+      GrumpkinScalar,
+      NotePreimage,
+      AuthWitness,
+      L2Block,
+      L2Tx,
+    },
+    { Tx, TxReceipt, L2BlockL2Logs },
+    false,
+    ['start', 'stop'],
+  );
+}
+
+/**
+ * Creates an http server that forwards calls to the PXE and starts it on the given port.
+ * @param pxeService - PXE that answers queries to the created HTTP server.
+ * @param port - Port to listen in.
+ * @returns A running http server.
+ */
+export function startPXEHttpServer(pxeService: PXE, port: string | number): http.Server {
+  const rpcServer = createPXERpcServer(pxeService);
+
+  const app = rpcServer.getApp();
+  const httpServer = http.createServer(app.callback());
+  httpServer.listen(port);
+
+  return httpServer;
+}

package/src/pxe_service/create_pxe_service.ts

@@ -0,0 +1,52 @@
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import { TestKeyStore } from '@aztec/key-store';
+import { AztecNode, KeyStore } from '@aztec/types';
+
+import { PXEServiceConfig } from '../config/index.js';
+import { Database, MemoryDB } from '../database/index.js';
+import { PXEService } from './pxe_service.js';
+
+/**
+ * Optional information for creating an PXEService.
+ */
+interface CreatePXEServiceOptions {
+  /**
+   * A secure storage for cryptographic keys.
+   */
+  keyStore?: KeyStore;
+  /**
+   * Storage for the PXE.
+   */
+  db?: Database;
+}
+
+/**
+ * Create and start an PXEService instance with the given AztecNode.
+ * If no keyStore or database is provided, it will use TestKeyStore and MemoryDB as default values.
+ * Returns a Promise that resolves to the started PXEService instance.
+ *
+ * @param aztecNode - The AztecNode instance to be used by the server.
+ * @param config - The PXE Service Config to use
+ * @param options - (Optional) Optional information for creating an PXEService.
+ * @returns A Promise that resolves to the started PXEService instance.
+ */
+export async function createPXEService(
+  aztecNode: AztecNode,
+  config: PXEServiceConfig,
+  { keyStore, db }: CreatePXEServiceOptions = {},
+  useLogSuffix: string | boolean | undefined = undefined,
+) {
+  const logSuffix =
+    typeof useLogSuffix === 'boolean'
+      ? useLogSuffix
+        ? Math.random().toString(16).slice(2, 8)
+        : undefined
+      : useLogSuffix;
+
+  keyStore = keyStore || new TestKeyStore(await Grumpkin.new());
+  db = db || new MemoryDB(logSuffix);
+
+  const server = new PXEService(keyStore, aztecNode, db, config, logSuffix);
+  await server.start();
+  return server;
+}

package/src/pxe_service/index.ts

@@ -0,0 +1,3 @@
+export * from './pxe_service.js';
+export * from './create_pxe_service.js';
+export { pxeTestSuite } from './test/pxe_test_suite.js';