@aztec/pxe 0.8.6

package/src/bin/index.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env -S node --no-warnings
+import { createDebugLogger } from '@aztec/foundation/log';
+import { createAztecNodeRpcClient } from '@aztec/types';
+
+import { getPXEServiceConfig } from '../config/index.js';
+import { startPXEHttpServer } from '../pxe_http/index.js';
+import { createPXEService } from '../pxe_service/index.js';
+
+const { PXE_PORT = 8080, AZTEC_NODE_URL = 'http://localhost:8079' } = process.env;
+
+const logger = createDebugLogger('aztec:pxe_service');
+
+/**
+ * Create and start a new PXE HTTP Server
+ */
+async function main() {
+  logger.info(`Setting up PXE...`);
+
+  const pxeConfig = getPXEServiceConfig();
+  const nodeRpcClient = createAztecNodeRpcClient(AZTEC_NODE_URL);
+  const pxeService = await createPXEService(nodeRpcClient, pxeConfig);
+
+  const shutdown = async () => {
+    logger.info('Shutting down...');
+    await pxeService.stop();
+    process.exit(0);
+  };
+
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+
+  startPXEHttpServer(pxeService, PXE_PORT);
+  logger.info(`PXE listening on port ${PXE_PORT}`);
+}
+
+main().catch(err => {
+  logger.error(err);
+  process.exit(1);
+});

package/src/config/index.ts

@@ -0,0 +1,34 @@
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * Configuration settings for the PXE Service.
+ */
+export interface PXEServiceConfig {
+  /**
+   * The interval to wait between polling for new blocks.
+   */
+  l2BlockPollingIntervalMS: number;
+}
+
+/**
+ * Creates an instance of PXEServiceConfig out of environment variables using sensible defaults for integration testing if not set.
+ */
+export function getPXEServiceConfig(): PXEServiceConfig {
+  const { PXE_BLOCK_POLLING_INTERVAL_MS } = process.env;
+
+  return {
+    l2BlockPollingIntervalMS: PXE_BLOCK_POLLING_INTERVAL_MS ? +PXE_BLOCK_POLLING_INTERVAL_MS : 1000,
+  };
+}
+
+/**
+ * Returns package name and version.
+ */
+export function getPackageInfo() {
+  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+  const { version, name } = JSON.parse(readFileSync(packageJsonPath).toString());
+
+  return { version, name };
+}

package/src/contract_data_oracle/index.ts

@@ -0,0 +1,151 @@
+import { AztecAddress, CircuitsWasm, MembershipWitness, VK_TREE_HEIGHT } from '@aztec/circuits.js';
+import { FunctionDebugMetadata, FunctionSelector, getFunctionDebugMetadata } from '@aztec/foundation/abi';
+import { ContractDatabase, StateInfoProvider } from '@aztec/types';
+
+import { ContractTree } from '../contract_tree/index.js';
+
+/**
+ * ContractDataOracle serves as a data manager and retriever for Aztec.nr contracts.
+ * It provides methods to obtain contract addresses, function ABI, bytecode, and membership witnesses
+ * from a given contract address and function selector. The class maintains a cache of ContractTree instances
+ * to efficiently serve the requested data. It interacts with the ContractDatabase and AztecNode to fetch
+ * the required information and facilitate cryptographic proof generation.
+ */
+export class ContractDataOracle {
+  private trees: ContractTree[] = [];
+
+  constructor(private db: ContractDatabase, private stateProvider: StateInfoProvider) {}
+
+  /**
+   * Retrieve the portal contract address associated with the given contract address.
+   * This function searches for the corresponding contract tree in the local cache and returns the portal contract address.
+   * If the contract tree is not found in the cache, it fetches the contract data from the database and creates a new ContractTree instance.
+   * Throws an error if the contract address is not found in the database.
+   *
+   * @param contractAddress - The AztecAddress of the contract whose portal contract address needs to be retrieved.
+   * @returns A Promise that resolves to the portal contract address.
+   */
+  public async getPortalContractAddress(contractAddress: AztecAddress) {
+    const tree = await this.getTree(contractAddress);
+    return tree.contract.portalContract;
+  }
+
+  /**
+   * Retrieves the ABI of a specified function within a given contract.
+   * The function is identified by its selector, which is a unique code generated from the function's signature.
+   * Throws an error if the contract address or function selector are invalid or not found.
+   *
+   * @param contractAddress - The AztecAddress representing the contract containing the function.
+   * @param selector - The function selector.
+   * @returns The corresponding function's ABI as an object.
+   */
+  public async getFunctionAbi(contractAddress: AztecAddress, selector: FunctionSelector) {
+    const tree = await this.getTree(contractAddress);
+    return tree.getFunctionAbi(selector);
+  }
+
+  /**
+   * Retrieves the debug metadata of a specified function within a given contract.
+   * The function is identified by its selector, which is a unique code generated from the function's signature.
+   * Returns undefined if the debug metadata for the given function is not found.
+   *
+   * @param contractAddress - The AztecAddress representing the contract containing the function.
+   * @param selector - The function selector.
+   * @returns The corresponding function's ABI as an object.
+   */
+  public async getFunctionDebugMetadata(
+    contractAddress: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionDebugMetadata | undefined> {
+    const contract = await this.db.getContract(contractAddress);
+    const functionAbi = contract?.functions.find(f => f.selector.equals(selector));
+
+    if (!contract || !functionAbi) {
+      return undefined;
+    }
+
+    return getFunctionDebugMetadata(contract, functionAbi.name);
+  }
+
+  /**
+   * Retrieve the bytecode of a specific function in a contract at the given address.
+   * The returned bytecode is required for executing and verifying the function's behavior
+   * in the Aztec network. Throws an error if the contract or function cannot be found.
+   *
+   * @param contractAddress - The contract's address.
+   * @param selector - The function selector.
+   * @returns A Promise that resolves to a Buffer containing the bytecode of the specified function.
+   */
+  public async getBytecode(contractAddress: AztecAddress, selector: FunctionSelector) {
+    const tree = await this.getTree(contractAddress);
+    return tree.getBytecode(selector);
+  }
+
+  /**
+   * 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.
+   */
+  public async getContractMembershipWitness(contractAddress: AztecAddress) {
+    const tree = await this.getTree(contractAddress);
+    return tree.getContractMembershipWitness();
+  }
+
+  /**
+   * 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.
+   */
+  public async getFunctionMembershipWitness(contractAddress: AztecAddress, selector: FunctionSelector) {
+    const tree = await this.getTree(contractAddress);
+    return tree.getFunctionMembershipWitness(selector);
+  }
+
+  /**
+   * 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.
+   */
+  public async getVkMembershipWitness() {
+    // TODO
+    return await Promise.resolve(MembershipWitness.random(VK_TREE_HEIGHT));
+  }
+
+  /**
+   * Retrieve or create a ContractTree instance based on the provided AztecAddress.
+   * If an existing tree with the same contract address is found in the cache, it will be returned.
+   * Otherwise, a new ContractTree instance will be created using the contract data from the database
+   * and added to the cache before returning.
+   *
+   * @param contractAddress - The AztecAddress of the contract for which the ContractTree is required.
+   * @returns A ContractTree instance associated with the specified contract address.
+   * @throws An Error if the contract is not found in the ContractDatabase.
+   */
+  private async getTree(contractAddress: AztecAddress) {
+    let tree = this.trees.find(t => t.contract.completeAddress.address.equals(contractAddress));
+    if (!tree) {
+      const contract = await this.db.getContract(contractAddress);
+      if (!contract) {
+        throw new Error(`Unknown contract: ${contractAddress}`);
+      }
+
+      const wasm = await CircuitsWasm.get();
+      tree = new ContractTree(contract, this.stateProvider, wasm);
+      this.trees.push(tree);
+    }
+    return tree;
+  }
+}

package/src/contract_database/index.ts

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

package/src/contract_database/memory_contract_database.ts

@@ -0,0 +1,58 @@
+import { FunctionSelector } from '@aztec/circuits.js';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { DebugLogger } from '@aztec/foundation/log';
+import { ContractDao, ContractDatabase } from '@aztec/types';
+
+/**
+ * The MemoryContractDatabase class serves as an in-memory implementation of the ContractDatabase interface.
+ * It allows for storing and retrieving contract data, such as ContractDao objects and associated function bytecodes,
+ * within a contracts array. This class is particularly useful for testing and development purposes where a
+ * persistent storage may not be required.
+ */
+export class MemoryContractDatabase implements ContractDatabase {
+  private contracts: ContractDao[] = [];
+
+  constructor(protected log: DebugLogger) {}
+
+  /**
+   * Adds a new ContractDao instance to the memory-based contract database.
+   * The function stores the contract in an array and returns a resolved promise indicating successful addition.
+   *
+   * @param contract - The ContractDao instance to be added to the memory database.
+   * @returns A Promise that resolves when the contract is successfully added.
+   */
+  public addContract(contract: ContractDao) {
+    this.log(`Adding contract ${contract.completeAddress.address.toString()}`);
+    this.contracts.push(contract);
+    return Promise.resolve();
+  }
+
+  /**
+   * Retrieve a ContractDao instance with the specified AztecAddress from the in-memory contracts list.
+   * Returns the first match found or undefined if no contract with the given address is found.
+   *
+   * @param address - The AztecAddress to search for in the stored contracts.
+   * @returns A Promise resolving to the ContractDao instance matching the given address or undefined.
+   */
+  public getContract(address: AztecAddress): Promise<ContractDao | undefined> {
+    return Promise.resolve(this.contracts.find(c => c.completeAddress.address.equals(address)));
+  }
+
+  public getContracts(): Promise<ContractDao[]> {
+    return Promise.resolve(this.contracts);
+  }
+
+  /**
+   * Retrieve the bytecode associated with a given contract address and function selector.
+   * This function searches through the stored contracts to find a matching contract and function,
+   * then returns the corresponding bytecode. If no match is found, it returns undefined.
+   *
+   * @param contractAddress - The AztecAddress representing the contract address to look for.
+   * @param selector - The function selector.
+   * @returns A Promise that resolves to the bytecode of the matching function or undefined if not found.
+   */
+  public async getCode(contractAddress: AztecAddress, selector: FunctionSelector) {
+    const contract = await this.getContract(contractAddress);
+    return contract?.functions.find(f => f.selector.equals(selector))?.bytecode;
+  }
+}

package/src/contract_tree/index.ts

@@ -0,0 +1,245 @@
+import {
+  CONTRACT_TREE_HEIGHT,
+  CircuitsWasm,
+  EthAddress,
+  FUNCTION_TREE_HEIGHT,
+  Fr,
+  FunctionData,
+  MembershipWitness,
+  NewContractConstructor,
+  NewContractData,
+  computeFunctionTree,
+  computeFunctionTreeData,
+  generateFunctionLeaves,
+  hashVKStr,
+  isConstrained,
+  isConstructor,
+} from '@aztec/circuits.js';
+import {
+  computeCompleteAddress,
+  computeContractLeaf,
+  computeFunctionTreeRoot,
+  computeVarArgsHash,
+  hashConstructor,
+} from '@aztec/circuits.js/abis';
+import { ContractAbi, FunctionSelector } from '@aztec/foundation/abi';
+import { assertLength } from '@aztec/foundation/serialize';
+import { AztecNode, ContractDao, MerkleTreeId, PublicKey, StateInfoProvider } from '@aztec/types';
+
+/**
+ * The ContractTree class represents a Merkle tree of functions for a particular contract.
+ * It manages the construction of the function tree, computes its root, and generates membership witnesses
+ * for constrained functions. This class also enables lookup of specific function ABI and bytecode using selectors.
+ * It is used in combination with the AztecNode to compute various data for executing private transactions.
+ */
+export class ContractTree {
+  private functionLeaves?: Fr[];
+  private functionTree?: Fr[];
+  private functionTreeRoot?: Fr;
+  private contractIndex?: bigint;
+
+  constructor(
+    /**
+     * The contract data object containing the ABI and contract address.
+     */
+    public readonly contract: ContractDao,
+    private stateInfoProvider: StateInfoProvider,
+    private wasm: CircuitsWasm,
+    /**
+     * Data associated with the contract constructor for a new contract.
+     */
+    public readonly newContractConstructor?: NewContractConstructor,
+  ) {}
+
+  /**
+   * Create a new ContractTree instance from the provided contract ABI, constructor arguments, and related data.
+   * The function generates function leaves for constrained functions, computes the function tree root,
+   * and hashes the constructor's verification key. It then computes the contract address using the contract
+   * and portal contract addresses, contract address salt, and generated data. Finally, it returns a new
+   * ContractTree instance containing the contract data and computed values.
+   *
+   * @param abi - The contract's ABI containing the functions and their metadata.
+   * @param args - An array of Fr elements representing the constructor's arguments.
+   * @param portalContract - The Ethereum address of the portal smart contract.
+   * @param contractAddressSalt - An Fr element representing the salt used to compute the contract address.
+   * @param from - The public key of the contract deployer.
+   * @param node - An instance of the AztecNode class representing the current node.
+   * @returns A new ContractTree instance containing the contract data and computed values.
+   */
+  public static async new(
+    abi: ContractAbi,
+    args: Fr[],
+    portalContract: EthAddress,
+    contractAddressSalt: Fr,
+    from: PublicKey,
+    node: AztecNode,
+  ) {
+    const wasm = await CircuitsWasm.get();
+    const constructorAbi = abi.functions.find(isConstructor);
+    if (!constructorAbi) {
+      throw new Error('Constructor not found.');
+    }
+    if (!constructorAbi.verificationKey) {
+      throw new Error('Missing verification key for the constructor.');
+    }
+
+    const functions = abi.functions.map(f => ({
+      ...f,
+      selector: FunctionSelector.fromNameAndParameters(f.name, f.parameters),
+    }));
+    const leaves = generateFunctionLeaves(functions, wasm);
+    const root = computeFunctionTreeRoot(wasm, leaves);
+    const functionData = FunctionData.fromAbi(constructorAbi);
+    const vkHash = hashVKStr(constructorAbi.verificationKey, wasm);
+    const argsHash = await computeVarArgsHash(wasm, args);
+    const constructorHash = hashConstructor(wasm, functionData, argsHash, vkHash);
+
+    const completeAddress = computeCompleteAddress(wasm, from, contractAddressSalt, root, constructorHash);
+
+    const contractDao: ContractDao = {
+      ...abi,
+      completeAddress,
+      functions,
+      portalContract,
+    };
+    const NewContractConstructor = {
+      functionData,
+      vkHash,
+    };
+    return new ContractTree(contractDao, node, wasm, NewContractConstructor);
+  }
+
+  /**
+   * Retrieve the ABI of a given function.
+   * The function is identified by its selector, which represents a unique identifier for the function's signature.
+   * Throws an error if the function with the provided selector is not found in the contract.
+   *
+   * @param selector - The function selector.
+   * @returns The ABI object containing relevant information about the targeted function.
+   */
+  public getFunctionAbi(selector: FunctionSelector) {
+    const abi = this.contract.functions.find(f => f.selector.equals(selector));
+    if (!abi) {
+      throw new Error(
+        `Unknown function. Selector ${selector.toString()} not found in the ABI of contract ${this.contract.completeAddress.address.toString()}. Expected one of: ${this.contract.functions
+          .map(f => f.selector.toString())
+          .join(', ')}`,
+      );
+    }
+    return abi;
+  }
+
+  /**
+   * Retrieve the bytecode of a function in the contract by its function selector.
+   * The function selector is a unique identifier for each function in a contract.
+   * Throws an error if the function with the given selector is not found in the contract.
+   *
+   * @param selector - The selector of a function to get bytecode for.
+   * @returns The bytecode of the function as a string.
+   */
+  public getBytecode(selector: FunctionSelector) {
+    return this.getFunctionAbi(selector).bytecode;
+  }
+
+  /**
+   * Retrieves the contract membership witness for the current contract tree instance.
+   * The contract membership witness is a proof that demonstrates the existence of the contract
+   * in the global contract merkle tree. This proof contains the index of the contract's leaf
+   * in the tree and the sibling path needed to construct the root of the merkle tree.
+   * If the witness hasn't been previously computed, this function will request the contract node
+   * to find the contract's index and path in order to create the membership witness.
+   *
+   * @returns A Promise that resolves to the MembershipWitness object for the given contract tree.
+   */
+  public async getContractMembershipWitness() {
+    const index = await this.getContractIndex();
+
+    const siblingPath = await this.stateInfoProvider.getContractPath(index);
+    return new MembershipWitness<typeof CONTRACT_TREE_HEIGHT>(
+      CONTRACT_TREE_HEIGHT,
+      index,
+      assertLength(siblingPath.toFieldArray(), CONTRACT_TREE_HEIGHT),
+    );
+  }
+
+  /**
+   * Calculate and return the root of the function tree for the current contract.
+   * This root is a cryptographic commitment to the set of constrained functions within the contract,
+   * which is used in the Aztec node's proof system. The root will be cached after the first call.
+   *
+   * @returns A promise that resolves to the Fr (finite field element) representation of the function tree root.
+   */
+  public getFunctionTreeRoot() {
+    if (!this.functionTreeRoot) {
+      const leaves = this.getFunctionLeaves();
+      this.functionTreeRoot = computeFunctionTreeRoot(this.wasm, leaves);
+    }
+    return Promise.resolve(this.functionTreeRoot);
+  }
+
+  /**
+   * Retrieve the membership witness of a function within a contract's function tree.
+   * A membership witness represents the position and authentication path of a target function
+   * in the Merkle tree of constrained functions. It is required to prove the existence of the
+   * function within the contract during execution.
+   *
+   * @param selector - The function selector.
+   * @returns A MembershipWitness instance representing the position and authentication path of the function in the function tree.
+   */
+  public getFunctionMembershipWitness(
+    selector: FunctionSelector,
+  ): Promise<MembershipWitness<typeof FUNCTION_TREE_HEIGHT>> {
+    const targetFunctions = this.contract.functions.filter(isConstrained);
+    const functionIndex = targetFunctions.findIndex(f => f.selector.equals(selector));
+    if (functionIndex < 0) {
+      return Promise.resolve(MembershipWitness.empty(FUNCTION_TREE_HEIGHT, 0n));
+    }
+
+    if (!this.functionTree) {
+      const leaves = this.getFunctionLeaves();
+      this.functionTree = computeFunctionTree(this.wasm, leaves);
+    }
+    const functionTreeData = computeFunctionTreeData(this.functionTree, functionIndex);
+    return Promise.resolve(
+      new MembershipWitness<typeof FUNCTION_TREE_HEIGHT>(
+        FUNCTION_TREE_HEIGHT,
+        BigInt(functionIndex),
+        assertLength(functionTreeData.siblingPath, FUNCTION_TREE_HEIGHT),
+      ),
+    );
+  }
+
+  /**
+   * Retrieve the function leaves for the contract tree.
+   * Function leaves are computed based on constrained functions present in the contract.
+   * It caches the computed function leaves and returns them if already calculated.
+   *
+   * @returns An array of Fr representing the function leaves.
+   */
+  private getFunctionLeaves() {
+    if (!this.functionLeaves) {
+      this.functionLeaves = generateFunctionLeaves(this.contract.functions, this.wasm);
+    }
+    return this.functionLeaves;
+  }
+
+  private async getContractIndex() {
+    if (this.contractIndex === undefined) {
+      const { completeAddress, portalContract } = this.contract;
+      const root = await this.getFunctionTreeRoot();
+      const newContractData = new NewContractData(completeAddress.address, portalContract, root);
+      const commitment = computeContractLeaf(this.wasm, newContractData);
+      this.contractIndex = await this.stateInfoProvider.findLeafIndex(
+        MerkleTreeId.CONTRACT_TREE,
+        commitment.toBuffer(),
+      );
+      if (this.contractIndex === undefined) {
+        throw new Error(
+          `Failed to find contract at ${completeAddress.address} with portal ${portalContract} resulting in commitment ${commitment}.`,
+        );
+      }
+      return this.contractIndex;
+    }
+    return this.contractIndex;
+  }
+}

package/src/database/database.ts

@@ -0,0 +1,131 @@
+import { CompleteAddress, HistoricBlockData } from '@aztec/circuits.js';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+import { ContractDatabase, MerkleTreeId, PublicKey } from '@aztec/types';
+
+import { NoteSpendingInfoDao } from './note_spending_info_dao.js';
+
+/**
+ * A database interface that provides methods for retrieving, adding, and removing transactional data related to Aztec
+ * addresses, storage slots, and nullifiers.
+ */
+export interface Database extends ContractDatabase {
+  /**
+   * Add a auth witness to the database.
+   * @param messageHash - The message hash.
+   * @param witness - An array of field elements representing the auth witness.
+   */
+  addAuthWitness(messageHash: Fr, witness: Fr[]): Promise<void>;
+
+  /**
+   * Fetching the auth witness for a given message hash.
+   * @param messageHash - The message hash.
+   * @returns A Promise that resolves to an array of field elements representing the auth witness.
+   */
+  getAuthWitness(messageHash: Fr): Promise<Fr[]>;
+
+  /**
+   * Get auxiliary transaction data based on contract address and storage slot.
+   * It searches for matching NoteSpendingInfoDao objects in the MemoryDB's noteSpendingInfoTable
+   * where both the contractAddress and storageSlot properties match the given inputs.
+   *
+   * @param contract - The contract address.
+   * @param storageSlot - A Fr object representing the storage slot to search for in the auxiliary data.
+   * @returns An array of NoteSpendingInfoDao objects that fulfill the contract address and storage slot criteria.
+   */
+  getNoteSpendingInfo(contract: AztecAddress, storageSlot: Fr): Promise<NoteSpendingInfoDao[]>;
+
+  /**
+   * Add a NoteSpendingInfoDao instance to the noteSpendingInfoTable.
+   * This function is used to store auxiliary data related to a transaction,
+   * such as contract address and storage slot, in the database.
+   *
+   * @param noteSpendingInfoDao - The NoteSpendingInfoDao instance containing the auxiliary data of a transaction.
+   * @returns A promise that resolves when the auxiliary data is added to the database.
+   */
+  addNoteSpendingInfo(noteSpendingInfoDao: NoteSpendingInfoDao): Promise<void>;
+
+  /**
+   * Adds an array of NoteSpendingInfoDaos to the noteSpendingInfoTable.
+   * This function is used to insert multiple transaction auxiliary data objects into the database at once,
+   * which can improve performance when dealing with large numbers of transactions.
+   *
+   * @param noteSpendingInfoDaos - An array of NoteSpendingInfoDao instances representing the auxiliary data of transactions.
+   * @returns A Promise that resolves when all NoteSpendingInfoDaos have been successfully added to the noteSpendingInfoTable.
+   */
+  addNoteSpendingInfoBatch(noteSpendingInfoDaos: NoteSpendingInfoDao[]): Promise<void>;
+
+  /**
+   * Remove nullified transaction auxiliary data records associated with the given account and nullifiers.
+   * The function filters the records based on matching account and nullifier values, and updates the
+   * noteSpendingInfoTable with the remaining records. It returns an array of removed NoteSpendingInfoDao instances.
+   *
+   * @param nullifiers - An array of Fr instances representing nullifiers to be matched.
+   * @param account - A PublicKey instance representing the account for which the records are being removed.
+   * @returns A Promise resolved with an array of removed NoteSpendingInfoDao instances.
+   */
+  removeNullifiedNoteSpendingInfo(nullifiers: Fr[], account: PublicKey): Promise<NoteSpendingInfoDao[]>;
+
+  /**
+   * Retrieve the stored Merkle tree roots from the database.
+   * The function returns a Promise that resolves to an object containing the MerkleTreeId as keys
+   * and their corresponding Fr values as roots. Throws an error if the tree roots are not set in the
+   * memory database.
+   *
+   * @returns An object containing the Merkle tree roots for each merkle tree id.
+   */
+  getTreeRoots(): Record<MerkleTreeId, Fr>;
+
+  /**
+   * Set the tree roots for the Merkle trees in the database.
+   * This function updates the 'treeRoots' property of the instance
+   * with the provided 'roots' object containing MerkleTreeId and Fr pairs.
+   * Note that this will overwrite any existing tree roots in the database.
+   *
+   * @param roots - A Record object mapping MerkleTreeIds to their corresponding Fr root values.
+   * @returns A Promise that resolves when the tree roots have been successfully updated in the database.
+   */
+  setTreeRoots(roots: Record<MerkleTreeId, Fr>): Promise<void>;
+
+  /**
+   * Retrieve the stored Historic Block Data from the database.
+   * The function returns a Promise that resolves to the Historic Block Data.
+   * This data is required to reproduce block attestations.
+   * Throws an error if the historic block data is not available within the database.
+   *
+   * note: this data is a combination of the tree roots and the global variables hash.
+   */
+  getHistoricBlockData(): HistoricBlockData;
+
+  /**
+   * Set the latest Historic Block Data.
+   * This function updates the 'global variables hash' and `tree roots` property of the instance
+   * Note that this will overwrite any existing hash or roots in the database.
+   *
+   * @param historicBlockData - An object containing the most recent historic block data.
+   * @returns A Promise that resolves when the hash has been successfully updated in the database.
+   */
+  setHistoricBlockData(historicBlockData: HistoricBlockData): Promise<void>;
+
+  /**
+   * Adds complete address to the database.
+   * @param address - The complete address to add.
+   * @returns A promise resolving to true if the address was added, false if it already exists.
+   * @throws If we try to add a CompleteAddress with the same AztecAddress but different public key or partial
+   * address.
+   */
+  addCompleteAddress(address: CompleteAddress): Promise<boolean>;
+
+  /**
+   * Retrieves the complete address corresponding to the provided aztec address.
+   * @param address - The aztec address of the complete address contract.
+   * @returns A promise that resolves to a CompleteAddress instance if the address is found, or undefined if not found.
+   */
+  getCompleteAddress(address: AztecAddress): Promise<CompleteAddress | undefined>;
+
+  /**
+   * Retrieves the list of complete address added to this database
+   * @returns A promise that resolves to an array of AztecAddress instances.
+   */
+  getCompleteAddresses(): Promise<CompleteAddress[]>;
+}

package/src/database/index.ts

@@ -0,0 +1,3 @@
+export * from './database.js';
+export * from './memory_db.js';
+export * from './note_spending_info_dao.js';