@aztec/txe 3.0.0-nightly.20250925 → 3.0.0-nightly.20250927

package/dest/txe_session.js

@@ -3,42 +3,21 @@ import { createLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { AddressDataProvider, CapsuleDataProvider, NoteDataProvider, PXEOracleInterface, PrivateEventDataProvider, TaggingDataProvider } from '@aztec/pxe/server';
+import { ExecutionNoteCache, HashedValuesCache, PrivateExecutionOracle, UtilityExecutionOracle } from '@aztec/pxe/simulator';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Body, L2Block } from '@aztec/stdlib/block';
 import { GasSettings } from '@aztec/stdlib/gas';
-import { PrivateContextInputs } from '@aztec/stdlib/kernel';
-import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import { CallContext, GlobalVariables, TxContext } from '@aztec/stdlib/tx';
-import { TXE } from './oracle/txe_oracle.js';
+import { makeAppendOnlyTreeSnapshot, makeGlobalVariables } from '@aztec/stdlib/testing';
+import { CallContext, TxContext } from '@aztec/stdlib/tx';
 import { TXEOraclePublicContext } from './oracle/txe_oracle_public_context.js';
 import { TXEOracleTopLevelContext } from './oracle/txe_oracle_top_level_context.js';
 import { RPCTranslator } from './rpc_translator.js';
 import { TXEStateMachine } from './state_machine/index.js';
 import { TXEAccountDataProvider } from './util/txe_account_data_provider.js';
 import { TXEContractDataProvider } from './util/txe_contract_data_provider.js';
-import { getSingleTxBlockRequestHash } from './utils/block_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.
- */ var SessionState = /*#__PURE__*/ function(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.
-   */ SessionState[SessionState["TOP_LEVEL"] = 0] = "TOP_LEVEL";
-    /**
-   * The private state is entered via the `private_context` function. In this state the PXE oracles that `#[private]`
-   * functions use are available, such as those related to note retrieval, notification of side-effects, capsule access,
-   * etc. */ SessionState[SessionState["PRIVATE"] = 1] = "PRIVATE";
-    /**
-   * The public state is entered via the `public_context` function. In this state the AVM opcodes that `#[public]`
-   * functions execute are resolved as oracles by TXE, since Noir tests are not transpiled. */ SessionState[SessionState["PUBLIC"] = 2] = "PUBLIC";
-    /**
-   * The utility state is entered via the `utility_context` function. In this state the PXE oracles that `#[utility]`
-   * functions use are available, such as those related to (unconstrained) note retrieval, capsule access, public
-   * storage reads, etc.
-   */ SessionState[SessionState["UTILITY"] = 3] = "UTILITY";
-    return SessionState;
-}(SessionState || {});
+import { getSingleTxBlockRequestHash, insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from './utils/block_creation.js';
+import { makeTxEffect } from './utils/tx_effect_creation.js';
 const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
 /**
  * A `TXESession` corresponds to a Noir `#[test]` function, and handles all of its oracle calls, stores test-specific
@@ -56,6 +35,7 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
     nextBlockTimestamp;
     pxeOracleInterface;
     state;
+    authwits;
     constructor(logger, stateMachine, oracleHandler, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, chainId, version, nextBlockTimestamp, pxeOracleInterface){
         this.logger = logger;
         this.stateMachine = stateMachine;
@@ -68,7 +48,10 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
         this.version = version;
         this.nextBlockTimestamp = nextBlockTimestamp;
         this.pxeOracleInterface = pxeOracleInterface;
-        this.state = 0;
+        this.state = {
+            name: 'TOP_LEVEL'
+        };
+        this.authwits = new Map();
     }
     static async init(protocolContracts) {
         const store = await openTmpStore('txe-session');
@@ -90,7 +73,7 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
         const version = new Fr(await stateMachine.node.getVersion());
         const chainId = new Fr(await stateMachine.node.getChainId());
         const pxeOracleInterface = new PXEOracleInterface(stateMachine.node, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, stateMachine.syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider);
-        const topLevelOracleHandler = new TXEOracleTopLevelContext(stateMachine, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, pxeOracleInterface, nextBlockTimestamp, version, chainId);
+        const topLevelOracleHandler = new TXEOracleTopLevelContext(stateMachine, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, pxeOracleInterface, nextBlockTimestamp, version, chainId, new Map());
         await topLevelOracleHandler.txeAdvanceBlocksBy(1);
         return new TXESession(createLogger('txe:session'), stateMachine, topLevelOracleHandler, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, version, chainId, nextBlockTimestamp, pxeOracleInterface);
     }
@@ -100,26 +83,85 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
    * @param inputs The inputs of the oracle.
    * @returns The oracle return values.
    */ processFunction(functionName, inputs) {
-        return new RPCTranslator(this, this.oracleHandler)[functionName](...inputs);
+        try {
+            return new RPCTranslator(this, this.oracleHandler)[functionName](...inputs);
+        } catch (error) {
+            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() {
-        if (this.state == 1) {
-            await this.exitPrivateContext();
-        } else if (this.state == 2) {
-            await this.exitPublicContext();
-        } else if (this.state == 3) {
-            this.exitUtilityContext();
-        } else if (this.state == 0) {
-            throw new Error(`Expected to be in state other than ${SessionState[0]}`);
-        } 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;
+                }
         }
-        this.oracleHandler = new TXEOracleTopLevelContext(this.stateMachine, this.contractDataProvider, this.keyStore, this.addressDataProvider, this.accountDataProvider, this.pxeOracleInterface, this.nextBlockTimestamp, this.version, this.chainId);
-        this.state = 0;
-        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 enterPrivateState(contractAddress = DEFAULT_ADDRESS, anchorBlockNumber) {
+        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.removeNullifiedNotes(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: latestBlock.globalVariables.blockNumber + 1,
+            timestamp: this.nextBlockTimestamp,
+            version: this.version,
+            chainId: this.chainId
+        });
+        const txRequestHash = getSingleTxBlockRequestHash(nextBlockGlobalVariables.blockNumber);
+        const noteCache = new ExecutionNoteCache(txRequestHash);
+        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, this.pxeOracleInterface);
+        // We store the note cache 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,
+            txRequestHash,
+            noteCache
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
+        return this.oracleHandler.getPrivateContextInputs();
     }
-    async setPublicContext(contractAddress) {
-        this.exitTopLevelContext();
+    async enterPublicState(contractAddress) {
+        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;
@@ -130,73 +172,73 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
             chainId: this.chainId
         });
         this.oracleHandler = new TXEOraclePublicContext(contractAddress ?? DEFAULT_ADDRESS, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), getSingleTxBlockRequestHash(globalVariables.blockNumber), globalVariables);
-        this.state = 2;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
-    }
-    async setPrivateContext(contractAddress, anchorBlockNumber) {
-        this.exitTopLevelContext();
-        // A PrivateContext 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 the PrivateContext will create with the single transaction that
-        // contains 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 anchorBlockGlobalVariables = makeGlobalVariables(undefined, {
-            blockNumber: anchorBlock.globalVariables.blockNumber,
-            timestamp: anchorBlock.globalVariables.timestamp,
-            version: this.version,
-            chainId: this.chainId
-        });
-        const nextBlockGlobalVariables = makeGlobalVariables(undefined, {
-            blockNumber: latestBlock.globalVariables.blockNumber + 1,
-            timestamp: this.nextBlockTimestamp,
-            version: this.version,
-            chainId: this.chainId
-        });
-        const privateContextInputs = await this.getPrivateContextInputs(anchorBlockGlobalVariables.blockNumber, contractAddress ?? DEFAULT_ADDRESS);
-        this.oracleHandler = await TXE.create(contractAddress ?? DEFAULT_ADDRESS, this.pxeOracleInterface, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), anchorBlockGlobalVariables, nextBlockGlobalVariables, getSingleTxBlockRequestHash(nextBlockGlobalVariables.blockNumber));
-        this.state = 1;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
-        return privateContextInputs;
+        this.state = {
+            name: 'PUBLIC'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
     }
-    async setUtilityContext(contractAddress) {
-        this.exitTopLevelContext();
-        // A UtilityContext is built using the latest block as a reference, mimicking what would happen if PXE had synced
-        // all the way to the tip of the chain.
-        const latestBlock = await this.stateMachine.node.getBlockHeader('latest');
-        this.oracleHandler = await TXE.create(contractAddress ?? DEFAULT_ADDRESS, this.pxeOracleInterface, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), latestBlock.globalVariables, GlobalVariables.empty(), Fr.random());
-        this.state = 3;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
+    async enterUtilityState(contractAddress = DEFAULT_ADDRESS) {
+        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.removeNullifiedNotes(contractAddress);
+        this.oracleHandler = new UtilityExecutionOracle(contractAddress, [], [], this.pxeOracleInterface);
+        this.state = {
+            name: 'UTILITY'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
     }
-    exitTopLevelContext() {
-        this.assertState(0);
+    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.
-        this.nextBlockTimestamp = this.oracleHandler.close();
+        // 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.close();
     }
-    async exitPublicContext() {
-        this.assertState(2);
-        const block = await this.oracleHandler.close();
+    async exitPrivateState() {
+        if (this.state.name != 'PRIVATE') {
+            throw new Error(`Expected to be in state 'PRIVATE', but got '${this.state.name}' instead`);
+        }
+        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.txRequestHash, 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
+        });
     }
-    async exitPrivateContext() {
-        this.assertState(1);
+    async exitPublicState() {
+        if (this.state.name != 'PUBLIC') {
+            throw new Error(`Expected to be in state 'PUBLIC', but got '${this.state.name}' instead`);
+        }
         const block = await this.oracleHandler.close();
         await this.stateMachine.handleL2Block(block);
     }
     exitUtilityContext() {
-        this.assertState(3);
-    }
-    assertState(state) {
-        if (this.state != state) {
-            throw new Error(`Expected to be in state ${SessionState[state]}, but got '${SessionState[this.state]}' instead`);
+        if (this.state.name != 'UTILITY') {
+            throw new Error(`Expected to be in state 'UTILITY', but got '${this.state.name}' instead`);
         }
     }
-    async getPrivateContextInputs(anchorBlockNumber, contractAddress) {
-        this.logger.info(`Creating private context for block ${anchorBlockNumber}`);
-        const sender = await AztecAddress.random();
-        return new PrivateContextInputs(new CallContext(sender, contractAddress, FunctionSelector.empty(), false), await this.stateMachine.node.getBlockHeader(anchorBlockNumber), new TxContext(this.chainId, this.version, GasSettings.empty()), 0);
-    }
 }

package/dest/utils/tx_effect_creation.d.ts

@@ -0,0 +1,5 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { ExecutionNoteCache } from '@aztec/pxe/simulator';
+import { TxEffect } from '@aztec/stdlib/tx';
+export declare function makeTxEffect(noteCache: ExecutionNoteCache, txRequestHash: Fr, txBlockNumber: number): Promise<TxEffect>;
+//# sourceMappingURL=tx_effect_creation.d.ts.map

package/dest/utils/tx_effect_creation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_effect_creation.d.ts","sourceRoot":"","sources":["../../src/utils/tx_effect_creation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,EAAE,QAAQ,EAAU,MAAM,kBAAkB,CAAC;AAEpD,wBAAsB,YAAY,CAChC,SAAS,EAAE,kBAAkB,EAC7B,aAAa,EAAE,EAAE,EACjB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,QAAQ,CAAC,CA2BnB"}

package/dest/utils/tx_effect_creation.js

@@ -0,0 +1,16 @@
+import { Fr } from '@aztec/foundation/fields';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
+import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+export async function makeTxEffect(noteCache, txRequestHash, txBlockNumber) {
+    const txEffect = TxEffect.empty();
+    const { usedTxRequestHashForNonces } = noteCache.finish();
+    const nonceGenerator = usedTxRequestHashForNonces ? txRequestHash : noteCache.getAllNullifiers()[0];
+    txEffect.noteHashes = await Promise.all(noteCache.getAllNotes().map(async (pendingNote, i)=>computeUniqueNoteHash(await computeNoteHashNonce(nonceGenerator, i), await siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption))));
+    // Nullifiers are already siloed
+    txEffect.nullifiers = noteCache.getAllNullifiers();
+    if (usedTxRequestHashForNonces) {
+        txEffect.nullifiers.unshift(txRequestHash);
+    }
+    txEffect.txHash = new TxHash(new Fr(txBlockNumber));
+    return txEffect;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/txe",
-  "version": "3.0.0-nightly.20250925",
+  "version": "3.0.0-nightly.20250927",
   "type": "module",
   "exports": "./dest/index.js",
   "bin": "./dest/bin/index.js",
@@ -61,20 +61,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "3.0.0-nightly.20250925",
-    "@aztec/archiver": "3.0.0-nightly.20250925",
-    "@aztec/aztec-node": "3.0.0-nightly.20250925",
-    "@aztec/aztec.js": "3.0.0-nightly.20250925",
-    "@aztec/bb-prover": "3.0.0-nightly.20250925",
-    "@aztec/constants": "3.0.0-nightly.20250925",
-    "@aztec/foundation": "3.0.0-nightly.20250925",
-    "@aztec/key-store": "3.0.0-nightly.20250925",
-    "@aztec/kv-store": "3.0.0-nightly.20250925",
-    "@aztec/protocol-contracts": "3.0.0-nightly.20250925",
-    "@aztec/pxe": "3.0.0-nightly.20250925",
-    "@aztec/simulator": "3.0.0-nightly.20250925",
-    "@aztec/stdlib": "3.0.0-nightly.20250925",
-    "@aztec/world-state": "3.0.0-nightly.20250925",
+    "@aztec/accounts": "3.0.0-nightly.20250927",
+    "@aztec/archiver": "3.0.0-nightly.20250927",
+    "@aztec/aztec-node": "3.0.0-nightly.20250927",
+    "@aztec/aztec.js": "3.0.0-nightly.20250927",
+    "@aztec/bb-prover": "3.0.0-nightly.20250927",
+    "@aztec/constants": "3.0.0-nightly.20250927",
+    "@aztec/foundation": "3.0.0-nightly.20250927",
+    "@aztec/key-store": "3.0.0-nightly.20250927",
+    "@aztec/kv-store": "3.0.0-nightly.20250927",
+    "@aztec/protocol-contracts": "3.0.0-nightly.20250927",
+    "@aztec/pxe": "3.0.0-nightly.20250927",
+    "@aztec/simulator": "3.0.0-nightly.20250927",
+    "@aztec/stdlib": "3.0.0-nightly.20250927",
+    "@aztec/world-state": "3.0.0-nightly.20250927",
     "zod": "^3.23.8"
   },
   "devDependencies": {

package/src/oracle/interfaces.ts

@@ -0,0 +1,80 @@
+import type { CompleteAddress, ContractArtifact, ContractInstanceWithAddress, TxHash } from '@aztec/aztec.js';
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { UInt32, 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 #[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 #[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;
+
+  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>;
+}
+
+/**
+ * Oracle methods associated with the execution of an Aztec Noir test.
+ */
+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,
+    secret: Fr,
+  ): Promise<CompleteAddress>;
+  txeAddAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+  txeGetLastBlockTimestamp(): Promise<bigint>;
+  txeGetLastTxEffects(): Promise<{
+    txHash: TxHash;
+    noteHashes: Fr[];
+    nullifiers: Fr[];
+  }>;
+  txePrivateCallNewFlow(
+    from: AztecAddress,
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    args: Fr[],
+    argsHash: Fr,
+    isStaticCall: boolean,
+  ): Promise<Fr[]>;
+  txeSimulateUtilityFunction(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    args: Fr[],
+  ): Promise<Fr[]>;
+  txePublicCallNewFlow(
+    from: AztecAddress,
+    targetContractAddress: AztecAddress,
+    calldata: Fr[],
+    isStaticCall: boolean,
+  ): Promise<Fr[]>;
+}

package/src/oracle/txe_oracle_public_context.ts

@@ -1,7 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Body, L2Block } from '@aztec/stdlib/block';
 import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
@@ -15,9 +15,11 @@ import { GlobalVariables, TxEffect, TxHash } from '@aztec/stdlib/tx';
 import type { UInt32 } from '@aztec/stdlib/types';
 
 import { insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from '../utils/block_creation.js';
-import { TXETypedOracle } from './txe_typed_oracle.js';
+import type { IAvmExecutionOracle } from './interfaces.js';
+
+export class TXEOraclePublicContext implements IAvmExecutionOracle {
+  isAvm = true as const;
 
-export class TXEOraclePublicContext extends TXETypedOracle {
   private logger: Logger;
   private transientUniqueNoteHashes: Fr[] = [];
   private transientSiloedNullifiers: Fr[] = [];
@@ -29,7 +31,6 @@ export class TXEOraclePublicContext extends TXETypedOracle {
     private txRequestHash: Fr,
     private globalVariables: GlobalVariables,
   ) {
-    super('TXEOraclePublicContext');
     this.logger = createLogger('txe:public_context');
 
     this.logger.debug('Entering Public Context', {
@@ -39,42 +40,46 @@ export class TXEOraclePublicContext extends TXETypedOracle {
     });
   }
 
-  override avmOpcodeAddress(): Promise<AztecAddress> {
+  avmOpcodeAddress(): Promise<AztecAddress> {
     return Promise.resolve(this.contractAddress);
   }
 
-  override avmOpcodeBlockNumber(): Promise<UInt32> {
+  avmOpcodeSender(): Promise<AztecAddress> {
+    return Promise.resolve(AztecAddress.ZERO); // todo: change?
+  }
+
+  avmOpcodeBlockNumber(): Promise<UInt32> {
     return Promise.resolve(this.globalVariables.blockNumber);
   }
 
-  override avmOpcodeTimestamp(): Promise<bigint> {
+  avmOpcodeTimestamp(): Promise<bigint> {
     return Promise.resolve(this.globalVariables.timestamp);
   }
 
-  override avmOpcodeIsStaticCall(): Promise<boolean> {
+  avmOpcodeIsStaticCall(): Promise<boolean> {
     return Promise.resolve(false);
   }
 
-  override avmOpcodeChainId(): Promise<Fr> {
+  avmOpcodeChainId(): Promise<Fr> {
     return Promise.resolve(this.globalVariables.chainId);
   }
 
-  override avmOpcodeVersion(): Promise<Fr> {
+  avmOpcodeVersion(): Promise<Fr> {
     return Promise.resolve(this.globalVariables.version);
   }
 
-  override async avmOpcodeEmitNullifier(nullifier: Fr) {
+  async avmOpcodeEmitNullifier(nullifier: Fr) {
     const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
     this.transientSiloedNullifiers.push(siloedNullifier);
   }
 
-  override async avmOpcodeEmitNoteHash(noteHash: Fr) {
+  async avmOpcodeEmitNoteHash(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);
   }
 
-  override async avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean> {
+  async avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean> {
     const nullifier = await siloNullifier(targetAddress, innerNullifier!);
 
     const treeIndex = (
@@ -85,7 +90,7 @@ export class TXEOraclePublicContext extends TXETypedOracle {
     return treeIndex !== undefined || transientIndex !== undefined;
   }
 
-  override async avmOpcodeStorageWrite(slot: Fr, value: Fr) {
+  async avmOpcodeStorageWrite(slot: Fr, value: Fr) {
     this.logger.debug('AVM storage write', { slot, value });
 
     const dataWrite = new PublicDataWrite(await computePublicDataTreeLeafSlot(this.contractAddress, slot), value);
@@ -97,7 +102,7 @@ export class TXEOraclePublicContext extends TXETypedOracle {
     ]);
   }
 
-  override async avmOpcodeStorageRead(slot: Fr): Promise<Fr> {
+  async avmOpcodeStorageRead(slot: Fr): Promise<Fr> {
     const leafSlot = await computePublicDataTreeLeafSlot(this.contractAddress, slot);
 
     const lowLeafResult = await this.forkedWorldTrees.getPreviousValueIndex(