@aztec/txe 0.0.1-commit.e558bd1c → 0.0.1-commit.e5a3663dd

package/src/txe_session.ts

@@ -3,11 +3,12 @@ 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 {
   AddressStore,
   AnchorBlockStore,
+  CapsuleService,
   CapsuleStore,
+  ContractStore,
   JobCoordinator,
   NoteService,
   NoteStore,
@@ -41,7 +42,7 @@ import { GasSettings } from '@aztec/stdlib/gas';
 import { computeProtocolNullifier } from '@aztec/stdlib/hash';
 import { PrivateContextInputs } from '@aztec/stdlib/kernel';
 import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import { CallContext, GlobalVariables, TxContext } from '@aztec/stdlib/tx';
+import { CallContext, GlobalVariables, OFFCHAIN_MESSAGE_IDENTIFIER, TxContext } from '@aztec/stdlib/tx';
 
 import { z } from 'zod';
 
@@ -54,7 +55,6 @@ 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';
-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';
 
@@ -113,6 +113,69 @@ export interface TXESessionStateHandler {
   enterPublicState(contractAddress?: AztecAddress): Promise<void>;
   enterPrivateState(contractAddress?: AztecAddress, anchorBlockNumber?: BlockNumber): Promise<PrivateContextInputs>;
   enterUtilityState(contractAddress?: AztecAddress): Promise<void>;
+
+  // TODO(F-335): Exposing the job info is abstraction breakage - drop the following 2 functions.
+  cycleJob(): Promise<string>;
+  getCurrentJob(): string;
+
+  /**
+   * Runs an executor-style top-level call (private/public call, utility execution) with last-call tracking.
+   */
+  withTopLevelCallTracking<T>(work: () => Promise<{ result: T; txHash?: Fr }>): Promise<T>;
+
+  /**
+   * Captures a raw offchain effect payload for consumption from test environment. Called by the `emit_offchain_effect`
+   * oracle handler whenever a contract function emits an offchain message, at any call depth.
+   */
+  recordOffchainEffect(data: Fr[]): void;
+
+  /**
+   * Returns the raw offchain effect payloads emitted by the last top-level call. Each payload follows the protocol
+   * convention documented on `OFFCHAIN_MESSAGE_IDENTIFIER`, i.e. `[identifier, recipient, ...ciphertext]`. Decoding into
+   * `OffchainMessage` structs happens on the Noir side of the test helper. Marks the buffer as queried so the
+   * unqueried-messages warning doesn't fire on the next reset.
+   */
+  getLastCallOffchainEffects(): { effects: Fr[][] };
+
+  /**
+   * Returns the context of the last top-level call: its tx hash (`Fr.ZERO` if the call was tx-less) and the anchor
+   * block timestamp captured at the start of the call. Does *not* mark the buffer as queried — context reads are
+   * metadata, not effect consumption.
+   */
+  getLastCallContext(): { txHash: Fr; anchorBlockTimestamp: bigint };
+}
+
+/**
+ * Session state tracking the most recently completed top-level call: the offchain effect buffer it produced, and the
+ * call's context (tx hash + anchor block timestamp). The context is refreshed on every top-level call, independently
+ * of whether the call produced offchain effects.
+ */
+interface LastCallState {
+  /**
+   * Raw offchain effect payloads emitted by the currently-executing (or most recently completed) top-level call. Wiped
+   * at the start of every top-level entry point, appended to on every `emit_offchain_effect` oracle invocation.
+   */
+  offchainEffects: Fr[][];
+  /**
+   * Tracks whether the test has queried `effects` since the last reset. If a new top-level call clobbers the buffer
+   * without it being queried first, any accumulated messages are lost and we emit a warning so tests don't silently
+   * drop delivery.
+   */
+  queried: boolean;
+  /**
+   * Tx hash of the most recently completed top-level call, or `Fr.ZERO` if the call was tx-less (context setters,
+   * utility execution). Populated by call executor handlers after execution completes.
+   */
+  txHash: Fr;
+  /**
+   * Anchor block timestamp of the most recently completed top-level call, captured from the anchor block header that
+   * was active when the call started. Populated by call executor handlers after execution completes.
+   */
+  anchorBlockTimestamp: bigint;
+}
+
+function emptyLastCallState(): LastCallState {
+  return { offchainEffects: [], queried: false, txHash: Fr.ZERO, anchorBlockTimestamp: 0n };
 }
 
 /**
@@ -122,6 +185,7 @@ export interface TXESessionStateHandler {
 export class TXESession implements TXESessionStateHandler {
   private state: SessionState = { name: 'TOP_LEVEL' };
   private authwits: Map<string, AuthWitness> = new Map();
+  private lastCallInfo: LastCallState = emptyLastCallState();
 
   constructor(
     private logger: Logger,
@@ -131,7 +195,7 @@ export class TXESession implements TXESessionStateHandler {
       | IPrivateExecutionOracle
       | IAvmExecutionOracle
       | ITxeExecutionOracle,
-    private contractStore: TXEContractStore,
+    private contractStore: ContractStore,
     private noteStore: NoteStore,
     private keyStore: KeyStore,
     private addressStore: AddressStore,
@@ -148,12 +212,11 @@ export class TXESession implements TXESessionStateHandler {
     private nextBlockTimestamp: bigint,
   ) {}
 
-  static async init(protocolContracts: ProtocolContract[]) {
+  static async init(contractStore: ContractStore) {
     const store = await openTmpStore('txe-session');
 
     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);
@@ -172,12 +235,6 @@ export class TXESession implements TXESessionStateHandler {
       noteStore,
     ]);
 
-    // Register protocol contracts.
-    for (const { contractClass, instance, artifact } of protocolContracts) {
-      await contractStore.addContractArtifact(contractClass.id, artifact);
-      await contractStore.addContractInstance(instance);
-    }
-
     const archiver = new TXEArchiver(store);
     const anchorBlockStore = new AnchorBlockStore(store);
     const stateMachine = await TXEStateMachine.create(archiver, anchorBlockStore, contractStore, noteStore);
@@ -188,6 +245,8 @@ export class TXESession implements TXESessionStateHandler {
 
     const initialJobId = jobCoordinator.beginJob();
 
+    const logger = createLogger('txe:session');
+
     const topLevelOracleHandler = new TXEOracleTopLevelContext(
       stateMachine,
       contractStore,
@@ -200,16 +259,15 @@ export class TXESession implements TXESessionStateHandler {
       senderAddressBookStore,
       capsuleStore,
       privateEventStore,
-      initialJobId,
       nextBlockTimestamp,
       version,
       chainId,
       new Map(),
     );
-    await topLevelOracleHandler.txeAdvanceBlocksBy(1);
+    await topLevelOracleHandler.advanceBlocksBy(1);
 
     return new TXESession(
-      createLogger('txe:session'),
+      logger,
       stateMachine,
       topLevelOracleHandler,
       contractStore,
@@ -261,6 +319,61 @@ export class TXESession implements TXESessionStateHandler {
     }
   }
 
+  getCurrentJob(): string {
+    return this.currentJobId;
+  }
+
+  /** Commits the current job and begins a new one. Returns the new job ID. */
+  async cycleJob(): Promise<string> {
+    await this.jobCoordinator.commitJob(this.currentJobId);
+    this.currentJobId = this.jobCoordinator.beginJob();
+    return this.currentJobId;
+  }
+
+  private resetLastCall(): void {
+    const notQueriedMessageCount = this.lastCallInfo.queried
+      ? 0
+      : this.lastCallInfo.offchainEffects.filter(payload => payload[0]?.equals(OFFCHAIN_MESSAGE_IDENTIFIER)).length;
+    if (notQueriedMessageCount > 0) {
+      this.logger.warn(
+        `Dropping ${notQueriedMessageCount} unqueried offchain message(s) from the previous top-level call. ` +
+          `To deliver them, call \`env.offchain_messages()\` and forward the result to the recipient contract's ` +
+          `\`offchain_receive\` utility before issuing another top-level call. To intentionally discard, assign ` +
+          `to \`let _ = env.offchain_messages()\` to silence this warning.`,
+      );
+    }
+    this.lastCallInfo = emptyLastCallState();
+  }
+
+  recordOffchainEffect(data: Fr[]): void {
+    this.lastCallInfo.offchainEffects.push(data);
+  }
+
+  private setLastCallContext(txHash: Fr, anchorBlockTimestamp: bigint): void {
+    this.lastCallInfo.txHash = txHash;
+    this.lastCallInfo.anchorBlockTimestamp = anchorBlockTimestamp;
+  }
+
+  async withTopLevelCallTracking<T>(work: () => Promise<{ result: T; txHash?: Fr }>): Promise<T> {
+    this.resetLastCall();
+    // Capture the anchor *before* `work` runs: private/public executor calls mine a new block as a
+    // side effect, and that block's timestamp should not be attributed to this call's anchor.
+    const anchorBlockTimestamp = (await this.stateMachine.node.getBlockHeader('latest'))!.globalVariables.timestamp;
+    const { result, txHash } = await work();
+    this.setLastCallContext(txHash ?? Fr.ZERO, anchorBlockTimestamp);
+    return result;
+  }
+
+  getLastCallOffchainEffects(): { effects: Fr[][] } {
+    this.lastCallInfo.queried = true;
+    return { effects: this.lastCallInfo.offchainEffects };
+  }
+
+  getLastCallContext(): { txHash: Fr; anchorBlockTimestamp: bigint } {
+    const { txHash, anchorBlockTimestamp } = this.lastCallInfo;
+    return { txHash, anchorBlockTimestamp };
+  }
+
   async enterTopLevelState() {
     switch (this.state.name) {
       case 'PRIVATE': {
@@ -284,8 +397,7 @@ 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();
+    await this.cycleJob();
 
     this.oracleHandler = new TXEOracleTopLevelContext(
       this.stateMachine,
@@ -299,7 +411,6 @@ export class TXESession implements TXESessionStateHandler {
       this.senderAddressBookStore,
       this.capsuleStore,
       this.privateEventStore,
-      this.currentJobId,
       this.nextBlockTimestamp,
       this.version,
       this.chainId,
@@ -315,6 +426,7 @@ export class TXESession implements TXESessionStateHandler {
     anchorBlockNumber?: BlockNumber,
   ): Promise<PrivateContextInputs> {
     this.exitTopLevelState();
+    this.resetLastCall();
 
     // 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
@@ -323,6 +435,7 @@ export class TXESession implements TXESessionStateHandler {
 
     await new NoteService(this.noteStore, this.stateMachine.node, anchorBlock!, this.currentJobId).syncNoteNullifiers(
       contractAddress,
+      await this.keyStore.getAccounts(),
     );
     const latestBlock = await this.stateMachine.node.getBlockHeader('latest');
 
@@ -339,30 +452,34 @@ export class TXESession implements TXESessionStateHandler {
     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!,
+    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,
-      [],
-      [],
-      new HashedValuesCache(),
+      authWitnesses: [],
+      capsules: [],
+      executionCache: new HashedValuesCache(),
       noteCache,
       taggingIndexCache,
-      this.contractStore,
-      this.noteStore,
-      this.keyStore,
-      this.addressStore,
-      this.stateMachine.node,
-      this.senderTaggingStore,
-      this.recipientTaggingStore,
-      this.senderAddressBookStore,
-      this.capsuleStore,
-      this.privateEventStore,
-      this.stateMachine.contractSyncService,
-      this.currentJobId,
-    );
+      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,
+      capsuleService: new CapsuleService(this.capsuleStore, await this.keyStore.getAccounts()),
+      privateEventStore: this.privateEventStore,
+      contractSyncService: this.stateMachine.contractSyncService,
+      l2TipsStore: this.stateMachine.node,
+      jobId: this.currentJobId,
+      scopes: await this.keyStore.getAccounts(),
+      messageContextService: this.stateMachine.messageContextService,
+      simulator: new WASMSimulator(),
+    });
 
     // 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
@@ -372,17 +489,22 @@ export class TXESession implements TXESessionStateHandler {
     this.state = { name: 'PRIVATE', nextBlockGlobalVariables, noteCache, taggingIndexCache };
     this.logger.debug(`Entered state ${this.state.name}`);
 
+    // Record the *resolved* anchor's timestamp — if the caller pinned the anchor to a past block
+    // via `anchorBlockNumber`, "latest" would be the wrong anchor for offchain-message semantics.
+    this.setLastCallContext(Fr.ZERO, anchorBlock!.globalVariables.timestamp);
+
     return (this.oracleHandler as PrivateExecutionOracle).getPrivateContextInputs();
   }
 
   async enterPublicState(contractAddress?: AztecAddress) {
     this.exitTopLevelState();
+    this.resetLastCall();
 
     // 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 latestHeader = (await this.stateMachine.node.getBlockHeader('latest'))!;
     const globalVariables = makeGlobalVariables(undefined, {
-      blockNumber: BlockNumber(latestBlockNumber + 1),
+      blockNumber: BlockNumber(latestHeader.globalVariables.blockNumber + 1),
       timestamp: this.nextBlockTimestamp,
       version: this.version,
       chainId: this.chainId,
@@ -397,10 +519,14 @@ export class TXESession implements TXESessionStateHandler {
 
     this.state = { name: 'PUBLIC' };
     this.logger.debug(`Entered state ${this.state.name}`);
+
+    // Public state is anchored at the latest block.
+    this.setLastCallContext(Fr.ZERO, latestHeader.globalVariables.timestamp);
   }
 
   async enterUtilityState(contractAddress: AztecAddress = DEFAULT_ADDRESS) {
     this.exitTopLevelState();
+    this.resetLastCall();
 
     const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
 
@@ -414,27 +540,35 @@ export class TXESession implements TXESessionStateHandler {
       this.stateMachine.node,
       anchorBlockHeader,
       this.currentJobId,
-    ).syncNoteNullifiers(contractAddress);
+    ).syncNoteNullifiers(contractAddress, await this.keyStore.getAccounts());
 
-    this.oracleHandler = new UtilityExecutionOracle(
+    this.oracleHandler = new UtilityExecutionOracle({
       contractAddress,
-      [],
-      [],
+      authWitnesses: [],
+      capsules: [],
       anchorBlockHeader,
-      this.contractStore,
-      this.noteStore,
-      this.keyStore,
-      this.addressStore,
-      this.stateMachine.node,
-      this.recipientTaggingStore,
-      this.senderAddressBookStore,
-      this.capsuleStore,
-      this.privateEventStore,
-      this.currentJobId,
-    );
+      contractStore: this.contractStore,
+      noteStore: this.noteStore,
+      keyStore: this.keyStore,
+      addressStore: this.addressStore,
+      aztecNode: this.stateMachine.node,
+      recipientTaggingStore: this.recipientTaggingStore,
+      senderAddressBookStore: this.senderAddressBookStore,
+      capsuleService: new CapsuleService(this.capsuleStore, await this.keyStore.getAccounts()),
+      privateEventStore: this.privateEventStore,
+      messageContextService: this.stateMachine.messageContextService,
+      contractSyncService: this.stateMachine.contractSyncService,
+      l2TipsStore: this.stateMachine.node,
+      jobId: this.currentJobId,
+      scopes: await this.keyStore.getAccounts(),
+      simulator: new WASMSimulator(),
+    });
 
     this.state = { name: 'UTILITY' };
     this.logger.debug(`Entered state ${this.state.name}`);
+
+    // Utility state anchors at whatever the anchor block store is pointing to (tracked as latest).
+    this.setLastCallContext(Fr.ZERO, anchorBlockHeader.globalVariables.timestamp);
   }
 
   private exitTopLevelState() {
@@ -444,8 +578,8 @@ export class TXESession implements TXESessionStateHandler {
 
     // 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
+    // others, it will create empty blocks (via `advanceBlocksBy` and `deploy`), create blocks with transactions via
+    // `privateCallNewFlow` and `publicCallNewFlow`, add accounts to PXE via `addAccount`, 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
@@ -499,30 +633,36 @@ export class TXESession implements TXESessionStateHandler {
   }
 
   private utilityExecutorForContractSync(anchorBlock: any) {
-    return async (call: FunctionCall) => {
+    return async (call: FunctionCall, scopes: AztecAddress[]) => {
       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.recipientTaggingStore,
-          this.senderAddressBookStore,
-          this.capsuleStore,
-          this.privateEventStore,
-          this.currentJobId,
-        );
-        await new WASMSimulator()
+        const simulator = new WASMSimulator();
+        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,
+          capsuleService: new CapsuleService(this.capsuleStore, scopes),
+          privateEventStore: this.privateEventStore,
+          messageContextService: this.stateMachine.messageContextService,
+          contractSyncService: this.stateMachine.contractSyncService,
+          l2TipsStore: this.stateMachine.node,
+          jobId: this.currentJobId,
+          scopes,
+          simulator,
+        });
+        await simulator
           .executeUserCircuit(toACVMWitness(0, call.args), entryPointArtifact, new Oracle(oracle).toACIRCallback())
           .catch((err: Error) => {
             err.message = resolveAssertionMessageFromError(err, entryPointArtifact);

package/src/util/encoding.ts

@@ -3,6 +3,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { type ContractArtifact, ContractArtifactSchema } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
 import { type ContractInstanceWithAddress, ContractInstanceWithAddressSchema } from '@aztec/stdlib/contract';
 
 import { z } from 'zod';
@@ -25,6 +26,10 @@ export function addressFromSingle(obj: ForeignCallSingle) {
   return new AztecAddress(fromSingle(obj));
 }
 
+export function blockHashFromSingle(obj: ForeignCallSingle) {
+  return new BlockHash(fromSingle(obj));
+}
+
 export function fromArray(obj: ForeignCallArray) {
   return obj.map(str => Fr.fromBuffer(hexToBuffer(str)));
 }

package/src/util/txe_public_contract_data_source.ts

@@ -1,19 +1,11 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 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 ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import {
-  type ContractClassPublic,
-  type ContractDataSource,
-  type ContractInstanceWithAddress,
-  computePrivateFunctionsRoot,
-  computePublicBytecodeCommitment,
-  getContractClassPrivateFunctionFromArtifact,
-} from '@aztec/stdlib/contract';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 export class TXEPublicContractDataSource implements ContractDataSource {
-  #privateFunctionsRoot: Map<string, Buffer> = new Map();
   constructor(
     private blockNumber: BlockNumber,
     private contractStore: ContractStore,
@@ -24,42 +16,22 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   }
 
   async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    const contractClass = await this.contractStore.getContractClass(id);
+    const contractClass = await this.contractStore.getContractClassWithPreimage(id);
     if (!contractClass) {
       return;
     }
-    const artifact = await this.contractStore.getContractArtifact(id);
-    if (!artifact) {
-      return;
-    }
-
-    let privateFunctionsRoot;
-    if (!this.#privateFunctionsRoot.has(id.toString())) {
-      const privateFunctions = await Promise.all(
-        artifact.functions
-          .filter(fn => fn.functionType === FunctionType.PRIVATE)
-          .map(fn => getContractClassPrivateFunctionFromArtifact(fn)),
-      );
-      privateFunctionsRoot = await computePrivateFunctionsRoot(privateFunctions);
-      this.#privateFunctionsRoot.set(id.toString(), privateFunctionsRoot.toBuffer());
-    } else {
-      privateFunctionsRoot = Fr.fromBuffer(this.#privateFunctionsRoot.get(id.toString())!);
-    }
-
     return {
-      id,
-      artifactHash: contractClass!.artifactHash,
-      packedBytecode: contractClass!.packedBytecode,
-      privateFunctionsRoot,
-      version: contractClass!.version,
-      privateFunctions: [],
-      utilityFunctions: [],
+      id: contractClass.id,
+      artifactHash: contractClass.artifactHash,
+      packedBytecode: contractClass.packedBytecode,
+      privateFunctionsRoot: contractClass.privateFunctionsRoot,
+      version: contractClass.version,
     };
   }
 
   async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
-    const contractClass = await this.contractStore.getContractClass(id);
-    return contractClass && computePublicBytecodeCommitment(contractClass.packedBytecode);
+    const contractClass = await this.contractStore.getContractClassWithPreimage(id);
+    return contractClass?.publicBytecodeCommitment;
   }
 
   async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {

package/dest/util/txe_contract_store.d.ts

@@ -1,12 +0,0 @@
-import type { ContractArtifact } from '@aztec/aztec.js/abi';
-import { Fr } from '@aztec/aztec.js/fields';
-import { ContractStore } from '@aztec/pxe/server';
-export type ContractArtifactWithHash = ContractArtifact & {
-    artifactHash: Fr;
-};
-export declare class TXEContractStore extends ContractStore {
-    #private;
-    addContractArtifact(id: Fr, artifact: ContractArtifact | ContractArtifactWithHash): Promise<void>;
-    getContractArtifact(contractClassId: Fr): Promise<ContractArtifact | ContractArtifactWithHash | undefined>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX2NvbnRyYWN0X3N0b3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbC90eGVfY29udHJhY3Rfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDNUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWxELE1BQU0sTUFBTSx3QkFBd0IsR0FBRyxnQkFBZ0IsR0FBRztJQUFFLFlBQVksRUFBRSxFQUFFLENBQUE7Q0FBRSxDQUFDO0FBTy9FLHFCQUFhLGdCQUFpQixTQUFRLGFBQWE7O0lBRzNCLG1CQUFtQixDQUN2QyxFQUFFLEVBQUUsRUFBRSxFQUNOLFFBQVEsRUFBRSxnQkFBZ0IsR0FBRyx3QkFBd0IsR0FDcEQsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUtmO0lBRXFCLG1CQUFtQixDQUN2QyxlQUFlLEVBQUUsRUFBRSxHQUNsQixPQUFPLENBQUMsZ0JBQWdCLEdBQUcsd0JBQXdCLEdBQUcsU0FBUyxDQUFDLENBUWxFO0NBQ0YifQ==

package/dest/util/txe_contract_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"txe_contract_store.d.ts","sourceRoot":"","sources":["../../src/util/txe_contract_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD,MAAM,MAAM,wBAAwB,GAAG,gBAAgB,GAAG;IAAE,YAAY,EAAE,EAAE,CAAA;CAAE,CAAC;AAO/E,qBAAa,gBAAiB,SAAQ,aAAa;;IAG3B,mBAAmB,CACvC,EAAE,EAAE,EAAE,EACN,QAAQ,EAAE,gBAAgB,GAAG,wBAAwB,GACpD,OAAO,CAAC,IAAI,CAAC,CAKf;IAEqB,mBAAmB,CACvC,eAAe,EAAE,EAAE,GAClB,OAAO,CAAC,gBAAgB,GAAG,wBAAwB,GAAG,SAAS,CAAC,CAQlE;CACF"}

package/dest/util/txe_contract_store.js

@@ -1,22 +0,0 @@
-import { Fr } from '@aztec/aztec.js/fields';
-import { ContractStore } from '@aztec/pxe/server';
-/*
- * 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 TXEContractStore extends ContractStore {
-    #artifactHashes = new Map();
-    async addContractArtifact(id, artifact) {
-        if ('artifactHash' in artifact) {
-            this.#artifactHashes.set(id.toString(), artifact.artifactHash.toBuffer());
-        }
-        await super.addContractArtifact(id, artifact);
-    }
-    async getContractArtifact(contractClassId) {
-        const artifact = await super.getContractArtifact(contractClassId);
-        if (artifact && this.#artifactHashes.has(contractClassId.toString())) {
-            artifact.artifactHash = Fr.fromBuffer(this.#artifactHashes.get(contractClassId.toString()));
-        }
-        return artifact;
-    }
-}

package/src/util/txe_contract_store.ts

@@ -1,36 +0,0 @@
-import type { ContractArtifact } from '@aztec/aztec.js/abi';
-import { Fr } from '@aztec/aztec.js/fields';
-import { ContractStore } from '@aztec/pxe/server';
-
-export type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
-
-/*
- * 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 TXEContractStore extends ContractStore {
-  #artifactHashes: Map<string, Buffer> = new Map();
-
-  public override async addContractArtifact(
-    id: Fr,
-    artifact: ContractArtifact | ContractArtifactWithHash,
-  ): Promise<void> {
-    if ('artifactHash' in artifact) {
-      this.#artifactHashes.set(id.toString(), artifact.artifactHash.toBuffer());
-    }
-    await super.addContractArtifact(id, artifact);
-  }
-
-  public override async getContractArtifact(
-    contractClassId: Fr,
-  ): Promise<ContractArtifact | ContractArtifactWithHash | undefined> {
-    const artifact = await super.getContractArtifact(contractClassId);
-    if (artifact && this.#artifactHashes.has(contractClassId.toString())) {
-      (artifact as ContractArtifactWithHash).artifactHash = Fr.fromBuffer(
-        this.#artifactHashes.get(contractClassId.toString())!,
-      );
-    }
-    return artifact;
-  }
-}