@aztec/pxe 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/dest/bin/check_oracle_version.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=check_oracle_version.d.ts.map

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,29 @@
+import { keccak256String } from '@aztec/foundation/crypto';
+import deterministicStringify from 'json-stringify-deterministic';
+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.
+ *
+ * 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 oracle = new Oracle(new OracleMock());
+    // We use keccak256 here just because we already have it in the dependencies.
+    const oracleInterfaceHash = keccak256String(deterministicStringify(oracle.toACIRCallback()));
+    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.`);
+    }
+}
+assertOracleInterfaceMatches();

package/dest/bin/index.js

@@ -1,11 +1,31 @@
 #!/usr/bin/env -S node --no-warnings
+import { createNamespacedSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 import { createLogger } from '@aztec/foundation/log';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import { PXESchema, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import http from 'http';
 import { getPXEServiceConfig } from '../config/index.js';
 import { createPXEService } from '../entrypoints/server/utils.js';
-import { startPXEHttpServer } from '../pxe_http/index.js';
 const { PXE_PORT = 8080, AZTEC_NODE_URL = 'http://localhost:8079' } = process.env;
 const logger = createLogger('pxe:service');
+/**
+ * Creates an http server that forwards calls to the PXE and starts it on the given port.
+ * @param pxeService - PXE that answers queries to the created HTTP server.
+ * @param port - Port to listen in.
+ * @param maxBatchSize - Maximum allowed batch size for JSON RPC batch requests.
+ * @returns A running http server.
+ */ function startPXEHttpServer(pxeService, port, opts = {}) {
+    const rpcServer = createNamespacedSafeJsonRpcServer({
+        pxe: [
+            pxeService,
+            PXESchema
+        ]
+    }, opts);
+    const app = rpcServer.getApp();
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    const httpServer = http.createServer(app.callback());
+    httpServer.listen(port);
+    return httpServer;
+}
 /**
  * Create and start a new PXE HTTP Server
  */ async function main() {

package/dest/config/index.d.ts

@@ -1,7 +1,6 @@
 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
@@ -22,15 +21,11 @@ export interface KernelProverConfig {
  * Configuration settings for the PXE.
  */
 export interface PXEConfig {
-    /** L2 block to start scanning from for new accounts */
-    l2StartingBlock: number;
+    /** 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 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;
 };

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,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,yFAAyF;IACzF,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,kBAAkB,GAAG,cAAc,GAAG,eAAe,GAAG,WAAW,CAAC;AAE/G,MAAM,MAAM,aAAa,GAAG;IAC1B,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,CAKlE,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,GAAG,gBAAgB,CAWrF,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,gBAAgB,CAQnE"}

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,10 +5,10 @@ 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'
+    l2BlockBatchSize: {
+        env: 'PXE_L2_BLOCK_BATCH_SIZE',
+        ...numberConfigHelper(50),
+        description: 'Maximum amount of blocks to pull from the stream in one request when synchronizing'
     },
     bbBinaryPath: {
         env: 'BB_BINARY_PATH',
@@ -27,7 +26,7 @@ export const pxeConfigMappings = {
     proverEnabled: {
         env: 'PXE_PROVER_ENABLED',
         description: 'Enable real proofs',
-        ...booleanConfigHelper()
+        ...booleanConfigHelper(true)
     }
 };
 /**
@@ -36,15 +35,6 @@ export const pxeConfigMappings = {
     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,7 +48,8 @@ export const allPxeConfigMappings = {
         env: 'PXE_PROVER_ENABLED',
         parseEnv: (val)=>parseBooleanEnv(val) || !!process.env.NETWORK,
         description: 'Enable real proofs',
-        isBoolean: true
+        isBoolean: true,
+        defaultValue: true
     }
 };
 /**
@@ -69,6 +60,6 @@ export const allPxeConfigMappings = {
     return {
         ...pxeConfig,
         ...cliOptions,
-        proverEnabled: pxeConfig.proverEnabled || !!cliOptions.network
+        proverEnabled: pxeConfig.proverEnabled
     };
 }

package/dest/config/package_info.js

@@ -1,6 +1,6 @@
 export function getPackageInfo() {
     return {
-        version: '0.1.0',
+        version: '2.1.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 { AbiDecoded, 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 decoded ABI value containing the function's return data.
+     */
+    runUtility(call: FunctionCall, authwits: AuthWitness[], scopes?: AztecAddress[]): Promise<AbiDecoded>;
+    getStats(): import("./execution_data_provider.js").ExecutionStats;
+}
+/**
+ * Generates the final public inputs of the tail kernel circuit, an empty ClientIVC 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=contract_function_simulator.d.ts.map

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":"AAUA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAK9C,OAAO,EACL,KAAK,gBAAgB,EAOtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAA+B,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAG3D,OAAO,EAIL,KAAK,iCAAiC,EACtC,oCAAoC,EAKrC,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAGL,sBAAsB,EAEtB,kBAAkB,EAEnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAQ1E;;GAEG;AACH,qBAAa,yBAAyB;IAIlC,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,SAAS;IAJnB,OAAO,CAAC,GAAG,CAAS;gBAGV,qBAAqB,EAAE,qBAAqB,EAC5C,SAAS,EAAE,gBAAgB;IAKrC;;;;;;;;;;;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;IAiGlC;;;;;;;OAOG;IACU,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IA0ClH,QAAQ;CAGT;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,CA+LlF"}

package/dest/contract_function_simulator/contract_function_simulator.js

@@ -0,0 +1,245 @@
+import { 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 { 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 { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { ExecutionError, createSimulationError, extractCallStack, resolveAssertionMessageFromError, toACVMWitness, witnessMapToFields } from '@aztec/simulator/client';
+import { FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Gas } from '@aztec/stdlib/gas';
+import { computeNoteHashNonce, 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 { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { CallContext, HashedValues, PrivateExecutionResult, TxConstantData, collectNested } from '@aztec/stdlib/tx';
+import { ExecutionNoteCache } from './execution_note_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 header = await this.executionDataProvider.getBlockHeader();
+        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 = 1;
+        const callContext = new CallContext(msgSender, contractAddress, await FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters), entryPointArtifact.isStatic);
+        const txRequestHash = await request.toTxRequest().hash();
+        const noteCache = new ExecutionNoteCache(txRequestHash);
+        const privateExecutionOracle = new PrivateExecutionOracle(request.firstCallArgsHash, request.txContext, callContext, header, request.authWitnesses, request.capsules, HashedValuesCache.create(request.argsOfCalls), noteCache, this.executionDataProvider, this.simulator, 0, startSideEffectCounter, undefined, scopes, senderForTags);
+        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 { usedTxRequestHashForNonces } = noteCache.finish();
+            const firstNullifierHint = usedTxRequestHashForNonces ? 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 decoded ABI value containing the function's return data.
+   */ 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
+                });
+            });
+            const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
+            this.log.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
+            return decodeFromAbi(entryPointArtifact.returnTypes, 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 ClientIVC 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.historicalHeader, privateExecutionResult.entrypoint.publicInputs.txContext, getVKTreeRoot(), protocolContractTreeRoot);
+    const hasPublicCalls = privateExecutionResult.publicFunctionCalldata.length !== 0;
+    let inputsForRollup;
+    let inputsForPublic;
+    const sortByCounter = (a, b)=>a.counter - b.counter;
+    const getEffect = (orderedSideEffect)=>orderedSideEffect.sideEffect;
+    const sortedNullifiers = nullifiers.sort(sortByCounter).map(getEffect);
+    // 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);
+    }
+    // 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
+        // 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(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));
+        inputsForRollup = new PartialPrivateTailPublicInputsForRollup(accumulatedDataForRollup);
+    } else {
+        const nonRevertibleData = PrivateToPublicAccumulatedData.empty();
+        // 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 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));
+        inputsForPublic = new PartialPrivateTailPublicInputsForPublic(nonRevertibleData, revertibleData, publicTeardownCallRequest ?? PublicCallRequest.empty());
+    }
+    const publicInputs = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ new Gas(0, 0), /*feePayer=*/ AztecAddress.zero(), /*includeByTimestamp=*/ 0n, hasPublicCalls ? inputsForPublic : undefined, !hasPublicCalls ? inputsForRollup : undefined);
+    return {
+        publicInputs,
+        clientIvcProof: ClientIvcProof.empty(),
+        executionSteps: executionSteps
+    };
+}