@aztec/txe 0.0.1-commit.c7c42ec → 0.0.1-commit.cd76b27

package/src/txe_session.ts

@@ -4,9 +4,12 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import type { ProtocolContract } from '@aztec/protocol-contracts';
+import type { AccessScopes } from '@aztec/pxe/client/lazy';
 import {
   AddressStore,
+  AnchorBlockStore,
   CapsuleStore,
+  JobCoordinator,
   NoteService,
   NoteStore,
   PrivateEventStore,
@@ -20,10 +23,19 @@ import {
   HashedValuesCache,
   type IPrivateExecutionOracle,
   type IUtilityExecutionOracle,
+  Oracle,
   PrivateExecutionOracle,
   UtilityExecutionOracle,
 } from '@aztec/pxe/simulator';
-import { FunctionSelector } from '@aztec/stdlib/abi';
+import {
+  ExecutionError,
+  WASMSimulator,
+  createSimulationError,
+  extractCallStack,
+  resolveAssertionMessageFromError,
+  toACVMWitness,
+} from '@aztec/simulator/client';
+import { FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasSettings } from '@aztec/stdlib/gas';
@@ -34,10 +46,12 @@ import { CallContext, GlobalVariables, TxContext } from '@aztec/stdlib/tx';
 
 import { z } from 'zod';
 
+import { DEFAULT_ADDRESS } from './constants.js';
 import type { IAvmExecutionOracle, ITxeExecutionOracle } from './oracle/interfaces.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 type { ForeignCallArgs, ForeignCallResult } from './util/encoding.js';
 import { TXEAccountStore } from './util/txe_account_store.js';
@@ -64,7 +78,6 @@ type SessionState =
   | {
       name: 'PRIVATE';
       nextBlockGlobalVariables: GlobalVariables;
-      protocolNullifier: Fr;
       noteCache: ExecutionNoteCache;
       taggingIndexCache: ExecutionTaggingIndexCache;
     }
@@ -103,8 +116,6 @@ export interface TXESessionStateHandler {
   enterUtilityState(contractAddress?: AztecAddress): Promise<void>;
 }
 
-export 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.
@@ -131,6 +142,8 @@ export class TXESession implements TXESessionStateHandler {
     private senderAddressBookStore: SenderAddressBookStore,
     private capsuleStore: CapsuleStore,
     private privateEventStore: PrivateEventStore,
+    private jobCoordinator: JobCoordinator,
+    private currentJobId: string,
     private chainId: Fr,
     private version: Fr,
     private nextBlockTimestamp: bigint,
@@ -142,7 +155,7 @@ export class TXESession implements TXESessionStateHandler {
     const addressStore = new AddressStore(store);
     const privateEventStore = new PrivateEventStore(store);
     const contractStore = new TXEContractStore(store);
-    const noteStore = await NoteStore.create(store);
+    const noteStore = new NoteStore(store);
     const senderTaggingStore = new SenderTaggingStore(store);
     const recipientTaggingStore = new RecipientTaggingStore(store);
     const senderAddressBookStore = new SenderAddressBookStore(store);
@@ -150,18 +163,32 @@ export class TXESession implements TXESessionStateHandler {
     const keyStore = new KeyStore(store);
     const accountStore = new TXEAccountStore(store);
 
+    // Create job coordinator and register staged stores
+    const jobCoordinator = new JobCoordinator(store);
+    jobCoordinator.registerStores([
+      capsuleStore,
+      senderTaggingStore,
+      recipientTaggingStore,
+      privateEventStore,
+      noteStore,
+    ]);
+
     // Register protocol contracts.
     for (const { contractClass, instance, artifact } of protocolContracts) {
       await contractStore.addContractArtifact(contractClass.id, artifact);
       await contractStore.addContractInstance(instance);
     }
 
-    const stateMachine = await TXEStateMachine.create(store);
+    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,
@@ -174,6 +201,7 @@ export class TXESession implements TXESessionStateHandler {
       senderAddressBookStore,
       capsuleStore,
       privateEventStore,
+      initialJobId,
       nextBlockTimestamp,
       version,
       chainId,
@@ -195,6 +223,8 @@ export class TXESession implements TXESessionStateHandler {
       senderAddressBookStore,
       capsuleStore,
       privateEventStore,
+      jobCoordinator,
+      initialJobId,
       version,
       chainId,
       nextBlockTimestamp,
@@ -254,6 +284,10 @@ export class TXESession implements TXESessionStateHandler {
       }
     }
 
+    // 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,
@@ -266,6 +300,7 @@ export class TXESession implements TXESessionStateHandler {
       this.senderAddressBookStore,
       this.capsuleStore,
       this.privateEventStore,
+      this.currentJobId,
       this.nextBlockTimestamp,
       this.version,
       this.chainId,
@@ -282,21 +317,15 @@ export class TXESession implements TXESessionStateHandler {
   ): Promise<PrivateContextInputs> {
     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 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');
+
+    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, {
@@ -311,35 +340,39 @@ export class TXESession implements TXESessionStateHandler {
     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(),
+    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,
-      this.contractStore,
-      this.noteStore,
-      this.keyStore,
-      this.addressStore,
-      this.stateMachine.node,
-      this.stateMachine.anchorBlockStore,
-      this.senderTaggingStore,
-      this.recipientTaggingStore,
-      this.senderAddressBookStore,
-      this.capsuleStore,
-      this.privateEventStore,
-    );
+      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, protocolNullifier, noteCache, taggingIndexCache };
+    this.state = { name: 'PRIVATE', nextBlockGlobalVariables, noteCache, taggingIndexCache };
     this.logger.debug(`Entered state ${this.state.name}`);
 
     return (this.oracleHandler as PrivateExecutionOracle).getPrivateContextInputs();
@@ -372,6 +405,8 @@ export class TXESession implements TXESessionStateHandler {
   async enterUtilityState(contractAddress: AztecAddress = 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
@@ -380,27 +415,27 @@ export class TXESession implements TXESessionStateHandler {
     await new NoteService(
       this.noteStore,
       this.stateMachine.node,
-      this.stateMachine.anchorBlockStore,
-    ).syncNoteNullifiers(contractAddress);
-
-    const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+      anchorBlockHeader,
+      this.currentJobId,
+    ).syncNoteNullifiers(contractAddress, 'ALL_SCOPES');
 
-    this.oracleHandler = new UtilityExecutionOracle(
+    this.oracleHandler = new UtilityExecutionOracle({
       contractAddress,
-      [],
-      [],
+      authWitnesses: [],
+      capsules: [],
       anchorBlockHeader,
-      this.contractStore,
-      this.noteStore,
-      this.keyStore,
-      this.addressStore,
-      this.stateMachine.node,
-      this.stateMachine.anchorBlockStore,
-      this.recipientTaggingStore,
-      this.senderAddressBookStore,
-      this.capsuleStore,
-      this.privateEventStore,
-    );
+      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',
+    });
 
     this.state = { name: 'UTILITY' };
     this.logger.debug(`Entered state ${this.state.name}`);
@@ -435,11 +470,7 @@ export class TXESession implements TXESessionStateHandler {
     // 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.protocolNullifier,
-      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();
@@ -470,4 +501,49 @@ export class TXESession implements TXESessionStateHandler {
       throw new Error(`Expected to be in state 'UTILITY', but got '${this.state.name}' instead`);
     }
   }
+
+  private utilityExecutorForContractSync(anchorBlock: any) {
+    return async (call: FunctionCall, scopes: AccessScopes) => {
+      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: Error) => {
+            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'));
+      }
+    };
+  }
 }

package/src/utils/block_creation.ts

@@ -4,13 +4,12 @@ import {
   NULLIFIER_SUBTREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
 } from '@aztec/constants';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { Body, L2Block, L2BlockHeader } from '@aztec/stdlib/block';
-import { makeContentCommitment } from '@aztec/stdlib/testing';
+import { Body, L2Block } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot, MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
-import { GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
+import { BlockHeader, GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
 
 /**
  * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
@@ -47,20 +46,18 @@ export async function insertTxEffectIntoWorldTrees(
 export async function makeTXEBlockHeader(
   worldTrees: MerkleTreeWriteOperations,
   globalVariables: GlobalVariables,
-): Promise<L2BlockHeader> {
+): Promise<BlockHeader> {
   const stateReference = await worldTrees.getStateReference();
   const archiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
 
-  return new L2BlockHeader(
-    new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
-    makeContentCommitment(),
-    stateReference,
+  return BlockHeader.from({
+    lastArchive: new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
+    spongeBlobHash: Fr.ZERO,
+    state: stateReference,
     globalVariables,
-    Fr.ZERO,
-    Fr.ZERO,
-    Fr.ZERO,
-    Fr.ZERO,
-  );
+    totalFees: Fr.ZERO,
+    totalManaUsed: Fr.ZERO,
+  });
 }
 
 /**
@@ -84,11 +81,17 @@ export async function makeTXEBlock(
   const header = await makeTXEBlockHeader(worldTrees, globalVariables);
 
   // Update the archive tree with this block's header hash
-  await worldTrees.updateArchive(header.toBlockHeader());
+  await worldTrees.updateArchive(header);
 
   // Get the new archive state after updating
   const newArchiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
   const newArchive = new AppendOnlyTreeSnapshot(new Fr(newArchiveInfo.root), Number(newArchiveInfo.size));
 
-  return new L2Block(newArchive, header, new Body(txEffects));
+  // L2Block requires checkpointNumber and indexWithinCheckpoint.
+  // TXE uses 1-block-per-checkpoint for testing simplicity, so we can use block number as checkpoint number.
+  // This uses the deprecated fromBlockNumber method intentionally for the TXE testing environment.
+  const checkpointNumber = CheckpointNumber.fromBlockNumber(globalVariables.blockNumber);
+  const indexWithinCheckpoint = IndexWithinCheckpoint(0);
+
+  return new L2Block(newArchive, header, new Body(txEffects), checkpointNumber, indexWithinCheckpoint);
 }

package/src/utils/tx_effect_creation.ts

@@ -4,16 +4,12 @@ import type { ExecutionNoteCache } from '@aztec/pxe/simulator';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
 import { TxEffect, TxHash } from '@aztec/stdlib/tx';
 
-export async function makeTxEffect(
-  noteCache: ExecutionNoteCache,
-  protocolNullifier: Fr,
-  txBlockNumber: BlockNumber,
-): Promise<TxEffect> {
+export async function makeTxEffect(noteCache: ExecutionNoteCache, txBlockNumber: BlockNumber): Promise<TxEffect> {
   const txEffect = TxEffect.empty();
 
-  const { usedProtocolNullifierForNonces } = noteCache.finish();
-  const nonceGenerator = usedProtocolNullifierForNonces ? protocolNullifier : noteCache.getAllNullifiers()[0];
+  noteCache.finish();
 
+  const nonceGenerator = noteCache.getNonceGenerator();
   txEffect.noteHashes = await Promise.all(
     noteCache
       .getAllNotes()
@@ -28,10 +24,6 @@ export async function makeTxEffect(
   // Nullifiers are already siloed
   txEffect.nullifiers = noteCache.getAllNullifiers();
 
-  if (usedProtocolNullifierForNonces) {
-    txEffect.nullifiers.unshift(protocolNullifier);
-  }
-
   txEffect.txHash = new TxHash(new Fr(txBlockNumber));
 
   return txEffect;