@aztec/txe 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/src/txe_session.ts

@@ -1,4 +1,5 @@
-import { AztecAddress, Fr } from '@aztec/aztec.js';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+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';
@@ -7,48 +8,83 @@ import {
   AddressDataProvider,
   CapsuleDataProvider,
   NoteDataProvider,
+  PXEOracleInterface,
   PrivateEventDataProvider,
   TaggingDataProvider,
 } from '@aztec/pxe/server';
-import type { PrivateContextInputs } from '@aztec/stdlib/kernel';
-import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import type { UInt32 } from '@aztec/stdlib/types';
-
-import { TXE } from './oracle/txe_oracle.js';
+import {
+  ExecutionNoteCache,
+  ExecutionTaggingIndexCache,
+  HashedValuesCache,
+  type IPrivateExecutionOracle,
+  type IUtilityExecutionOracle,
+  PrivateExecutionOracle,
+  UtilityExecutionOracle,
+} from '@aztec/pxe/simulator';
+import { FunctionSelector } 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 { CallContext, GlobalVariables, TxContext } from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+import type { IAvmExecutionOracle, ITxeExecutionOracle } from './oracle/interfaces.js';
 import { TXEOraclePublicContext } from './oracle/txe_oracle_public_context.js';
-import type { TXETypedOracle } from './oracle/txe_typed_oracle.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 { TXEService } from './txe_service/txe_service.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 { makeTxEffect } from './utils/tx_effect_creation.js';
 
 /**
- * A TXE Session can be ine one of four states, which change as the test progresses and different oracles are called.
- * The current state determines which oracles are available.
+ * A TXE Session can be in one of four states, which change as the test progresses and different oracles are called.
+ * The current state determines which oracles are available. Some states also have data associated with them.
  */
-enum SessionState {
+type SessionState =
   /**
    * The top-level state is the default state, before any other state has been entered. This is where contracts can be
    * deployed, accounts created, blocks mined, etc.
    */
-  TOP_LEVEL,
+  | {
+      name: 'TOP_LEVEL';
+    }
   /**
-   * The private state is entered via the `private_context` function. In this state the PXE oracles that `#[private]`
+   * The private state is entered via the `private_context` function. In this state the PXE oracles that `#[external("private")]`
    * functions use are available, such as those related to note retrieval, notification of side-effects, capsule access,
    * etc. */
-  PRIVATE,
+  | {
+      name: 'PRIVATE';
+      nextBlockGlobalVariables: GlobalVariables;
+      protocolNullifier: Fr;
+      noteCache: ExecutionNoteCache;
+      taggingIndexCache: ExecutionTaggingIndexCache;
+    }
   /**
-   * The public state is entered via the `public_context` function. In this state the AVM opcodes that `#[public]`
+   * The public state is entered via the `public_context` function. In this state the AVM opcodes that `#[external("public")]`
    * functions execute are resolved as oracles by TXE, since Noir tests are not transpiled. */
-  PUBLIC,
+  | {
+      name: 'PUBLIC';
+    }
   /**
-   * The utility state is entered via the `utility_context` function. In this state the PXE oracles that `#[utility]`
+   * The utility state is entered via the `utility_context` function. In this state the PXE oracles that `#[external("utility")]`
    * functions use are available, such as those related to (unconstrained) note retrieval, capsule access, public
    * storage reads, etc.
    */
-  UTILITY,
-}
+  | {
+      name: 'UTILITY';
+    };
 
 type MethodNames<T> = {
   [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
@@ -58,13 +94,16 @@ type MethodNames<T> = {
  * The name of an oracle function that TXE supports, which are a combination of PXE oracles, non-transpiled AVM opcodes,
  * and custom TXE oracles.
  */
-export type TXEOracleFunctionName = MethodNames<TXEService>;
+export type TXEOracleFunctionName = Exclude<
+  MethodNames<RPCTranslator>,
+  'constructor' | 'handlerAsMisc' | 'handlerAsUtility' | 'handlerAsPrivate' | 'handlerAsAvm' | 'handlerAsTxe'
+>;
 
 export interface TXESessionStateHandler {
-  setTopLevelContext(): Promise<void>;
-  setPublicContext(contractAddress?: AztecAddress): Promise<void>;
-  setPrivateContext(contractAddress?: AztecAddress, historicalBlockNumber?: UInt32): Promise<PrivateContextInputs>;
-  setUtilityContext(contractAddress?: AztecAddress): Promise<void>;
+  enterTopLevelState(): Promise<void>;
+  enterPublicState(contractAddress?: AztecAddress): Promise<void>;
+  enterPrivateState(contractAddress?: AztecAddress, anchorBlockNumber?: BlockNumber): Promise<PrivateContextInputs>;
+  enterUtilityState(contractAddress?: AztecAddress): Promise<void>;
 }
 
 const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
@@ -74,13 +113,25 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
  * state, etc., independent of all other tests running in parallel.
  */
 export class TXESession implements TXESessionStateHandler {
-  state = SessionState.TOP_LEVEL;
+  private state: SessionState = { name: 'TOP_LEVEL' };
+  private authwits: Map<string, AuthWitness> = new Map();
 
   constructor(
     private logger: Logger,
     private stateMachine: TXEStateMachine,
-    private oracleHandler: TXETypedOracle,
-    private legacyTXEOracle: TXE,
+    private oracleHandler:
+      | IUtilityExecutionOracle
+      | IPrivateExecutionOracle
+      | IAvmExecutionOracle
+      | ITxeExecutionOracle,
+    private contractDataProvider: TXEContractDataProvider,
+    private keyStore: KeyStore,
+    private addressDataProvider: AddressDataProvider,
+    private accountDataProvider: TXEAccountDataProvider,
+    private chainId: Fr,
+    private version: Fr,
+    private nextBlockTimestamp: bigint,
+    private pxeOracleInterface: PXEOracleInterface,
   ) {}
 
   static async init(protocolContracts: ProtocolContract[]) {
@@ -103,22 +154,49 @@ export class TXESession implements TXESessionStateHandler {
 
     const stateMachine = await TXEStateMachine.create(store);
 
-    const txeOracle = new TXE(
+    const nextBlockTimestamp = BigInt(Math.floor(new Date().getTime() / 1000));
+    const version = new Fr(await stateMachine.node.getVersion());
+    const chainId = new Fr(await stateMachine.node.getChainId());
+
+    const pxeOracleInterface = new PXEOracleInterface(
+      stateMachine.node,
       keyStore,
       contractDataProvider,
       noteDataProvider,
       capsuleDataProvider,
+      stateMachine.syncDataProvider,
       taggingDataProvider,
       addressDataProvider,
       privateEventDataProvider,
-      accountDataProvider,
-      DEFAULT_ADDRESS,
-      await stateMachine.synchronizer.nativeWorldStateService.fork(),
+    );
+
+    const topLevelOracleHandler = new TXEOracleTopLevelContext(
       stateMachine,
+      contractDataProvider,
+      keyStore,
+      addressDataProvider,
+      accountDataProvider,
+      pxeOracleInterface,
+      nextBlockTimestamp,
+      version,
+      chainId,
+      new Map(),
     );
-    await txeOracle.txeAdvanceBlocksBy(1);
+    await topLevelOracleHandler.txeAdvanceBlocksBy(1);
 
-    return new TXESession(createLogger('txe:session'), stateMachine, txeOracle, txeOracle);
+    return new TXESession(
+      createLogger('txe:session'),
+      stateMachine,
+      topLevelOracleHandler,
+      contractDataProvider,
+      keyStore,
+      addressDataProvider,
+      accountDataProvider,
+      version,
+      chainId,
+      nextBlockTimestamp,
+      pxeOracleInterface,
+    );
   }
 
   /**
@@ -128,94 +206,229 @@ export class TXESession implements TXESessionStateHandler {
    * @returns The oracle return values.
    */
   processFunction(functionName: TXEOracleFunctionName, inputs: ForeignCallArgs): Promise<ForeignCallResult> {
-    return (new TXEService(this, this.oracleHandler) as any)[functionName](...inputs);
+    try {
+      const translator = new RPCTranslator(this, this.oracleHandler) as any;
+      // We perform a runtime validation to check that the function name corresponds to a real oracle handler.
+      const validatedFunctionName = z
+        .string()
+        .refine(fn => typeof translator[fn] === 'function' && !fn.startsWith('handlerAs') && fn !== 'constructor')
+        .parse(functionName) as TXEOracleFunctionName;
+
+      return translator[validatedFunctionName](...inputs);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error(`${functionName} does not correspond to any oracle handler available on RPCTranslator`);
+      } else if (error instanceof Error) {
+        throw new Error(
+          `Execution error while processing function ${functionName} in state ${this.state.name}: ${error.message}`,
+        );
+      } else {
+        throw new Error(
+          `Unknown execution error while processing function ${functionName} in state ${this.state.name}`,
+        );
+      }
+    }
   }
 
-  async setTopLevelContext(): Promise<void> {
-    if (this.state == SessionState.PRIVATE) {
-      await this.oracleHandler.txeAdvanceBlocksBy(1);
-      this.oracleHandler.txeSetContractAddress(DEFAULT_ADDRESS);
-    } else if (this.state == SessionState.PUBLIC) {
-      const block = await (this.oracleHandler as TXEOraclePublicContext).close();
-
-      await this.stateMachine.handleL2Block(block);
-
-      this.legacyTXEOracle.baseFork = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
-      this.legacyTXEOracle.txeSetContractAddress(DEFAULT_ADDRESS);
-      this.legacyTXEOracle.setBlockNumber(block.number + 1);
-
-      this.oracleHandler = this.legacyTXEOracle;
-    } else if (this.state == SessionState.UTILITY) {
-      this.oracleHandler.txeSetContractAddress(DEFAULT_ADDRESS);
-    } else if (this.state == SessionState.TOP_LEVEL) {
-      throw new Error(`Expected to be in state other than ${SessionState[SessionState.TOP_LEVEL]}`);
-    } else {
-      throw new Error(`Unexpected state '${this.state}'`);
+  async enterTopLevelState() {
+    switch (this.state.name) {
+      case 'PRIVATE': {
+        await this.exitPrivateState();
+        break;
+      }
+      case 'PUBLIC': {
+        await this.exitPublicState();
+        break;
+      }
+      case 'UTILITY': {
+        this.exitUtilityContext();
+        break;
+      }
+      case 'TOP_LEVEL': {
+        throw new Error(`Expected to be in state other than TOP_LEVEL`);
+      }
+      default: {
+        this.state satisfies never;
+      }
     }
 
-    this.state = SessionState.TOP_LEVEL;
-    this.logger.debug(`Entered state ${SessionState[this.state]}`);
+    this.oracleHandler = new TXEOracleTopLevelContext(
+      this.stateMachine,
+      this.contractDataProvider,
+      this.keyStore,
+      this.addressDataProvider,
+      this.accountDataProvider,
+      this.pxeOracleInterface,
+      this.nextBlockTimestamp,
+      this.version,
+      this.chainId,
+      this.authwits,
+    );
+
+    this.state = { name: 'TOP_LEVEL' };
+    this.logger.debug(`Entered state ${this.state.name}`);
   }
 
-  async setPublicContext(contractAddress?: AztecAddress): Promise<void> {
-    this.assertInTopLevelState();
+  async enterPrivateState(
+    contractAddress: AztecAddress = DEFAULT_ADDRESS,
+    anchorBlockNumber?: BlockNumber,
+  ): 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);
+
+    // Private execution has two associated block numbers: the anchor block (i.e. the historical block that is used to
+    // build the proof), and the *next* block, i.e. the one we'll create once the execution ends, and which will contain
+    // a single transaction with the effects of what was done in the test.
+    const anchorBlock = await this.stateMachine.node.getBlockHeader(anchorBlockNumber ?? 'latest');
+    const latestBlock = await this.stateMachine.node.getBlockHeader('latest');
+
+    const nextBlockGlobalVariables = makeGlobalVariables(undefined, {
+      blockNumber: BlockNumber(latestBlock!.globalVariables.blockNumber + 1),
+      timestamp: this.nextBlockTimestamp,
+      version: this.version,
+      chainId: this.chainId,
+    });
 
+    const txRequestHash = getSingleTxBlockRequestHash(nextBlockGlobalVariables.blockNumber);
+    const protocolNullifier = await computeProtocolNullifier(txRequestHash);
+    const noteCache = new ExecutionNoteCache(protocolNullifier);
+    const taggingIndexCache = new ExecutionTaggingIndexCache();
+
+    this.oracleHandler = new PrivateExecutionOracle(
+      Fr.ZERO,
+      new TxContext(this.chainId, this.version, GasSettings.empty()),
+      new CallContext(AztecAddress.ZERO, contractAddress, FunctionSelector.empty(), false),
+      anchorBlock!,
+      [],
+      [],
+      new HashedValuesCache(),
+      noteCache,
+      taggingIndexCache,
+      this.pxeOracleInterface,
+    );
+
+    // 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.logger.debug(`Entered state ${this.state.name}`);
+
+    return (this.oracleHandler as PrivateExecutionOracle).getPrivateContextInputs();
+  }
+
+  async enterPublicState(contractAddress?: AztecAddress) {
+    this.exitTopLevelState();
+
+    // 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 globalVariables = makeGlobalVariables(undefined, {
-      blockNumber: await this.legacyTXEOracle.utilityGetBlockNumber(),
-      timestamp: await this.legacyTXEOracle.utilityGetTimestamp(),
-      version: await this.legacyTXEOracle.utilityGetVersion(),
-      chainId: await this.legacyTXEOracle.utilityGetChainId(),
+      blockNumber: BlockNumber(latestBlockNumber + 1),
+      timestamp: this.nextBlockTimestamp,
+      version: this.version,
+      chainId: this.chainId,
     });
 
-    const txRequestHash = new Fr(globalVariables.blockNumber + 6969);
-
     this.oracleHandler = new TXEOraclePublicContext(
       contractAddress ?? DEFAULT_ADDRESS,
       await this.stateMachine.synchronizer.nativeWorldStateService.fork(),
-      txRequestHash,
+      getSingleTxBlockRequestHash(globalVariables.blockNumber),
       globalVariables,
     );
 
-    this.state = SessionState.PUBLIC;
-    this.logger.debug(`Entered state ${SessionState[this.state]}`);
+    this.state = { name: 'PUBLIC' };
+    this.logger.debug(`Entered state ${this.state.name}`);
   }
 
-  async setPrivateContext(
-    contractAddress?: AztecAddress,
-    historicalBlockNumber?: UInt32,
-  ): Promise<PrivateContextInputs> {
-    this.assertInTopLevelState();
-
-    if (contractAddress) {
-      this.oracleHandler.txeSetContractAddress(contractAddress);
-    }
+  async enterUtilityState(contractAddress: AztecAddress = DEFAULT_ADDRESS) {
+    this.exitTopLevelState();
 
-    const privateContextInputs = await this.oracleHandler.txeGetPrivateContextInputs(historicalBlockNumber);
+    // 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);
 
-    this.state = SessionState.PRIVATE;
-    this.logger.debug(`Entered state ${SessionState[this.state]}`);
+    this.oracleHandler = new UtilityExecutionOracle(contractAddress, [], [], this.pxeOracleInterface);
 
-    return privateContextInputs;
+    this.state = { name: 'UTILITY' };
+    this.logger.debug(`Entered state ${this.state.name}`);
   }
 
-  setUtilityContext(contractAddress?: AztecAddress): Promise<void> {
-    this.assertInTopLevelState();
+  private exitTopLevelState() {
+    if (this.state.name != 'TOP_LEVEL') {
+      throw new Error(`Expected to be in state 'TOP_LEVEL', but got '${this.state.name}' instead`);
+    }
+
+    // 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
+    // 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
+    // the authwits if not persisted, so we'd not be able to pass more than one per execution.
+    // Ideally authwits would be passed alongside a contract call instead of pre-seeded.
+    [this.nextBlockTimestamp, this.authwits] = (this.oracleHandler as TXEOracleTopLevelContext).close();
+  }
 
-    if (contractAddress) {
-      this.oracleHandler.txeSetContractAddress(contractAddress);
+  private async exitPrivateState() {
+    if (this.state.name != 'PRIVATE') {
+      throw new Error(`Expected to be in state 'PRIVATE', but got '${this.state.name}' instead`);
     }
 
-    this.state = SessionState.UTILITY;
-    this.logger.debug(`Entered state ${SessionState[this.state]}`);
+    this.logger.debug('Exiting Private state, building block with collected side effects', {
+      blockNumber: this.state.nextBlockGlobalVariables.blockNumber,
+    });
+
+    // 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,
+    );
+
+    // 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]),
+    );
+    await this.stateMachine.handleL2Block(block);
+
+    await forkedWorldTrees.close();
+
+    this.logger.debug('Exited PublicContext with built block', {
+      blockNumber: block.number,
+      txEffects: block.body.txEffects,
+    });
+  }
+
+  private async exitPublicState() {
+    if (this.state.name != 'PUBLIC') {
+      throw new Error(`Expected to be in state 'PUBLIC', but got '${this.state.name}' instead`);
+    }
 
-    return Promise.resolve();
+    const block = await (this.oracleHandler as TXEOraclePublicContext).close();
+    await this.stateMachine.handleL2Block(block);
   }
 
-  private assertInTopLevelState() {
-    if (this.state != SessionState.TOP_LEVEL) {
-      throw new Error(
-        `Expected to be in state ${SessionState[SessionState.TOP_LEVEL]}, but got '${SessionState[this.state]}' instead`,
-      );
+  private exitUtilityContext() {
+    if (this.state.name != 'UTILITY') {
+      throw new Error(`Expected to be in state 'UTILITY', but got '${this.state.name}' instead`);
     }
   }
 }

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_contract_data_provider.ts

@@ -1,4 +1,5 @@
-import { type ContractArtifact, Fr } from '@aztec/aztec.js';
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { Fr } from '@aztec/aztec.js/fields';
 import { ContractDataProvider } from '@aztec/pxe/server';
 
 export type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };

package/src/util/txe_public_contract_data_source.ts

@@ -1,4 +1,6 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ContractDataProvider } from '@aztec/pxe/server';
 import { type ContractArtifact, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
@@ -10,22 +12,23 @@ import {
   getContractClassPrivateFunctionFromArtifact,
 } from '@aztec/stdlib/contract';
 
-import type { TXE } from '../oracle/txe_oracle.js';
-
 export class TXEPublicContractDataSource implements ContractDataSource {
   #privateFunctionsRoot: Map<string, Buffer> = new Map();
-  constructor(private txeOracle: TXE) {}
+  constructor(
+    private blockNumber: BlockNumber,
+    private contractDataProvider: ContractDataProvider,
+  ) {}
 
-  getBlockNumber(): Promise<number> {
-    return this.txeOracle.utilityGetBlockNumber();
+  getBlockNumber(): Promise<BlockNumber> {
+    return Promise.resolve(this.blockNumber);
   }
 
   async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
+    const contractClass = await this.contractDataProvider.getContractClass(id);
     if (!contractClass) {
       return;
     }
-    const artifact = await this.txeOracle.getContractDataProvider().getContractArtifact(id);
+    const artifact = await this.contractDataProvider.getContractArtifact(id);
     if (!artifact) {
       return;
     }
@@ -55,12 +58,12 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   }
 
   async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
-    const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
+    const contractClass = await this.contractDataProvider.getContractClass(id);
     return contractClass && computePublicBytecodeCommitment(contractClass.packedBytecode);
   }
 
   async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
+    const instance = await this.contractDataProvider.getContractInstance(address);
     return instance && { ...instance, address };
   }
 
@@ -69,12 +72,12 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   }
 
   async getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined> {
-    const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
-    return instance && this.txeOracle.getContractDataProvider().getContractArtifact(instance.currentContractClassId);
+    const instance = await this.contractDataProvider.getContractInstance(address);
+    return instance && this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
   }
 
   async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    return await this.txeOracle.getContractDataProvider().getDebugFunctionName(address, selector);
+    return await this.contractDataProvider.getDebugFunctionName(address, selector);
   }
 
   registerContractFunctionSignatures(_signatures: []): Promise<void> {

package/src/utils/block_creation.ts

@@ -0,0 +1,64 @@
+import {
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  NULLIFIER_SUBTREE_HEIGHT,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+} from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { L2BlockHeader } from '@aztec/stdlib/block';
+import { makeContentCommitment } from '@aztec/stdlib/testing';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
+
+/**
+ * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
+ * @param blockNumber The number for the block in which there is a single transaction.
+ * @returns The transaction request hash.
+ */
+export function getSingleTxBlockRequestHash(blockNumber: BlockNumber): Fr {
+  return new Fr(blockNumber + 9999); // Why does this need to be a high number? Why do small numbered nullifiers already exist?
+}
+
+export async function insertTxEffectIntoWorldTrees(
+  txEffect: TxEffect,
+  worldTrees: MerkleTreeWriteOperations,
+): Promise<void> {
+  await worldTrees.appendLeaves(
+    MerkleTreeId.NOTE_HASH_TREE,
+    padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+  );
+
+  await worldTrees.batchInsert(
+    MerkleTreeId.NULLIFIER_TREE,
+    padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(nullifier => nullifier.toBuffer()),
+    NULLIFIER_SUBTREE_HEIGHT,
+  );
+
+  await worldTrees.appendLeaves(
+    MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+    padArrayEnd<Fr, number>(txEffect.l2ToL1Msgs, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
+  );
+
+  // We do not need to add public data writes because we apply them as we go.
+}
+
+export async function makeTXEBlockHeader(
+  worldTrees: MerkleTreeWriteOperations,
+  globalVariables: GlobalVariables,
+): Promise<L2BlockHeader> {
+  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,
+    globalVariables,
+    Fr.ZERO,
+    Fr.ZERO,
+    Fr.ZERO,
+    Fr.ZERO,
+  );
+}