@aztec/txe 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/dest/txe_session.js

@@ -1,38 +1,27 @@
-import { AztecAddress, Fr } from '@aztec/aztec.js';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { AddressDataProvider, CapsuleDataProvider, NoteDataProvider, PrivateEventDataProvider, TaggingDataProvider } from '@aztec/pxe/server';
+import { AddressStore, AnchorBlockStore, CapsuleStore, JobCoordinator, NoteService, NoteStore, PrivateEventStore, RecipientTaggingStore, SenderAddressBookStore, SenderTaggingStore } from '@aztec/pxe/server';
+import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, Oracle, PrivateExecutionOracle, UtilityExecutionOracle } from '@aztec/pxe/simulator';
+import { ExecutionError, WASMSimulator, createSimulationError, extractCallStack, resolveAssertionMessageFromError, toACVMWitness } from '@aztec/simulator/client';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasSettings } from '@aztec/stdlib/gas';
+import { computeProtocolNullifier } from '@aztec/stdlib/hash';
 import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import { TXE } from './oracle/txe_oracle.js';
+import { CallContext, TxContext } from '@aztec/stdlib/tx';
+import { z } from 'zod';
+import { DEFAULT_ADDRESS } from './constants.js';
 import { TXEOraclePublicContext } from './oracle/txe_oracle_public_context.js';
+import { TXEOracleTopLevelContext } from './oracle/txe_oracle_top_level_context.js';
+import { RPCTranslator } from './rpc_translator.js';
+import { TXEArchiver } from './state_machine/archiver.js';
 import { TXEStateMachine } from './state_machine/index.js';
-import { TXEService } from './txe_service/txe_service.js';
-import { TXEAccountDataProvider } from './util/txe_account_data_provider.js';
-import { TXEContractDataProvider } from './util/txe_contract_data_provider.js';
-/**
- * A TXE Session can be ine one of four states, which change as the test progresses and different oracles are called.
- * The current state determines which oracles are available.
- */ var SessionState = /*#__PURE__*/ function(SessionState) {
-    /**
-   * The top-level state is the default state, before any other state has been entered. This is where contracts can be
-   * deployed, accounts created, blocks mined, etc.
-   */ SessionState[SessionState["TOP_LEVEL"] = 0] = "TOP_LEVEL";
-    /**
-   * The private state is entered via the `private_context` function. In this state the PXE oracles that `#[private]`
-   * functions use are available, such as those related to note retrieval, notification of side-effects, capsule access,
-   * etc. */ SessionState[SessionState["PRIVATE"] = 1] = "PRIVATE";
-    /**
-   * The public state is entered via the `public_context` function. In this state the AVM opcodes that `#[public]`
-   * functions execute are resolved as oracles by TXE, since Noir tests are not transpiled. */ SessionState[SessionState["PUBLIC"] = 2] = "PUBLIC";
-    /**
-   * The utility state is entered via the `utility_context` function. In this state the PXE oracles that `#[utility]`
-   * functions use are available, such as those related to (unconstrained) note retrieval, capsule access, public
-   * storage reads, etc.
-   */ SessionState[SessionState["UTILITY"] = 3] = "UTILITY";
-    return SessionState;
-}(SessionState || {});
-const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
+import { TXEAccountStore } from './util/txe_account_store.js';
+import { getSingleTxBlockRequestHash, insertTxEffectIntoWorldTrees, makeTXEBlock } from './utils/block_creation.js';
+import { makeTxEffect } from './utils/tx_effect_creation.js';
 /**
  * A `TXESession` corresponds to a Noir `#[test]` function, and handles all of its oracle calls, stores test-specific
  * state, etc., independent of all other tests running in parallel.
@@ -40,34 +29,77 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
     logger;
     stateMachine;
     oracleHandler;
-    legacyTXEOracle;
+    contractStore;
+    noteStore;
+    keyStore;
+    addressStore;
+    accountStore;
+    senderTaggingStore;
+    recipientTaggingStore;
+    senderAddressBookStore;
+    capsuleStore;
+    privateEventStore;
+    jobCoordinator;
+    currentJobId;
+    chainId;
+    version;
+    nextBlockTimestamp;
     state;
-    constructor(logger, stateMachine, oracleHandler, legacyTXEOracle){
+    authwits;
+    constructor(logger, stateMachine, oracleHandler, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, jobCoordinator, currentJobId, chainId, version, nextBlockTimestamp){
         this.logger = logger;
         this.stateMachine = stateMachine;
         this.oracleHandler = oracleHandler;
-        this.legacyTXEOracle = legacyTXEOracle;
-        this.state = 0;
+        this.contractStore = contractStore;
+        this.noteStore = noteStore;
+        this.keyStore = keyStore;
+        this.addressStore = addressStore;
+        this.accountStore = accountStore;
+        this.senderTaggingStore = senderTaggingStore;
+        this.recipientTaggingStore = recipientTaggingStore;
+        this.senderAddressBookStore = senderAddressBookStore;
+        this.capsuleStore = capsuleStore;
+        this.privateEventStore = privateEventStore;
+        this.jobCoordinator = jobCoordinator;
+        this.currentJobId = currentJobId;
+        this.chainId = chainId;
+        this.version = version;
+        this.nextBlockTimestamp = nextBlockTimestamp;
+        this.state = {
+            name: 'TOP_LEVEL'
+        };
+        this.authwits = new Map();
     }
-    static async init(protocolContracts) {
+    static async init(contractStore) {
         const store = await openTmpStore('txe-session');
-        const addressDataProvider = new AddressDataProvider(store);
-        const privateEventDataProvider = new PrivateEventDataProvider(store);
-        const contractDataProvider = new TXEContractDataProvider(store);
-        const noteDataProvider = await NoteDataProvider.create(store);
-        const taggingDataProvider = new TaggingDataProvider(store);
-        const capsuleDataProvider = new CapsuleDataProvider(store);
+        const addressStore = new AddressStore(store);
+        const privateEventStore = new PrivateEventStore(store);
+        const noteStore = new NoteStore(store);
+        const senderTaggingStore = new SenderTaggingStore(store);
+        const recipientTaggingStore = new RecipientTaggingStore(store);
+        const senderAddressBookStore = new SenderAddressBookStore(store);
+        const capsuleStore = new CapsuleStore(store);
         const keyStore = new KeyStore(store);
-        const accountDataProvider = new TXEAccountDataProvider(store);
-        // Register protocol contracts.
-        for (const { contractClass, instance, artifact } of protocolContracts){
-            await contractDataProvider.addContractArtifact(contractClass.id, artifact);
-            await contractDataProvider.addContractInstance(instance);
-        }
-        const stateMachine = await TXEStateMachine.create(store);
-        const txeOracle = new TXE(keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, accountDataProvider, DEFAULT_ADDRESS, await stateMachine.synchronizer.nativeWorldStateService.fork(), stateMachine);
-        await txeOracle.txeAdvanceBlocksBy(1);
-        return new TXESession(createLogger('txe:session'), stateMachine, txeOracle, txeOracle);
+        const accountStore = new TXEAccountStore(store);
+        // Create job coordinator and register staged stores
+        const jobCoordinator = new JobCoordinator(store);
+        jobCoordinator.registerStores([
+            capsuleStore,
+            senderTaggingStore,
+            recipientTaggingStore,
+            privateEventStore,
+            noteStore
+        ]);
+        const archiver = new TXEArchiver(store);
+        const anchorBlockStore = new AnchorBlockStore(store);
+        const stateMachine = await TXEStateMachine.create(archiver, anchorBlockStore, contractStore, noteStore);
+        const nextBlockTimestamp = BigInt(Math.floor(new Date().getTime() / 1000));
+        const version = new Fr(await stateMachine.node.getVersion());
+        const chainId = new Fr(await stateMachine.node.getChainId());
+        const initialJobId = jobCoordinator.beginJob();
+        const topLevelOracleHandler = new TXEOracleTopLevelContext(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, initialJobId, nextBlockTimestamp, version, chainId, new Map());
+        await topLevelOracleHandler.txeAdvanceBlocksBy(1);
+        return new TXESession(createLogger('txe:session'), stateMachine, topLevelOracleHandler, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, jobCoordinator, initialJobId, version, chainId, nextBlockTimestamp);
     }
     /**
    * Processes an oracle function invoked by the Noir test associated to this session.
@@ -75,64 +107,248 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
    * @param inputs The inputs of the oracle.
    * @returns The oracle return values.
    */ processFunction(functionName, inputs) {
-        return new TXEService(this, this.oracleHandler)[functionName](...inputs);
+        try {
+            const translator = new RPCTranslator(this, this.oracleHandler);
+            // We perform a runtime validation to check that the function name corresponds to a real oracle handler.
+            const validatedFunctionName = z.string().refine((fn)=>typeof translator[fn] === 'function' && !fn.startsWith('handlerAs') && fn !== 'constructor').parse(functionName);
+            return translator[validatedFunctionName](...inputs);
+        } catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`${functionName} does not correspond to any oracle handler available on RPCTranslator`);
+            } else if (error instanceof Error) {
+                throw new Error(`Execution error while processing function ${functionName} in state ${this.state.name}: ${error.message}`);
+            } else {
+                throw new Error(`Unknown execution error while processing function ${functionName} in state ${this.state.name}`);
+            }
+        }
     }
-    async setTopLevelContext() {
-        if (this.state == 1) {
-            await this.oracleHandler.txeAdvanceBlocksBy(1);
-            this.oracleHandler.txeSetContractAddress(DEFAULT_ADDRESS);
-        } else if (this.state == 2) {
-            const block = await this.oracleHandler.close();
-            await this.stateMachine.handleL2Block(block);
-            this.legacyTXEOracle.baseFork = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
-            this.legacyTXEOracle.txeSetContractAddress(DEFAULT_ADDRESS);
-            this.legacyTXEOracle.setBlockNumber(block.number + 1);
-            this.oracleHandler = this.legacyTXEOracle;
-        } else if (this.state == 3) {
-            this.oracleHandler.txeSetContractAddress(DEFAULT_ADDRESS);
-        } else if (this.state == 0) {
-            throw new Error(`Expected to be in state other than ${SessionState[0]}`);
-        } else {
-            throw new Error(`Unexpected state '${this.state}'`);
+    async enterTopLevelState() {
+        switch(this.state.name){
+            case 'PRIVATE':
+                {
+                    await this.exitPrivateState();
+                    break;
+                }
+            case 'PUBLIC':
+                {
+                    await this.exitPublicState();
+                    break;
+                }
+            case 'UTILITY':
+                {
+                    this.exitUtilityContext();
+                    break;
+                }
+            case 'TOP_LEVEL':
+                {
+                    throw new Error(`Expected to be in state other than TOP_LEVEL`);
+                }
+            default:
+                {
+                    this.state;
+                }
         }
-        this.state = 0;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
+        // Commit all staged stores from the job that was just completed, then begin a new job
+        await this.jobCoordinator.commitJob(this.currentJobId);
+        this.currentJobId = this.jobCoordinator.beginJob();
+        this.oracleHandler = new TXEOracleTopLevelContext(this.stateMachine, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.accountStore, this.senderTaggingStore, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.currentJobId, this.nextBlockTimestamp, this.version, this.chainId, this.authwits);
+        this.state = {
+            name: 'TOP_LEVEL'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
     }
-    async setPublicContext(contractAddress) {
-        this.assertInTopLevelState();
+    async enterPrivateState(contractAddress = DEFAULT_ADDRESS, anchorBlockNumber) {
+        this.exitTopLevelState();
+        // Private execution has two associated block numbers: the anchor block (i.e. the historical block that is used to
+        // build the proof), and the *next* block, i.e. the one we'll create once the execution ends, and which will contain
+        // a single transaction with the effects of what was done in the test.
+        const anchorBlock = await this.stateMachine.node.getBlockHeader(anchorBlockNumber ?? 'latest');
+        await new NoteService(this.noteStore, this.stateMachine.node, anchorBlock, this.currentJobId).syncNoteNullifiers(contractAddress, 'ALL_SCOPES');
+        const latestBlock = await this.stateMachine.node.getBlockHeader('latest');
+        const nextBlockGlobalVariables = makeGlobalVariables(undefined, {
+            blockNumber: BlockNumber(latestBlock.globalVariables.blockNumber + 1),
+            timestamp: this.nextBlockTimestamp,
+            version: this.version,
+            chainId: this.chainId
+        });
+        const txRequestHash = getSingleTxBlockRequestHash(nextBlockGlobalVariables.blockNumber);
+        const protocolNullifier = await computeProtocolNullifier(txRequestHash);
+        const noteCache = new ExecutionNoteCache(protocolNullifier);
+        const taggingIndexCache = new ExecutionTaggingIndexCache();
+        const utilityExecutor = this.utilityExecutorForContractSync(anchorBlock);
+        this.oracleHandler = new PrivateExecutionOracle({
+            argsHash: Fr.ZERO,
+            txContext: new TxContext(this.chainId, this.version, GasSettings.empty()),
+            callContext: new CallContext(AztecAddress.ZERO, contractAddress, FunctionSelector.empty(), false),
+            anchorBlockHeader: anchorBlock,
+            utilityExecutor,
+            authWitnesses: [],
+            capsules: [],
+            executionCache: new HashedValuesCache(),
+            noteCache,
+            taggingIndexCache,
+            contractStore: this.contractStore,
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: this.stateMachine.node,
+            senderTaggingStore: this.senderTaggingStore,
+            recipientTaggingStore: this.recipientTaggingStore,
+            senderAddressBookStore: this.senderAddressBookStore,
+            capsuleStore: this.capsuleStore,
+            privateEventStore: this.privateEventStore,
+            contractSyncService: this.stateMachine.contractSyncService,
+            jobId: this.currentJobId,
+            scopes: 'ALL_SCOPES'
+        });
+        // We store the note and tagging index caches fed into the PrivateExecutionOracle (along with some other auxiliary
+        // data) in order to refer to it later, mimicking the way this object is used by the ContractFunctionSimulator. The
+        // difference resides in that the simulator has all information needed in order to run the simulation, while ours
+        // will be ongoing as the different oracles will be invoked from the Noir test, until eventually the private
+        // execution finishes.
+        this.state = {
+            name: 'PRIVATE',
+            nextBlockGlobalVariables,
+            noteCache,
+            taggingIndexCache
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
+        return this.oracleHandler.getPrivateContextInputs();
+    }
+    async enterPublicState(contractAddress) {
+        this.exitTopLevelState();
+        // The PublicContext will create a block with a single transaction in it, containing the effects of what was done in
+        // the test. The block therefore gets the *next* block number and timestamp.
+        const latestBlockNumber = (await this.stateMachine.node.getBlockHeader('latest')).globalVariables.blockNumber;
         const globalVariables = makeGlobalVariables(undefined, {
-            blockNumber: await this.legacyTXEOracle.utilityGetBlockNumber(),
-            timestamp: await this.legacyTXEOracle.utilityGetTimestamp(),
-            version: await this.legacyTXEOracle.utilityGetVersion(),
-            chainId: await this.legacyTXEOracle.utilityGetChainId()
+            blockNumber: BlockNumber(latestBlockNumber + 1),
+            timestamp: this.nextBlockTimestamp,
+            version: this.version,
+            chainId: this.chainId
+        });
+        this.oracleHandler = new TXEOraclePublicContext(contractAddress ?? DEFAULT_ADDRESS, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), getSingleTxBlockRequestHash(globalVariables.blockNumber), globalVariables);
+        this.state = {
+            name: 'PUBLIC'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
+    }
+    async enterUtilityState(contractAddress = DEFAULT_ADDRESS) {
+        this.exitTopLevelState();
+        const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        // There is no automatic message discovery and contract-driven syncing process in inlined private or utility
+        // contexts, which means that known nullifiers are also not searched for, since it is during the tagging sync that
+        // we perform this. We therefore search for known nullifiers now, as otherwise notes that were nullified would not
+        // be removed from the database.
+        // TODO(#12553): make the synchronizer sync here instead and remove this
+        await new NoteService(this.noteStore, this.stateMachine.node, anchorBlockHeader, this.currentJobId).syncNoteNullifiers(contractAddress, 'ALL_SCOPES');
+        this.oracleHandler = new UtilityExecutionOracle({
+            contractAddress,
+            authWitnesses: [],
+            capsules: [],
+            anchorBlockHeader,
+            contractStore: this.contractStore,
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: this.stateMachine.node,
+            recipientTaggingStore: this.recipientTaggingStore,
+            senderAddressBookStore: this.senderAddressBookStore,
+            capsuleStore: this.capsuleStore,
+            privateEventStore: this.privateEventStore,
+            jobId: this.currentJobId,
+            scopes: 'ALL_SCOPES'
         });
-        const txRequestHash = new Fr(globalVariables.blockNumber + 6969);
-        this.oracleHandler = new TXEOraclePublicContext(contractAddress ?? DEFAULT_ADDRESS, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), txRequestHash, globalVariables);
-        this.state = 2;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
+        this.state = {
+            name: 'UTILITY'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
+    }
+    exitTopLevelState() {
+        if (this.state.name != 'TOP_LEVEL') {
+            throw new Error(`Expected to be in state 'TOP_LEVEL', but got '${this.state.name}' instead`);
+        }
+        // Note that while all public and private contexts do is build a single block that we then process when exiting
+        // those, the top level context performs a large number of actions not captured in the following 'close' call. Among
+        // others, it will create empty blocks (via `txeAdvanceBlocksBy` and `deploy`), create blocks with transactions via
+        // `txePrivateCallNewFlow` and `txePublicCallNewFlow`, add accounts to PXE via `txeAddAccount`, etc. This is a
+        // slight inconsistency in the working model of this class, but is not too bad.
+        // TODO: it's quite unfortunate that we need to capture the authwits created to later pass them again when the top
+        // level context is re-created. This is because authwits create a temporary utility context that'd otherwise reset
+        // the authwits if not persisted, so we'd not be able to pass more than one per execution.
+        // Ideally authwits would be passed alongside a contract call instead of pre-seeded.
+        [this.nextBlockTimestamp, this.authwits] = this.oracleHandler.close();
     }
-    async setPrivateContext(contractAddress, historicalBlockNumber) {
-        this.assertInTopLevelState();
-        if (contractAddress) {
-            this.oracleHandler.txeSetContractAddress(contractAddress);
+    async exitPrivateState() {
+        if (this.state.name != 'PRIVATE') {
+            throw new Error(`Expected to be in state 'PRIVATE', but got '${this.state.name}' instead`);
         }
-        const privateContextInputs = await this.oracleHandler.txeGetPrivateContextInputs(historicalBlockNumber);
-        this.state = 1;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
-        return privateContextInputs;
+        this.logger.debug('Exiting Private state, building block with collected side effects', {
+            blockNumber: this.state.nextBlockGlobalVariables.blockNumber
+        });
+        // We rely on the note cache to determine the effects of the transaction. This is incomplete as it doesn't private
+        // logs (other effects like enqueued public calls don't need to be considered since those are not allowed).
+        const txEffect = await makeTxEffect(this.state.noteCache, this.state.nextBlockGlobalVariables.blockNumber);
+        // We build a block holding just this transaction
+        const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
+        await insertTxEffectIntoWorldTrees(txEffect, forkedWorldTrees);
+        const block = await makeTXEBlock(forkedWorldTrees, this.state.nextBlockGlobalVariables, [
+            txEffect
+        ]);
+        await this.stateMachine.handleL2Block(block);
+        await forkedWorldTrees.close();
+        this.logger.debug('Exited PublicContext with built block', {
+            blockNumber: block.number,
+            txEffects: block.body.txEffects
+        });
     }
-    setUtilityContext(contractAddress) {
-        this.assertInTopLevelState();
-        if (contractAddress) {
-            this.oracleHandler.txeSetContractAddress(contractAddress);
+    async exitPublicState() {
+        if (this.state.name != 'PUBLIC') {
+            throw new Error(`Expected to be in state 'PUBLIC', but got '${this.state.name}' instead`);
         }
-        this.state = 3;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
-        return Promise.resolve();
+        const block = await this.oracleHandler.close();
+        await this.stateMachine.handleL2Block(block);
     }
-    assertInTopLevelState() {
-        if (this.state != 0) {
-            throw new Error(`Expected to be in state ${SessionState[0]}, but got '${SessionState[this.state]}' instead`);
+    exitUtilityContext() {
+        if (this.state.name != 'UTILITY') {
+            throw new Error(`Expected to be in state 'UTILITY', but got '${this.state.name}' instead`);
         }
     }
+    utilityExecutorForContractSync(anchorBlock) {
+        return async (call, scopes)=>{
+            const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+            if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
+                throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
+            }
+            try {
+                const oracle = new UtilityExecutionOracle({
+                    contractAddress: call.to,
+                    authWitnesses: [],
+                    capsules: [],
+                    anchorBlockHeader: anchorBlock,
+                    contractStore: this.contractStore,
+                    noteStore: this.noteStore,
+                    keyStore: this.keyStore,
+                    addressStore: this.addressStore,
+                    aztecNode: this.stateMachine.node,
+                    recipientTaggingStore: this.recipientTaggingStore,
+                    senderAddressBookStore: this.senderAddressBookStore,
+                    capsuleStore: this.capsuleStore,
+                    privateEventStore: this.privateEventStore,
+                    jobId: this.currentJobId,
+                    scopes
+                });
+                await new WASMSimulator().executeUserCircuit(toACVMWitness(0, call.args), 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
+                    });
+                });
+            } catch (err) {
+                throw createSimulationError(err instanceof Error ? err : new Error('Unknown error contract data sync'));
+            }
+        };
+    }
 }