@aztec/txe 0.0.0-test.0 → 0.0.1-commit.001888fc

package/src/index.ts

@@ -1,25 +1,30 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
+import { type NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js/abi';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import {
-  AztecAddress,
-  type ContractArtifact,
   type ContractInstanceWithAddress,
-  Fr,
-  PublicKeys,
-  deriveKeys,
-  getContractInstanceFromDeployParams,
-  loadContractArtifact,
-} from '@aztec/aztec.js';
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys, deriveKeys } from '@aztec/aztec.js/keys';
 import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 import type { Logger } from '@aztec/foundation/log';
-import { type ProtocolContract, protocolContractNames } from '@aztec/protocol-contracts';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
-import type { ApiSchemaFor, ZodFor } from '@aztec/stdlib/schemas';
+import { ContractStore } from '@aztec/pxe/server';
+import { computeArtifactHash } from '@aztec/stdlib/contract';
+import type { ContractArtifactWithHash } from '@aztec/stdlib/contract';
+import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
+import { zodFor } from '@aztec/stdlib/schemas';
 
+import { createHash } from 'crypto';
+import { createReadStream } from 'fs';
 import { readFile, readdir } from 'fs/promises';
-import { join } from 'path';
+import { join, parse } from 'path';
 import { z } from 'zod';
 
-import { TXEService } from './txe_service/txe_service.js';
+import { type TXEOracleFunctionName, TXESession } from './txe_session.js';
 import {
   type ForeignCallArgs,
   ForeignCallArgsSchema,
@@ -27,107 +32,154 @@ import {
   type ForeignCallResult,
   ForeignCallResultSchema,
   type ForeignCallSingle,
+  addressFromSingle,
   fromArray,
   fromSingle,
-  toForeignCallResult,
   toSingle,
 } from './util/encoding.js';
 
-const TXESessions = new Map<number, TXEService>();
+const sessions = new Map<number, TXESession>();
 
-const TXEArtifactsCache = new Map<string, { artifact: ContractArtifact; instance: ContractInstanceWithAddress }>();
-
-type MethodNames<T> = {
-  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
-}[keyof T];
+/*
+ * TXE typically has to load the same contract artifacts over and over again for multiple tests,
+ * so we cache them here to avoid loading from disk repeatedly.
+ *
+ * The in-flight map coalesces concurrent requests for the same cache key so that
+ * computeArtifactHash (very expensive) is only run once even under parallelism.
+ */
+const TXEArtifactsCache = new Map<
+  string,
+  { artifact: ContractArtifactWithHash; instance: ContractInstanceWithAddress }
+>();
+const TXEArtifactsCacheInFlight = new Map<
+  string,
+  Promise<{ artifact: ContractArtifactWithHash; instance: ContractInstanceWithAddress }>
+>();
 
 type TXEForeignCallInput = {
   session_id: number;
-  function: MethodNames<TXEService> | 'reset';
+  function: TXEOracleFunctionName;
   root_path: string;
   package_name: string;
   inputs: ForeignCallArgs;
 };
 
-const TXEForeignCallInputSchema = z.object({
-  // eslint-disable-next-line camelcase
-  session_id: z.number().int().nonnegative(),
-  function: z.string() as ZodFor<MethodNames<TXEService> | 'reset'>,
-  // eslint-disable-next-line camelcase
-  root_path: z.string(),
-  // eslint-disable-next-line camelcase
-  package_name: z.string(),
-  inputs: ForeignCallArgsSchema,
-}) satisfies ZodFor<TXEForeignCallInput>;
+const TXEForeignCallInputSchema = zodFor<TXEForeignCallInput>()(
+  z.object({
+    // eslint-disable-next-line camelcase
+    session_id: z.number().int().nonnegative(),
+    function: z.string() as z.ZodType<TXEOracleFunctionName>,
+    // eslint-disable-next-line camelcase
+    root_path: z.string(),
+    // eslint-disable-next-line camelcase
+    package_name: z.string(),
+    inputs: ForeignCallArgsSchema,
+  }),
+);
 
 class TXEDispatcher {
-  private protocolContracts!: ProtocolContract[];
+  private contractStore!: ContractStore;
 
   constructor(private logger: Logger) {}
 
+  private fastHashFile(path: string) {
+    return new Promise(resolve => {
+      const fd = createReadStream(path);
+      const hash = createHash('sha1');
+      hash.setEncoding('hex');
+
+      fd.on('end', function () {
+        hash.end();
+        resolve(hash.read());
+      });
+
+      fd.pipe(hash);
+    });
+  }
+
   async #processDeployInputs({ inputs, root_path: rootPath, package_name: packageName }: TXEForeignCallInput) {
-    const [pathStr, contractName, initializer] = inputs.slice(0, 3).map(input =>
+    const [contractPath, initializer] = inputs.slice(0, 2).map(input =>
       fromArray(input as ForeignCallArray)
         .map(char => String.fromCharCode(char.toNumber()))
         .join(''),
     );
 
-    const decodedArgs = fromArray(inputs[4] as ForeignCallArray);
-    const secret = fromSingle(inputs[5] as ForeignCallSingle);
+    const decodedArgs = fromArray(inputs[3] as ForeignCallArray);
+    const secret = fromSingle(inputs[4] as ForeignCallSingle);
+    const salt = fromSingle(inputs[5] as ForeignCallSingle);
+    const deployer = addressFromSingle(inputs[6] as ForeignCallSingle);
     const publicKeys = secret.equals(Fr.ZERO) ? PublicKeys.default() : (await deriveKeys(secret)).publicKeys;
     const publicKeysHash = await publicKeys.hash();
 
-    const cacheKey = `${pathStr}-${contractName}-${initializer}-${decodedArgs
+    let artifactPath = '';
+    const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
+    if (contractDirectory) {
+      if (contractDirectory.includes('@')) {
+        // We're deploying a contract that belongs in a workspace
+        // env.deploy("../path/to/workspace/root@packageName/contractName")
+        const [workspace, pkg] = contractDirectory.split('@');
+        const targetPath = join(rootPath, workspace, '/target');
+        this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
+        artifactPath = join(targetPath, `${pkg}-${contractFilename}.json`);
+      } else {
+        // We're deploying a standalone external contract
+        // env.deploy("../path/to/contract/root/contractName")
+        const targetPath = join(rootPath, contractDirectory, '/target');
+        this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
+        [artifactPath] = (await readdir(targetPath)).filter(file => file.endsWith(`-${contractFilename}.json`));
+      }
+    } else {
+      // We're deploying a local contract
+      // env.deploy("contractName")
+      artifactPath = join(rootPath, './target', `${packageName}-${contractFilename}.json`);
+    }
+
+    const fileHash = await this.fastHashFile(artifactPath);
+
+    const cacheKey = `${contractDirectory ?? ''}-${contractFilename}-${initializer}-${decodedArgs
       .map(arg => arg.toString())
-      .join('-')}-${publicKeysHash.toString()}`;
+      .join('-')}-${publicKeysHash}-${salt}-${deployer}-${fileHash}`;
 
-    let artifact;
     let instance;
+    let artifact: ContractArtifactWithHash;
 
     if (TXEArtifactsCache.has(cacheKey)) {
       this.logger.debug(`Using cached artifact for ${cacheKey}`);
       ({ artifact, instance } = TXEArtifactsCache.get(cacheKey)!);
     } else {
-      let artifactPath = '';
-      // We're deploying the contract under test
-      // env.deploy_self("contractName")
-      if (!pathStr) {
-        artifactPath = join(rootPath, './target', `${packageName}-${contractName}.json`);
-      } else {
-        // We're deploying a contract that belongs in a workspace
-        // env.deploy("../path/to/workspace/root@packageName", "contractName")
-        if (pathStr.includes('@')) {
-          const [workspace, pkg] = pathStr.split('@');
-          const targetPath = join(rootPath, workspace, './target');
-          this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
-          artifactPath = join(targetPath, `${pkg}-${contractName}.json`);
-        } else {
-          // We're deploying a standalone contract
-          // env.deploy("../path/to/contract/root", "contractName")
-          const targetPath = join(rootPath, pathStr, './target');
-          this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
-          [artifactPath] = (await readdir(targetPath)).filter(file => file.endsWith(`-${contractName}.json`));
-        }
+      if (!TXEArtifactsCacheInFlight.has(cacheKey)) {
+        this.logger.debug(`Loading compiled artifact ${artifactPath}`);
+        const compute = async () => {
+          const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8')) as NoirCompiledContract;
+          const artifactWithoutHash = loadContractArtifact(artifactJSON);
+          const computedArtifact: ContractArtifactWithHash = {
+            ...artifactWithoutHash,
+            // Artifact hash is *very* expensive to compute, so we do it here once
+            // and the TXE contract data provider can cache it
+            artifactHash: await computeArtifactHash(artifactWithoutHash),
+          };
+          this.logger.debug(
+            `Deploy ${computedArtifact.name} with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`,
+          );
+          const computedInstance = await getContractInstanceFromInstantiationParams(computedArtifact, {
+            constructorArgs: decodedArgs,
+            skipArgsDecoding: true,
+            salt,
+            publicKeys,
+            constructorArtifact: initializer ? initializer : undefined,
+            deployer,
+          });
+          const result = { artifact: computedArtifact, instance: computedInstance };
+          TXEArtifactsCache.set(cacheKey, result);
+          TXEArtifactsCacheInFlight.delete(cacheKey);
+          return result;
+        };
+        TXEArtifactsCacheInFlight.set(cacheKey, compute());
       }
-      this.logger.debug(`Loading compiled artifact ${artifactPath}`);
-      artifact = loadContractArtifact(JSON.parse(await readFile(artifactPath, 'utf-8')));
-      this.logger.debug(
-        `Deploy ${
-          artifact.name
-        } with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`,
-      );
-      instance = await getContractInstanceFromDeployParams(artifact, {
-        constructorArgs: decodedArgs,
-        skipArgsDecoding: true,
-        salt: Fr.ONE,
-        publicKeys,
-        constructorArtifact: initializer ? initializer : undefined,
-        deployer: AztecAddress.ZERO,
-      });
-      TXEArtifactsCache.set(cacheKey, { artifact, instance });
+      ({ artifact, instance } = await TXEArtifactsCacheInFlight.get(cacheKey)!);
     }
 
-    inputs.splice(0, 2, artifact, instance, toSingle(secret));
+    inputs.splice(0, 1, artifact, instance, toSingle(secret));
   }
 
   async #processAddAccountInputs({ inputs }: TXEForeignCallInput) {
@@ -135,25 +187,42 @@ class TXEDispatcher {
 
     const cacheKey = `SchnorrAccountContract-${secret}`;
 
-    let artifact;
+    let artifact: ContractArtifactWithHash;
     let instance;
 
     if (TXEArtifactsCache.has(cacheKey)) {
       this.logger.debug(`Using cached artifact for ${cacheKey}`);
       ({ artifact, instance } = TXEArtifactsCache.get(cacheKey)!);
     } else {
-      const keys = await deriveKeys(secret);
-      const args = [keys.publicKeys.masterIncomingViewingPublicKey.x, keys.publicKeys.masterIncomingViewingPublicKey.y];
-      artifact = SchnorrAccountContractArtifact;
-      instance = await getContractInstanceFromDeployParams(artifact, {
-        constructorArgs: args,
-        skipArgsDecoding: true,
-        salt: Fr.ONE,
-        publicKeys: keys.publicKeys,
-        constructorArtifact: 'constructor',
-        deployer: AztecAddress.ZERO,
-      });
-      TXEArtifactsCache.set(cacheKey, { artifact, instance });
+      if (!TXEArtifactsCacheInFlight.has(cacheKey)) {
+        const compute = async () => {
+          const keys = await deriveKeys(secret);
+          const args = [
+            keys.publicKeys.masterIncomingViewingPublicKey.x,
+            keys.publicKeys.masterIncomingViewingPublicKey.y,
+          ];
+          const computedArtifact: ContractArtifactWithHash = {
+            ...SchnorrAccountContractArtifact,
+            // Artifact hash is *very* expensive to compute, so we do it here once
+            // and the TXE contract data provider can cache it
+            artifactHash: await computeArtifactHash(SchnorrAccountContractArtifact),
+          };
+          const computedInstance = await getContractInstanceFromInstantiationParams(computedArtifact, {
+            constructorArgs: args,
+            skipArgsDecoding: true,
+            salt: Fr.ONE,
+            publicKeys: keys.publicKeys,
+            constructorArtifact: 'constructor',
+            deployer: AztecAddress.ZERO,
+          });
+          const result = { artifact: computedArtifact, instance: computedInstance };
+          TXEArtifactsCache.set(cacheKey, result);
+          TXEArtifactsCacheInFlight.delete(cacheKey);
+          return result;
+        };
+        TXEArtifactsCacheInFlight.set(cacheKey, compute());
+      }
+      ({ artifact, instance } = await TXEArtifactsCacheInFlight.get(cacheKey)!);
     }
 
     inputs.splice(0, 0, artifact, instance);
@@ -164,35 +233,34 @@ class TXEDispatcher {
     const { session_id: sessionId, function: functionName, inputs } = callData;
     this.logger.debug(`Calling ${functionName} on session ${sessionId}`);
 
-    if (!TXESessions.has(sessionId) && functionName != 'reset') {
+    if (!sessions.has(sessionId)) {
       this.logger.debug(`Creating new session ${sessionId}`);
-      if (!this.protocolContracts) {
-        this.protocolContracts = await Promise.all(
-          protocolContractNames.map(name => new BundledProtocolContractsProvider().getProtocolContractArtifact(name)),
-        );
+      if (!this.contractStore) {
+        const kvStore = await openTmpStore('txe-contracts');
+        this.contractStore = new ContractStore(kvStore);
+        const provider = new BundledProtocolContractsProvider();
+        for (const name of protocolContractNames) {
+          const { instance, artifact } = await provider.getProtocolContractArtifact(name);
+          await this.contractStore.addContractArtifact(artifact);
+          await this.contractStore.addContractInstance(instance);
+        }
+        this.logger.debug('Registered protocol contracts in shared contract store');
       }
-      TXESessions.set(sessionId, await TXEService.init(this.logger, this.protocolContracts));
+      sessions.set(sessionId, await TXESession.init(this.contractStore));
     }
 
     switch (functionName) {
-      case 'reset': {
-        TXESessions.delete(sessionId) &&
-          this.logger.debug(`Called reset on session ${sessionId}, yeeting it out of existence`);
-        return toForeignCallResult([]);
-      }
-      case 'deploy': {
+      case 'aztec_txe_deploy': {
         await this.#processDeployInputs(callData);
         break;
       }
-      case 'addAccount': {
+      case 'aztec_txe_addAccount': {
         await this.#processAddAccountInputs(callData);
         break;
       }
     }
 
-    const txeService = TXESessions.get(sessionId);
-    const response = await (txeService as any)[functionName](...inputs);
-    return response;
+    return await sessions.get(sessionId)!.processFunction(functionName, inputs);
   }
 }
 

package/src/oracle/interfaces.ts

@@ -0,0 +1,87 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { CompleteAddress } from '@aztec/aztec.js/addresses';
+import type { ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
+import { TxHash } from '@aztec/aztec.js/tx';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EventSelector, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+// These interfaces complement the ones defined in PXE, and combined with those contain the full list of oracles used by
+// aztec-nr. In particular, these include the ones needed to run Brillig code associated to #[external("public")] functions that has
+// not been transpiled (e.g. in the context of a Noir test) as well as the ones associated with managing the state of
+// such a Noir test (deploying contracts, manipulating block time, making calls, etc) - the so called 'top level test
+// context'.
+
+/**
+ * Oracle methods associated with the execution of an Aztec #[external("public")] function.
+ *
+ * Note that real contracts have their Brillig calls to these be transpiled into opcodes, the oracles are only executed
+ * as such when running the original Brillig code, e.g. when invoking functions that interact with a PublicContext
+ * directly in a Noir test.
+ */
+export interface IAvmExecutionOracle {
+  isAvm: true;
+
+  address(): Promise<AztecAddress>;
+  sender(): Promise<AztecAddress>;
+  blockNumber(): Promise<BlockNumber>;
+  timestamp(): Promise<bigint>;
+  isStaticCall(): Promise<boolean>;
+  chainId(): Promise<Fr>;
+  version(): Promise<Fr>;
+  emitNullifier(nullifier: Fr): Promise<void>;
+  emitNoteHash(noteHash: Fr): Promise<void>;
+  nullifierExists(siloedNullifier: Fr): Promise<boolean>;
+  storageWrite(slot: Fr, value: Fr): Promise<void>;
+  storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr>;
+}
+
+/**
+ * Oracle methods associated with the execution of an Aztec Noir test.
+ */
+export interface ITxeExecutionOracle {
+  isTxe: true;
+
+  getDefaultAddress(): AztecAddress;
+  getNextBlockNumber(): Promise<BlockNumber>;
+  getNextBlockTimestamp(): Promise<UInt64>;
+  advanceBlocksBy(blocks: number): Promise<void>;
+  advanceTimestampBy(duration: UInt64): void;
+  deploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, foreignSecret: Fr): Promise<void>;
+  createAccount(secret: Fr): Promise<CompleteAddress>;
+  addAccount(artifact: ContractArtifact, instance: ContractInstanceWithAddress, secret: Fr): Promise<CompleteAddress>;
+  addAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+  getLastBlockTimestamp(): Promise<bigint>;
+  getLastTxEffects(): Promise<{
+    txHash: TxHash;
+    noteHashes: Fr[];
+    nullifiers: Fr[];
+  }>;
+  getPrivateEvents(selector: EventSelector, contractAddress: AztecAddress, scope: AztecAddress): Promise<Fr[][]>;
+  privateCallNewFlow(
+    from: AztecAddress,
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    args: Fr[],
+    argsHash: Fr,
+    isStaticCall: boolean,
+    jobId: string,
+  ): Promise<Fr[]>;
+  executeUtilityFunction(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    args: Fr[],
+    jobId: string,
+  ): Promise<Fr[]>;
+  publicCallNewFlow(
+    from: AztecAddress,
+    targetContractAddress: AztecAddress,
+    calldata: Fr[],
+    isStaticCall: boolean,
+  ): Promise<Fr[]>;
+  // TODO(F-335): Drop this from here as it's not a real oracle handler - it's only called from
+  // RPCTranslator::txeGetPrivateEvents and never from Noir.
+  syncContractNonOracleMethod(contractAddress: AztecAddress, scope: AztecAddress, jobId: string): Promise<void>;
+}

package/src/oracle/txe_oracle_public_context.ts

@@ -0,0 +1,158 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { L2Block } from '@aztec/stdlib/block';
+import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import {
+  MerkleTreeId,
+  type MerkleTreeWriteOperations,
+  PublicDataTreeLeaf,
+  PublicDataTreeLeafPreimage,
+} from '@aztec/stdlib/trees';
+import { GlobalVariables, TxEffect, TxHash } from '@aztec/stdlib/tx';
+
+import { insertTxEffectIntoWorldTrees, makeTXEBlock } from '../utils/block_creation.js';
+import type { IAvmExecutionOracle } from './interfaces.js';
+
+export class TXEOraclePublicContext implements IAvmExecutionOracle {
+  isAvm = true as const;
+
+  private logger: Logger;
+  private transientUniqueNoteHashes: Fr[] = [];
+  private transientSiloedNullifiers: Fr[] = [];
+  private publicDataWrites: PublicDataWrite[] = [];
+
+  constructor(
+    private contractAddress: AztecAddress,
+    private forkedWorldTrees: MerkleTreeWriteOperations,
+    private txRequestHash: Fr,
+    private globalVariables: GlobalVariables,
+  ) {
+    this.logger = createLogger('txe:public_context');
+
+    this.logger.debug('Entering Public Context', {
+      contractAddress,
+      blockNumber: globalVariables.blockNumber,
+      timestamp: globalVariables.timestamp,
+    });
+  }
+
+  address(): Promise<AztecAddress> {
+    return Promise.resolve(this.contractAddress);
+  }
+
+  sender(): Promise<AztecAddress> {
+    return Promise.resolve(AztecAddress.ZERO); // todo: change?
+  }
+
+  blockNumber(): Promise<BlockNumber> {
+    return Promise.resolve(this.globalVariables.blockNumber);
+  }
+
+  timestamp(): Promise<bigint> {
+    return Promise.resolve(this.globalVariables.timestamp);
+  }
+
+  isStaticCall(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  chainId(): Promise<Fr> {
+    return Promise.resolve(this.globalVariables.chainId);
+  }
+
+  version(): Promise<Fr> {
+    return Promise.resolve(this.globalVariables.version);
+  }
+
+  async emitNullifier(nullifier: Fr) {
+    const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
+    this.transientSiloedNullifiers.push(siloedNullifier);
+  }
+
+  async emitNoteHash(noteHash: Fr) {
+    const siloedNoteHash = await siloNoteHash(this.contractAddress, noteHash);
+    // TODO: make the note hash unique - they are only siloed right now
+    this.transientUniqueNoteHashes.push(siloedNoteHash);
+  }
+
+  async nullifierExists(siloedNullifier: Fr): Promise<boolean> {
+    const treeIndex = (
+      await this.forkedWorldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()])
+    )[0];
+    const transientIndex = this.transientSiloedNullifiers.find(n => n.equals(siloedNullifier));
+
+    return treeIndex !== undefined || transientIndex !== undefined;
+  }
+
+  async storageWrite(slot: Fr, value: Fr) {
+    this.logger.debug('AVM storage write', { slot, value });
+
+    const dataWrite = new PublicDataWrite(await computePublicDataTreeLeafSlot(this.contractAddress, slot), value);
+
+    this.publicDataWrites.push(dataWrite);
+
+    await this.forkedWorldTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+      new PublicDataTreeLeaf(dataWrite.leafSlot, dataWrite.value).toBuffer(),
+    ]);
+  }
+
+  async storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr> {
+    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
+
+    const lowLeafResult = await this.forkedWorldTrees.getPreviousValueIndex(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      leafSlot.toBigInt(),
+    );
+
+    const value =
+      !lowLeafResult || !lowLeafResult.alreadyPresent
+        ? Fr.ZERO
+        : (
+            (await this.forkedWorldTrees.getLeafPreimage(
+              MerkleTreeId.PUBLIC_DATA_TREE,
+              lowLeafResult.index,
+            )) as PublicDataTreeLeafPreimage
+          ).leaf.value;
+
+    this.logger.debug('AVM storage read', { slot, contractAddress, value });
+
+    return value;
+  }
+
+  async close(): Promise<L2Block> {
+    this.logger.debug('Exiting Public Context, building block with collected side effects', {
+      blockNumber: this.globalVariables.blockNumber,
+    });
+
+    const txEffect = this.makeTxEffect();
+    await insertTxEffectIntoWorldTrees(txEffect, this.forkedWorldTrees);
+
+    const block = await makeTXEBlock(this.forkedWorldTrees, this.globalVariables, [txEffect]);
+
+    await this.forkedWorldTrees.close();
+
+    this.logger.debug('Exited PublicContext with built block', {
+      blockNumber: block.number,
+      txEffects: block.body.txEffects,
+    });
+
+    return block;
+  }
+
+  private makeTxEffect(): TxEffect {
+    const txEffect = TxEffect.empty();
+
+    txEffect.noteHashes = this.transientUniqueNoteHashes;
+    txEffect.nullifiers = [this.txRequestHash, ...this.transientSiloedNullifiers];
+
+    txEffect.publicDataWrites = this.publicDataWrites;
+    // TODO: support public logs
+
+    txEffect.txHash = new TxHash(new Fr(this.globalVariables.blockNumber));
+
+    return txEffect;
+  }
+}