@aztec/txe 0.0.1-commit.3100065 → 0.0.1-commit.321f6a9

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

@@ -8,19 +8,29 @@ import {
   BLOCK_HASH,
   BLOCK_NUMBER,
   BOOL,
-  BYTE,
   BoundedVec,
+  type CompositeMapping,
   DELIVERY_MODE,
   ETH_ADDRESS,
   FIELD,
   FUNCTION_SELECTOR,
+  LEAF_INDEX,
   NOTE_SELECTOR,
   Option,
   type OracleRegistryEntry,
   SLOT_NUMBER,
-  type StructField,
+  type StructMapping,
   type TypeMapping,
+  U8,
   U32,
+  U64,
+  U128,
+  isArrayMapping,
+  isBoundedVecMapping,
+  isFixedArrayMapping,
+  isFixedBoundedVecMapping,
+  isOptionMapping,
+  isStructMapping,
   tryFieldWidth,
 } from '@aztec/pxe/simulator';
 import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
@@ -50,15 +60,18 @@ export function synthesizeDefaultFixtures(
 }
 
 /**
- * The test-value implementations, one per oracle type, mirroring the Noir synthesizer tables (`scalars` and
- * `synthesizers` in `noir-projects/aztec-nr/.../macros/oracle_testing.nr`) exactly.
+ * The scalar test-value implementations, mirroring the Noir synthesizer's `scalars` table in
+ * `noir-projects/aztec-nr/.../macros/oracle_testing.nr` exactly.
  */
-const TEST_VALUE_IMPLS: TestValueImpl[] = [
+const SCALAR_IMPLS: ScalarImpl[] = [
   scalar(FIELD, seed => new Fr(seed)),
   scalar(U32, seed => seed),
   scalar(BLOCK_NUMBER, seed => BlockNumber(seed)),
   scalar(BIGINT, seed => BigInt(seed)),
-  scalar(BYTE, seed => seed),
+  scalar(U64, seed => BigInt(seed)),
+  scalar(U128, seed => BigInt(seed)),
+  scalar(LEAF_INDEX, seed => seed),
+  scalar(U8, seed => seed),
   scalar(BOOL, seed => seed % 2 !== 0),
   scalar(AZTEC_ADDRESS, seed => AztecAddress.fromNumberUnsafe(seed)),
   scalar(ETH_ADDRESS, seed => EthAddress.fromField(new Fr(seed))),
@@ -70,12 +83,18 @@ const TEST_VALUE_IMPLS: TestValueImpl[] = [
   scalar(DELIVERY_MODE, seed =>
     seed % 2 === 0 ? AppTaggingSecretKind.UNCONSTRAINED : AppTaggingSecretKind.CONSTRAINED,
   ),
-  composite(isOption, (type, seed) => [
-    named(Option.some(firstValue(type.inner, seed)), 'some'),
-    named(Option.none(firstValue(type.inner, seed)), 'none'),
+];
+
+/**
+ * The composite test-value implementations, one per combinator, mirroring the Noir synthesizer's `synthesizers` table.
+ */
+const COMPOSITE_IMPLS: CompositeImpl[] = [
+  composite(isOptionMapping, (type, seed) => [
+    named(Option.some(testValueFor(type.inner, seed)), 'some'),
+    named(Option.none(testValueFor(type.inner, seed)), 'none'),
   ]),
-  composite(isArray, (type, seed) => [unnamed(collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH))]),
-  composite(isBoundedVec, (type, seed) => [
+  composite(isArrayMapping, (type, seed) => [unnamed(collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH))]),
+  composite(isBoundedVecMapping, (type, seed) => [
     unnamed(
       BoundedVec.from({
         data: collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH),
@@ -83,17 +102,20 @@ const TEST_VALUE_IMPLS: TestValueImpl[] = [
       }),
     ),
   ]),
-  composite(isStruct, (type, seed) => [unnamed(structValue(type, seed))]),
+  composite(isStructMapping, (type, seed) => [unnamed(structValue(type, seed))]),
   // A fixed-length array uses its real (signature) length, unlike the generic-length ARRAY which is pinned to
   // DEFAULT_ARRAY_LENGTH.
-  composite(isFixedArray, (type, seed) => [unnamed(collectionData(type.inner, seed, type.length))]),
+  composite(isFixedArrayMapping, (type, seed) => [unnamed(collectionData(type.inner, seed, type.length))]),
   // Same for a fixed-capacity bounded vec: real capacity, DEFAULT_ARRAY_LENGTH elements (its value type is a plain
   // element array, unlike the two-slot BOUNDED_VEC), clamped to the capacity so small vecs stay valid.
-  composite(isFixedBoundedVec, (type, seed) => [
+  composite(isFixedBoundedVecMapping, (type, seed) => [
     unnamed(collectionData(type.inner, seed, Math.min(DEFAULT_ARRAY_LENGTH, type.maxLength))),
   ]),
 ];
 
+/** The scalar mappings with a registered test-value impl. */
+export const SCALAR_MAPPINGS: TypeMapping<any>[] = SCALAR_IMPLS.map(impl => impl.mapping);
+
 /**
  * The base every seed is offset by, applied once where a parameter's position becomes its seed, so generated values
  * stay clear of 0. Must match `SEED_BASE` in the Noir `oracle_testing.nr`.
@@ -125,32 +147,34 @@ function named(value: unknown, name: string): Scenario {
   return { value, name };
 }
 
-/**
- * One type's test-value implementation, mirroring a Noir `TestValueSynthesizer` entry: `match` selects the type and
- * `scenarios` yields its [`Scenario`]s for `seed`, one per serialization shape, like the Noir entry's `scenarios`
- * function.
- */
-interface TestValueImpl {
+/** An impl for the single scalar `mapping` it synthesizes for. */
+type ScalarImpl = {
+  mapping: TypeMapping<any>;
+  scenarios: (type: TypeMapping<any>, seed: number) => Scenario[];
+};
+
+/** An impl for a whole family of composite mappings, selected by its `kind` type guard. */
+type CompositeImpl = {
   match: (type: TypeMapping<any>) => boolean;
   scenarios: (type: TypeMapping<any>, seed: number) => Scenario[];
-}
+};
 
-/** A scalar impl: matches the singleton `type` by identity and yields a single unnamed scenario. */
-function scalar(type: TypeMapping<any>, value: (seed: number) => unknown): TestValueImpl {
-  return { match: t => t === type, scenarios: (_type, seed) => [unnamed(value(seed))] };
+/** A scalar impl yielding a single unnamed scenario. */
+function scalar(mapping: TypeMapping<any>, value: (seed: number) => unknown): ScalarImpl {
+  return { mapping, scenarios: (_type, seed) => [unnamed(value(seed))] };
 }
 
-/** A composite impl: selected by the `kind` type guard, recursing through its element/inner mapping. */
+/** A composite impl, recursing through the matched mapping's element/inner mapping. */
 function composite<K extends CompositeMapping>(
   guard: (type: TypeMapping<any>) => type is K,
   scenarios: (type: K, seed: number) => Scenario[],
-): TestValueImpl {
+): CompositeImpl {
   return { match: guard, scenarios: (type, seed) => scenarios(type as K, seed) };
 }
 
 /** Synthesized element values for a collection. */
 function collectionData(element: TypeMapping<any>, seed: number, length: number): unknown[] {
-  return Array.from({ length }, (_, i) => firstValue(element, seed + i));
+  return Array.from({ length }, (_, i) => testValueFor(element, seed + i));
 }
 
 /**
@@ -161,7 +185,7 @@ function structValue(type: StructMapping, seed: number): Record<string, unknown>
   const value: Record<string, unknown> = {};
   let offset = 0;
   for (const field of type.fields) {
-    value[field.name] = firstValue(field.type, seed + offset);
+    value[field.name] = testValueFor(field.type, seed + offset);
     const width = tryFieldWidth(field.type.shape);
     if (width === undefined) {
       // A variable-width field has no flat offset to seed the next field at, so only this oracle is unsynthesizable.
@@ -177,15 +201,18 @@ function structValue(type: StructMapping, seed: number): Record<string, unknown>
  * dispatcher. Throws if the type has no matching impl.
  */
 function scenariosForType(type: TypeMapping<any>, seed: number): Scenario[] {
-  const impl = TEST_VALUE_IMPLS.find(i => i.match(type));
+  const impl = SCALAR_IMPLS.find(i => i.mapping === type) ?? COMPOSITE_IMPLS.find(i => i.match(type));
   if (!impl) {
     throw new UnsynthesizableTypeError(type);
   }
   return impl.scenarios(type, seed);
 }
 
-/** The first (representative) test value of `type`, used for collection elements and `Option` inners. */
-function firstValue(type: TypeMapping<any>, seed: number): unknown {
+/**
+ * The test value of `type` at `seed`, matching what the Noir synthesizer produces for the same type and seed. Throws
+ * for types without a test-value impl.
+ */
+export function testValueFor(type: TypeMapping<any>, seed: number): unknown {
   return scenariosForType(type, seed)[0].value;
 }
 
@@ -242,41 +269,3 @@ function synthesizeScenariosOrThrow(entry: OracleRegistryEntry): OracleTestScena
   }
   return scenarios;
 }
-
-/**
- * The composite `TypeMapping`s (`ARRAY`/`BOUNDED_VEC`/`OPTION`/`STRUCT`/`FIXED_ARRAY`/`FIXED_BOUNDED_VEC`),
- * discriminated by `kind`. The combinators attach `kind` plus the inner mapping(s) at construction; the registry
- * erases params to the base `TypeMapping`, so the guards below recover the structure for recursion.
- */
-type ArrayMapping = TypeMapping & { kind: 'array'; inner: TypeMapping };
-type BoundedVecMapping = TypeMapping & { kind: 'bounded-vec'; inner: TypeMapping };
-type OptionMapping = TypeMapping & { kind: 'option'; inner: TypeMapping };
-type StructMapping = TypeMapping & { kind: 'struct'; fields: readonly StructField[] };
-type FixedArrayMapping = TypeMapping & { kind: 'fixed-array'; inner: TypeMapping; length: number };
-type FixedBoundedVecMapping = TypeMapping & { kind: 'fixed-bounded-vec'; inner: TypeMapping; maxLength: number };
-type CompositeMapping =
-  | ArrayMapping
-  | BoundedVecMapping
-  | OptionMapping
-  | StructMapping
-  | FixedArrayMapping
-  | FixedBoundedVecMapping;
-
-function isArray(type: TypeMapping<any>): type is ArrayMapping {
-  return 'kind' in type && type.kind === 'array';
-}
-function isBoundedVec(type: TypeMapping<any>): type is BoundedVecMapping {
-  return 'kind' in type && type.kind === 'bounded-vec';
-}
-function isOption(type: TypeMapping<any>): type is OptionMapping {
-  return 'kind' in type && type.kind === 'option';
-}
-function isStruct(type: TypeMapping<any>): type is StructMapping {
-  return 'kind' in type && type.kind === 'struct';
-}
-function isFixedArray(type: TypeMapping<any>): type is FixedArrayMapping {
-  return 'kind' in type && type.kind === 'fixed-array';
-}
-function isFixedBoundedVec(type: TypeMapping<any>): type is FixedBoundedVecMapping {
-  return 'kind' in type && type.kind === 'fixed-bounded-vec';
-}

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

@@ -2,7 +2,7 @@
 import type { Logger } from '@aztec/foundation/log';
 import { createLogger } from '@aztec/foundation/log';
 import { withoutHexPrefix } from '@aztec/foundation/string';
-import { BOUNDED_VEC, BYTE, BoundedVec, Option, type OracleRegistryEntry, makeEntry } from '@aztec/pxe/simulator';
+import { BOUNDED_VEC, BoundedVec, Option, type OracleRegistryEntry, U8, makeEntry } from '@aztec/pxe/simulator';
 
 import type { ForeignCallArgs, ForeignCallResult } from '../../utils/encoding.js';
 import { toInputSlots } from '../txe_oracle_registry.js';
@@ -10,7 +10,7 @@ import { synthesizeDefaultFixtures } from './default_fixtures.js';
 
 /** Name of the meta-oracle that Noir tests call to announce the next call's scenario by name. */
 const SET_SCENARIO_ORACLE = 'aztec_oracle_test_set_scenario';
-export const SET_SCENARIO_ENTRY = makeEntry({ params: [{ name: 'name', type: BOUNDED_VEC(BYTE) }] });
+export const SET_SCENARIO_ENTRY = makeEntry({ params: [{ name: 'name', type: BOUNDED_VEC(U8) }] });
 
 export type OracleTestCallInput = {
   session_id: number;

package/src/oracle/txe_oracle_registry.ts

@@ -14,7 +14,6 @@ import type { TaggingSecretStrategy } from '@aztec/pxe/server';
 import {
   ARRAY,
   AZTEC_ADDRESS,
-  BIGINT,
   BLOCK_NUMBER,
   BOOL,
   ETH_ADDRESS,
@@ -22,17 +21,20 @@ import {
   FIXED_ARRAY,
   FUNCTION_SELECTOR,
   type InputSlot,
+  LEAF,
   type MaybePromise,
   OPTION,
   ORACLE_REGISTRY,
   type OracleRegistryEntry,
   type OutputSlot,
   type ParamTypes,
+  SCALAR,
   STR,
   STRUCT,
   type SlotShape,
   type TypeMapping,
   U32,
+  U64,
   buildACIRCallback,
   makeEntry,
 } from '@aztec/pxe/simulator';
@@ -59,12 +61,13 @@ export type { BlockHash } from '@aztec/stdlib/block';
 export type { MembershipWitness } from '@aztec/foundation/trees';
 export type { NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 
-const GAS_SETTINGS: TypeMapping<GasSettings> = {
+const GAS_SETTINGS: TypeMapping<GasSettings> = LEAF({
+  kind: 'gas-settings',
   deserialization: {
     fn: ([reader]) => GasSettings.fromFields(reader.readFieldArray(GAS_SETTINGS_LENGTH)),
   },
   shape: [{ len: GAS_SETTINGS_LENGTH }],
-};
+});
 
 // Tagging secret strategy discriminants. Must match the Noir test helper `TaggingSecretStrategy` in
 // aztec-nr `test/helpers/tagging_secret_strategy.nr`. This is a test-only oracle (only `set_tagging_secret_strategies`
@@ -74,7 +77,8 @@ const STRATEGY_ARBITRARY_SECRET = 2;
 const STRATEGY_ADDRESS_DERIVED = 3;
 const STRATEGY_INTERACTIVE_HANDSHAKE = 4;
 
-const TAGGING_SECRET_STRATEGY: TypeMapping<TaggingSecretStrategy> = {
+const TAGGING_SECRET_STRATEGY: TypeMapping<TaggingSecretStrategy> = LEAF({
+  kind: 'tagging-secret-strategy',
   serialization: {
     fn: strategy => {
       switch (strategy.type) {
@@ -108,24 +112,27 @@ const TAGGING_SECRET_STRATEGY: TypeMapping<TaggingSecretStrategy> = {
     },
   },
   shape: ['scalar', 'scalar', 'scalar'],
-};
+});
 
-const PRIVATE_CONTEXT_INPUTS: TypeMapping<PrivateContextInputs> = {
+const PRIVATE_CONTEXT_INPUTS: TypeMapping<PrivateContextInputs> = LEAF({
+  kind: 'private-context-inputs',
   serialization: { fn: v => v.toFields() },
   shape: Array<SlotShape>(PRIVATE_CONTEXT_INPUTS_LENGTH).fill('scalar'),
-};
+});
 
-const COMPLETE_ADDRESS: TypeMapping<CompleteAddress> = {
+const COMPLETE_ADDRESS: TypeMapping<CompleteAddress> = LEAF({
+  kind: 'complete-address',
   serialization: { fn: v => [v.address.toField(), ...v.publicKeys.toFields()] },
   shape: Array<SlotShape>(8).fill('scalar'), // address + 7 public-key fields
-};
+});
 
 const TXE_TX_EFFECTS: TypeMapping<{
   txHash: TxHash;
   noteHashes: Fr[];
   nullifiers: Fr[];
   privateLogs: PrivateLog[];
-}> = {
+}> = LEAF({
+  kind: 'txe-tx-effects',
   serialization: {
     fn: ({ txHash, noteHashes, nullifiers, privateLogs }) => {
       const emittedLogs = privateLogs.map(log => log.getEmittedFields());
@@ -164,9 +171,10 @@ const TXE_TX_EFFECTS: TypeMapping<{
     { len: MAX_PRIVATE_LOGS_PER_TX },
     'scalar',
   ],
-};
+});
 
-const TXE_OFFCHAIN_EFFECTS: TypeMapping<{ effects: Fr[][] }> = {
+const TXE_OFFCHAIN_EFFECTS: TypeMapping<{ effects: Fr[][] }> = LEAF({
+  kind: 'txe-offchain-effects',
   serialization: {
     fn: ({ effects }) => {
       const rawArrayStorage = effects
@@ -188,9 +196,10 @@ const TXE_OFFCHAIN_EFFECTS: TypeMapping<{ effects: Fr[][] }> = {
     { len: MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY },
     'scalar',
   ],
-};
+});
 
-const TXE_CALL_CONTEXT: TypeMapping<{ txHash: Fr; anchorBlockTimestamp: bigint }> = {
+const TXE_CALL_CONTEXT: TypeMapping<{ txHash: Fr; anchorBlockTimestamp: bigint }> = LEAF({
+  kind: 'txe-call-context',
   serialization: {
     fn: ({ txHash, anchorBlockTimestamp }) => {
       const isSome = txHash.isZero() ? 0 : 1;
@@ -198,7 +207,7 @@ const TXE_CALL_CONTEXT: TypeMapping<{ txHash: Fr; anchorBlockTimestamp: bigint }
     },
   },
   shape: ['scalar', 'scalar', 'scalar'], // discriminant, txHash, anchor block timestamp
-};
+});
 
 const CONTRACT_INSTANCE_MEMBER: TypeMapping<{ exists: boolean; member: Fr }[]> = FIXED_ARRAY(
   STRUCT([
@@ -208,13 +217,14 @@ const CONTRACT_INSTANCE_MEMBER: TypeMapping<{ exists: boolean; member: Fr }[]> =
   1,
 );
 
-const EVENT_SELECTOR: TypeMapping<EventSelector> = {
+const EVENT_SELECTOR: TypeMapping<EventSelector> = SCALAR({
+  kind: 'event-selector',
   serialization: { fn: v => [v.toField()] },
   deserialization: { fn: ([reader]) => EventSelector.fromField(reader.readField()) },
-  shape: ['scalar'],
-};
+});
 
-const TXE_PRIVATE_EVENTS: TypeMapping<Fr[][]> = {
+const TXE_PRIVATE_EVENTS: TypeMapping<Fr[][]> = LEAF({
+  kind: 'txe-private-events',
   serialization: {
     fn: events => {
       const rawArrayStorage = events
@@ -235,7 +245,7 @@ const TXE_PRIVATE_EVENTS: TypeMapping<Fr[][]> = {
     { len: MAX_PRIVATE_EVENTS_PER_TXE_QUERY },
     'scalar',
   ],
-};
+});
 
 export const TXE_ORACLE_REGISTRY = {
   ...ORACLE_REGISTRY,
@@ -270,14 +280,14 @@ export const TXE_ORACLE_REGISTRY = {
 
   aztec_txe_getNextBlockNumber: makeEntry({ returnType: BLOCK_NUMBER }),
 
-  aztec_txe_getNextBlockTimestamp: makeEntry({ returnType: BIGINT }),
+  aztec_txe_getNextBlockTimestamp: makeEntry({ returnType: U64 }),
 
   aztec_txe_advanceBlocksBy: makeEntry({
     params: [{ name: 'blocks', type: U32 }],
   }),
 
   aztec_txe_advanceTimestampBy: makeEntry({
-    params: [{ name: 'duration', type: BIGINT }],
+    params: [{ name: 'duration', type: U64 }],
   }),
 
   aztec_txe_deploy: makeEntry({
@@ -294,7 +304,10 @@ export const TXE_ORACLE_REGISTRY = {
   }),
 
   aztec_txe_createAccount: makeEntry({
-    params: [{ name: 'secret', type: FIELD }],
+    params: [
+      { name: 'secret', type: FIELD },
+      { name: 'partialAddress', type: FIELD },
+    ],
     returnType: COMPLETE_ADDRESS,
   }),
 
@@ -327,8 +340,12 @@ export const TXE_ORACLE_REGISTRY = {
     ],
   }),
 
+  aztec_txe_setAuthorizeAllUtilityCallTargets: makeEntry({
+    params: [{ name: 'authorizeAll', type: BOOL }],
+  }),
+
   aztec_txe_getLastBlockTimestamp: makeEntry({
-    returnType: BIGINT,
+    returnType: U64,
   }),
 
   aztec_txe_getLastTxEffects: makeEntry({ returnType: TXE_TX_EFFECTS }),
@@ -387,7 +404,7 @@ export const TXE_ORACLE_REGISTRY = {
 
   aztec_avm_blockNumber: makeEntry({ returnType: BLOCK_NUMBER }),
 
-  aztec_avm_timestamp: makeEntry({ returnType: BIGINT }),
+  aztec_avm_timestamp: makeEntry({ returnType: U64 }),
 
   aztec_avm_isStaticCall: makeEntry({ returnType: BOOL }),
 

package/src/oracle/txe_oracle_top_level_context.ts

@@ -53,10 +53,10 @@ import {
   witnessMapToFields,
 } from '@aztec/simulator/client';
 import {
-  CppPublicTxSimulator,
   GuardedMerkleTreeOperations,
   PublicContractsDB,
   PublicProcessor,
+  PublicTxSimulator,
 } from '@aztec/simulator/server';
 import { type ContractArtifact, EventSelector, FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
@@ -126,6 +126,7 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     private chainId: Fr,
     private authwits: Map<string, AuthWitness>,
     private taggingSecretStrategies: TXETaggingSecretStrategies,
+    private authorizeAllUtilityCallTargets: boolean,
     private readonly artifactResolver: TXEArtifactResolver,
     private readonly rootPath: string,
     private readonly packageName: string,
@@ -335,9 +336,8 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     return completeAddress;
   }
 
-  async createAccount(secret: Fr) {
-    // This is a foot gun !
-    const completeAddress = await this.keyStore.addAccount(await deriveKeys(secret), secret);
+  async createAccount(secret: Fr, partialAddress: Fr) {
+    const completeAddress = await this.keyStore.addAccount(await deriveKeys(secret), partialAddress);
     await this.accountStore.setAccount(completeAddress.address, completeAddress);
     await this.addressStore.addCompleteAddress(completeAddress);
     this.logger.debug(`Created account ${completeAddress.address}`);
@@ -373,6 +373,10 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     apply(AppTaggingSecretKind.CONSTRAINED, constrainedStrategy);
   }
 
+  setAuthorizeAllUtilityCallTargets(authorizeAll: boolean): void {
+    this.authorizeAllUtilityCallTargets = authorizeAll;
+  }
+
   async sendL1ToL2Message(content: Fr, secretHash: Fr, sender: EthAddress, recipient: AztecAddress): Promise<Fr> {
     // Messages are appended to the tree, so the next free slot is simply the current tree size.
     const { size } = await this.stateMachine.synchronizer
@@ -487,7 +491,6 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     const privateExecutionOracle = new PrivateExecutionOracle({
       argsHash,
       txContext,
-      // The TXE does not run the init kernel's salt binding, so no tx-request salt is in scope.
       txRequestSalt: Fr.ZERO,
       callContext,
       anchorBlockHeader: blockHeader,
@@ -577,7 +580,7 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     globals.version = this.version;
     globals.gasFees = GasFees.empty();
 
-    const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
+    await using forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
 
     const bindings = this.logger.getBindings();
     const contractsDB = new PublicContractsDB(
@@ -592,11 +595,20 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
       collectStatistics: false,
       collectCallMetadata: true,
     });
+    // The AVM simulator reads this fork's contracts DB, scoped by fork id, for each simulation.
+    const forkId = forkedWorldTrees.getRevision().forkId;
     const processor = new PublicProcessor(
       globals,
       guardedMerkleTrees,
       contractsDB,
-      new CppPublicTxSimulator(guardedMerkleTrees, contractsDB, globals, config, bindings),
+      new PublicTxSimulator(
+        this.stateMachine.synchronizer.avmSimulator,
+        globals,
+        contractsDB,
+        forkId,
+        config,
+        bindings,
+      ),
       new TestDateProvider(),
       undefined,
       createLogger('simulator:public-processor', bindings),
@@ -647,8 +659,6 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
 
     if (isStaticCall) {
       await checkpoint!.revert();
-
-      await forkedWorldTrees.close();
       return { returnValues: executionResult.returnValues ?? [], offchainEffects };
     }
 
@@ -669,8 +679,6 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
 
     await this.stateMachine.handleL2Block(l2Block);
 
-    await forkedWorldTrees.close();
-
     return { returnValues: executionResult.returnValues ?? [], offchainEffects };
   }
 
@@ -706,7 +714,7 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     globals.version = this.version;
     globals.gasFees = GasFees.empty();
 
-    const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
+    await using forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
 
     const bindings2 = this.logger.getBindings();
     const contractsDB = new PublicContractsDB(
@@ -721,7 +729,16 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
       collectStatistics: false,
       collectCallMetadata: true,
     });
-    const simulator = new CppPublicTxSimulator(guardedMerkleTrees, contractsDB, globals, config, bindings2);
+    // The AVM simulator reads this fork's contracts DB, scoped by fork id, for each simulation.
+    const forkId2 = forkedWorldTrees.getRevision().forkId;
+    const simulator = new PublicTxSimulator(
+      this.stateMachine.synchronizer.avmSimulator,
+      globals,
+      contractsDB,
+      forkId2,
+      config,
+      bindings2,
+    );
     const processor = new PublicProcessor(
       globals,
       guardedMerkleTrees,
@@ -807,9 +824,6 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
 
     if (isStaticCall) {
       await checkpoint!.revert();
-
-      await forkedWorldTrees.close();
-
       return returnValues ?? [];
     }
 
@@ -830,8 +844,6 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
 
     await this.stateMachine.handleL2Block(l2Block);
 
-    await forkedWorldTrees.close();
-
     return returnValues ?? [];
   }
 
@@ -918,7 +930,7 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     try {
       const simulator = new WASMSimulator();
       const utilityExecutor = async (syncCall: FunctionCall, execScopes: AztecAddress[]) => {
-        await this.executeUtilityCall(syncCall, { scopes: execScopes, jobId, authorizedUtilityCallTargets });
+        await this.executeUtilityCall(syncCall, { scopes: execScopes, jobId });
       };
       const oracle = new UtilityExecutionOracle({
         callContext: CallContext.from({
@@ -946,10 +958,10 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
         jobId,
         scopes,
         simulator,
-        utilityExecutor,
         hooks: composeHooks({
           authorizeUtilityCall: this.buildAuthorizeUtilityCallHook('utility', authorizedUtilityCallTargets),
         }),
+        utilityExecutor,
         // Execution-tree root (top-level utility run or contract sync): own store; nested frames inherit it.
         transientArrayService: new TransientArrayService(),
       });
@@ -975,9 +987,19 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     }
   }
 
-  close(): [bigint, Map<string, AuthWitness>, TXETaggingSecretStrategies] {
+  close(): {
+    nextBlockTimestamp: bigint;
+    authwits: Map<string, AuthWitness>;
+    taggingSecretStrategies: TXETaggingSecretStrategies;
+    authorizeAllUtilityCallTargets: boolean;
+  } {
     this.logger.debug('Exiting Top Level Context');
-    return [this.nextBlockTimestamp, this.authwits, this.taggingSecretStrategies];
+    return {
+      nextBlockTimestamp: this.nextBlockTimestamp,
+      authwits: this.authwits,
+      taggingSecretStrategies: this.taggingSecretStrategies,
+      authorizeAllUtilityCallTargets: this.authorizeAllUtilityCallTargets,
+    };
   }
 
   private async getLastBlockNumber(): Promise<BlockNumber> {
@@ -989,6 +1011,9 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     callerContext: 'private' | 'private view' | 'utility',
     authorizedTargets: AztecAddress[],
   ): ExecutionHooks['authorizeUtilityCall'] | undefined {
+    if (this.authorizeAllUtilityCallTargets) {
+      return authorizeAllUtilityCallsHook;
+    }
     if (authorizedTargets.length === 0) {
       return undefined;
     }
@@ -998,3 +1023,11 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
       });
   }
 }
+
+/**
+ * An `authorizeUtilityCall` hook that authorizes every cross-contract utility call.
+ *
+ * Backs the `aztec_txe_setAuthorizeAllUtilityCallTargets` oracle.
+ */
+export const authorizeAllUtilityCallsHook: NonNullable<ExecutionHooks['authorizeUtilityCall']> = () =>
+  Promise.resolve({ authorized: true });

package/src/oracle/txe_oracle_version.ts

@@ -5,13 +5,13 @@
  *
  * The Noir counterparts are in `noir-projects/aztec-nr/aztec/src/test/helpers/txe_oracles.nr`.
  */
-export const TXE_ORACLE_VERSION_MAJOR = 3;
-export const TXE_ORACLE_VERSION_MINOR = 0;
+export const TXE_ORACLE_VERSION_MAJOR = 4;
+export const TXE_ORACLE_VERSION_MINOR = 1;
 
 /**
- * This hash is computed from the TXE oracle interfaces (IAvmExecutionOracle and ITxeExecutionOracle) and is used to
+ * This hash is computed from the TXE-specific entries in `TXE_ORACLE_REGISTRY` and is used to
  * detect when those interfaces change. When it does, bump:
  *   - TXE_ORACLE_VERSION_MAJOR (and reset MINOR to 0) for breaking changes, or
  *   - TXE_ORACLE_VERSION_MINOR for additive changes (new oracle method added).
  */
-export const TXE_ORACLE_INTERFACE_HASH = 'bea75bd85baebd7aa1438efb1defab496d27540bc805a8d854bb74b8d45fd859';
+export const TXE_ORACLE_INTERFACE_HASH = '1a6c578d0a47cd8dd7dae07fd00abe781225a73920c596d873afcc061c0e4284';