@aztec/pxe 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/contract_function_simulator/contract_function_simulator.js

@@ -1,68 +1,137 @@
-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 { CircuitKind } from '@aztec/bb.js';
+import { AVM_EMITNOTEHASH_BASE_L2_GAS, AVM_EMITNULLIFIER_BASE_L2_GAS, AVM_SENDL2TOL1MSG_BASE_L2_GAS, DA_GAS_PER_FIELD, FIXED_AVM_STARTUP_L2_GAS, L2_GAS_PER_CONTRACT_CLASS_LOG, L2_GAS_PER_L2_TO_L1_MSG, L2_GAS_PER_NOTE_HASH, L2_GAS_PER_NULLIFIER, 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_NOTE_HASH_READ_REQUESTS_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, MAX_TX_LIFETIME, PRIVATE_TX_L2_GAS_OVERHEAD, PUBLIC_DATA_WRITE_LENGTH, PUBLIC_TX_L2_GAS_OVERHEAD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
 import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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, decodeFromAbi } from '@aztec/stdlib/abi';
+import { FunctionSelector, FunctionType } 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 { computeNoteHashNonce, computeProtocolNullifier, computeSiloedPrivateLogFirstField, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { ClaimedLengthArray, PartialPrivateTailPublicInputsForPublic, PartialPrivateTailPublicInputsForRollup, PrivateKernelTailCircuitPublicInputs, PrivateToPublicAccumulatedData, PrivateToRollupAccumulatedData, PublicCallRequest, ReadRequestActionEnum, ScopedLogHash, ScopedNoteHash, ScopedNullifier, ScopedReadRequest, buildTransientDataHints, getNoteHashReadRequestResetActions, getNullifierReadRequestResetActions } 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 { MerkleTreeId } from '@aztec/stdlib/trees';
+import { CallContext, HashedValues, PrivateExecutionResult, TxConstantData, collectNested, collectNoteHashNullifierCounterMap, getFinalMinRevertibleSideEffectCounter } from '@aztec/stdlib/tx';
+import { CapsuleService } from '../storage/capsule_store/capsule_service.js';
+import { FactService } from '../storage/fact_store/index.js';
+import { AnchoredContractData } from './anchored_contract_data.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';
+import { buildACIRCallback } from './oracle/acir_callback.js';
+import { executePrivateFunction } from './oracle/private_execution.js';
 import { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
 import { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
+import { TransientArrayService } from './transient_array_service.js';
 /**
  * The contract function simulator.
  */ export class ContractFunctionSimulator {
-    executionDataProvider;
-    simulator;
     log;
-    constructor(executionDataProvider, simulator){
-        this.executionDataProvider = executionDataProvider;
-        this.simulator = simulator;
+    contractStore;
+    contractClassService;
+    overrides;
+    noteStore;
+    keyStore;
+    addressStore;
+    aztecNode;
+    l2TipsStore;
+    senderTaggingStore;
+    recipientTaggingStore;
+    taggingSecretSourcesStore;
+    capsuleStore;
+    factStore;
+    privateEventStore;
+    simulator;
+    contractSyncService;
+    txResolver;
+    hooks;
+    constructor(args){
+        this.contractStore = args.contractStore;
+        this.contractClassService = args.contractClassService;
+        this.overrides = args.overrides;
+        this.noteStore = args.noteStore;
+        this.keyStore = args.keyStore;
+        this.addressStore = args.addressStore;
+        this.aztecNode = args.aztecNode;
+        this.l2TipsStore = args.l2TipsStore;
+        this.senderTaggingStore = args.senderTaggingStore;
+        this.recipientTaggingStore = args.recipientTaggingStore;
+        this.taggingSecretSourcesStore = args.taggingSecretSourcesStore;
+        this.capsuleStore = args.capsuleStore;
+        this.factStore = args.factStore;
+        this.privateEventStore = args.privateEventStore;
+        this.simulator = args.simulator;
+        this.contractSyncService = args.contractSyncService;
+        this.txResolver = args.txResolver;
+        this.hooks = args.hooks;
         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) {
+   */ async run(request, { msgSender = AztecAddress.NULL_MSG_SENDER, anchorBlockHeader, senderForTags, scopes, jobId }) {
         const simulatorSetupTimer = new Timer();
-        const anchorBlockHeader = await this.executionDataProvider.getAnchorBlockHeader();
-        await verifyCurrentClassId(contractAddress, this.executionDataProvider);
-        const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
+        const contractAddress = request.origin;
+        const anchoredContractData = new AnchoredContractData(this.contractStore, this.contractClassService, anchorBlockHeader, this.overrides);
+        const entryPointArtifact = await anchoredContractData.getFunctionArtifactWithDebugMetadata(contractAddress, request.functionSelector);
+        if (!entryPointArtifact) {
+            throw new Error(`Cannot run function ${request.functionSelector} on ${contractAddress}: the contract is not registered. ` + `Register it via wallet.registerContract(...).`);
+        }
         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 startSideEffectCounter = 2;
         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 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);
+        // One shared transient store for the whole execution tree rooted at this transaction. Threaded into every child
+        // private oracle and inherited by nested utility frames, so that frames of the same contract see each other's
+        // transient arrays, then discarded when run() returns.
+        const transientArrayService = new TransientArrayService();
+        const privateExecutionOracle = new PrivateExecutionOracle({
+            argsHash: request.firstCallArgsHash,
+            txContext: request.txContext,
+            txRequestSalt: request.salt,
+            callContext,
+            anchorBlockHeader,
+            utilityExecutor: async (call, execScopes)=>{
+                await this.runUtility(call, [], anchorBlockHeader, execScopes, jobId);
+            },
+            authWitnesses: request.authWitnesses,
+            capsules: request.capsules,
+            executionCache: HashedValuesCache.create(request.argsOfCalls),
+            noteCache,
+            taggingIndexCache,
+            anchoredContractData,
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: this.aztecNode,
+            senderTaggingStore: this.senderTaggingStore,
+            recipientTaggingStore: this.recipientTaggingStore,
+            taggingSecretSourcesStore: this.taggingSecretSourcesStore,
+            capsuleService: new CapsuleService(this.capsuleStore, scopes),
+            factService: new FactService(this.factStore, scopes),
+            privateEventStore: this.privateEventStore,
+            txResolver: this.txResolver,
+            contractSyncService: this.contractSyncService,
+            jobId,
+            totalPublicCalldataCount: 0,
+            sideEffectCounter: startSideEffectCounter,
+            scopes,
+            senderForTags,
+            simulator: this.simulator,
+            l2TipsStore: this.l2TipsStore,
+            hooks: this.hooks,
+            transientArrayService
+        });
         const setupTime = simulatorSetupTimer.ms();
         try {
             // Note: any nested private function calls are made recursively within this
@@ -71,15 +140,14 @@ import { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
             // 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 firstNullifierHint = noteCache.getNonceGenerator();
             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);
+                const calldata = await privateExecutionOracle.getHashPreimage(r.calldataHash);
                 return new HashedValues(calldata, r.calldataHash);
             }));
             const teardownTime = simulatorTeardownTimer.ms();
@@ -95,28 +163,60 @@ import { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
             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);
+   * @returns A return value of the utility function in a form as returned by the simulator (Noir fields)
+   */ async runUtility(call, authwits, anchorBlockHeader, scopes, jobId) {
+        const anchoredContractData = new AnchoredContractData(this.contractStore, this.contractClassService, anchorBlockHeader, this.overrides);
+        const entryPointArtifact = await anchoredContractData.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+        if (!entryPointArtifact) {
+            throw new Error(`Cannot run function ${call.selector} on ${call.to}: the contract is not registered. ` + `Register it via wallet.registerContract(...).`);
+        }
         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);
+        const utilityExecutor = async (syncCall, execScopes)=>{
+            await this.runUtility(syncCall, [], anchorBlockHeader, execScopes, jobId);
+        };
+        const oracle = new UtilityExecutionOracle({
+            callContext: CallContext.from({
+                msgSender: AztecAddress.NULL_MSG_SENDER,
+                contractAddress: call.to,
+                functionSelector: call.selector,
+                isStaticCall: true
+            }),
+            authWitnesses: authwits,
+            capsules: [],
+            anchorBlockHeader,
+            anchoredContractData,
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: this.aztecNode,
+            recipientTaggingStore: this.recipientTaggingStore,
+            taggingSecretSourcesStore: this.taggingSecretSourcesStore,
+            capsuleService: new CapsuleService(this.capsuleStore, scopes),
+            factService: new FactService(this.factStore, scopes),
+            privateEventStore: this.privateEventStore,
+            txResolver: this.txResolver,
+            contractSyncService: this.contractSyncService,
+            l2TipsStore: this.l2TipsStore,
+            jobId,
+            scopes,
+            simulator: this.simulator,
+            hooks: this.hooks,
+            utilityExecutor,
+            // Execution-tree root (top-level utility run or contract sync): own store; nested frames inherit it.
+            transientArrayService: new TransientArrayService()
+        });
         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)=>{
+            const acirExecutionResult = await this.simulator.executeUserCircuit(initialWitness, entryPointArtifact, buildACIRCallback(oracle)).catch((err)=>{
                 err.message = resolveAssertionMessageFromError(err, entryPointArtifact);
                 throw new ExecutionError(err.message, {
                     contractAddress: call.to,
@@ -125,16 +225,31 @@ import { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
                     cause: err
                 });
             });
-            const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
-            this.log.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
-            return decodeFromAbi(entryPointArtifact.returnTypes, returnWitness);
+            this.log.verbose(`Utility execution for ${call.to}.${call.selector} completed`);
+            return {
+                result: witnessMapToFields(acirExecutionResult.returnWitness),
+                offchainEffects: oracle.getOffchainEffects()
+            };
         } 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();
+    /**
+   * Returns the execution statistics collected during the simulator run.
+   * @returns The execution statistics.
+   */ getStats() {
+        const nodeRPCCalls = typeof this.aztecNode.getStats === 'function' ? this.aztecNode.getStats() : {
+            perMethod: {},
+            roundTrips: {
+                roundTrips: 0,
+                totalBlockingTime: 0,
+                roundTripDurations: [],
+                roundTripMethods: []
+            }
+        };
+        return {
+            nodeRPCCalls
+        };
     }
 }
 class OrderedSideEffect {
@@ -152,38 +267,54 @@ class OrderedSideEffect {
  * (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.
+ * @param debugFunctionNameGetter - A provider for contract data in order to get function names and debug info.
+ * @param node - AztecNode for verifying settled read requests against the note hash and nullifier trees.
+ * @param minRevertibleSideEffectCounterOverride - Optional override for the min revertible side effect counter.
+ * Used by TXE to simulate account contract behavior (setting the counter before app execution).
  * @returns The simulated proving result.
- */ export async function generateSimulatedProvingResult(privateExecutionResult, nonceGenerator, contractDataProvider) {
-    const siloedNoteHashes = [];
-    const nullifiers = [];
+ */ export async function generateSimulatedProvingResult(privateExecutionResult, debugFunctionNameGetter, node, minRevertibleSideEffectCounterOverride) {
     const taggedPrivateLogs = [];
     const l2ToL1Messages = [];
     const contractClassLogsHashes = [];
     const publicCallRequests = [];
     const executionSteps = [];
+    // Unsiloed scoped arrays — used for squashing, read request verification,
+    // and siloed at the end only for the surviving items
+    const scopedNoteHashes = [];
+    const scopedNullifiers = [];
+    // Read requests for verification
+    const noteHashReadRequests = [];
+    const nullifierReadRequests = [];
     let publicTeardownCallRequest;
+    // We set expiration timestamp to anchor_block_timestamp + MAX_TX_LIFETIME (24h) just like kernels do
+    let expirationTimestamp = privateExecutionResult.entrypoint.publicInputs.anchorBlockHeader.globalVariables.timestamp + BigInt(MAX_TX_LIFETIME);
+    let feePayer = AztecAddress.zero();
     const executions = [
         privateExecutionResult.entrypoint
     ];
     while(executions.length !== 0){
         const execution = executions.shift();
         executions.unshift(...execution.nestedExecutionResults);
+        // Just like kernels we overwrite the default value if the call sets it.
+        const callExpirationTimestamp = execution.publicInputs.expirationTimestamp;
+        if (callExpirationTimestamp !== 0n && callExpirationTimestamp < expirationTimestamp) {
+            expirationTimestamp = callExpirationTimestamp;
+        }
         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);
+        if (execution.publicInputs.isFeePayer) {
+            if (!feePayer.isZero()) {
+                throw new Error('Multiple fee payers found in private execution result');
+            }
+            feePayer = contractAddress;
+        }
+        scopedNoteHashes.push(...execution.publicInputs.noteHashes.getActiveItems().filter((nh)=>!nh.isEmpty()).map((nh)=>nh.scope(contractAddress)));
+        scopedNullifiers.push(...execution.publicInputs.nullifiers.getActiveItems().map((n)=>n.scope(contractAddress)));
+        taggedPrivateLogs.push(...await Promise.all(execution.publicInputs.privateLogs.getActiveItems().map(async (metadata)=>{
+            metadata.log.fields[0] = await computeSiloedPrivateLogFirstField(contractAddress, metadata.log.fields[0]);
+            return new OrderedSideEffect(metadata, metadata.counter);
+        })));
+        noteHashReadRequests.push(...execution.publicInputs.noteHashReadRequests.getActiveItems());
+        nullifierReadRequests.push(...execution.publicInputs.nullifierReadRequests.getActiveItems());
         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)));
@@ -192,16 +323,25 @@ class OrderedSideEffect {
         }
         publicTeardownCallRequest = execution.publicInputs.publicTeardownCallRequest.isEmpty() ? publicTeardownCallRequest : execution.publicInputs.publicTeardownCallRequest;
         executionSteps.push({
-            functionName: await contractDataProvider.getDebugFunctionName(execution.publicInputs.callContext.contractAddress, execution.publicInputs.callContext.functionSelector),
+            functionName: await debugFunctionNameGetter(execution.publicInputs.callContext.contractAddress, execution.publicInputs.callContext.functionSelector),
             timings: execution.profileResult?.timings ?? {
                 witgen: 0,
                 oracles: {}
             },
+            kind: CircuitKind.App,
             bytecode: execution.acir,
             vk: execution.vk,
             witness: execution.partialWitness
         });
     }
+    const noteHashNullifierCounterMap = collectNoteHashNullifierCounterMap(privateExecutionResult);
+    const minRevertibleSideEffectCounter = minRevertibleSideEffectCounterOverride ?? getFinalMinRevertibleSideEffectCounter(privateExecutionResult);
+    const scopedNoteHashesCLA = new ClaimedLengthArray(padArrayEnd(scopedNoteHashes, ScopedNoteHash.empty(), MAX_NOTE_HASHES_PER_TX), scopedNoteHashes.length);
+    const scopedNullifiersCLA = new ClaimedLengthArray(padArrayEnd(scopedNullifiers, ScopedNullifier.empty(), MAX_NULLIFIERS_PER_TX), scopedNullifiers.length);
+    const { filteredNoteHashes, filteredNullifiers, filteredPrivateLogs } = squashTransientSideEffects(taggedPrivateLogs, scopedNoteHashesCLA, scopedNullifiersCLA, noteHashNullifierCounterMap, minRevertibleSideEffectCounter);
+    await verifyReadRequests(node, await privateExecutionResult.entrypoint.publicInputs.anchorBlockHeader.hash(), noteHashReadRequests, nullifierReadRequests, scopedNoteHashesCLA, scopedNullifiersCLA);
+    const siloedNoteHashes = await Promise.all(filteredNoteHashes.sort((a, b)=>a.counter - b.counter).map(async (nh)=>new OrderedSideEffect(await siloNoteHash(nh.contractAddress, nh.value), nh.counter)));
+    const siloedNullifiers = await Promise.all(filteredNullifiers.sort((a, b)=>a.counter - b.counter).map(async (n)=>new OrderedSideEffect(await siloNullifier(n.contractAddress, n.value), n.counter)));
     const constantData = new TxConstantData(privateExecutionResult.entrypoint.publicInputs.anchorBlockHeader, privateExecutionResult.entrypoint.publicInputs.txContext, getVKTreeRoot(), protocolContractsHash);
     const hasPublicCalls = privateExecutionResult.publicFunctionCalldata.length !== 0;
     let inputsForRollup;
@@ -210,54 +350,117 @@ class OrderedSideEffect {
     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);
-    }
+    const [nonRevertibleNullifiers, revertibleNullifiers] = splitOrderedSideEffects(siloedNullifiers, minRevertibleSideEffectCounter);
+    // The protocol nullifier is the nonce generator and the tx's first nullifier. It is injected by the
+    // init kernel (at counter 1, index 0) rather than emitted by any private call, so it is absent from
+    // the executed nullifiers above. Mirror the kernel here by prepending it as the first non-revertible
+    // nullifier.
+    const nonceGenerator = privateExecutionResult.firstNullifier;
+    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 uniqueNoteHashes = await Promise.all(siloedNoteHashes.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);
+        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(filteredPrivateLogs.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, isPrivateOnlyTx);
         inputsForRollup = new PartialPrivateTailPublicInputsForRollup(accumulatedDataForRollup);
     } else {
-        const [nonRevertibleNoteHashes, revertibleNoteHashes] = splitOrderedSideEffects(siloedNoteHashes.sort(sortByCounter), minRevertibleSideEffectCounter);
+        const [nonRevertibleNoteHashes, revertibleNoteHashes] = splitOrderedSideEffects(siloedNoteHashes, minRevertibleSideEffectCounter);
+        const nonRevertibleUniqueNoteHashes = await Promise.all(nonRevertibleNoteHashes.map(async (noteHash, i)=>{
+            const nonce = await computeNoteHashNonce(nonceGenerator, i);
+            return await computeUniqueNoteHash(nonce, noteHash);
+        }));
         const [nonRevertibleL2ToL1Messages, revertibleL2ToL1Messages] = splitOrderedSideEffects(l2ToL1Messages.sort(sortByCounter), minRevertibleSideEffectCounter);
-        const [nonRevertibleTaggedPrivateLogs, revertibleTaggedPrivateLogs] = splitOrderedSideEffects(taggedPrivateLogs, minRevertibleSideEffectCounter);
+        const [nonRevertibleTaggedPrivateLogs, revertibleTaggedPrivateLogs] = splitOrderedSideEffects(filteredPrivateLogs, 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 nonRevertibleData = new PrivateToPublicAccumulatedData(padArrayEnd(nonRevertibleUniqueNoteHashes, 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));
+        gasUsed = meterGasUsed(revertibleData, isPrivateOnlyTx).add(meterGasUsed(nonRevertibleData, isPrivateOnlyTx));
         if (publicTeardownCallRequest) {
-            gasUsed.add(privateExecutionResult.entrypoint.publicInputs.txContext.gasSettings.teardownGasLimits);
+            gasUsed = 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);
+        l2Gas: isPrivateOnlyTx ? PRIVATE_TX_L2_GAS_OVERHEAD : PUBLIC_TX_L2_GAS_OVERHEAD,
+        daGas: TX_DA_GAS_OVERHEAD
+    })), /*feePayer=*/ feePayer, /*expirationTimestamp=*/ expirationTimestamp, hasPublicCalls ? inputsForPublic : undefined, !hasPublicCalls ? inputsForRollup : undefined);
     return {
         publicInputs,
         chonkProof: ChonkProof.empty(),
         executionSteps
     };
 }
+/**
+ * Squashes transient note hashes and nullifiers, mimicking the behavior
+ * of the reset kernels. Returns the filtered (surviving) scoped items and private logs.
+ */ function squashTransientSideEffects(taggedPrivateLogs, scopedNoteHashesCLA, scopedNullifiersCLA, noteHashNullifierCounterMap, minRevertibleSideEffectCounter) {
+    const { numTransientData, hints: transientDataHints } = buildTransientDataHints(scopedNoteHashesCLA, scopedNullifiersCLA, /*futureNoteHashReads=*/ [], /*futureNullifierReads=*/ [], /*futureLogs=*/ [], noteHashNullifierCounterMap, minRevertibleSideEffectCounter);
+    const squashedNoteHashCounters = new Set();
+    const squashedNullifierCounters = new Set();
+    for(let i = 0; i < numTransientData; i++){
+        const hint = transientDataHints[i];
+        squashedNoteHashCounters.add(scopedNoteHashesCLA.array[hint.noteHashIndex].counter);
+        squashedNullifierCounters.add(scopedNullifiersCLA.array[hint.nullifierIndex].counter);
+    }
+    return {
+        filteredNoteHashes: scopedNoteHashesCLA.getActiveItems().filter((nh)=>!squashedNoteHashCounters.has(nh.counter)),
+        filteredNullifiers: scopedNullifiersCLA.getActiveItems().filter((n)=>!squashedNullifierCounters.has(n.counter)),
+        filteredPrivateLogs: taggedPrivateLogs.filter((item)=>!squashedNoteHashCounters.has(item.sideEffect.noteHashCounter)).map((item)=>new OrderedSideEffect(item.sideEffect.log, item.counter))
+    };
+}
+/**
+ * Verifies settled read requests by checking membership in the note hash and nullifier trees
+ * at the tx's anchor block, mimicking the behavior of the kernels
+ */ async function verifyReadRequests(node, anchorBlockHash, noteHashReadRequests, nullifierReadRequests, scopedNoteHashesCLA, scopedNullifiersCLA) {
+    const noteHashReadRequestsCLA = new ClaimedLengthArray(padArrayEnd(noteHashReadRequests, ScopedReadRequest.empty(), MAX_NOTE_HASH_READ_REQUESTS_PER_TX), noteHashReadRequests.length);
+    const nullifierReadRequestsCLA = new ClaimedLengthArray(padArrayEnd(nullifierReadRequests, ScopedReadRequest.empty(), MAX_NULLIFIER_READ_REQUESTS_PER_TX), nullifierReadRequests.length);
+    const noteHashResetActions = getNoteHashReadRequestResetActions(noteHashReadRequestsCLA, scopedNoteHashesCLA);
+    const nullifierResetActions = getNullifierReadRequestResetActions(nullifierReadRequestsCLA, scopedNullifiersCLA);
+    const settledNoteHashReads = [];
+    for(let i = 0; i < noteHashResetActions.actions.length; i++){
+        if (noteHashResetActions.actions[i] === ReadRequestActionEnum.READ_AS_SETTLED) {
+            settledNoteHashReads.push({
+                index: i,
+                value: noteHashReadRequests[i].value
+            });
+        }
+    }
+    const settledNullifierReads = [];
+    for(let i = 0; i < nullifierResetActions.actions.length; i++){
+        if (nullifierResetActions.actions[i] === ReadRequestActionEnum.READ_AS_SETTLED) {
+            settledNullifierReads.push({
+                index: i,
+                value: nullifierReadRequests[i].value
+            });
+        }
+    }
+    const [noteHashResults, nullifierResults] = await Promise.all([
+        settledNoteHashReads.length > 0 ? node.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NOTE_HASH_TREE, settledNoteHashReads.map(({ value })=>value)) : [],
+        settledNullifierReads.length > 0 ? node.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, settledNullifierReads.map(({ value })=>value)) : []
+    ]);
+    for(let i = 0; i < settledNoteHashReads.length; i++){
+        if (!noteHashResults[i]) {
+            throw new Error(`Note hash read request at index ${settledNoteHashReads[i].index} is reading an unknown note hash: ${settledNoteHashReads[i].value}`);
+        }
+    }
+    for(let i = 0; i < settledNullifierReads.length; i++){
+        if (!nullifierResults[i]) {
+            throw new Error(`Nullifier read request at index ${settledNullifierReads[i].index} is reading an unknown nullifier: ${settledNullifierReads[i].value}`);
+        }
+    }
+}
 function splitOrderedSideEffects(effects, minRevertibleSideEffectCounter) {
     const revertibleSideEffects = [];
     const nonRevertibleSideEffects = [];
     effects.forEach((effect)=>{
-        if (effect.counter < minRevertibleSideEffectCounter) {
+        if (minRevertibleSideEffectCounter === 0 || effect.counter < minRevertibleSideEffectCounter) {
             nonRevertibleSideEffects.push(effect.sideEffect);
         } else {
             revertibleSideEffects.push(effect.sideEffect);
@@ -268,27 +471,34 @@ function splitOrderedSideEffects(effects, minRevertibleSideEffectCounter) {
         revertibleSideEffects
     ];
 }
-function meterGasUsed(data) {
+function meterGasUsed(data, isPrivateOnlyTx) {
     let meteredDAFields = 0;
     let meteredL2Gas = 0;
     const numNoteHashes = arrayNonEmptyLength(data.noteHashes, (hash)=>hash.isEmpty());
     meteredDAFields += numNoteHashes;
-    meteredL2Gas += numNoteHashes * AVM_EMITNOTEHASH_BASE_L2_GAS;
+    const noteHashBaseGas = isPrivateOnlyTx ? L2_GAS_PER_NOTE_HASH : AVM_EMITNOTEHASH_BASE_L2_GAS;
+    meteredL2Gas += numNoteHashes * noteHashBaseGas;
     const numNullifiers = arrayNonEmptyLength(data.nullifiers, (nullifier)=>nullifier.isEmpty());
     meteredDAFields += numNullifiers;
-    meteredL2Gas += numNullifiers * AVM_EMITNULLIFIER_BASE_L2_GAS;
+    const nullifierBaseGas = isPrivateOnlyTx ? L2_GAS_PER_NULLIFIER : AVM_EMITNULLIFIER_BASE_L2_GAS;
+    meteredL2Gas += numNullifiers * nullifierBaseGas;
     const numL2toL1Messages = arrayNonEmptyLength(data.l2ToL1Msgs, (msg)=>msg.isEmpty());
     meteredDAFields += numL2toL1Messages;
-    meteredL2Gas += numL2toL1Messages * AVM_SENDL2TOL1MSG_BASE_L2_GAS;
+    const l2ToL1MessageBaseGas = isPrivateOnlyTx ? L2_GAS_PER_L2_TO_L1_MSG : AVM_SENDL2TOL1MSG_BASE_L2_GAS;
+    meteredL2Gas += numL2toL1Messages * l2ToL1MessageBaseGas;
     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);
+    // Every contract class log emits its contract address as an additional field
+    meteredDAFields += data.contractClassLogsHashes.reduce((acc, log)=>!log.isEmpty() ? acc + log.logHash.length + 1 : acc, 0);
     meteredL2Gas += numContractClassLogs * L2_GAS_PER_CONTRACT_CLASS_LOG;
-    const meteredDAGas = meteredDAFields * DA_BYTES_PER_FIELD * DA_GAS_PER_BYTE;
+    if (isPrivateOnlyTx) {
+        // The public data write that the private tx base rollup always performs to update the fee payer's balance.
+        meteredDAFields += PUBLIC_DATA_WRITE_LENGTH;
+    }
+    const meteredDAGas = meteredDAFields * DA_GAS_PER_FIELD;
     if (data.publicCallRequests) {
         const dataForPublic = data;
         const numPublicCallRequests = arrayNonEmptyLength(dataForPublic.publicCallRequests, (req)=>req.isEmpty());

package/dest/contract_function_simulator/ephemeral_array_service.d.ts

@@ -0,0 +1,28 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+/** In-memory store for ephemeral arrays scoped to a single contract call frame. */
+export declare class EphemeralArrayService {
+    #private;
+    /** Returns all elements in the array, or an empty array if uninitialized. */
+    readArrayAt(slot: Fr): Fr[][];
+    /** Returns the number of elements in the array at the given slot. */
+    len(slot: Fr): number;
+    /** Appends an element to the array and returns the new length. */
+    push(slot: Fr, elements: Fr[]): number;
+    /** Removes and returns the last element. Throws if empty. */
+    pop(slot: Fr): Fr[];
+    /** Returns the element at the given index. Throws if out of bounds. */
+    get(slot: Fr, index: number): Fr[];
+    /** Overwrites the element at the given index. Throws if out of bounds. */
+    set(slot: Fr, index: number, value: Fr[]): void;
+    /** Removes the element at the given index, shifting subsequent elements backward. Throws if out of bounds. */
+    remove(slot: Fr, index: number): void;
+    /** Removes all elements from the array. */
+    clear(slot: Fr): void;
+    /** Allocates a fresh, unused slot for a new ephemeral array. */
+    allocateSlot(): Fr;
+    /** Creates a new ephemeral array pre-populated with the given elements and returns its slot. */
+    newArray(elements: Fr[][]): Fr;
+    /** Copies `count` elements from the source array to the destination array (overwrites destination). */
+    copy(srcSlot: Fr, dstSlot: Fr, count: number): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBoZW1lcmFsX2FycmF5X3NlcnZpY2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb250cmFjdF9mdW5jdGlvbl9zaW11bGF0b3IvZXBoZW1lcmFsX2FycmF5X3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXBELG1GQUFtRjtBQUNuRixxQkFBYSxxQkFBcUI7O0lBT2hDLDZFQUE2RTtJQUM3RSxXQUFXLENBQUMsSUFBSSxFQUFFLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSxDQUU1QjtJQU1ELHFFQUFxRTtJQUNyRSxHQUFHLENBQUMsSUFBSSxFQUFFLEVBQUUsR0FBRyxNQUFNLENBRXBCO0lBRUQsa0VBQWtFO0lBQ2xFLElBQUksQ0FBQyxJQUFJLEVBQUUsRUFBRSxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUUsR0FBRyxNQUFNLENBS3JDO0lBRUQsNkRBQTZEO0lBQzdELEdBQUcsQ0FBQyxJQUFJLEVBQUUsRUFBRSxHQUFHLEVBQUUsRUFBRSxDQVFsQjtJQUVELHVFQUF1RTtJQUN2RSxHQUFHLENBQUMsSUFBSSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLEVBQUUsRUFBRSxDQVFqQztJQUVELDBFQUEwRTtJQUMxRSxHQUFHLENBQUMsSUFBSSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsR0FBRyxJQUFJLENBUTlDO0lBRUQsOEdBQThHO0lBQzlHLE1BQU0sQ0FBQyxJQUFJLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsSUFBSSxDQVFwQztJQUVELDJDQUEyQztJQUMzQyxLQUFLLENBQUMsSUFBSSxFQUFFLEVBQUUsR0FBRyxJQUFJLENBRXBCO0lBRUQsZ0VBQWdFO0lBQ2hFLFlBQVksSUFBSSxFQUFFLENBTWpCO0lBRUQsZ0dBQWdHO0lBQ2hHLFFBQVEsQ0FBQyxRQUFRLEVBQUUsRUFBRSxFQUFFLEVBQUUsR0FBRyxFQUFFLENBSTdCO0lBRUQsdUdBQXVHO0lBQ3ZHLElBQUksQ0FBQyxPQUFPLEVBQUUsRUFBRSxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxJQUFJLENBVWxEO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"ephemeral_array_service.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/ephemeral_array_service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,mFAAmF;AACnF,qBAAa,qBAAqB;;IAOhC,6EAA6E;IAC7E,WAAW,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,CAE5B;IAMD,qEAAqE;IACrE,GAAG,CAAC,IAAI,EAAE,EAAE,GAAG,MAAM,CAEpB;IAED,kEAAkE;IAClE,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,MAAM,CAKrC;IAED,6DAA6D;IAC7D,GAAG,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,CAQlB;IAED,uEAAuE;IACvE,GAAG,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,EAAE,EAAE,CAQjC;IAED,0EAA0E;IAC1E,GAAG,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,IAAI,CAQ9C;IAED,8GAA8G;IAC9G,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAQpC;IAED,2CAA2C;IAC3C,KAAK,CAAC,IAAI,EAAE,EAAE,GAAG,IAAI,CAEpB;IAED,gEAAgE;IAChE,YAAY,IAAI,EAAE,CAMjB;IAED,gGAAgG;IAChG,QAAQ,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,CAI7B;IAED,uGAAuG;IACvG,IAAI,CAAC,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAUlD;CACF"}