@aztec/txe 0.0.1-commit.24de95ac → 0.0.1-commit.3469e52

package/dest/txe_session.js

@@ -1,25 +1,27 @@
-import { Fr } from '@aztec/foundation/fields';
+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, PXEOracleInterface, PrivateEventDataProvider, TaggingDataProvider } from '@aztec/pxe/server';
-import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, PrivateExecutionOracle, UtilityExecutionOracle } from '@aztec/pxe/simulator';
-import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AddressStore, 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 { Body, L2Block } from '@aztec/stdlib/block';
 import { GasSettings } from '@aztec/stdlib/gas';
-import { makeAppendOnlyTreeSnapshot, makeGlobalVariables } from '@aztec/stdlib/testing';
+import { computeProtocolNullifier } from '@aztec/stdlib/hash';
+import { makeGlobalVariables } from '@aztec/stdlib/testing';
 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 { TXEStateMachine } from './state_machine/index.js';
-import { TXEAccountDataProvider } from './util/txe_account_data_provider.js';
-import { TXEContractDataProvider } from './util/txe_contract_data_provider.js';
-import { getSingleTxBlockRequestHash, insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from './utils/block_creation.js';
+import { TXEAccountStore } from './util/txe_account_store.js';
+import { TXEContractStore } from './util/txe_contract_store.js';
+import { getSingleTxBlockRequestHash, insertTxEffectIntoWorldTrees, makeTXEBlock } from './utils/block_creation.js';
 import { makeTxEffect } from './utils/tx_effect_creation.js';
-const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
 /**
  * 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.
@@ -27,28 +29,42 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
     logger;
     stateMachine;
     oracleHandler;
-    contractDataProvider;
+    contractStore;
+    noteStore;
     keyStore;
-    addressDataProvider;
-    accountDataProvider;
+    addressStore;
+    accountStore;
+    senderTaggingStore;
+    recipientTaggingStore;
+    senderAddressBookStore;
+    capsuleStore;
+    privateEventStore;
+    jobCoordinator;
+    currentJobId;
     chainId;
     version;
     nextBlockTimestamp;
-    pxeOracleInterface;
     state;
     authwits;
-    constructor(logger, stateMachine, oracleHandler, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, chainId, version, nextBlockTimestamp, pxeOracleInterface){
+    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.contractDataProvider = contractDataProvider;
+        this.contractStore = contractStore;
+        this.noteStore = noteStore;
         this.keyStore = keyStore;
-        this.addressDataProvider = addressDataProvider;
-        this.accountDataProvider = accountDataProvider;
+        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.pxeOracleInterface = pxeOracleInterface;
         this.state = {
             name: 'TOP_LEVEL'
         };
@@ -56,27 +72,37 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
     }
     static async init(protocolContracts) {
         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 contractStore = new TXEContractStore(store);
+        const noteStore = await NoteStore.create(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);
+        const accountStore = new TXEAccountStore(store);
+        // Create job coordinator and register staged stores
+        const jobCoordinator = new JobCoordinator(store);
+        jobCoordinator.registerStores([
+            capsuleStore,
+            senderTaggingStore,
+            recipientTaggingStore,
+            privateEventStore
+        ]);
         // Register protocol contracts.
         for (const { contractClass, instance, artifact } of protocolContracts){
-            await contractDataProvider.addContractArtifact(contractClass.id, artifact);
-            await contractDataProvider.addContractInstance(instance);
+            await contractStore.addContractArtifact(contractClass.id, artifact);
+            await contractStore.addContractInstance(instance);
         }
         const stateMachine = await TXEStateMachine.create(store);
         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 pxeOracleInterface = new PXEOracleInterface(stateMachine.node, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, stateMachine.syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider);
-        const topLevelOracleHandler = new TXEOracleTopLevelContext(stateMachine, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, pxeOracleInterface, nextBlockTimestamp, version, chainId, new Map());
+        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, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, version, chainId, nextBlockTimestamp, pxeOracleInterface);
+        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.
@@ -125,7 +151,10 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
                     this.state;
                 }
         }
-        this.oracleHandler = new TXEOracleTopLevelContext(this.stateMachine, this.contractDataProvider, this.keyStore, this.addressDataProvider, this.accountDataProvider, this.pxeOracleInterface, this.nextBlockTimestamp, this.version, this.chainId, this.authwits);
+        // 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'
         };
@@ -133,27 +162,24 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
     }
     async enterPrivateState(contractAddress = DEFAULT_ADDRESS, anchorBlockNumber) {
         this.exitTopLevelState();
-        // 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 this.pxeOracleInterface.syncNoteNullifiers(contractAddress);
+        await new NoteService(this.noteStore, this.stateMachine.node, this.stateMachine.anchorBlockStore).syncNoteNullifiers(contractAddress);
         // 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');
         const latestBlock = await this.stateMachine.node.getBlockHeader('latest');
         const nextBlockGlobalVariables = makeGlobalVariables(undefined, {
-            blockNumber: latestBlock.globalVariables.blockNumber + 1,
+            blockNumber: BlockNumber(latestBlock.globalVariables.blockNumber + 1),
             timestamp: this.nextBlockTimestamp,
             version: this.version,
             chainId: this.chainId
         });
         const txRequestHash = getSingleTxBlockRequestHash(nextBlockGlobalVariables.blockNumber);
-        const noteCache = new ExecutionNoteCache(txRequestHash);
+        const protocolNullifier = await computeProtocolNullifier(txRequestHash);
+        const noteCache = new ExecutionNoteCache(protocolNullifier);
         const taggingIndexCache = new ExecutionTaggingIndexCache();
-        this.oracleHandler = new PrivateExecutionOracle(Fr.ZERO, new TxContext(this.chainId, this.version, GasSettings.empty()), new CallContext(AztecAddress.ZERO, contractAddress, FunctionSelector.empty(), false), anchorBlock, [], [], new HashedValuesCache(), noteCache, taggingIndexCache, this.pxeOracleInterface);
+        const utilityExecutor = this.utilityExecutorForContractSync(anchorBlock);
+        this.oracleHandler = new PrivateExecutionOracle(Fr.ZERO, new TxContext(this.chainId, this.version, GasSettings.empty()), new CallContext(AztecAddress.ZERO, contractAddress, FunctionSelector.empty(), false), anchorBlock, utilityExecutor, [], [], new HashedValuesCache(), noteCache, taggingIndexCache, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.stateMachine.node, this.stateMachine.anchorBlockStore, this.senderTaggingStore, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.currentJobId);
         // 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
@@ -162,7 +188,6 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
         this.state = {
             name: 'PRIVATE',
             nextBlockGlobalVariables,
-            txRequestHash,
             noteCache,
             taggingIndexCache
         };
@@ -175,7 +200,7 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
         // 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: latestBlockNumber + 1,
+            blockNumber: BlockNumber(latestBlockNumber + 1),
             timestamp: this.nextBlockTimestamp,
             version: this.version,
             chainId: this.chainId
@@ -193,8 +218,9 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
         // 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 this.pxeOracleInterface.syncNoteNullifiers(contractAddress);
-        this.oracleHandler = new UtilityExecutionOracle(contractAddress, [], [], this.pxeOracleInterface);
+        await new NoteService(this.noteStore, this.stateMachine.node, this.stateMachine.anchorBlockStore).syncNoteNullifiers(contractAddress);
+        const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        this.oracleHandler = new UtilityExecutionOracle(contractAddress, [], [], anchorBlockHeader, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.stateMachine.node, this.stateMachine.anchorBlockStore, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.currentJobId);
         this.state = {
             name: 'UTILITY'
         };
@@ -224,13 +250,13 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
         });
         // 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.txRequestHash, this.state.nextBlockGlobalVariables.blockNumber);
+        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 = new L2Block(makeAppendOnlyTreeSnapshot(), await makeTXEBlockHeader(forkedWorldTrees, this.state.nextBlockGlobalVariables), new Body([
+        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', {
@@ -250,4 +276,26 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
             throw new Error(`Expected to be in state 'UTILITY', but got '${this.state.name}' instead`);
         }
     }
+    utilityExecutorForContractSync(anchorBlock) {
+        return async (call)=>{
+            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(call.to, [], [], anchorBlock, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.stateMachine.node, this.stateMachine.anchorBlockStore, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.currentJobId);
+                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'));
+            }
+        };
+    }
 }