@aztec/txe 0.0.1-commit.b655e406 → 0.0.1-commit.b9865e97

package/src/msgpackr_fr_extension.ts

@@ -0,0 +1,23 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import { addExtension } from 'msgpackr';
+
+// `@aztec/native/msgpack_channel` registers a msgpackr extension that packs `Fr` instances to
+// their raw 32-byte buffer for the C++ world-state side to deserialize. Because `@aztec/native`
+// is externalized in TXE's esbuild config (it loads a `.node` binary that can't be bundled),
+// the `Fr` class the extension is keyed on belongs to the *external* `@aztec/foundation`
+// module instance — a different class identity than the `Fr` bundled into the TXE worker /
+// bin. msgpackr's extension match uses `instanceof`, so bundled `Fr` instances slip through
+// and msgpackr falls back to `Fr.toJSON()` (returns `Fr.toString()` — a `0x...` hex string).
+// The C++ side then sees a string where a 32-byte binary was expected and throws
+// `msgpack::type_error` whose `what()` is literally `"std::bad_cast"`.
+//
+// Fix: register the same extension under the BUNDLED `Fr` class identity. msgpackr's extension
+// table holds an entry per `Class`, so both Fr classes now resolve to the same `write` callback
+// and produce the same wire format. Imported as a side-effect from `./index.js` so both the
+// worker (via `./worker.ts`) and the main-thread RPC server (via `./rpc_server.ts`) get the
+// registration before any `sendMessage` runs.
+addExtension({
+  Class: Fr,
+  write: (fr: Fr) => fr.toBuffer(),
+});

package/src/oracle/interfaces.ts

@@ -1,11 +1,12 @@
-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 type { Fr } from '@aztec/foundation/fields';
-import type { FunctionSelector } from '@aztec/stdlib/abi';
+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 { UInt32, UInt64 } from '@aztec/stdlib/types';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { PrivateLog } from '@aztec/stdlib/logs';
+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
@@ -23,18 +24,27 @@ import type { UInt32, UInt64 } from '@aztec/stdlib/types';
 export interface IAvmExecutionOracle {
   isAvm: true;
 
-  avmOpcodeAddress(): Promise<AztecAddress>;
-  avmOpcodeSender(): Promise<AztecAddress>;
-  avmOpcodeBlockNumber(): Promise<UInt32>;
-  avmOpcodeTimestamp(): Promise<bigint>;
-  avmOpcodeIsStaticCall(): Promise<boolean>;
-  avmOpcodeChainId(): Promise<Fr>;
-  avmOpcodeVersion(): Promise<Fr>;
-  avmOpcodeEmitNullifier(nullifier: Fr): Promise<void>;
-  avmOpcodeEmitNoteHash(noteHash: Fr): Promise<void>;
-  avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean>;
-  avmOpcodeStorageWrite(slot: Fr, value: Fr): Promise<void>;
-  avmOpcodeStorageRead(slot: Fr): Promise<Fr>;
+  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>;
+  getContractInstanceDeployer(address: AztecAddress): Promise<{ member: Fr; exists: boolean }>;
+  getContractInstanceClassId(address: AztecAddress): Promise<{ member: Fr; exists: boolean }>;
+  getContractInstanceInitializationHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }>;
+  getContractInstanceImmutablesHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }>;
+  returndataSize(): Promise<Fr>;
+  returndataCopy(rdOffset: number, copySize: number): Promise<Fr[]>;
+  call(l2Gas: number, daGas: number, address: AztecAddress, argsLength: number, args: Fr[]): Promise<Fr[]>;
+  staticCall(l2Gas: number, daGas: number, address: AztecAddress, argsLength: number, args: Fr[]): Promise<Fr[]>;
+  successCopy(): Promise<Fr>;
 }
 
 /**
@@ -43,41 +53,57 @@ export interface IAvmExecutionOracle {
 export interface ITxeExecutionOracle {
   isTxe: true;
 
-  txeGetNextBlockNumber(): Promise<number>;
-  txeGetNextBlockTimestamp(): Promise<UInt64>;
-  txeAdvanceBlocksBy(blocks: number): Promise<void>;
-  txeAdvanceTimestampBy(duration: UInt64): void;
-  txeDeploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, foreignSecret: Fr): Promise<void>;
-  txeCreateAccount(secret: Fr): Promise<CompleteAddress>;
-  txeAddAccount(
-    artifact: ContractArtifact,
-    instance: ContractInstanceWithAddress,
+  getDefaultAddress(): AztecAddress;
+  getNextBlockNumber(): Promise<BlockNumber>;
+  getNextBlockTimestamp(): Promise<UInt64>;
+  advanceBlocksBy(blocks: number): Promise<void>;
+  advanceTimestampBy(duration: UInt64): void;
+  deploy(
+    contractPath: string,
+    initializer: string,
+    args: Fr[],
     secret: Fr,
-  ): Promise<CompleteAddress>;
-  txeAddAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
-  txeGetLastBlockTimestamp(): Promise<bigint>;
-  txeGetLastTxEffects(): Promise<{
+    salt: Fr,
+    deployer: AztecAddress,
+  ): Promise<Fr[]>;
+  createAccount(secret: Fr): Promise<CompleteAddress>;
+  addAccount(secret: Fr): Promise<CompleteAddress>;
+  addAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+  getLastBlockTimestamp(): Promise<bigint>;
+  getLastTxEffects(): Promise<{
     txHash: TxHash;
     noteHashes: Fr[];
     nullifiers: Fr[];
+    privateLogs: PrivateLog[];
   }>;
-  txePrivateCallNewFlow(
-    from: AztecAddress,
+  getPrivateEvents(selector: EventSelector, contractAddress: AztecAddress, scope: AztecAddress): Promise<Fr[][]>;
+  privateCallNewFlow(
+    from: AztecAddress | undefined,
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     args: Fr[],
     argsHash: Fr,
     isStaticCall: boolean,
-  ): Promise<Fr[]>;
-  txeSimulateUtilityFunction(
+    additionalScopes: AztecAddress[],
+    jobId: string,
+    authorizedUtilityCallTargets: AztecAddress[],
+    gasSettings: GasSettings,
+  ): Promise<{ returnValues: Fr[]; offchainEffects: Fr[][] }>;
+  executeUtilityFunction(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     args: Fr[],
+    jobId: string,
+    authorizedUtilityCallTargets: AztecAddress[],
   ): Promise<Fr[]>;
-  txePublicCallNewFlow(
-    from: AztecAddress,
+  publicCallNewFlow(
+    from: AztecAddress | undefined,
     targetContractAddress: AztecAddress,
     calldata: Fr[],
     isStaticCall: boolean,
+    gasSettings: GasSettings,
   ): 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/test-resolver/fixtures.ts

@@ -0,0 +1,84 @@
+/* eslint-disable camelcase */
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type NamedValue, Option } from '@aztec/pxe/simulator';
+
+import { TXE_ORACLE_REGISTRY } from '../txe_oracle_registry.js';
+
+/**
+ * Fixture definitions for oracle roundtrip tests.
+ *
+ * Each key is an oracle name from TXE_ORACLE_REGISTRY, and the value is an array of scenarios. The resolver selects a
+ * scenario (by name for multi-scenario oracles, or automatically for single-scenario ones), verifies that the
+ * deserialized inputs match the fixture's expected values, and returns the fixture output.
+ *
+ * To add a new oracle test:
+ * 1. Add a fixture entry here with the expected inputs and output.
+ * 2. Add a Noir `#[oracle_test]` function that calls the oracle with the same input values and asserts the output.
+ */
+export const ORACLE_TEST_FIXTURES: OracleTestFixtures = {
+  aztec_avm_storageRead: [
+    makeScenario({
+      inputs: { slot: new Fr(10), contractAddress: AztecAddress.fromNumber(1) },
+      output: new Fr(42),
+    }),
+  ],
+
+  aztec_prv_getSenderForTags: [
+    makeScenario({
+      scenario: 'some',
+      inputs: {},
+      output: Option.some(AztecAddress.fromNumber(42)),
+    }),
+    makeScenario({
+      scenario: 'none',
+      inputs: {},
+      output: Option.none(AztecAddress.ZERO),
+    }),
+  ],
+};
+
+/**
+ * Converts a `NamedValue` tuple (from `deserializeParams`) to a record.
+ * `[NamedValue<'slot', Fr>, NamedValue<'addr', AztecAddress>]` → `{ slot: Fr, addr: AztecAddress }`.
+ */
+type NamedValuesToRecord<T extends readonly NamedValue[]> = {
+  [K in T[number] as K extends NamedValue<infer N, any> ? N : never]: K extends NamedValue<string, infer V> ? V : never;
+};
+
+/** Extracts the deserialized inputs record type from an oracle registry entry. */
+type OracleInputs<K extends keyof typeof TXE_ORACLE_REGISTRY> = (typeof TXE_ORACLE_REGISTRY)[K] extends {
+  deserializeParams(...args: any[]): infer P;
+}
+  ? P extends readonly NamedValue[]
+    ? NamedValuesToRecord<P>
+    : Record<string, never>
+  : Record<string, never>;
+
+/** Extracts the return type from an oracle registry entry's serializeReturn method. */
+type OracleOutput<K extends keyof typeof TXE_ORACLE_REGISTRY> = (typeof TXE_ORACLE_REGISTRY)[K] extends {
+  serializeReturn(result: infer R): any;
+}
+  ? R
+  : void;
+
+/** A single test scenario for an oracle, typed against the oracle registry. */
+export interface OracleTestScenario<K extends keyof typeof TXE_ORACLE_REGISTRY = keyof typeof TXE_ORACLE_REGISTRY> {
+  /** Scenario name for selection via `#[oracle_test("name")]`. Required when an oracle has multiple scenarios. */
+  scenario?: string;
+  /** Expected deserialized inputs. */
+  inputs: OracleInputs<K>;
+  /** Return value to serialize back to Noir. */
+  output: OracleOutput<K>;
+}
+
+type OracleTestFixtures = {
+  [K in keyof typeof TXE_ORACLE_REGISTRY]?: OracleTestScenario<K>[];
+};
+
+/** Creates a typed fixture scenario for a given oracle. */
+function makeScenario<K extends keyof typeof TXE_ORACLE_REGISTRY>(
+  scenario: OracleTestScenario<K>,
+): OracleTestScenario<K> {
+  return scenario;
+}

package/src/oracle/test-resolver/index.ts

@@ -0,0 +1,45 @@
+/* eslint-disable camelcase */
+import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import type { Logger } from '@aztec/foundation/log';
+import type { ApiSchemaFor } from '@aztec/foundation/schemas';
+import { zodFor } from '@aztec/stdlib/schemas';
+
+import { z } from 'zod';
+
+import { ForeignCallArgsSchema, type ForeignCallResult, ForeignCallResultSchema } from '../../utils/encoding.js';
+import { TXE_ORACLE_REGISTRY } from '../txe_oracle_registry.js';
+import { ORACLE_TEST_FIXTURES } from './fixtures.js';
+import { type OracleTestCallInput, OracleTestResolver } from './resolver.js';
+
+const OracleTestCallInputSchema = zodFor<OracleTestCallInput>()(
+  z.object({
+    session_id: z.number().nonnegative(),
+    function: z.string(),
+    root_path: z.string(),
+    package_name: z.string(),
+    inputs: ForeignCallArgsSchema,
+  }),
+);
+
+/** Narrowed interface exposing only the RPC method. */
+interface OracleTestRpcHandler {
+  resolve_foreign_call(callData: OracleTestCallInput): Promise<ForeignCallResult>;
+}
+
+const OracleTestRpcHandlerSchema: ApiSchemaFor<OracleTestRpcHandler> = {
+  resolve_foreign_call: z.function({
+    input: z.tuple([OracleTestCallInputSchema]),
+    output: ForeignCallResultSchema,
+  }),
+};
+
+/** Creates an RPC server backed by the oracle test resolver. */
+export function createOracleTestRpcServer(logger: Logger) {
+  const resolver = new OracleTestResolver(TXE_ORACLE_REGISTRY, ORACLE_TEST_FIXTURES, logger);
+  const server = createSafeJsonRpcServer<OracleTestRpcHandler>(resolver, OracleTestRpcHandlerSchema, {
+    http200OnError: true,
+  });
+  return { server, resolver };
+}
+
+export { OracleTestResolver } from './resolver.js';

package/src/oracle/test-resolver/resolver.ts

@@ -0,0 +1,165 @@
+/* eslint-disable camelcase */
+import type { Logger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
+import { withHexPrefix, withoutHexPrefix } from '@aztec/foundation/string';
+import type { InputSlot, OracleRegistryEntry } from '@aztec/pxe/simulator';
+
+import type { ForeignCallArgs, ForeignCallResult } from '../../utils/encoding.js';
+import type { OracleTestScenario } from './fixtures.js';
+
+/** Name of the meta-oracle that Noir tests call to select a fixture scenario by name. */
+const SET_SCENARIO_ORACLE = 'aztec_oracle_test_set_scenario';
+
+export type OracleTestCallInput = {
+  session_id: number;
+  function: string;
+  root_path: string;
+  package_name: string;
+  inputs: ForeignCallArgs;
+};
+
+/**
+ * Oracle resolver for roundtrip tests. Selects a fixture scenario, verifies that the received inputs match, and
+ * returns the corresponding fixture output.
+ *
+ * For oracles with a single fixture, it is selected automatically. For oracles with multiple fixtures, Noir tests
+ * must call the `oracle_test_set_scenario` meta-oracle to select a specific scenario by name before calling the
+ * real oracle.
+ */
+export class OracleTestResolver {
+  private readonly calledOracles = new Set<string>();
+  private readonly pendingScenario = new Map<number, string>();
+  private readonly logger: Logger;
+
+  constructor(
+    private readonly registry: Record<string, OracleRegistryEntry>,
+    private readonly fixtures: Record<string, OracleTestScenario[]>,
+    logger?: Logger,
+  ) {
+    this.logger = logger ?? createLogger('txe:test-resolver');
+  }
+
+  // eslint-disable-next-line require-await
+  async resolve_foreign_call(callData: OracleTestCallInput): Promise<ForeignCallResult> {
+    const oracleName = callData.function;
+    this.logger.debug('Resolving oracle', { oracleName });
+
+    if (oracleName === SET_SCENARIO_ORACLE) {
+      return this.#handleSetScenario(callData);
+    }
+
+    this.calledOracles.add(oracleName);
+
+    if (!(oracleName in this.registry)) {
+      throw new Error(`Oracle '${oracleName}' not found in registry`);
+    }
+    const entry = this.registry[oracleName];
+
+    const scenarios = this.fixtures[oracleName];
+    if (!scenarios || scenarios.length === 0) {
+      throw new Error(`No fixture defined for oracle '${oracleName}'`);
+    }
+
+    const match = this.#selectScenario(callData.session_id, oracleName, scenarios);
+    this.#verifyInputs(callData.inputs, entry, match, oracleName);
+
+    this.logger.debug('Verified scenario for oracle', { oracleName });
+
+    const outputSlots = entry.serializeReturn(match.output);
+    return {
+      values: outputSlots.map(slot => (Array.isArray(slot) ? slot.map(withoutHexPrefix) : withoutHexPrefix(slot))),
+    };
+  }
+
+  /** Returns oracles that have a fixture defined but were never called during testing. */
+  getUncalledFixtures(): string[] {
+    return Object.keys(this.fixtures).filter(name => !this.calledOracles.has(name));
+  }
+
+  /** Returns oracles in the registry that have no fixture defined at all. */
+  getMissingFixtures(): string[] {
+    return Object.keys(this.registry).filter(name => !(name in this.fixtures));
+  }
+
+  #handleSetScenario(callData: { session_id: number; inputs: ForeignCallArgs }): ForeignCallResult {
+    const charCodes = callData.inputs[0] as string[];
+    const scenarioName = charCodes
+      .map(hex => Number(BigInt(hex.startsWith('0x') ? hex : `0x${hex}`)))
+      .map(code => String.fromCharCode(code))
+      .join('');
+
+    this.logger.debug('Setting scenario for next oracle call', { sessionId: callData.session_id, scenarioName });
+    this.pendingScenario.set(callData.session_id, scenarioName);
+
+    return { values: [] };
+  }
+
+  /** Selects a scenario by pending name (for multi-fixture oracles) or returns the single fixture. */
+  #selectScenario(sessionId: number, oracleName: string, fixtures: OracleTestScenario[]): OracleTestScenario {
+    const selectedName = this.pendingScenario.get(sessionId);
+
+    if (selectedName !== undefined) {
+      this.pendingScenario.delete(sessionId);
+      const matches = fixtures.filter(s => s.scenario === selectedName);
+      if (matches.length === 0) {
+        const available = fixtures.map(s => s.scenario).join(', ');
+        throw new Error(`No scenario named '${selectedName}' for oracle '${oracleName}'. Available: ${available}`);
+      }
+      if (matches.length > 1) {
+        throw new Error(`Duplicate scenario name '${selectedName}' for oracle '${oracleName}'`);
+      }
+      return matches[0];
+    }
+
+    if (fixtures.length === 1) {
+      return fixtures[0];
+    }
+
+    throw new Error(
+      `Oracle '${oracleName}' has ${fixtures.length} fixture scenarios. ` +
+        `Use #[oracle_test("scenario_name")] to select one.`,
+    );
+  }
+
+  /** Deserializes actual inputs and verifies they match the scenario's expected inputs. */
+  #verifyInputs(
+    rawInputs: ForeignCallArgs,
+    entry: OracleRegistryEntry,
+    scenario: OracleTestScenario,
+    oracleName: string,
+  ): void {
+    const expectedInputs = scenario.inputs as Record<string, unknown>;
+    if (Object.keys(expectedInputs).length === 0) {
+      return;
+    }
+
+    const normalized: InputSlot[] = rawInputs.map(v =>
+      Array.isArray(v) ? (v as string[]).map(withHexPrefix) : [withHexPrefix(v as string)],
+    );
+    const named = entry.deserializeParams(normalized);
+
+    for (const param of named) {
+      if (!(param.name in expectedInputs)) {
+        throw new Error(
+          `Unexpected param '${param.name}' for oracle '${oracleName}'. ` +
+            `Expected: ${Object.keys(expectedInputs).join(', ')}`,
+        );
+      }
+      if (!valuesEqual(param.value, expectedInputs[param.name])) {
+        const scenarioLabel = scenario.scenario ? ` (scenario '${scenario.scenario}')` : '';
+        throw new Error(
+          `Input mismatch for oracle '${oracleName}'${scenarioLabel}: ` +
+            `param '${param.name}' expected ${String(expectedInputs[param.name])} ` +
+            `but got ${String(param.value)}`,
+        );
+      }
+    }
+  }
+}
+
+function valuesEqual(actual: unknown, expected: unknown): boolean {
+  if (Array.isArray(actual) && Array.isArray(expected)) {
+    return actual.length === expected.length && actual.every((v, i) => valuesEqual(v, expected[i]));
+  }
+  return String(actual) === String(expected);
+}

package/src/oracle/txe_oracle_public_context.ts

@@ -1,10 +1,12 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { ContractStore } from '@aztec/pxe/server';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Body, L2Block } from '@aztec/stdlib/block';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
-import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
 import {
   MerkleTreeId,
   type MerkleTreeWriteOperations,
@@ -12,9 +14,8 @@ import {
   PublicDataTreeLeafPreimage,
 } from '@aztec/stdlib/trees';
 import { GlobalVariables, TxEffect, TxHash } from '@aztec/stdlib/tx';
-import type { UInt32 } from '@aztec/stdlib/types';
 
-import { insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from '../utils/block_creation.js';
+import { insertTxEffectIntoWorldTrees, makeTXEBlock } from '../utils/block_creation.js';
 import type { IAvmExecutionOracle } from './interfaces.js';
 
 export class TXEOraclePublicContext implements IAvmExecutionOracle {
@@ -30,6 +31,7 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
     private forkedWorldTrees: MerkleTreeWriteOperations,
     private txRequestHash: Fr,
     private globalVariables: GlobalVariables,
+    private contractStore: ContractStore,
   ) {
     this.logger = createLogger('txe:public_context');
 
@@ -40,57 +42,55 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
     });
   }
 
-  avmOpcodeAddress(): Promise<AztecAddress> {
+  address(): Promise<AztecAddress> {
     return Promise.resolve(this.contractAddress);
   }
 
-  avmOpcodeSender(): Promise<AztecAddress> {
+  sender(): Promise<AztecAddress> {
     return Promise.resolve(AztecAddress.ZERO); // todo: change?
   }
 
-  avmOpcodeBlockNumber(): Promise<UInt32> {
+  blockNumber(): Promise<BlockNumber> {
     return Promise.resolve(this.globalVariables.blockNumber);
   }
 
-  avmOpcodeTimestamp(): Promise<bigint> {
+  timestamp(): Promise<bigint> {
     return Promise.resolve(this.globalVariables.timestamp);
   }
 
-  avmOpcodeIsStaticCall(): Promise<boolean> {
+  isStaticCall(): Promise<boolean> {
     return Promise.resolve(false);
   }
 
-  avmOpcodeChainId(): Promise<Fr> {
+  chainId(): Promise<Fr> {
     return Promise.resolve(this.globalVariables.chainId);
   }
 
-  avmOpcodeVersion(): Promise<Fr> {
+  version(): Promise<Fr> {
     return Promise.resolve(this.globalVariables.version);
   }
 
-  async avmOpcodeEmitNullifier(nullifier: Fr) {
+  async emitNullifier(nullifier: Fr) {
     const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
     this.transientSiloedNullifiers.push(siloedNullifier);
   }
 
-  async avmOpcodeEmitNoteHash(noteHash: Fr) {
+  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 avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean> {
-    const nullifier = await siloNullifier(targetAddress, innerNullifier!);
-
+  async nullifierExists(siloedNullifier: Fr): Promise<boolean> {
     const treeIndex = (
-      await this.forkedWorldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()])
+      await this.forkedWorldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()])
     )[0];
-    const transientIndex = this.transientSiloedNullifiers.find(n => n.equals(nullifier));
+    const transientIndex = this.transientSiloedNullifiers.find(n => n.equals(siloedNullifier));
 
     return treeIndex !== undefined || transientIndex !== undefined;
   }
 
-  async avmOpcodeStorageWrite(slot: Fr, value: Fr) {
+  async storageWrite(slot: Fr, value: Fr) {
     this.logger.debug('AVM storage write', { slot, value });
 
     const dataWrite = new PublicDataWrite(await computePublicDataTreeLeafSlot(this.contractAddress, slot), value);
@@ -102,8 +102,8 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
     ]);
   }
 
-  async avmOpcodeStorageRead(slot: Fr): Promise<Fr> {
-    const leafSlot = await computePublicDataTreeLeafSlot(this.contractAddress, slot);
+  async storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr> {
+    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
 
     const lowLeafResult = await this.forkedWorldTrees.getPreviousValueIndex(
       MerkleTreeId.PUBLIC_DATA_TREE,
@@ -120,11 +120,68 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
             )) as PublicDataTreeLeafPreimage
           ).leaf.value;
 
-    this.logger.debug('AVM storage read', { slot, value });
+    this.logger.debug('AVM storage read', { slot, contractAddress, value });
 
     return value;
   }
 
+  getContractInstanceDeployer(address: AztecAddress): Promise<{ member: Fr; exists: boolean }> {
+    return this.getContractInstanceMember(address, i => i.deployer.toField());
+  }
+
+  getContractInstanceClassId(address: AztecAddress): Promise<{ member: Fr; exists: boolean }> {
+    return this.getContractInstanceMember(address, i => i.currentContractClassId);
+  }
+
+  getContractInstanceInitializationHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }> {
+    return this.getContractInstanceMember(address, i => i.initializationHash);
+  }
+
+  getContractInstanceImmutablesHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }> {
+    return this.getContractInstanceMember(address, i => i.immutablesHash);
+  }
+
+  private async getContractInstanceMember(
+    address: AztecAddress,
+    accessor: (instance: ContractInstanceWithAddress) => Fr,
+  ): Promise<{ member: Fr; exists: boolean }> {
+    const instance = await this.contractStore.getContractInstance(address);
+    if (!instance) {
+      return { member: Fr.ZERO, exists: false };
+    }
+    return { member: accessor(instance), exists: true };
+  }
+
+  returndataSize(): Promise<Fr> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
+  returndataCopy(_rdOffset: number, _copySize: number): Promise<Fr[]> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
+  call(_l2Gas: number, _daGas: number, _address: AztecAddress, _argsLength: number, _args: Fr[]): Promise<Fr[]> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
+  staticCall(_l2Gas: number, _daGas: number, _address: AztecAddress, _argsLength: number, _args: Fr[]): Promise<Fr[]> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
+  successCopy(): Promise<Fr> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
   async close(): Promise<L2Block> {
     this.logger.debug('Exiting Public Context, building block with collected side effects', {
       blockNumber: this.globalVariables.blockNumber,
@@ -133,11 +190,7 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
     const txEffect = this.makeTxEffect();
     await insertTxEffectIntoWorldTrees(txEffect, this.forkedWorldTrees);
 
-    const block = new L2Block(
-      makeAppendOnlyTreeSnapshot(),
-      await makeTXEBlockHeader(this.forkedWorldTrees, this.globalVariables),
-      new Body([txEffect]),
-    );
+    const block = await makeTXEBlock(this.forkedWorldTrees, this.globalVariables, [txEffect]);
 
     await this.forkedWorldTrees.close();