@aztec/pxe 0.0.0-test.0

package/src/config/index.ts

@@ -0,0 +1,124 @@
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+  parseBooleanEnv,
+} from '@aztec/foundation/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import type { Network } from '@aztec/stdlib/network';
+
+export { getPackageInfo } from './package_info.js';
+
+/**
+ * Temporary configuration until WASM can be used instead of native
+ */
+export interface BBProverConfig {
+  bbWorkingDirectory?: string;
+  bbBinaryPath?: string;
+  bbSkipCleanup?: boolean;
+}
+
+/**
+ * Configuration settings for the prover factory
+ */
+export interface KernelProverConfig {
+  /** Whether we are running with real proofs */
+  proverEnabled?: boolean;
+}
+/**
+ * Configuration settings for the PXE.
+ */
+export interface PXEConfig {
+  /** L2 block to start scanning from for new accounts */
+  l2StartingBlock: number;
+}
+
+export type PXEServiceConfig = PXEConfig & KernelProverConfig & BBProverConfig & DataStoreConfig & ChainConfig;
+
+export type CliPXEOptions = {
+  /** External Aztec network to connect to. e.g. devnet */
+  network?: Network;
+  /** API Key required by the external network's node */
+  apiKey?: string;
+  /** Custom Aztec Node URL to connect to  */
+  nodeUrl?: string;
+};
+
+export const pxeConfigMappings: ConfigMappingsType<PXEServiceConfig> = {
+  ...dataConfigMappings,
+  ...chainConfigMappings,
+  l2StartingBlock: {
+    env: 'PXE_L2_STARTING_BLOCK',
+    ...numberConfigHelper(INITIAL_L2_BLOCK_NUM),
+    description: 'L2 block to start scanning from for new accounts',
+  },
+  bbBinaryPath: {
+    env: 'BB_BINARY_PATH',
+    description: 'Path to the BB binary',
+  },
+  bbWorkingDirectory: {
+    env: 'BB_WORKING_DIRECTORY',
+    description: 'Working directory for the BB binary',
+  },
+  bbSkipCleanup: {
+    env: 'BB_SKIP_CLEANUP',
+    description: 'True to skip cleanup of temporary files for debugging purposes',
+    ...booleanConfigHelper(),
+  },
+  proverEnabled: {
+    env: 'PXE_PROVER_ENABLED',
+    description: 'Enable real proofs',
+    ...booleanConfigHelper(),
+  },
+};
+
+/**
+ * Creates an instance of PXEServiceConfig out of environment variables using sensible defaults for integration testing if not set.
+ */
+export function getPXEServiceConfig(): PXEServiceConfig {
+  return getConfigFromMappings<PXEServiceConfig>(pxeConfigMappings);
+}
+
+export const pxeCliConfigMappings: ConfigMappingsType<CliPXEOptions> = {
+  network: {
+    env: 'NETWORK',
+    parseEnv: (val: string) => val as Network,
+    description: 'External Aztec network to connect to. e.g. devnet',
+  },
+  apiKey: {
+    env: 'API_KEY',
+    description: "API Key required by the external network's node",
+  },
+  nodeUrl: {
+    env: 'AZTEC_NODE_URL',
+    description: 'Custom Aztec Node URL to connect to',
+  },
+};
+
+export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEServiceConfig> = {
+  ...pxeConfigMappings,
+  ...pxeCliConfigMappings,
+  ...dataConfigMappings,
+  proverEnabled: {
+    env: 'PXE_PROVER_ENABLED',
+    parseEnv: (val: string) => parseBooleanEnv(val) || !!process.env.NETWORK,
+    description: 'Enable real proofs',
+    isBoolean: true,
+  },
+};
+
+/**
+ * Creates an instance of CliPxeOptions out of environment variables
+ */
+export function getCliPXEOptions(): CliPXEOptions & PXEServiceConfig {
+  const pxeConfig = getPXEServiceConfig();
+  const cliOptions = getConfigFromMappings<CliPXEOptions>(pxeCliConfigMappings);
+  return {
+    ...pxeConfig,
+    ...cliOptions,
+    proverEnabled: pxeConfig.proverEnabled || !!cliOptions.network,
+  };
+}

package/src/config/package_info.ts

@@ -0,0 +1,3 @@
+export function getPackageInfo() {
+  return { version: '0.1.0', name: '@aztec/pxe' };
+}

package/src/entrypoints/client/bundle/index.ts

@@ -0,0 +1,5 @@
+export * from '../../../pxe_service/index.js';
+export * from '../../../config/index.js';
+export * from '../../../storage/index.js';
+export * from './utils.js';
+export { PXEOracleInterface } from '../../../pxe_oracle_interface/index.js';

package/src/entrypoints/client/bundle/utils.ts

@@ -0,0 +1,58 @@
+import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/indexeddb';
+import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { WASMSimulator } from '@aztec/simulator/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+import type { PXEServiceConfig } from '../../../config/index.js';
+import { PXEService } from '../../../pxe_service/pxe_service.js';
+import type { PXECreationOptions } from '../pxe_creation_options.js';
+
+/**
+ * Create and start an PXEService instance with the given AztecNode.
+ * If no keyStore or database is provided, it will use KeyStore 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,
+  options: PXECreationOptions = { loggers: {} },
+) {
+  const l1Contracts = await aztecNode.getL1ContractAddresses();
+  const configWithContracts = {
+    ...config,
+    l1Contracts,
+  } as PXEServiceConfig;
+
+  const store = await createStore(
+    'pxe_data',
+    configWithContracts,
+    options.loggers.store ?? createLogger('pxe:data:indexeddb'),
+  );
+
+  const simulationProvider = new WASMSimulator();
+  const prover =
+    options.prover ??
+    new BBWASMBundlePrivateKernelProver(
+      simulationProvider,
+      16,
+      options.loggers.prover ?? createLogger('bb:wasm:bundle'),
+    );
+  const protocolContractsProvider = new BundledProtocolContractsProvider();
+  const pxe = await PXEService.create(
+    aztecNode,
+    store,
+    prover,
+    simulationProvider,
+    protocolContractsProvider,
+    config,
+    options.loggers.pxe ?? createLogger('pxe:service'),
+  );
+  return pxe;
+}

package/src/entrypoints/client/lazy/index.ts

@@ -0,0 +1,5 @@
+export * from '../../../pxe_service/index.js';
+export * from '../../../config/index.js';
+export * from '../../../storage/index.js';
+export * from './utils.js';
+export { PXEOracleInterface } from '../../../pxe_oracle_interface/index.js';

package/src/entrypoints/client/lazy/utils.ts

@@ -0,0 +1,53 @@
+import { BBWASMLazyPrivateKernelProver } from '@aztec/bb-prover/wasm/lazy';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/indexeddb';
+import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/providers/lazy';
+import { WASMSimulator } from '@aztec/simulator/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+import type { PXEServiceConfig } from '../../../config/index.js';
+import { PXEService } from '../../../pxe_service/pxe_service.js';
+import type { PXECreationOptions } from '../pxe_creation_options.js';
+
+/**
+ * Create and start an PXEService instance with the given AztecNode.
+ * 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
+ * @returns A Promise that resolves to the started PXEService instance.
+ */
+export async function createPXEService(
+  aztecNode: AztecNode,
+  config: PXEServiceConfig,
+  options: PXECreationOptions = { loggers: {} },
+) {
+  const l1Contracts = await aztecNode.getL1ContractAddresses();
+  const configWithContracts = {
+    ...config,
+    l1Contracts,
+  } as PXEServiceConfig;
+
+  const store = await createStore(
+    'pxe_data',
+    configWithContracts,
+    options.loggers.store ?? createLogger('pxe:data:indexeddb'),
+  );
+
+  const simulationProvider = new WASMSimulator();
+  const prover =
+    options.prover ??
+    new BBWASMLazyPrivateKernelProver(simulationProvider, 16, options.loggers.prover ?? createLogger('bb:wasm:lazy'));
+  const protocolContractsProvider = new LazyProtocolContractsProvider();
+  const pxe = await PXEService.create(
+    aztecNode,
+    store,
+    prover,
+    simulationProvider,
+    protocolContractsProvider,
+    config,
+    options.loggers.pxe ?? createLogger('pxe:service'),
+  );
+  return pxe;
+}

package/src/entrypoints/client/pxe_creation_options.ts

@@ -0,0 +1,7 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
+
+export type PXECreationOptions = {
+  loggers: { store?: Logger; pxe?: Logger; prover?: Logger };
+  prover?: PrivateKernelProver;
+};

package/src/entrypoints/server/index.ts

@@ -0,0 +1,6 @@
+export * from '../../pxe_service/index.js';
+export * from '../../pxe_http/index.js';
+export * from '../../config/index.js';
+export * from '../../storage/index.js';
+export * from './utils.js';
+export { PXEOracleInterface } from '../../pxe_oracle_interface/index.js';

package/src/entrypoints/server/utils.ts

@@ -0,0 +1,71 @@
+import { BBNativePrivateKernelProver } from '@aztec/bb-prover';
+import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { type SimulationProvider, WASMSimulator } from '@aztec/simulator/client';
+import type { AztecNode, PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
+
+import type { PXEServiceConfig } from '../../config/index.js';
+import { PXEService } from '../../pxe_service/pxe_service.js';
+import { PXE_DATA_SCHEMA_VERSION } from './index.js';
+
+/**
+ * Create and start an PXEService instance with the given AztecNode.
+ * If no keyStore or database is provided, it will use KeyStore 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 useLogSuffix - (Optional) Log suffix for PXE's logger.
+ * @param proofCreator - An optional proof creator to use in place of any other configuration
+ * @returns A Promise that resolves to the started PXEService instance.
+ */
+export async function createPXEService(
+  aztecNode: AztecNode,
+  config: PXEServiceConfig,
+  useLogSuffix: string | boolean | undefined = undefined,
+  proofCreator?: PrivateKernelProver,
+) {
+  const logSuffix =
+    typeof useLogSuffix === 'boolean' ? (useLogSuffix ? randomBytes(3).toString('hex') : undefined) : useLogSuffix;
+
+  const l1Contracts = await aztecNode.getL1ContractAddresses();
+  const configWithContracts = {
+    ...config,
+    l1Contracts,
+  } as PXEServiceConfig;
+
+  const store = await createStore(
+    'pxe_data',
+    PXE_DATA_SCHEMA_VERSION,
+    configWithContracts,
+    createLogger('pxe:data:lmdb'),
+  );
+
+  const simulationProvider = new WASMSimulator();
+  const prover = proofCreator ?? (await createProver(config, simulationProvider, logSuffix));
+  const protocolContractsProvider = new BundledProtocolContractsProvider();
+  const pxe = await PXEService.create(
+    aztecNode,
+    store,
+    prover,
+    simulationProvider,
+    protocolContractsProvider,
+    config,
+    logSuffix,
+  );
+  return pxe;
+}
+
+function createProver(config: PXEServiceConfig, simulationProvider: SimulationProvider, logSuffix?: string) {
+  if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
+    return new BBWASMBundlePrivateKernelProver(simulationProvider, 16);
+  } else {
+    const bbConfig = config as Required<Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> &
+      PXEServiceConfig;
+    const log = createLogger('pxe:bb-native-prover' + (logSuffix ? `:${logSuffix}` : ''));
+    return BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, simulationProvider, log);
+  }
+}

package/src/kernel_oracle/index.ts

@@ -0,0 +1,117 @@
+import { type NOTE_HASH_TREE_HEIGHT, PUBLIC_DATA_TREE_HEIGHT, VK_TREE_HEIGHT } from '@aztec/constants';
+import type { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import type { KeyStore } from '@aztec/key-store';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { L2BlockNumber } from '@aztec/stdlib/block';
+import { computeContractClassIdPreimage, computeSaltedInitializationHash } from '@aztec/stdlib/contract';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
+import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
+import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
+import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
+
+import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
+import type { ProvingDataOracle } from './../kernel_prover/proving_data_oracle.js';
+
+// TODO: Block number should not be "latest".
+// It should be fixed at the time the proof is being simulated. I.e., it should be the same as the value defined in the constant data.
+/**
+ * A data oracle that provides information needed for simulating a transaction.
+ */
+export class KernelOracle implements ProvingDataOracle {
+  constructor(
+    private contractDataProvider: ContractDataProvider,
+    private keyStore: KeyStore,
+    private node: AztecNode,
+    private blockNumber: L2BlockNumber = 'latest',
+    private log = createLogger('pxe:kernel_oracle'),
+  ) {}
+
+  public async getContractAddressPreimage(address: AztecAddress) {
+    const instance = await this.contractDataProvider.getContractInstance(address);
+    return {
+      saltedInitializationHash: await computeSaltedInitializationHash(instance),
+      ...instance,
+    };
+  }
+
+  public async getContractClassIdPreimage(contractClassId: Fr) {
+    const contractClass = await this.contractDataProvider.getContractClass(contractClassId);
+    return computeContractClassIdPreimage(contractClass);
+  }
+
+  public async getFunctionMembershipWitness(contractClassId: Fr, selector: FunctionSelector) {
+    return await this.contractDataProvider.getFunctionMembershipWitness(contractClassId, selector);
+  }
+
+  public getVkMembershipWitness(vk: VerificationKeyAsFields) {
+    const leafIndex = getVKIndex(vk);
+    return Promise.resolve(new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
+  }
+
+  async getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>> {
+    const path = await this.node.getNoteHashSiblingPath(this.blockNumber, leafIndex);
+    return new MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>(
+      path.pathSize,
+      leafIndex,
+      path.toFields() as Tuple<Fr, typeof NOTE_HASH_TREE_HEIGHT>,
+    );
+  }
+
+  getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined> {
+    return this.node.getNullifierMembershipWitness(this.blockNumber, nullifier);
+  }
+
+  async getNoteHashTreeRoot(): Promise<Fr> {
+    const header = await this.node.getBlockHeader(this.blockNumber);
+    if (!header) {
+      throw new Error(`No block header found for block number ${this.blockNumber}`);
+    }
+    return header.state.partial.noteHashTree.root;
+  }
+
+  public getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinScalar> {
+    return this.keyStore.getMasterSecretKey(masterPublicKey);
+  }
+
+  public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string> {
+    return this.contractDataProvider.getDebugFunctionName(contractAddress, selector);
+  }
+
+  public async getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints> {
+    const { sharedMutableSlot, sharedMutableHashSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(
+      contractAddress,
+    );
+
+    const hashLeafSlot = await computePublicDataTreeLeafSlot(
+      ProtocolContractAddress.ContractInstanceDeployer,
+      sharedMutableHashSlot,
+    );
+    const updatedClassIdWitness = await this.node.getPublicDataTreeWitness(this.blockNumber, hashLeafSlot);
+
+    if (!updatedClassIdWitness) {
+      throw new Error(`No public data tree witness found for ${hashLeafSlot}`);
+    }
+
+    const readStorage = (storageSlot: Fr) =>
+      this.node.getPublicStorageAt(this.blockNumber, ProtocolContractAddress.ContractInstanceDeployer, storageSlot);
+    const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, readStorage);
+
+    return new UpdatedClassIdHints(
+      new MembershipWitness(
+        PUBLIC_DATA_TREE_HEIGHT,
+        updatedClassIdWitness.index,
+        updatedClassIdWitness.siblingPath.toTuple(),
+      ),
+      updatedClassIdWitness.leafPreimage,
+      sharedMutableValues,
+    );
+  }
+}