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

package/src/bin/check_oracle_version.ts

@@ -1,14 +1,12 @@
-import { keccak256String } from '@aztec/foundation/crypto';
+import { keccak256String } from '@aztec/foundation/crypto/keccak';
 
-import deterministicStringify from 'json-stringify-deterministic';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import ts from 'typescript';
+import { fileURLToPath } from 'url';
 
-import { Oracle } from '../contract_function_simulator/oracle/oracle.js';
-import { TypedOracle } from '../contract_function_simulator/oracle/typed_oracle.js';
 import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
 
-// Create a minimal mock implementation of TypedOracle to instantiate the Oracle class for interface verification.
-class OracleMock extends TypedOracle {}
-
 /**
  * Verifies that the Oracle interface matches the expected interface hash.
  *
@@ -22,15 +20,141 @@ class OracleMock extends TypedOracle {}
  * oracle interface like we do in PXE (i.e., there is no single Oracle class that contains only the oracles).
  */
 function assertOracleInterfaceMatches(): void {
-  const oracle = new Oracle(new OracleMock());
+  const oracleInterfaceSignature = getOracleInterfaceSignature();
+
   // We use keccak256 here just because we already have it in the dependencies.
-  const oracleInterfaceHash = keccak256String(deterministicStringify(oracle.toACIRCallback()));
+  const oracleInterfaceHash = keccak256String(oracleInterfaceSignature);
   if (oracleInterfaceHash !== ORACLE_INTERFACE_HASH) {
     // This check exists only to notify you when you need to update the ORACLE_VERSION constant.
     throw new Error(
-      `The TypedOracle interface has changed, which implies a breaking change in the aztec.nr/PXE oracle interface. Update ORACLE_INTERFACE_HASH to ${oracleInterfaceHash} and bump ORACLE_VERSION in pxe/src/oracle_version.ts.`,
+      `The Oracle interface has changed, which implies a breaking change in the aztec.nr/PXE oracle interface. Update ORACLE_INTERFACE_HASH to ${oracleInterfaceHash} and bump ORACLE_VERSION in pxe/src/oracle_version.ts.`,
     );
   }
 }
 
+/**
+ * Constructs a signature of the Oracle interface while ignoring methods that are not foreign call handlers.
+ */
+function getOracleInterfaceSignature(): string {
+  const excludedProps = [
+    'handler',
+    'constructor',
+    'toACIRCallback',
+    'handlerAsMisc',
+    'handlerAsUtility',
+    'handlerAsPrivate',
+  ] as const;
+
+  // Get the path to Oracle.ts source file
+  // The script runs from dest/bin/ after compilation, so we need to go up to the package root
+  // then into src/ to find the source file
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  // Go up from dest/bin/ or src/bin/ to the package root (pxe/), then into src/
+  const packageRoot = dirname(dirname(currentDir)); // Go up from bin/ to pxe/
+  const oracleSourcePath = join(packageRoot, 'src/contract_function_simulator/oracle/oracle.ts');
+
+  // Read and parse the TypeScript source file
+  const sourceCode = readFileSync(oracleSourcePath, 'utf-8');
+  const sourceFile = ts.createSourceFile('oracle.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+
+  // Extract method signatures from the Oracle class
+  const methodSignatures: string[] = [];
+
+  function visit(node: ts.Node) {
+    // Look for class declaration named "Oracle"
+    if (ts.isClassDeclaration(node) && node.name?.text === 'Oracle') {
+      // Visit all members of the class
+      node.members.forEach(member => {
+        if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+          const methodName = member.name.text;
+
+          // Skip excluded methods
+          if (excludedProps.includes(methodName as (typeof excludedProps)[number])) {
+            return;
+          }
+
+          // Extract parameter signatures
+          const paramSignatures: string[] = [];
+          member.parameters.forEach(param => {
+            const paramName = extractParameterName(param, sourceFile);
+            const paramType = extractTypeString(param.type, sourceFile);
+            paramSignatures.push(`${paramName}: ${paramType}`);
+          });
+
+          // Extract return type
+          const returnType = extractTypeString(member.type, sourceFile);
+
+          // Build full signature: methodName(param1: Type1, param2: Type2): ReturnType
+          const signature = `${methodName}(${paramSignatures.join(', ')}): ${returnType}`;
+          methodSignatures.push(signature);
+        }
+      });
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+
+  // Sort signatures alphabetically for consistent hashing
+  methodSignatures.sort();
+
+  // Create a hashable representation by concatenating all signatures
+  return methodSignatures.join('');
+}
+
+/**
+ * Extracts the parameter name from a parameter node, handling destructured parameters.
+ */
+function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.SourceFile): string {
+  const name = param.name;
+
+  if (ts.isIdentifier(name)) {
+    return name.text;
+  }
+
+  if (ts.isArrayBindingPattern(name)) {
+    // Handle destructured parameters like [blockNumber]: ACVMField[]
+    // Extract the first element name
+    if (name.elements.length > 0) {
+      const element = name.elements[0];
+      if (ts.isBindingElement(element)) {
+        const elementName = element.name;
+        if (ts.isIdentifier(elementName)) {
+          return elementName.text;
+        }
+        // Nested destructuring - use text representation
+        if (ts.isArrayBindingPattern(elementName) || ts.isObjectBindingPattern(elementName)) {
+          return elementName.getText(sourceFile);
+        }
+      }
+    }
+    // Fallback: return the text representation
+    return name.getText(sourceFile);
+  }
+
+  if (ts.isObjectBindingPattern(name)) {
+    // Handle object destructuring
+    return name.getText(sourceFile);
+  }
+
+  // Fallback for any other case - this should never happen but TypeScript needs it
+  return (name as ts.Node).getText(sourceFile);
+}
+
+/**
+ * Extracts the type string from a type node, normalizing whitespace.
+ */
+function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
+  if (!typeNode) {
+    return 'void';
+  }
+
+  // Get the type text and normalize whitespace
+  let typeText = typeNode.getText(sourceFile);
+  // Normalize whitespace: remove extra spaces, newlines, and tabs
+  typeText = typeText.replace(/\s+/g, ' ').trim();
+  return typeText;
+}
+
 assertOracleInterfaceMatches();

package/src/config/index.ts

@@ -10,15 +10,6 @@ import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
 
 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
  */
@@ -26,22 +17,23 @@ export interface KernelProverConfig {
   /** Whether we are running with real proofs */
   proverEnabled?: boolean;
 }
+
 /**
- * Configuration settings for the PXE.
+ * Configuration settings for the synchronizer.
  */
-export interface PXEConfig {
+export interface SynchronizerConfig {
   /** Maximum amount of blocks to pull from the stream in one request when synchronizing */
   l2BlockBatchSize: number;
 }
 
-export type PXEServiceConfig = PXEConfig & KernelProverConfig & BBProverConfig & DataStoreConfig & ChainConfig;
+export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & SynchronizerConfig;
 
 export type CliPXEOptions = {
   /** Custom Aztec Node URL to connect to  */
   nodeUrl?: string;
 };
 
-export const pxeConfigMappings: ConfigMappingsType<PXEServiceConfig> = {
+export const pxeConfigMappings: ConfigMappingsType<PXEConfig> = {
   ...dataConfigMappings,
   ...chainConfigMappings,
   l2BlockBatchSize: {
@@ -49,19 +41,13 @@ export const pxeConfigMappings: ConfigMappingsType<PXEServiceConfig> = {
     ...numberConfigHelper(50),
     description: 'Maximum amount of blocks to pull from the stream in one request when synchronizing',
   },
-  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(),
-  },
+  // TODO: We're losing this feature in moving to bb.js api.
+  // Reimplement it as a setting that dumps the msgpack data on the bb.js backend if needed.
+  // 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',
@@ -70,10 +56,10 @@ export const pxeConfigMappings: ConfigMappingsType<PXEServiceConfig> = {
 };
 
 /**
- * Creates an instance of PXEServiceConfig out of environment variables using sensible defaults for integration testing if not set.
+ * Creates an instance of PXEConfig out of environment variables using sensible defaults for integration testing if not set.
  */
-export function getPXEServiceConfig(): PXEServiceConfig {
-  return getConfigFromMappings<PXEServiceConfig>(pxeConfigMappings);
+export function getPXEConfig(): PXEConfig {
+  return getConfigFromMappings<PXEConfig>(pxeConfigMappings);
 }
 
 export const pxeCliConfigMappings: ConfigMappingsType<CliPXEOptions> = {
@@ -83,7 +69,7 @@ export const pxeCliConfigMappings: ConfigMappingsType<CliPXEOptions> = {
   },
 };
 
-export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEServiceConfig> = {
+export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEConfig> = {
   ...pxeConfigMappings,
   ...pxeCliConfigMappings,
   ...dataConfigMappings,
@@ -99,8 +85,8 @@ export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEService
 /**
  * Creates an instance of CliPxeOptions out of environment variables
  */
-export function getCliPXEOptions(): CliPXEOptions & PXEServiceConfig {
-  const pxeConfig = getPXEServiceConfig();
+export function getCliPXEOptions(): CliPXEOptions & PXEConfig {
+  const pxeConfig = getPXEConfig();
   const cliOptions = getConfigFromMappings<CliPXEOptions>(pxeCliConfigMappings);
   return {
     ...pxeConfig,

package/src/config/package_info.ts

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

package/src/contract_function_simulator/contract_function_simulator.ts

@@ -1,4 +1,14 @@
 import {
+  AVM_EMITNOTEHASH_BASE_L2_GAS,
+  AVM_EMITNULLIFIER_BASE_L2_GAS,
+  AVM_SENDL2TOL1MSG_BASE_L2_GAS,
+  DA_BYTES_PER_FIELD,
+  DA_GAS_PER_BYTE,
+  FIXED_AVM_STARTUP_L2_GAS,
+  FIXED_DA_GAS,
+  FIXED_L2_GAS,
+  L2_GAS_PER_CONTRACT_CLASS_LOG,
+  L2_GAS_PER_PRIVATE_LOG,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_ENQUEUED_CALLS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
@@ -6,13 +16,13 @@ import {
   MAX_NULLIFIERS_PER_TX,
   MAX_PRIVATE_LOGS_PER_TX,
 } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import {
   type CircuitSimulator,
   ExecutionError,
@@ -22,12 +32,18 @@ import {
   toACVMWitness,
   witnessMapToFields,
 } from '@aztec/simulator/client';
-import type { AbiDecoded, FunctionCall } from '@aztec/stdlib/abi';
-import { FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Gas } from '@aztec/stdlib/gas';
-import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import {
+  computeNoteHashNonce,
+  computeProtocolNullifier,
+  computeUniqueNoteHash,
+  siloNoteHash,
+  siloNullifier,
+} from '@aztec/stdlib/hash';
 import {
   PartialPrivateTailPublicInputsForPublic,
   PartialPrivateTailPublicInputsForRollup,
@@ -41,7 +57,7 @@ import {
 } from '@aztec/stdlib/kernel';
 import { PrivateLog } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import {
   CallContext,
   HashedValues,
@@ -49,11 +65,13 @@ import {
   TxConstantData,
   TxExecutionRequest,
   collectNested,
+  getFinalMinRevertibleSideEffectCounter,
 } from '@aztec/stdlib/tx';
 
 import type { ContractDataProvider } from '../storage/index.js';
 import type { ExecutionDataProvider } from './execution_data_provider.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
+import { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
 import { HashedValuesCache } from './hashed_values_cache.js';
 import { Oracle } from './oracle/oracle.js';
 import { executePrivateFunction, verifyCurrentClassId } from './oracle/private_execution.js';
@@ -94,7 +112,7 @@ export class ContractFunctionSimulator {
     scopes?: AztecAddress[],
   ): Promise<PrivateExecutionResult> {
     const simulatorSetupTimer = new Timer();
-    const header = await this.executionDataProvider.getBlockHeader();
+    const anchorBlockHeader = await this.executionDataProvider.getAnchorBlockHeader();
 
     await verifyCurrentClassId(contractAddress, this.executionDataProvider);
 
@@ -111,7 +129,7 @@ export class ContractFunctionSimulator {
     }
 
     // reserve the first side effect for the tx hash (inserted by the private kernel)
-    const startSideEffectCounter = 1;
+    const startSideEffectCounter = 2;
 
     const callContext = new CallContext(
       msgSender,
@@ -120,25 +138,27 @@ export class ContractFunctionSimulator {
       entryPointArtifact.isStatic,
     );
 
-    const txRequestHash = await request.toTxRequest().hash();
-    const noteCache = new ExecutionNoteCache(txRequestHash);
+    const protocolNullifier = await computeProtocolNullifier(await request.toTxRequest().hash());
+    const noteCache = new ExecutionNoteCache(protocolNullifier);
+    const taggingIndexCache = new ExecutionTaggingIndexCache();
 
     const privateExecutionOracle = new PrivateExecutionOracle(
       request.firstCallArgsHash,
       request.txContext,
       callContext,
-      header,
+      anchorBlockHeader,
       request.authWitnesses,
       request.capsules,
       HashedValuesCache.create(request.argsOfCalls),
       noteCache,
+      taggingIndexCache,
       this.executionDataProvider,
-      this.simulator,
       0, // totalPublicArgsCount
       startSideEffectCounter,
       undefined, // log
       scopes,
       senderForTags,
+      this.simulator,
     );
 
     const setupTime = simulatorSetupTimer.ms();
@@ -156,8 +176,8 @@ export class ContractFunctionSimulator {
         request.functionSelector,
       );
       const simulatorTeardownTimer = new Timer();
-      const { usedTxRequestHashForNonces } = noteCache.finish();
-      const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
+      const { usedProtocolNullifierForNonces } = noteCache.finish();
+      const firstNullifierHint = usedProtocolNullifierForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
 
       const publicCallRequests = collectNested([executionResult], r =>
         r.publicInputs.publicCallRequests
@@ -195,9 +215,9 @@ export class ContractFunctionSimulator {
    * @param authwits - Authentication witnesses required for the function call.
    * @param scopes - Optional array of account addresses whose notes can be accessed in this call. Defaults to all
    * accounts if not specified.
-   * @returns A decoded ABI value containing the function's return data.
+   * @returns A return value of the utility function in a form as returned by the simulator (Noir fields)
    */
-  public async runUtility(call: FunctionCall, authwits: AuthWitness[], scopes?: AztecAddress[]): Promise<AbiDecoded> {
+  public async runUtility(call: FunctionCall, authwits: AuthWitness[], scopes?: AztecAddress[]): Promise<Fr[]> {
     await verifyCurrentClassId(call.to, this.executionDataProvider);
 
     const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(call.to, call.selector);
@@ -230,9 +250,8 @@ export class ContractFunctionSimulator {
           );
         });
 
-      const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
       this.log.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
-      return decodeFromAbi(entryPointArtifact.returnTypes, returnWitness);
+      return witnessMapToFields(acirExecutionResult.returnWitness);
     } catch (err) {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
@@ -255,7 +274,7 @@ class OrderedSideEffect<T> {
 }
 
 /**
- * Generates the final public inputs of the tail kernel circuit, an empty ClientIVC proof
+ * Generates the final public inputs of the tail kernel circuit, an empty Chonk proof
  * and the execution steps for a `PrivateExecutionResult` as if it had been
  * processed by the private kernel prover. This skips many of the checks performed by the kernels
  * (allowing state overrides) and is much faster, while still generating a valid
@@ -358,30 +377,35 @@ export async function generateSimulatedProvingResult(
   }
 
   const constantData = new TxConstantData(
-    privateExecutionResult.entrypoint.publicInputs.historicalHeader,
+    privateExecutionResult.entrypoint.publicInputs.anchorBlockHeader,
     privateExecutionResult.entrypoint.publicInputs.txContext,
     getVKTreeRoot(),
-    protocolContractTreeRoot,
+    protocolContractsHash,
   );
 
   const hasPublicCalls = privateExecutionResult.publicFunctionCalldata.length !== 0;
   let inputsForRollup;
   let inputsForPublic;
+  let gasUsed;
 
   const sortByCounter = <T>(a: OrderedSideEffect<T>, b: OrderedSideEffect<T>) => a.counter - b.counter;
   const getEffect = <T>(orderedSideEffect: OrderedSideEffect<T>) => orderedSideEffect.sideEffect;
 
-  const sortedNullifiers = nullifiers.sort(sortByCounter).map(getEffect);
+  const isPrivateOnlyTx = privateExecutionResult.publicFunctionCalldata.length === 0;
+  const minRevertibleSideEffectCounter = getFinalMinRevertibleSideEffectCounter(privateExecutionResult);
 
-  // If the tx generated no nullifiers, the nonce generator (txRequest hash)
-  // is injected as the first nullifier as per protocol rules.
-  if (sortedNullifiers.length === 0) {
-    sortedNullifiers.push(nonceGenerator);
+  const [nonRevertibleNullifiers, revertibleNullifiers] = splitOrderedSideEffects(
+    nullifiers.sort(sortByCounter),
+    minRevertibleSideEffectCounter,
+  );
+  if (nonRevertibleNullifiers.length > 0 && !nonRevertibleNullifiers[0].equals(nonceGenerator)) {
+    throw new Error('The first non revertible nullifier should be equal to the nonce generator. This is a bug!');
+  } else {
+    nonRevertibleNullifiers.unshift(nonceGenerator);
   }
 
-  // Private only
-  if (privateExecutionResult.publicFunctionCalldata.length === 0) {
-    // In case the tx only contains private functions, we must make the note hashes unique by using the
+  if (isPrivateOnlyTx) {
+    // We must make the note hashes unique by using the
     // nonce generator and their index in the tx.
     const uniqueNoteHashes = await Promise.all(
       siloedNoteHashes.sort(sortByCounter).map(async (orderedSideEffect, i) => {
@@ -393,7 +417,7 @@ export async function generateSimulatedProvingResult(
     );
     const accumulatedDataForRollup = new PrivateToRollupAccumulatedData(
       padArrayEnd(uniqueNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-      padArrayEnd(sortedNullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+      padArrayEnd(nonRevertibleNullifiers.concat(revertibleNullifiers), Fr.ZERO, MAX_NULLIFIERS_PER_TX),
       padArrayEnd(
         l2ToL1Messages.sort(sortByCounter).map(getEffect),
         ScopedL2ToL1Message.empty(),
@@ -406,39 +430,51 @@ export async function generateSimulatedProvingResult(
         MAX_CONTRACT_CLASS_LOGS_PER_TX,
       ),
     );
-
+    gasUsed = meterGasUsed(accumulatedDataForRollup);
     inputsForRollup = new PartialPrivateTailPublicInputsForRollup(accumulatedDataForRollup);
   } else {
-    const nonRevertibleData = PrivateToPublicAccumulatedData.empty();
+    const [nonRevertibleNoteHashes, revertibleNoteHashes] = splitOrderedSideEffects(
+      siloedNoteHashes.sort(sortByCounter),
+      minRevertibleSideEffectCounter,
+    );
+    const [nonRevertibleL2ToL1Messages, revertibleL2ToL1Messages] = splitOrderedSideEffects(
+      l2ToL1Messages.sort(sortByCounter),
+      minRevertibleSideEffectCounter,
+    );
+    const [nonRevertibleTaggedPrivateLogs, revertibleTaggedPrivateLogs] = splitOrderedSideEffects(
+      taggedPrivateLogs,
+      minRevertibleSideEffectCounter,
+    );
+    const [nonRevertibleContractClassLogHashes, revertibleContractClassLogHashes] = splitOrderedSideEffects(
+      contractClassLogsHashes.sort(sortByCounter),
+      minRevertibleSideEffectCounter,
+    );
+    const [nonRevertiblePublicCallRequests, revertiblePublicCallRequests] = splitOrderedSideEffects(
+      publicCallRequests.sort(sortByCounter),
+      minRevertibleSideEffectCounter,
+    );
 
-    // The nullifier array contains the nonce generator in position 0
-    // Here we remove it from the revertible data and
-    // add it as the first non-revertible nullifier (we can't have dupes!)
-    // This is because public processor will use that first non-revertible nullifier
-    // as the nonce generator for the note hashes in the revertible part of the tx.
-    const [firstNullifier] = sortedNullifiers.splice(0, 1);
-    nonRevertibleData.nullifiers[0] = firstNullifier;
+    const nonRevertibleData = new PrivateToPublicAccumulatedData(
+      padArrayEnd(nonRevertibleNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+      padArrayEnd(nonRevertibleNullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+      padArrayEnd(nonRevertibleL2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+      padArrayEnd(nonRevertibleTaggedPrivateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
+      padArrayEnd(nonRevertibleContractClassLogHashes, ScopedLogHash.empty(), MAX_CONTRACT_CLASS_LOGS_PER_TX),
+      padArrayEnd(nonRevertiblePublicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX),
+    );
 
     const revertibleData = new PrivateToPublicAccumulatedData(
-      padArrayEnd(siloedNoteHashes.sort(sortByCounter).map(getEffect), Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-      padArrayEnd(sortedNullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
-      padArrayEnd(
-        l2ToL1Messages.sort(sortByCounter).map(getEffect),
-        ScopedL2ToL1Message.empty(),
-        MAX_L2_TO_L1_MSGS_PER_TX,
-      ),
-      padArrayEnd(taggedPrivateLogs.sort(sortByCounter).map(getEffect), PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
-      padArrayEnd(
-        contractClassLogsHashes.sort(sortByCounter).map(getEffect),
-        ScopedLogHash.empty(),
-        MAX_CONTRACT_CLASS_LOGS_PER_TX,
-      ),
-      padArrayEnd(
-        publicCallRequests.sort(sortByCounter).map(getEffect),
-        PublicCallRequest.empty(),
-        MAX_ENQUEUED_CALLS_PER_TX,
-      ),
+      padArrayEnd(revertibleNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+      padArrayEnd(revertibleNullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+      padArrayEnd(revertibleL2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+      padArrayEnd(revertibleTaggedPrivateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
+      padArrayEnd(revertibleContractClassLogHashes, ScopedLogHash.empty(), MAX_CONTRACT_CLASS_LOGS_PER_TX),
+      padArrayEnd(revertiblePublicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX),
     );
+    gasUsed = meterGasUsed(revertibleData).add(meterGasUsed(nonRevertibleData));
+    if (publicTeardownCallRequest) {
+      gasUsed.add(privateExecutionResult.entrypoint.publicInputs.txContext.gasSettings.teardownGasLimits);
+    }
 
     inputsForPublic = new PartialPrivateTailPublicInputsForPublic(
       nonRevertibleData,
@@ -449,7 +485,7 @@ export async function generateSimulatedProvingResult(
 
   const publicInputs = new PrivateKernelTailCircuitPublicInputs(
     constantData,
-    /*gasUsed=*/ new Gas(0, 0),
+    /*gasUsed=*/ gasUsed.add(Gas.from({ l2Gas: FIXED_L2_GAS, daGas: FIXED_DA_GAS })),
     /*feePayer=*/ AztecAddress.zero(),
     /*includeByTimestamp=*/ 0n,
     hasPublicCalls ? inputsForPublic : undefined,
@@ -458,7 +494,60 @@ export async function generateSimulatedProvingResult(
 
   return {
     publicInputs,
-    clientIvcProof: ClientIvcProof.empty(),
-    executionSteps: executionSteps,
+    chonkProof: ChonkProof.empty(),
+    executionSteps,
   };
 }
+
+function splitOrderedSideEffects<T>(effects: OrderedSideEffect<T>[], minRevertibleSideEffectCounter: number) {
+  const revertibleSideEffects: T[] = [];
+  const nonRevertibleSideEffects: T[] = [];
+  effects.forEach(effect => {
+    if (effect.counter < minRevertibleSideEffectCounter) {
+      nonRevertibleSideEffects.push(effect.sideEffect);
+    } else {
+      revertibleSideEffects.push(effect.sideEffect);
+    }
+  });
+  return [nonRevertibleSideEffects, revertibleSideEffects];
+}
+
+function meterGasUsed(data: PrivateToRollupAccumulatedData | PrivateToPublicAccumulatedData) {
+  let meteredDAFields = 0;
+  let meteredL2Gas = 0;
+
+  const numNoteHashes = arrayNonEmptyLength(data.noteHashes, hash => hash.isEmpty());
+  meteredDAFields += numNoteHashes;
+  meteredL2Gas += numNoteHashes * AVM_EMITNOTEHASH_BASE_L2_GAS;
+
+  const numNullifiers = arrayNonEmptyLength(data.nullifiers, nullifier => nullifier.isEmpty());
+  meteredDAFields += numNullifiers;
+  meteredL2Gas += numNullifiers * AVM_EMITNULLIFIER_BASE_L2_GAS;
+
+  const numL2toL1Messages = arrayNonEmptyLength(data.l2ToL1Msgs, msg => msg.isEmpty());
+  meteredDAFields += numL2toL1Messages;
+  meteredL2Gas += numL2toL1Messages * AVM_SENDL2TOL1MSG_BASE_L2_GAS;
+
+  const numPrivatelogs = arrayNonEmptyLength(data.privateLogs, log => log.isEmpty());
+  // Every private log emits its length as an additional field
+  meteredDAFields += data.privateLogs.reduce((acc, log) => (!log.isEmpty() ? acc + log.emittedLength + 1 : acc), 0);
+  meteredL2Gas += numPrivatelogs * L2_GAS_PER_PRIVATE_LOG;
+
+  const numContractClassLogs = arrayNonEmptyLength(data.contractClassLogsHashes, log => log.isEmpty());
+  // Every contract class log emits its length and contract address as additional fields
+  meteredDAFields += data.contractClassLogsHashes.reduce(
+    (acc, log) => (!log.isEmpty() ? acc + log.logHash.length + 2 : acc),
+    0,
+  );
+  meteredL2Gas += numContractClassLogs * L2_GAS_PER_CONTRACT_CLASS_LOG;
+
+  const meteredDAGas = meteredDAFields * DA_BYTES_PER_FIELD * DA_GAS_PER_BYTE;
+
+  if ((data as PrivateToPublicAccumulatedData).publicCallRequests) {
+    const dataForPublic = data as PrivateToPublicAccumulatedData;
+
+    const numPublicCallRequests = arrayNonEmptyLength(dataForPublic.publicCallRequests, req => req.isEmpty());
+    meteredL2Gas += numPublicCallRequests * FIXED_AVM_STARTUP_L2_GAS;
+  }
+  return Gas.from({ l2Gas: meteredL2Gas, daGas: meteredDAGas });
+}