@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.5476d83

package/README.md

@@ -1,13 +1,13 @@
-# PXE Service & PXE
+# PXE & PXE
 
-`PXE Service` (pronounced "pixie service") is a server-side software that provides a set of apis for interacting with the Aztec network. It acts as a bridge between the network and client applications by exposing methods to manage accounts, deploy contracts, create transactions, and retrieve public and account-specific information. It provides a secure environment for the execution of sensitive operations, ensuring private information and decrypted data are not accessible to unauthorized applications. The PXE Service is a critical component of the Aztec network, and its security and reliability are essential to the overall trustworthiness of user's data.
+`PXE` (pronounced "pixie service") is a server-side software that provides a set of apis for interacting with the Aztec network. It acts as a bridge between the network and client applications by exposing methods to manage accounts, deploy contracts, create transactions, and retrieve public and account-specific information. It provides a secure environment for the execution of sensitive operations, ensuring private information and decrypted data are not accessible to unauthorized applications. The PXE is a critical component of the Aztec network, and its security and reliability are essential to the overall trustworthiness of user's data.
 
-`PXE` is the interface the PXE Service and every client-side instance implement. Various implementations of the client-side can exist, including those for different platforms such as mobile apps and web browsers. It is a relay between the dApps and the actual PXE Service.
+`PXE` is the interface the PXE and every client-side instance implement. Various implementations of the client-side can exist, including those for different platforms such as mobile apps and web browsers. It is a relay between the dApps and the actual PXE.
 
-### Main Components in an PXE Service
+### Main Components in an PXE
 
 - [Simulator](../simulator/)
 - [Key Store](../key-store/)
 - [Account State](./src/account_state/account_state.ts): It coordinates other components to synchronize and decrypt data, simulate transactions, and generate kernel proofs, for a specific account.
 
-![Pixie](./pixie.png)
+![Pixie](./pixie.png)

package/dest/bin/check_oracle_version.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tfb3JhY2xlX3ZlcnNpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vY2hlY2tfb3JhY2xlX3ZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/bin/check_oracle_version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_oracle_version.d.ts","sourceRoot":"","sources":["../../src/bin/check_oracle_version.ts"],"names":[],"mappings":""}

package/dest/bin/check_oracle_version.js

@@ -0,0 +1,39 @@
+import { keccak256String } from '@aztec/foundation/crypto';
+import { Oracle } from '../contract_function_simulator/oracle/oracle.js';
+import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
+/**
+ * Verifies that the Oracle interface matches the expected interface hash.
+ *
+ * The Oracle interface needs to be versioned to ensure compatibility between Aztec.nr and PXE. This function computes
+ * a hash of the Oracle interface and compares it against a known hash. If they don't match, it means the interface has
+ * changed and the ORACLE_VERSION constant needs to be incremented and the ORACLE_INTERFACE_HASH constant needs to be
+ * updated.
+ *
+ * TODO(#16581): The following only takes into consideration changes to the oracles defined in Oracle.ts and omits TXE
+ * oracles. Ensure this checks TXE oracles as well. This hasn't been implemented yet since we don't have a clean TXE
+ * oracle interface like we do in PXE (i.e., there is no single Oracle class that contains only the oracles).
+ */ function assertOracleInterfaceMatches() {
+    const excludedProps = [
+        'handler',
+        'constructor',
+        'toACIRCallback',
+        'handlerAsMisc',
+        'handlerAsUtility',
+        'handlerAsPrivate'
+    ];
+    // Create a hashable representation of the oracle interface by concatenating its method names. Return values are
+    // excluded from the hash calculation since they are typically arrays of fields and I didn't manage to reliably
+    // stringify them.
+    // TODO(#16581): we're only checking the functions implemented by the Oracle object, which is really an ACVM
+    // translator, akin to TXE's RPC translator. This is correct in that it is ultimately the foreign interface that
+    // matters, but incorrect in that it does not take into consideration TXE's extended interface. An improvement would
+    // be to check RPCTranslator from TXE, though that still seems a bit fragile.
+    const oracleInterfaceMethodNames = Object.getOwnPropertyNames(Oracle.prototype).filter((name)=>!excludedProps.includes(name)).sort().join('');
+    // We use keccak256 here just because we already have it in the dependencies.
+    const oracleInterfaceHash = keccak256String(oracleInterfaceMethodNames);
+    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 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.`);
+    }
+}
+assertOracleInterfaceMatches();

package/dest/config/index.d.ts

@@ -1,16 +1,7 @@
 import { type ConfigMappingsType } from '@aztec/foundation/config';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { type ChainConfig } 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
  */
@@ -19,30 +10,26 @@ export interface KernelProverConfig {
     proverEnabled?: boolean;
 }
 /**
- * Configuration settings for the PXE.
+ * Configuration settings for the synchronizer.
  */
-export interface PXEConfig {
-    /** L2 block to start scanning from for new accounts */
-    l2StartingBlock: number;
+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 = {
-    /** 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 declare const pxeConfigMappings: ConfigMappingsType<PXEServiceConfig>;
+export declare const pxeConfigMappings: ConfigMappingsType<PXEConfig>;
 /**
- * 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 declare function getPXEServiceConfig(): PXEServiceConfig;
+export declare function getPXEConfig(): PXEConfig;
 export declare const pxeCliConfigMappings: ConfigMappingsType<CliPXEOptions>;
-export declare const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEServiceConfig>;
+export declare const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEConfig>;
 /**
  * Creates an instance of CliPxeOptions out of environment variables
  */
-export declare function getCliPXEOptions(): CliPXEOptions & PXEServiceConfig;
-//# sourceMappingURL=index.d.ts.map
+export declare function getCliPXEOptions(): CliPXEOptions & PXEConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBS3hCLE1BQU0sMEJBQTBCLENBQUM7QUFDbEMsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFzQixNQUFNLHdCQUF3QixDQUFDO0FBQ2xGLE9BQU8sRUFBRSxLQUFLLFdBQVcsRUFBdUIsTUFBTSxzQkFBc0IsQ0FBQztBQUU3RSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbkQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLDhDQUE4QztJQUM5QyxhQUFhLENBQUMsRUFBRSxPQUFPLENBQUM7Q0FDekI7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyxrQkFBa0I7SUFDakMseUZBQXlGO0lBQ3pGLGdCQUFnQixFQUFFLE1BQU0sQ0FBQztDQUMxQjtBQUVELE1BQU0sTUFBTSxTQUFTLEdBQUcsa0JBQWtCLEdBQUcsZUFBZSxHQUFHLFdBQVcsR0FBRyxrQkFBa0IsQ0FBQztBQUVoRyxNQUFNLE1BQU0sYUFBYSxHQUFHO0lBQzFCLDJDQUEyQztJQUMzQyxPQUFPLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDbEIsQ0FBQztBQUVGLGVBQU8sTUFBTSxpQkFBaUIsRUFBRSxrQkFBa0IsQ0FBQyxTQUFTLENBb0IzRCxDQUFDO0FBRUY7O0dBRUc7QUFDSCx3QkFBZ0IsWUFBWSxJQUFJLFNBQVMsQ0FFeEM7QUFFRCxlQUFPLE1BQU0sb0JBQW9CLEVBQUUsa0JBQWtCLENBQUMsYUFBYSxDQUtsRSxDQUFDO0FBRUYsZUFBTyxNQUFNLG9CQUFvQixFQUFFLGtCQUFrQixDQUFDLGFBQWEsR0FBRyxTQUFTLENBVzlFLENBQUM7QUFFRjs7R0FFRztBQUNILHdCQUFnQixnQkFBZ0IsSUFBSSxhQUFhLEdBQUcsU0FBUyxDQVE1RCJ9

package/dest/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AACD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,uDAAuD;IACvD,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,kBAAkB,GAAG,cAAc,GAAG,eAAe,GAAG,WAAW,CAAC;AAE/G,MAAM,MAAM,aAAa,GAAG;IAC1B,wDAAwD;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,gBAAgB,CA0BlE,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD;AAED,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,CAclE,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,GAAG,gBAAgB,CAUrF,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,gBAAgB,CAQnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,yFAAyF;IACzF,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,SAAS,GAAG,kBAAkB,GAAG,eAAe,GAAG,WAAW,GAAG,kBAAkB,CAAC;AAEhG,MAAM,MAAM,aAAa,GAAG;IAC1B,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,SAAS,CAoB3D,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAED,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,CAKlE,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,GAAG,SAAS,CAW9E,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,SAAS,CAQ5D"}

package/dest/config/index.js

@@ -1,4 +1,3 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { booleanConfigHelper, getConfigFromMappings, numberConfigHelper, parseBooleanEnv } from '@aztec/foundation/config';
 import { dataConfigMappings } from '@aztec/kv-store/config';
 import { chainConfigMappings } from '@aztec/stdlib/config';
@@ -6,45 +5,30 @@ export { getPackageInfo } from './package_info.js';
 export const pxeConfigMappings = {
     ...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()
+    l2BlockBatchSize: {
+        env: 'PXE_L2_BLOCK_BATCH_SIZE',
+        ...numberConfigHelper(50),
+        description: 'Maximum amount of blocks to pull from the stream in one request when synchronizing'
     },
+    // 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',
-        ...booleanConfigHelper()
+        ...booleanConfigHelper(true)
     }
 };
 /**
- * Creates an instance of PXEServiceConfig out of environment variables using sensible defaults for integration testing if not set.
- */ export function getPXEServiceConfig() {
+ * Creates an instance of PXEConfig out of environment variables using sensible defaults for integration testing if not set.
+ */ export function getPXEConfig() {
     return getConfigFromMappings(pxeConfigMappings);
 }
 export const pxeCliConfigMappings = {
-    network: {
-        env: 'NETWORK',
-        parseEnv: (val)=>val,
-        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'
@@ -58,17 +42,18 @@ export const allPxeConfigMappings = {
         env: 'PXE_PROVER_ENABLED',
         parseEnv: (val)=>parseBooleanEnv(val) || !!process.env.NETWORK,
         description: 'Enable real proofs',
-        isBoolean: true
+        isBoolean: true,
+        defaultValue: true
     }
 };
 /**
  * Creates an instance of CliPxeOptions out of environment variables
  */ export function getCliPXEOptions() {
-    const pxeConfig = getPXEServiceConfig();
+    const pxeConfig = getPXEConfig();
     const cliOptions = getConfigFromMappings(pxeCliConfigMappings);
     return {
         ...pxeConfig,
         ...cliOptions,
-        proverEnabled: pxeConfig.proverEnabled || !!cliOptions.network
+        proverEnabled: pxeConfig.proverEnabled
     };
 }

package/dest/config/package_info.d.ts

@@ -2,4 +2,4 @@ export declare function getPackageInfo(): {
     version: string;
     name: string;
 };
-//# sourceMappingURL=package_info.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZV9pbmZvLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL3BhY2thZ2VfaW5mby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3QkFBZ0IsY0FBYzs7O0VBRTdCIn0=

package/dest/config/package_info.js

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

package/dest/contract_function_simulator/contract_function_simulator.d.ts

@@ -0,0 +1,56 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type CircuitSimulator } from '@aztec/simulator/client';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type PrivateKernelExecutionProofOutput, PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import { PrivateExecutionResult, TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { ContractDataProvider } from '../storage/index.js';
+import type { ExecutionDataProvider } from './execution_data_provider.js';
+/**
+ * The contract function simulator.
+ */
+export declare class ContractFunctionSimulator {
+    private executionDataProvider;
+    private simulator;
+    private log;
+    constructor(executionDataProvider: ExecutionDataProvider, simulator: CircuitSimulator);
+    /**
+     * Runs a private function.
+     * @param request - The transaction request.
+     * @param entryPointArtifact - The artifact of the entry point function.
+     * @param contractAddress - The address of the contract (should match request.origin)
+     * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract
+     * or a specific account.
+     * @param senderForTags - The address that is used as a tagging sender when emitting private logs. Returned from
+     * the `privateGetSenderForTags` oracle.
+     * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
+     * @returns The result of the execution.
+     */
+    run(request: TxExecutionRequest, contractAddress: AztecAddress, selector: FunctionSelector, msgSender?: AztecAddress, senderForTags?: AztecAddress, scopes?: AztecAddress[]): Promise<PrivateExecutionResult>;
+    /**
+     * Runs a utility function.
+     * @param call - The function call to execute.
+     * @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 return value of the utility function in a form as returned by the simulator (Noir fields)
+     */
+    runUtility(call: FunctionCall, authwits: AuthWitness[], scopes?: AztecAddress[]): Promise<Fr[]>;
+    getStats(): import("./execution_data_provider.js").ExecutionStats;
+}
+/**
+ * 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
+ * output that can be sent to the node for public simulation
+ * @param privateExecutionResult - The result of the private execution.
+ * @param nonceGenerator - A nonce generator for note hashes. According to the protocol rules,
+ * it can either be the first nullifier in the tx or the hash of the initial tx request if there are none.
+ * @param contractDataProvider - A provider for contract data in order to get function names and debug info.
+ * @returns The simulated proving result.
+ */
+export declare function generateSimulatedProvingResult(privateExecutionResult: PrivateExecutionResult, nonceGenerator: Fr, contractDataProvider: ContractDataProvider): Promise<PrivateKernelExecutionProofOutput<PrivateKernelTailCircuitPublicInputs>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfZnVuY3Rpb25fc2ltdWxhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3RfZnVuY3Rpb25fc2ltdWxhdG9yL2NvbnRyYWN0X2Z1bmN0aW9uX3NpbXVsYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFvQkEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBSzlDLE9BQU8sRUFDTCxLQUFLLGdCQUFnQixFQU90QixNQUFNLHlCQUF5QixDQUFDO0FBQ2pDLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxnQkFBZ0IsRUFBZ0IsTUFBTSxtQkFBbUIsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFTM0QsT0FBTyxFQUlMLEtBQUssaUNBQWlDLEVBQ3RDLG9DQUFvQyxFQUtyQyxNQUFNLHNCQUFzQixDQUFDO0FBSTlCLE9BQU8sRUFHTCxzQkFBc0IsRUFFdEIsa0JBQWtCLEVBR25CLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIsT0FBTyxLQUFLLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBUzFFOztHQUVHO0FBQ0gscUJBQWEseUJBQXlCO0lBSWxDLE9BQU8sQ0FBQyxxQkFBcUI7SUFDN0IsT0FBTyxDQUFDLFNBQVM7SUFKbkIsT0FBTyxDQUFDLEdBQUcsQ0FBUztJQUVwQixZQUNVLHFCQUFxQixFQUFFLHFCQUFxQixFQUM1QyxTQUFTLEVBQUUsZ0JBQWdCLEVBR3BDO0lBRUQ7Ozs7Ozs7Ozs7O09BV0c7SUFDVSxHQUFHLENBQ2QsT0FBTyxFQUFFLGtCQUFrQixFQUMzQixlQUFlLEVBQUUsWUFBWSxFQUM3QixRQUFRLEVBQUUsZ0JBQWdCLEVBQzFCLFNBQVMsZUFBNkMsRUFDdEQsYUFBYSxDQUFDLEVBQUUsWUFBWSxFQUM1QixNQUFNLENBQUMsRUFBRSxZQUFZLEVBQUUsR0FDdEIsT0FBTyxDQUFDLHNCQUFzQixDQUFDLENBZ0dqQztJQUdEOzs7Ozs7O09BT0c7SUFDVSxVQUFVLENBQUMsSUFBSSxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsV0FBVyxFQUFFLEVBQUUsTUFBTSxDQUFDLEVBQUUsWUFBWSxFQUFFLEdBQUcsT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBc0MzRztJQUdELFFBQVEsMERBRVA7Q0FDRjtBQVlEOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsd0JBQXNCLDhCQUE4QixDQUNsRCxzQkFBc0IsRUFBRSxzQkFBc0IsRUFDOUMsY0FBYyxFQUFFLEVBQUUsRUFDbEIsb0JBQW9CLEVBQUUsb0JBQW9CLEdBQ3pDLE9BQU8sQ0FBQyxpQ0FBaUMsQ0FBQyxvQ0FBb0MsQ0FBQyxDQUFDLENBZ05sRiJ9

package/dest/contract_function_simulator/contract_function_simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_function_simulator.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/contract_function_simulator.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAK9C,OAAO,EACL,KAAK,gBAAgB,EAOtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAgB,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAS3D,OAAO,EAIL,KAAK,iCAAiC,EACtC,oCAAoC,EAKrC,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAGL,sBAAsB,EAEtB,kBAAkB,EAGnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAS1E;;GAEG;AACH,qBAAa,yBAAyB;IAIlC,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,SAAS;IAJnB,OAAO,CAAC,GAAG,CAAS;IAEpB,YACU,qBAAqB,EAAE,qBAAqB,EAC5C,SAAS,EAAE,gBAAgB,EAGpC;IAED;;;;;;;;;;;OAWG;IACU,GAAG,CACd,OAAO,EAAE,kBAAkB,EAC3B,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,eAA6C,EACtD,aAAa,CAAC,EAAE,YAAY,EAC5B,MAAM,CAAC,EAAE,YAAY,EAAE,GACtB,OAAO,CAAC,sBAAsB,CAAC,CAgGjC;IAGD;;;;;;;OAOG;IACU,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAsC3G;IAGD,QAAQ,0DAEP;CACF;AAYD;;;;;;;;;;;GAWG;AACH,wBAAsB,8BAA8B,CAClD,sBAAsB,EAAE,sBAAsB,EAC9C,cAAc,EAAE,EAAE,EAClB,oBAAoB,EAAE,oBAAoB,GACzC,OAAO,CAAC,iCAAiC,CAAC,oCAAoC,CAAC,CAAC,CAgNlF"}

package/dest/contract_function_simulator/contract_function_simulator.js

@@ -0,0 +1,300 @@
+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, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
+import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { ExecutionError, createSimulationError, extractCallStack, resolveAssertionMessageFromError, toACVMWitness, witnessMapToFields } from '@aztec/simulator/client';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Gas } from '@aztec/stdlib/gas';
+import { computeNoteHashNonce, computeProtocolNullifier, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { PartialPrivateTailPublicInputsForPublic, PartialPrivateTailPublicInputsForRollup, PrivateKernelTailCircuitPublicInputs, PrivateToPublicAccumulatedData, PrivateToRollupAccumulatedData, PublicCallRequest, ScopedLogHash } from '@aztec/stdlib/kernel';
+import { PrivateLog } from '@aztec/stdlib/logs';
+import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { CallContext, HashedValues, PrivateExecutionResult, TxConstantData, collectNested, getFinalMinRevertibleSideEffectCounter } from '@aztec/stdlib/tx';
+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';
+import { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
+import { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
+/**
+ * The contract function simulator.
+ */ export class ContractFunctionSimulator {
+    executionDataProvider;
+    simulator;
+    log;
+    constructor(executionDataProvider, simulator){
+        this.executionDataProvider = executionDataProvider;
+        this.simulator = simulator;
+        this.log = createLogger('simulator');
+    }
+    /**
+   * Runs a private function.
+   * @param request - The transaction request.
+   * @param entryPointArtifact - The artifact of the entry point function.
+   * @param contractAddress - The address of the contract (should match request.origin)
+   * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract
+   * or a specific account.
+   * @param senderForTags - The address that is used as a tagging sender when emitting private logs. Returned from
+   * the `privateGetSenderForTags` oracle.
+   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
+   * @returns The result of the execution.
+   */ async run(request, contractAddress, selector, msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE), senderForTags, scopes) {
+        const simulatorSetupTimer = new Timer();
+        const anchorBlockHeader = await this.executionDataProvider.getAnchorBlockHeader();
+        await verifyCurrentClassId(contractAddress, this.executionDataProvider);
+        const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
+        if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
+            throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
+        }
+        if (request.origin !== contractAddress) {
+            this.log.warn(`Request origin does not match contract address in simulation. Request origin: ${request.origin}, contract address: ${contractAddress}`);
+        }
+        // reserve the first side effect for the tx hash (inserted by the private kernel)
+        const startSideEffectCounter = 2;
+        const callContext = new CallContext(msgSender, contractAddress, await FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters), entryPointArtifact.isStatic);
+        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, anchorBlockHeader, request.authWitnesses, request.capsules, HashedValuesCache.create(request.argsOfCalls), noteCache, taggingIndexCache, this.executionDataProvider, 0, startSideEffectCounter, undefined, scopes, senderForTags, this.simulator);
+        const setupTime = simulatorSetupTimer.ms();
+        try {
+            // Note: any nested private function calls are made recursively within this
+            // function call. So this execution result is the result of executing _all_
+            // private functions of this tx (the results of those executions are contained
+            // within executionResult.nestedExecutionResults).
+            const executionResult = await executePrivateFunction(this.simulator, privateExecutionOracle, entryPointArtifact, contractAddress, request.functionSelector);
+            const simulatorTeardownTimer = new Timer();
+            const { usedProtocolNullifierForNonces } = noteCache.finish();
+            const firstNullifierHint = usedProtocolNullifierForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
+            const publicCallRequests = collectNested([
+                executionResult
+            ], (r)=>r.publicInputs.publicCallRequests.getActiveItems().map((r)=>r.inner).concat(r.publicInputs.publicTeardownCallRequest.isEmpty() ? [] : [
+                    r.publicInputs.publicTeardownCallRequest
+                ]));
+            const publicFunctionsCalldata = await Promise.all(publicCallRequests.map(async (r)=>{
+                const calldata = await privateExecutionOracle.privateLoadFromExecutionCache(r.calldataHash);
+                return new HashedValues(calldata, r.calldataHash);
+            }));
+            const teardownTime = simulatorTeardownTimer.ms();
+            // Add simulator overhead to topmost call in the stack
+            if (executionResult.profileResult) {
+                executionResult.profileResult.timings.witgen += setupTime + teardownTime;
+            }
+            // Not to be confused with a PrivateCallExecutionResult. This is a superset
+            // of the PrivateCallExecutionResult, containing also firstNullifierHint
+            // and publicFunctionsCalldata.
+            return new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
+        } catch (err) {
+            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
+        }
+    }
+    // docs:start:execute_utility_function
+    /**
+   * Runs a utility function.
+   * @param call - The function call to execute.
+   * @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 return value of the utility function in a form as returned by the simulator (Noir fields)
+   */ async runUtility(call, authwits, scopes) {
+        await verifyCurrentClassId(call.to, this.executionDataProvider);
+        const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(call.to, call.selector);
+        if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
+            throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
+        }
+        const oracle = new UtilityExecutionOracle(call.to, authwits, [], this.executionDataProvider, undefined, scopes);
+        try {
+            this.log.verbose(`Executing utility function ${entryPointArtifact.name}`, {
+                contract: call.to,
+                selector: call.selector
+            });
+            const initialWitness = toACVMWitness(0, call.args);
+            const acirExecutionResult = await this.simulator.executeUserCircuit(initialWitness, entryPointArtifact, new Oracle(oracle).toACIRCallback()).catch((err)=>{
+                err.message = resolveAssertionMessageFromError(err, entryPointArtifact);
+                throw new ExecutionError(err.message, {
+                    contractAddress: call.to,
+                    functionSelector: call.selector
+                }, extractCallStack(err, entryPointArtifact.debug), {
+                    cause: err
+                });
+            });
+            this.log.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
+            return witnessMapToFields(acirExecutionResult.returnWitness);
+        } catch (err) {
+            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
+        }
+    }
+    // docs:end:execute_utility_function
+    getStats() {
+        return this.executionDataProvider.getStats();
+    }
+}
+class OrderedSideEffect {
+    sideEffect;
+    counter;
+    constructor(sideEffect, counter){
+        this.sideEffect = sideEffect;
+        this.counter = counter;
+    }
+}
+/**
+ * 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
+ * output that can be sent to the node for public simulation
+ * @param privateExecutionResult - The result of the private execution.
+ * @param nonceGenerator - A nonce generator for note hashes. According to the protocol rules,
+ * it can either be the first nullifier in the tx or the hash of the initial tx request if there are none.
+ * @param contractDataProvider - A provider for contract data in order to get function names and debug info.
+ * @returns The simulated proving result.
+ */ export async function generateSimulatedProvingResult(privateExecutionResult, nonceGenerator, contractDataProvider) {
+    const siloedNoteHashes = [];
+    const nullifiers = [];
+    const taggedPrivateLogs = [];
+    const l2ToL1Messages = [];
+    const contractClassLogsHashes = [];
+    const publicCallRequests = [];
+    const executionSteps = [];
+    let publicTeardownCallRequest;
+    const executions = [
+        privateExecutionResult.entrypoint
+    ];
+    while(executions.length !== 0){
+        const execution = executions.shift();
+        executions.unshift(...execution.nestedExecutionResults);
+        const { contractAddress } = execution.publicInputs.callContext;
+        const noteHashesFromExecution = await Promise.all(execution.publicInputs.noteHashes.getActiveItems().filter((noteHash)=>!noteHash.isEmpty()).map(async (noteHash)=>new OrderedSideEffect(await siloNoteHash(contractAddress, noteHash.value), noteHash.counter)));
+        const nullifiersFromExecution = await Promise.all(execution.publicInputs.nullifiers.getActiveItems().map(async (nullifier)=>new OrderedSideEffect(await siloNullifier(contractAddress, nullifier.value), nullifier.counter)));
+        const privateLogsFromExecution = await Promise.all(execution.publicInputs.privateLogs.getActiveItems().map(async (metadata)=>{
+            metadata.log.fields[0] = await poseidon2Hash([
+                contractAddress,
+                metadata.log.fields[0]
+            ]);
+            return new OrderedSideEffect(metadata.log, metadata.counter);
+        }));
+        siloedNoteHashes.push(...noteHashesFromExecution);
+        taggedPrivateLogs.push(...privateLogsFromExecution);
+        nullifiers.push(...nullifiersFromExecution);
+        l2ToL1Messages.push(...execution.publicInputs.l2ToL1Msgs.getActiveItems().map((message)=>new OrderedSideEffect(message.message.scope(contractAddress), message.counter)));
+        contractClassLogsHashes.push(...execution.publicInputs.contractClassLogsHashes.getActiveItems().map((contractClassLogHash)=>new OrderedSideEffect(contractClassLogHash.logHash.scope(contractAddress), contractClassLogHash.counter)));
+        publicCallRequests.push(...execution.publicInputs.publicCallRequests.getActiveItems().map((callRequest)=>new OrderedSideEffect(callRequest.inner, callRequest.counter)));
+        if (publicTeardownCallRequest !== undefined && !execution.publicInputs.publicTeardownCallRequest.isEmpty()) {
+            throw new Error('Trying to set multiple teardown requests');
+        }
+        publicTeardownCallRequest = execution.publicInputs.publicTeardownCallRequest.isEmpty() ? publicTeardownCallRequest : execution.publicInputs.publicTeardownCallRequest;
+        executionSteps.push({
+            functionName: await contractDataProvider.getDebugFunctionName(execution.publicInputs.callContext.contractAddress, execution.publicInputs.callContext.functionSelector),
+            timings: execution.profileResult?.timings ?? {
+                witgen: 0,
+                oracles: {}
+            },
+            bytecode: execution.acir,
+            vk: execution.vk,
+            witness: execution.partialWitness
+        });
+    }
+    const constantData = new TxConstantData(privateExecutionResult.entrypoint.publicInputs.anchorBlockHeader, privateExecutionResult.entrypoint.publicInputs.txContext, getVKTreeRoot(), protocolContractsHash);
+    const hasPublicCalls = privateExecutionResult.publicFunctionCalldata.length !== 0;
+    let inputsForRollup;
+    let inputsForPublic;
+    let gasUsed;
+    const sortByCounter = (a, b)=>a.counter - b.counter;
+    const getEffect = (orderedSideEffect)=>orderedSideEffect.sideEffect;
+    const isPrivateOnlyTx = privateExecutionResult.publicFunctionCalldata.length === 0;
+    const minRevertibleSideEffectCounter = getFinalMinRevertibleSideEffectCounter(privateExecutionResult);
+    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);
+    }
+    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)=>{
+            const siloedNoteHash = orderedSideEffect.sideEffect;
+            const nonce = await computeNoteHashNonce(nonceGenerator, i);
+            const uniqueNoteHash = await computeUniqueNoteHash(nonce, siloedNoteHash);
+            return uniqueNoteHash;
+        }));
+        const accumulatedDataForRollup = new PrivateToRollupAccumulatedData(padArrayEnd(uniqueNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX), padArrayEnd(nonRevertibleNullifiers.concat(revertibleNullifiers), 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));
+        gasUsed = meterGasUsed(accumulatedDataForRollup);
+        inputsForRollup = new PartialPrivateTailPublicInputsForRollup(accumulatedDataForRollup);
+    } else {
+        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);
+        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(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, revertibleData, publicTeardownCallRequest ?? PublicCallRequest.empty());
+    }
+    const publicInputs = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ gasUsed.add(Gas.from({
+        l2Gas: FIXED_L2_GAS,
+        daGas: FIXED_DA_GAS
+    })), /*feePayer=*/ AztecAddress.zero(), /*includeByTimestamp=*/ 0n, hasPublicCalls ? inputsForPublic : undefined, !hasPublicCalls ? inputsForRollup : undefined);
+    return {
+        publicInputs,
+        chonkProof: ChonkProof.empty(),
+        executionSteps
+    };
+}
+function splitOrderedSideEffects(effects, minRevertibleSideEffectCounter) {
+    const revertibleSideEffects = [];
+    const nonRevertibleSideEffects = [];
+    effects.forEach((effect)=>{
+        if (effect.counter < minRevertibleSideEffectCounter) {
+            nonRevertibleSideEffects.push(effect.sideEffect);
+        } else {
+            revertibleSideEffects.push(effect.sideEffect);
+        }
+    });
+    return [
+        nonRevertibleSideEffects,
+        revertibleSideEffects
+    ];
+}
+function meterGasUsed(data) {
+    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.publicCallRequests) {
+        const dataForPublic = data;
+        const numPublicCallRequests = arrayNonEmptyLength(dataForPublic.publicCallRequests, (req)=>req.isEmpty());
+        meteredL2Gas += numPublicCallRequests * FIXED_AVM_STARTUP_L2_GAS;
+    }
+    return Gas.from({
+        l2Gas: meteredL2Gas,
+        daGas: meteredDAGas
+    });
+}