@aztec/pxe 3.0.0-canary.a9708bd → 3.0.0-devnet.2

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

@@ -6,23 +6,23 @@ import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/prov
 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 { PXEConfig } from '../../../config/index.js';
+import { PXE } from '../../../pxe.js';
 import type { PXECreationOptions } from '../../pxe_creation_options.js';
 
 /**
- * Create and start an PXEService instance with the given AztecNode.
+ * Create and start an PXE 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.
+ * Returns a Promise that resolves to the started PXE 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.
+ * @param config - The PXE Config to use
+ * @param options - (Optional) Optional information for creating an PXE.
+ * @returns A Promise that resolves to the started PXE instance.
  */
-export async function createPXEService(
+export async function createPXE(
   aztecNode: AztecNode,
-  config: PXEServiceConfig,
+  config: PXEConfig,
   options: PXECreationOptions = { loggers: {} },
 ) {
   const logSuffix =
@@ -38,7 +38,7 @@ export async function createPXEService(
   const configWithContracts = {
     ...config,
     l1Contracts,
-  } as PXEServiceConfig;
+  } as PXEConfig;
 
   const storeLogger = loggers.store ? loggers.store : createLogger('pxe:data:idb' + (logSuffix ? `:${logSuffix}` : ''));
 
@@ -53,14 +53,6 @@ export async function createPXEService(
   const protocolContractsProvider = new BundledProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
-  const pxe = await PXEService.create(
-    aztecNode,
-    store,
-    prover,
-    simulator,
-    protocolContractsProvider,
-    config,
-    pxeLogger,
-  );
+  const pxe = await PXE.create(aztecNode, store, prover, simulator, protocolContractsProvider, config, pxeLogger);
   return pxe;
 }

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

@@ -1,5 +1,7 @@
-export * from '../../../pxe_service/index.js';
+export * from '../../../pxe.js';
 export * from '../../../config/index.js';
 export * from '../../../storage/index.js';
+export * from '../../../error_enriching.js';
 export * from './utils.js';
 export { PXEOracleInterface } from '../../../contract_function_simulator/pxe_oracle_interface.js';
+export { type PXECreationOptions } from '../../pxe_creation_options.js';

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

@@ -6,22 +6,22 @@ import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/provide
 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 { PXEConfig } from '../../../config/index.js';
+import { PXE } from '../../../pxe.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.
+ * Create and start an PXE instance with the given AztecNode.
+ * Returns a Promise that resolves to the started PXE instance.
  *
  * @param aztecNode - The AztecNode instance to be used by the server.
- * @param config - The PXE Service Config to use
+ * @param config - The PXE Config to use
  * @param
- * @returns A Promise that resolves to the started PXEService instance.
+ * @returns A Promise that resolves to the started PXE instance.
  */
-export async function createPXEService(
+export async function createPXE(
   aztecNode: AztecNode,
-  config: PXEServiceConfig,
+  config: PXEConfig,
   options: PXECreationOptions = { loggers: {} },
 ) {
   const logSuffix =
@@ -35,7 +35,7 @@ export async function createPXEService(
   const configWithContracts = {
     ...config,
     l1Contracts,
-  } as PXEServiceConfig;
+  } as PXEConfig;
 
   const loggers = options.loggers ?? {};
 
@@ -53,14 +53,6 @@ export async function createPXEService(
   const protocolContractsProvider = new LazyProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
-  const pxe = await PXEService.create(
-    aztecNode,
-    store,
-    prover,
-    simulator,
-    protocolContractsProvider,
-    config,
-    pxeLogger,
-  );
+  const pxe = await PXE.create(aztecNode, store, prover, simulator, protocolContractsProvider, config, pxeLogger);
   return pxe;
 }

package/src/entrypoints/server/index.ts

@@ -1,6 +1,8 @@
-export * from '../../pxe_service/index.js';
+export * from '../../pxe.js';
 export * from '../../config/index.js';
+export * from '../../error_enriching.js';
 export * from '../../storage/index.js';
 export * from './utils.js';
 export { PXEOracleInterface } from '../../contract_function_simulator/pxe_oracle_interface.js';
 export { ORACLE_VERSION } from '../../oracle_version.js';
+export { type PXECreationOptions } from '../pxe_creation_options.js';

package/src/entrypoints/server/utils.ts

@@ -12,52 +12,23 @@ import {
 import { FileCircuitRecorder } from '@aztec/simulator/testing';
 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 { PXEConfig } from '../../config/index.js';
+import { PXE } from '../../pxe.js';
 import { PXE_DATA_SCHEMA_VERSION } from '../../storage/index.js';
 import type { PXECreationOptions } from '../pxe_creation_options.js';
 
-type PXEConfigWithoutDefaults = Omit<
-  PXEServiceConfig,
-  'l1Contracts' | 'l1ChainId' | 'l2BlockBatchSize' | 'rollupVersion'
->;
+type PXEConfigWithoutDefaults = Omit<PXEConfig, 'l1Contracts' | 'l1ChainId' | 'l2BlockBatchSize' | 'rollupVersion'>;
 
-/**
- * Create and start an PXEService instance with the given AztecNode and config.
- *
- * @param aztecNode - The AztecNode instance to be used by the server.
- * @param config - The PXE Service Config to use
- * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
- * @returns A Promise that resolves to the started PXEService instance.
- */
-export function createPXEService(
+export async function createPXE(
   aztecNode: AztecNode,
   config: PXEConfigWithoutDefaults,
   options: PXECreationOptions = { loggers: {} },
 ) {
-  const simulator = new WASMSimulator();
   const recorder = process.env.CIRCUIT_RECORD_DIR
     ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR)
     : new MemoryCircuitRecorder();
-  const simulatorWithRecorder = new SimulatorRecorderWrapper(simulator, recorder);
-  return createPXEServiceWithSimulator(aztecNode, simulatorWithRecorder, config, options);
-}
+  const simulator = new SimulatorRecorderWrapper(new WASMSimulator(), recorder);
 
-/**
- * Create and start an PXEService instance with the given AztecNode, Simulator and config.
- *
- * @param aztecNode - The AztecNode instance to be used by the server.
- * @param simulator - The Simulator to use
- * @param config - The PXE Service Config to use
- * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
- * @returns A Promise that resolves to the started PXEService instance.
- */
-export async function createPXEServiceWithSimulator(
-  aztecNode: AztecNode,
-  simulator: CircuitSimulator,
-  config: PXEConfigWithoutDefaults,
-  options: PXECreationOptions = { loggers: {} },
-) {
   const logSuffix =
     typeof options.useLogSuffix === 'boolean'
       ? options.useLogSuffix
@@ -67,7 +38,7 @@ export async function createPXEServiceWithSimulator(
   const loggers = options.loggers ?? {};
 
   const { l1ChainId, l1ContractAddresses: l1Contracts, rollupVersion } = await aztecNode.getNodeInfo();
-  const configWithContracts: PXEServiceConfig = {
+  const configWithContracts: PXEConfig = {
     ...config,
     l1Contracts,
     l1ChainId,
@@ -92,7 +63,7 @@ export async function createPXEServiceWithSimulator(
   const protocolContractsProvider = new BundledProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
-  const pxe = await PXEService.create(
+  const pxe = await PXE.create(
     aztecNode,
     options.store,
     prover,
@@ -105,15 +76,14 @@ export async function createPXEServiceWithSimulator(
 }
 
 function createProver(
-  config: Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>,
+  config: Pick<PXEConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>,
   simulator: CircuitSimulator,
   logger?: Logger,
 ) {
   if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
     return new BBWASMBundlePrivateKernelProver(simulator, 16, logger);
   } else {
-    const bbConfig = config as Required<Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> &
-      PXEServiceConfig;
+    const bbConfig = config as Required<Pick<PXEConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> & PXEConfig;
     return BBNativePrivateKernelProver.new(
       { bbSkipCleanup: false, numConcurrentIVCVerifiers: 1, bbIVCConcurrency: 1, ...bbConfig },
       simulator,

package/src/{pxe_service/error_enriching.ts → error_enriching.ts}

@@ -4,7 +4,7 @@ import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type SimulationError, isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
 
-import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
+import type { ContractDataProvider } from './storage/contract_data_provider/contract_data_provider.js';
 
 /**
  * Adds contract and function names to a simulation error, if they
@@ -76,6 +76,10 @@ export async function enrichPublicSimulationError(
   const callStack = err.getCallStack();
   const originalFailingFunction = callStack[callStack.length - 1];
 
+  if (!originalFailingFunction) {
+    throw new Error(`Original failing function not found when enriching public simulation, missing callstack`);
+  }
+
   const artifact = await contractDataProvider.getPublicFunctionArtifact(originalFailingFunction.contractAddress);
   if (!artifact) {
     throw new Error(

package/src/oracle_version.ts

@@ -4,8 +4,8 @@
 ///
 /// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called
 /// and if the oracle version is incompatible an error is thrown.
-export const ORACLE_VERSION = 1;
+export const ORACLE_VERSION = 3;
 
 /// This hash is computed as by hashing the Oracle interface and it is used to detect when the Oracle interface changes,
 /// which in turn implies that you need to update the ORACLE_VERSION constant.
-export const ORACLE_INTERFACE_HASH = 'b48d38f93eaa084033fc5970bf96e559c33c4cdc07d889ab00b4d63f9590739d';
+export const ORACLE_INTERFACE_HASH = 'f9168ceb5a2227c148c5021ebffd4e2ca0da99885b87c5be3ee5ac0d8dd3d67c';

package/src/private_kernel/hints/compute_tx_include_by_timestamp.ts

@@ -31,8 +31,8 @@ export function computeTxIncludeByTimestamp(
     );
   }
 
-  const blockTimestamp = previousKernel.constants.historicalHeader.globalVariables.timestamp;
-  const maxTimestamp = blockTimestamp + BigInt(maxDuration);
+  const anchorBlockTimestamp = previousKernel.constants.anchorBlockHeader.globalVariables.timestamp;
+  const maxTimestamp = anchorBlockTimestamp + BigInt(maxDuration);
   const includeByTimestamp = previousKernel.includeByTimestamp;
 
   // If the includeByTimestamp set during the tx execution is greater than or equal to the max allowed duration,
@@ -44,13 +44,13 @@ export function computeTxIncludeByTimestamp(
 
   // Round it down to the nearest hour/min/second to reduce precision and avoid revealing the exact value.
   // This makes it harder for others to infer what function calls may have been used to produce a specific timestamp.
-  const roundedTimestamp = roundTimestamp(blockTimestamp, includeByTimestamp);
+  const roundedTimestamp = roundTimestamp(anchorBlockTimestamp, includeByTimestamp);
 
-  // The tx can't be published if the timestamp is the same or less than the historical block's timestamp.
+  // The tx can't be published if the timestamp is the same or less than the anchor block's timestamp.
   // Future blocks will have a greater timestamp, so the tx would never be included.
-  if (roundedTimestamp <= blockTimestamp) {
+  if (roundedTimestamp <= anchorBlockTimestamp) {
     throw new Error(
-      `Include-by timestamp must be greater than the historical block timestamp. Block timestamp: ${blockTimestamp}. Include-by timestamp: ${includeByTimestamp}.`,
+      `Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${includeByTimestamp}.`,
     );
   }
 

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -4,9 +4,8 @@ import { createLogger } from '@aztec/foundation/log';
 import { pushTestData } from '@aztec/foundation/testing';
 import { Timer } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { getProtocolContractLeafAndMembershipWitness, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { ProtocolContractsList } from '@aztec/protocol-contracts';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { computeContractAddressFromInstance } from '@aztec/stdlib/contract';
 import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 import {
   HidingKernelToPublicPrivateInputs,
@@ -24,7 +23,7 @@ import {
   type PrivateKernelTailCircuitPublicInputs,
   PrivateVerificationKeyHints,
 } from '@aztec/stdlib/kernel';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ClientIvcProof, ClientIvcProofWithPublicInputs } from '@aztec/stdlib/proofs';
 import {
   type PrivateCallExecutionResult,
   type PrivateExecutionResult,
@@ -168,7 +167,7 @@ export class PrivateKernelExecutionProver {
         const proofInput = new PrivateKernelInitCircuitPrivateInputs(
           txRequest,
           getVKTreeRoot(),
-          protocolContractTreeRoot,
+          ProtocolContractsList,
           privateCallData,
           isPrivateOnlyTx,
           executionResult.firstNullifier,
@@ -268,10 +267,10 @@ export class PrivateKernelExecutionProver {
     // Use the aggregated includeByTimestamp set throughout the tx execution.
     // TODO: Call `computeTxIncludeByTimestamp` to round the value down and reduce precision, improving privacy.
     const includeByTimestampUpperBound = previousKernelData.publicInputs.includeByTimestamp;
-    const blockTimestamp = previousKernelData.publicInputs.constants.historicalHeader.globalVariables.timestamp;
-    if (includeByTimestampUpperBound <= blockTimestamp) {
+    const anchorBlockTimestamp = previousKernelData.publicInputs.constants.anchorBlockHeader.globalVariables.timestamp;
+    if (includeByTimestampUpperBound <= anchorBlockTimestamp) {
       throw new Error(
-        `Include-by timestamp must be greater than the historical block timestamp. Block timestamp: ${blockTimestamp}. Include-by timestamp: ${includeByTimestampUpperBound}.`,
+        `Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${includeByTimestampUpperBound}.`,
       );
     }
 
@@ -281,8 +280,6 @@ export class PrivateKernelExecutionProver {
       includeByTimestampUpperBound,
     );
 
-    pushTestData('private-kernel-inputs-ordering', privateInputs);
-
     const witgenTimer = new Timer();
     const tailOutput = generateWitnesses
       ? await this.proofCreator.generateTailOutput(privateInputs)
@@ -355,8 +352,10 @@ export class PrivateKernelExecutionProver {
     let provingTime;
     if (!skipProofGeneration) {
       const provingTimer = new Timer();
-      clientIvcProof = await this.proofCreator.createClientIvcProof(executionSteps);
+      const proofWithPublicInputs = await this.proofCreator.createClientIvcProof(executionSteps);
       provingTime = provingTimer.ms();
+      this.ensurePublicInputsMatch(proofWithPublicInputs, tailOutput.publicInputs);
+      clientIvcProof = proofWithPublicInputs.removePublicInputs();
     } else {
       clientIvcProof = ClientIvcProof.random();
     }
@@ -369,6 +368,32 @@ export class PrivateKernelExecutionProver {
     };
   }
 
+  /**
+   * Checks that the public inputs of the civc proof match the public inputs of the tail circuit.
+   * This can only mismatch if there is a circuit / noir / bb bug.
+   * @param civcProof - The civc proof with public inputs.
+   * @param tailPublicInputs - The public inputs resulting from witness generation of the tail circuit.
+   */
+  private ensurePublicInputsMatch(
+    civcProof: ClientIvcProofWithPublicInputs,
+    tailPublicInputs: PrivateKernelTailCircuitPublicInputs,
+  ) {
+    const serializedCivcProofPublicInputs = civcProof.getPublicInputs();
+    const serializedTailPublicInputs = tailPublicInputs.publicInputs().toFields();
+    if (serializedCivcProofPublicInputs.length !== serializedTailPublicInputs.length) {
+      throw new Error(
+        `Public inputs length mismatch: ${serializedCivcProofPublicInputs.length} !== ${serializedTailPublicInputs.length}`,
+      );
+    }
+    if (
+      !serializedCivcProofPublicInputs.every((input: Fr, index: number) =>
+        input.equals(serializedTailPublicInputs[index]),
+      )
+    ) {
+      throw new Error(`Public inputs mismatch between kernel and civc proof`);
+    }
+  }
+
   private async getVkData(verificationKey: VerificationKeyData) {
     const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(verificationKey.keyAsFields);
     return new VkData(
@@ -394,17 +419,6 @@ export class PrivateKernelExecutionProver {
     const { artifactHash: contractClassArtifactHash, publicBytecodeCommitment: contractClassPublicBytecodeCommitment } =
       await this.oracle.getContractClassIdPreimage(currentContractClassId);
 
-    // This will be the address computed in the kernel by the executed class. We need to provide non membership of it in the protocol contract tree.
-    // This would only be equal to contractAddress if the currentClassId is equal to the original class id (no update happened).
-    const computedAddress = await computeContractAddressFromInstance({
-      originalContractClassId: currentContractClassId,
-      saltedInitializationHash,
-      publicKeys,
-    });
-
-    const { lowLeaf: protocolContractLeaf, witness: protocolContractMembershipWitness } =
-      await getProtocolContractLeafAndMembershipWitness(contractAddress, computedAddress);
-
     const updatedClassIdHints = await this.oracle.getUpdatedClassIdHints(contractAddress);
     return PrivateCallData.from({
       publicInputs,
@@ -415,8 +429,6 @@ export class PrivateKernelExecutionProver {
         contractClassPublicBytecodeCommitment,
         saltedInitializationHash,
         functionLeafMembershipWitness,
-        protocolContractMembershipWitness,
-        protocolContractLeaf,
         updatedClassIdHints,
       }),
     });