@aztec/txe 0.0.1-commit.d3ec352c → 0.0.1-commit.e6bd8901

package/src/state_machine/index.ts

@@ -1,10 +1,14 @@
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
 import { TestCircuitVerifier } from '@aztec/bb-prover/test';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { SyncDataProvider } from '@aztec/pxe/server';
-import { type L2Block, PublishedL2Block } from '@aztec/stdlib/block';
+import { AnchorBlockStore } from '@aztec/pxe/server';
+import { L2Block } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { getPackageVersion } from '@aztec/stdlib/update-checker';
 
 import { TXEArchiver } from './archiver.js';
@@ -21,13 +25,13 @@ export class TXEStateMachine {
     public node: AztecNode,
     public synchronizer: TXESynchronizer,
     public archiver: TXEArchiver,
-    public syncDataProvider: SyncDataProvider,
+    public anchorBlockStore: AnchorBlockStore,
   ) {}
 
   public static async create(db: AztecAsyncKVStore) {
     const archiver = new TXEArchiver(db);
     const synchronizer = await TXESynchronizer.create();
-    const syncDataProvider = new SyncDataProvider(db);
+    const anchorBlockStore = new AnchorBlockStore(db);
 
     const aztecNodeConfig = {} as AztecNodeConfig;
 
@@ -54,24 +58,43 @@ export class TXEStateMachine {
       log,
     );
 
-    return new this(node, synchronizer, archiver, syncDataProvider);
+    return new this(node, synchronizer, archiver, anchorBlockStore);
   }
 
   public async handleL2Block(block: L2Block) {
+    // Create a checkpoint from the block manually
+    const checkpoint = new Checkpoint(
+      block.archive,
+      CheckpointHeader.from({
+        lastArchiveRoot: block.header.lastArchive.root,
+        inHash: Fr.ZERO,
+        blobsHash: Fr.ZERO,
+        blockHeadersHash: Fr.ZERO,
+        epochOutHash: Fr.ZERO,
+        slotNumber: block.header.globalVariables.slotNumber,
+        timestamp: block.header.globalVariables.timestamp,
+        coinbase: block.header.globalVariables.coinbase,
+        feeRecipient: block.header.globalVariables.feeRecipient,
+        gasFees: block.header.globalVariables.gasFees,
+        totalManaUsed: block.header.totalManaUsed,
+      }),
+      [block],
+      CheckpointNumber.fromBlockNumber(block.number),
+    );
+
+    const publishedCheckpoint = new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(
+        BigInt(block.header.globalVariables.blockNumber),
+        block.header.globalVariables.timestamp,
+        block.header.globalVariables.blockNumber.toString(),
+      ),
+      [],
+    );
     await Promise.all([
-      this.synchronizer.handleL2Block(block.toL2Block()),
-      this.archiver.addBlocks([
-        PublishedL2Block.fromFields({
-          block,
-          l1: {
-            blockHash: block.header.globalVariables.blockNumber.toString(),
-            blockNumber: BigInt(block.header.globalVariables.blockNumber),
-            timestamp: block.header.globalVariables.timestamp,
-          },
-          attestations: [],
-        }),
-      ]),
-      this.syncDataProvider.setHeader(block.getBlockHeader()),
+      this.synchronizer.handleL2Block(block),
+      this.archiver.addCheckpoints([publishedCheckpoint], undefined),
+      this.anchorBlockStore.setHeader(block.header),
     ]);
   }
 }

package/src/state_machine/mock_epoch_cache.ts

@@ -12,14 +12,16 @@ export class MockEpochCache implements EpochCacheInterface {
       committee: undefined,
       seed: 0n,
       epoch: EpochNumber.ZERO,
+      isEscapeHatchOpen: false,
     });
   }
 
-  getEpochAndSlotNow(): EpochAndSlot {
+  getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint } {
     return {
       epoch: EpochNumber.ZERO,
       slot: SlotNumber(0),
       ts: 0n,
+      nowMs: 0n,
     };
   }
 
@@ -40,18 +42,15 @@ export class MockEpochCache implements EpochCacheInterface {
     return 0n;
   }
 
-  getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
-    currentProposer: EthAddress | undefined;
-    nextProposer: EthAddress | undefined;
-    currentSlot: SlotNumber;
-    nextSlot: SlotNumber;
-  }> {
-    return Promise.resolve({
-      currentProposer: undefined,
-      nextProposer: undefined,
+  getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
       currentSlot: SlotNumber(0),
       nextSlot: SlotNumber(0),
-    });
+    };
+  }
+
+  getProposerAttesterAddressInSlot(_slot: SlotNumber): Promise<EthAddress | undefined> {
+    return Promise.resolve(undefined);
   }
 
   isInCommittee(_slot: SlotTag, _validator: EthAddress): Promise<boolean> {

package/src/state_machine/synchronizer.ts

@@ -1,7 +1,7 @@
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/fields';
-import type { L2BlockNew } from '@aztec/stdlib/block';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { L2Block } from '@aztec/stdlib/block';
 import type {
   MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
@@ -23,11 +23,10 @@ export class TXESynchronizer implements WorldStateSynchronizer {
     return new this(nativeWorldStateService);
   }
 
-  public async handleL2Block(block: L2BlockNew) {
+  public async handleL2Block(block: L2Block) {
     await this.nativeWorldStateService.handleL2BlockAndMessages(
       block,
       Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero),
-      true,
     );
 
     this.blockNumber = block.header.globalVariables.blockNumber;

package/src/txe_session.ts

@@ -1,16 +1,19 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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 {
-  AddressDataProvider,
-  CapsuleDataProvider,
-  NoteDataProvider,
-  PXEOracleInterface,
-  PrivateEventDataProvider,
-  TaggingDataProvider,
+  AddressStore,
+  CapsuleStore,
+  JobCoordinator,
+  NoteService,
+  NoteStore,
+  PrivateEventStore,
+  RecipientTaggingStore,
+  SenderAddressBookStore,
+  SenderTaggingStore,
 } from '@aztec/pxe/server';
 import {
   ExecutionNoteCache,
@@ -18,34 +21,39 @@ 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 { Body, L2Block } from '@aztec/stdlib/block';
 import { GasSettings } from '@aztec/stdlib/gas';
 import { computeProtocolNullifier } from '@aztec/stdlib/hash';
 import { PrivateContextInputs } from '@aztec/stdlib/kernel';
-import { makeAppendOnlyTreeSnapshot, makeGlobalVariables } from '@aztec/stdlib/testing';
+import { makeGlobalVariables } from '@aztec/stdlib/testing';
 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 { TXEStateMachine } from './state_machine/index.js';
 import type { ForeignCallArgs, ForeignCallResult } from './util/encoding.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';
 
 /**
@@ -67,7 +75,6 @@ type SessionState =
   | {
       name: 'PRIVATE';
       nextBlockGlobalVariables: GlobalVariables;
-      protocolNullifier: Fr;
       noteCache: ExecutionNoteCache;
       taggingIndexCache: ExecutionTaggingIndexCache;
     }
@@ -106,8 +113,6 @@ export interface TXESessionStateHandler {
   enterUtilityState(contractAddress?: AztecAddress): Promise<void>;
 }
 
-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.
@@ -124,32 +129,51 @@ export class TXESession implements TXESessionStateHandler {
       | IPrivateExecutionOracle
       | IAvmExecutionOracle
       | ITxeExecutionOracle,
-    private contractDataProvider: TXEContractDataProvider,
+    private contractStore: TXEContractStore,
+    private noteStore: NoteStore,
     private keyStore: KeyStore,
-    private addressDataProvider: AddressDataProvider,
-    private accountDataProvider: TXEAccountDataProvider,
+    private addressStore: AddressStore,
+    private accountStore: TXEAccountStore,
+    private senderTaggingStore: SenderTaggingStore,
+    private recipientTaggingStore: RecipientTaggingStore,
+    private senderAddressBookStore: SenderAddressBookStore,
+    private capsuleStore: CapsuleStore,
+    private privateEventStore: PrivateEventStore,
+    private jobCoordinator: JobCoordinator,
+    private currentJobId: string,
     private chainId: Fr,
     private version: Fr,
     private nextBlockTimestamp: bigint,
-    private pxeOracleInterface: PXEOracleInterface,
   ) {}
 
   static async init(protocolContracts: ProtocolContract[]) {
     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 = 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);
+    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 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);
@@ -158,25 +182,21 @@ export class TXESession implements TXESessionStateHandler {
     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 initialJobId = jobCoordinator.beginJob();
 
     const topLevelOracleHandler = new TXEOracleTopLevelContext(
       stateMachine,
-      contractDataProvider,
+      contractStore,
+      noteStore,
       keyStore,
-      addressDataProvider,
-      accountDataProvider,
-      pxeOracleInterface,
+      addressStore,
+      accountStore,
+      senderTaggingStore,
+      recipientTaggingStore,
+      senderAddressBookStore,
+      capsuleStore,
+      privateEventStore,
+      initialJobId,
       nextBlockTimestamp,
       version,
       chainId,
@@ -188,14 +208,21 @@ export class TXESession implements TXESessionStateHandler {
       createLogger('txe:session'),
       stateMachine,
       topLevelOracleHandler,
-      contractDataProvider,
+      contractStore,
+      noteStore,
       keyStore,
-      addressDataProvider,
-      accountDataProvider,
+      addressStore,
+      accountStore,
+      senderTaggingStore,
+      recipientTaggingStore,
+      senderAddressBookStore,
+      capsuleStore,
+      privateEventStore,
+      jobCoordinator,
+      initialJobId,
       version,
       chainId,
       nextBlockTimestamp,
-      pxeOracleInterface,
     );
   }
 
@@ -252,13 +279,23 @@ 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.contractDataProvider,
+      this.contractStore,
+      this.noteStore,
       this.keyStore,
-      this.addressDataProvider,
-      this.accountDataProvider,
-      this.pxeOracleInterface,
+      this.addressStore,
+      this.accountStore,
+      this.senderTaggingStore,
+      this.recipientTaggingStore,
+      this.senderAddressBookStore,
+      this.capsuleStore,
+      this.privateEventStore,
+      this.currentJobId,
       this.nextBlockTimestamp,
       this.version,
       this.chainId,
@@ -275,12 +312,12 @@ 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 this.pxeOracleInterface.syncNoteNullifiers(contractAddress);
+    await new NoteService(
+      this.noteStore,
+      this.stateMachine.node,
+      this.stateMachine.anchorBlockStore,
+      this.currentJobId,
+    ).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
@@ -300,17 +337,30 @@ export class TXESession implements TXESessionStateHandler {
     const noteCache = new ExecutionNoteCache(protocolNullifier);
     const taggingIndexCache = new ExecutionTaggingIndexCache();
 
+    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.pxeOracleInterface,
+      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
@@ -318,7 +368,7 @@ export class TXESession implements TXESessionStateHandler {
     // 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();
@@ -356,9 +406,32 @@ export class TXESession implements TXESessionStateHandler {
     // 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,
+      this.currentJobId,
+    ).syncNoteNullifiers(contractAddress);
 
-    this.oracleHandler = new UtilityExecutionOracle(contractAddress, [], [], this.pxeOracleInterface);
+    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' };
     this.logger.debug(`Entered state ${this.state.name}`);
@@ -392,21 +465,14 @@ 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();
     await insertTxEffectIntoWorldTrees(txEffect, forkedWorldTrees);
 
-    const block = new L2Block(
-      makeAppendOnlyTreeSnapshot(),
-      await makeTXEBlockHeader(forkedWorldTrees, this.state.nextBlockGlobalVariables),
-      new Body([txEffect]),
-    );
+    const block = await makeTXEBlock(forkedWorldTrees, this.state.nextBlockGlobalVariables, [txEffect]);
     await this.stateMachine.handleL2Block(block);
 
     await forkedWorldTrees.close();
@@ -431,4 +497,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) => {
+      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: 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/util/encoding.ts

@@ -1,5 +1,5 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { type ContractArtifact, ContractArtifactSchema } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';

package/src/util/{txe_account_data_provider.ts → txe_account_store.ts}

@@ -2,7 +2,7 @@ import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { CompleteAddress } from '@aztec/stdlib/contract';
 
-export class TXEAccountDataProvider {
+export class TXEAccountStore {
   #accounts: AztecAsyncMap<string, Buffer>;
 
   constructor(store: AztecAsyncKVStore) {

package/src/util/{txe_contract_data_provider.ts → txe_contract_store.ts}

@@ -1,15 +1,15 @@
 import type { ContractArtifact } from '@aztec/aztec.js/abi';
 import { Fr } from '@aztec/aztec.js/fields';
-import { ContractDataProvider } from '@aztec/pxe/server';
+import { ContractStore } from '@aztec/pxe/server';
 
 export type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
 
 /*
- * A contract data provider that stores contract artifacts with their hashes. Since
+ * A contract store that stores contract artifacts with their hashes. Since
  * TXE typically deploys the same contract again and again for multiple tests, caching
  * the *very* expensive artifact hash computation improves testing speed significantly.
  */
-export class TXEContractDataProvider extends ContractDataProvider {
+export class TXEContractStore extends ContractStore {
   #artifactHashes: Map<string, Buffer> = new Map();
 
   public override async addContractArtifact(

package/src/util/txe_public_contract_data_source.ts

@@ -1,6 +1,6 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/fields';
-import type { ContractDataProvider } from '@aztec/pxe/server';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ContractStore } from '@aztec/pxe/server';
 import { type ContractArtifact, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
@@ -16,7 +16,7 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   #privateFunctionsRoot: Map<string, Buffer> = new Map();
   constructor(
     private blockNumber: BlockNumber,
-    private contractDataProvider: ContractDataProvider,
+    private contractStore: ContractStore,
   ) {}
 
   getBlockNumber(): Promise<BlockNumber> {
@@ -24,11 +24,11 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   }
 
   async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    const contractClass = await this.contractDataProvider.getContractClass(id);
+    const contractClass = await this.contractStore.getContractClass(id);
     if (!contractClass) {
       return;
     }
-    const artifact = await this.contractDataProvider.getContractArtifact(id);
+    const artifact = await this.contractStore.getContractArtifact(id);
     if (!artifact) {
       return;
     }
@@ -58,12 +58,12 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   }
 
   async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
-    const contractClass = await this.contractDataProvider.getContractClass(id);
+    const contractClass = await this.contractStore.getContractClass(id);
     return contractClass && computePublicBytecodeCommitment(contractClass.packedBytecode);
   }
 
   async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    const instance = await this.contractDataProvider.getContractInstance(address);
+    const instance = await this.contractStore.getContractInstance(address);
     return instance && { ...instance, address };
   }
 
@@ -72,12 +72,12 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   }
 
   async getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined> {
-    const instance = await this.contractDataProvider.getContractInstance(address);
-    return instance && this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
+    const instance = await this.contractStore.getContractInstance(address);
+    return instance && this.contractStore.getContractArtifact(instance.currentContractClassId);
   }
 
   async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    return await this.contractDataProvider.getDebugFunctionName(address, selector);
+    return await this.contractStore.getDebugFunctionName(address, selector);
   }
 
   registerContractFunctionSignatures(_signatures: []): Promise<void> {