@aztec/txe 0.0.1-commit.b8a057fa → 0.0.1-commit.be03c316

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,22 +61,24 @@ 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_strategy`
+// aztec-nr `test/helpers/tagging_secret_strategy.nr`. This is a test-only oracle (only `set_tagging_secret_strategies`
 // reads it), so the mapping lives here on the TXE side rather than in the production oracle type mappings.
 const STRATEGY_NON_INTERACTIVE_HANDSHAKE = 1;
 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,
   }),
 
@@ -320,12 +333,19 @@ export const TXE_ORACLE_REGISTRY = {
     returnType: FIELD,
   }),
 
-  aztec_txe_setTaggingSecretStrategy: makeEntry({
-    params: [{ name: 'strategy', type: OPTION(TAGGING_SECRET_STRATEGY) }],
+  aztec_txe_setTaggingSecretStrategies: makeEntry({
+    params: [
+      { name: 'unconstrainedStrategy', type: OPTION(TAGGING_SECRET_STRATEGY) },
+      { name: 'constrainedStrategy', type: OPTION(TAGGING_SECRET_STRATEGY) },
+    ],
+  }),
+
+  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 }),
@@ -384,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

@@ -73,6 +73,7 @@ import {
 } from '@aztec/stdlib/kernel';
 import { deriveKeys, hashPublicKey } from '@aztec/stdlib/keys';
 import type { PrivateLog } from '@aztec/stdlib/logs';
+import { AppTaggingSecretKind } from '@aztec/stdlib/logs';
 import { L1Actor, L1ToL2Message, L2Actor } from '@aztec/stdlib/messaging';
 import { ChonkProof } from '@aztec/stdlib/proofs';
 import { makeGlobalVariables } from '@aztec/stdlib/testing';
@@ -99,6 +100,7 @@ import type { TXEAccountStore } from '../utils/txe_account_store.js';
 import type { TXEArtifactResolver } from '../utils/txe_artifact_resolver.js';
 import { TXEPublicContractDataSource } from '../utils/txe_public_contract_data_source.js';
 import type { ITxeExecutionOracle } from './interfaces.js';
+import { type TXETaggingSecretStrategies, makeResolveTaggingSecretStrategyHook } from './tagging_secret_strategy.js';
 
 export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracle {
   isMisc = true as const;
@@ -123,7 +125,8 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     private version: Fr,
     private chainId: Fr,
     private authwits: Map<string, AuthWitness>,
-    private taggingSecretStrategy: TaggingSecretStrategy | undefined,
+    private taggingSecretStrategies: TXETaggingSecretStrategies,
+    private authorizeAllUtilityCallTargets: boolean,
     private readonly artifactResolver: TXEArtifactResolver,
     private readonly rootPath: string,
     private readonly packageName: string,
@@ -333,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}`);
@@ -356,8 +358,23 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     this.authwits.set(authWitness.requestHash.toString(), authWitness);
   }
 
-  setTaggingSecretStrategy(strategy: Option<TaggingSecretStrategy>): void {
-    this.taggingSecretStrategy = strategy.value;
+  setTaggingSecretStrategies(
+    unconstrainedStrategy: Option<TaggingSecretStrategy>,
+    constrainedStrategy: Option<TaggingSecretStrategy>,
+  ): void {
+    const apply = (mode: AppTaggingSecretKind, strategy: Option<TaggingSecretStrategy>) => {
+      if (strategy.isSome()) {
+        this.taggingSecretStrategies.set(mode, strategy.value);
+      } else {
+        this.taggingSecretStrategies.delete(mode);
+      }
+    };
+    apply(AppTaggingSecretKind.UNCONSTRAINED, unconstrainedStrategy);
+    apply(AppTaggingSecretKind.CONSTRAINED, constrainedStrategy);
+  }
+
+  setAuthorizeAllUtilityCallTargets(authorizeAll: boolean): void {
+    this.authorizeAllUtilityCallTargets = authorizeAll;
   }
 
   async sendL1ToL2Message(content: Fr, secretHash: Fr, sender: EthAddress, recipient: AztecAddress): Promise<Fr> {
@@ -471,7 +488,6 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     const simulator = new WASMSimulator();
 
     const transientArrayService = new TransientArrayService();
-    const taggingSecretStrategy = this.taggingSecretStrategy;
     const privateExecutionOracle = new PrivateExecutionOracle({
       argsHash,
       txContext,
@@ -511,9 +527,7 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
           isStaticCall ? 'private view' : 'private',
           authorizedUtilityCallTargets,
         ),
-        // Only configure the hook when a strategy was explicitly set, so that otherwise the default tagging secret
-        // strategy is exercised.
-        resolveTaggingSecretStrategy: taggingSecretStrategy ? () => Promise.resolve(taggingSecretStrategy) : undefined,
+        resolveTaggingSecretStrategy: makeResolveTaggingSecretStrategyHook(this.taggingSecretStrategies),
       }),
       transientArrayService,
     });
@@ -973,9 +987,19 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
     }
   }
 
-  close(): [bigint, Map<string, AuthWitness>, TaggingSecretStrategy | undefined] {
+  close(): {
+    nextBlockTimestamp: bigint;
+    authwits: Map<string, AuthWitness>;
+    taggingSecretStrategies: TXETaggingSecretStrategies;
+    authorizeAllUtilityCallTargets: boolean;
+  } {
     this.logger.debug('Exiting Top Level Context');
-    return [this.nextBlockTimestamp, this.authwits, this.taggingSecretStrategy];
+    return {
+      nextBlockTimestamp: this.nextBlockTimestamp,
+      authwits: this.authwits,
+      taggingSecretStrategies: this.taggingSecretStrategies,
+      authorizeAllUtilityCallTargets: this.authorizeAllUtilityCallTargets,
+    };
   }
 
   private async getLastBlockNumber(): Promise<BlockNumber> {
@@ -987,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;
     }
@@ -996,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 = 2;
-export const TXE_ORACLE_VERSION_MINOR = 3;
+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 = '4ed3618087fafb4aa63c6580996a69bf6bc257844035a2019692586b5b8daf34';
+export const TXE_ORACLE_INTERFACE_HASH = '1a6c578d0a47cd8dd7dae07fd00abe781225a73920c596d873afcc061c0e4284';

package/src/rpc_translator.ts

@@ -188,7 +188,7 @@ export class RPCTranslator {
     return callTxeHandler({
       oracle: 'aztec_txe_createAccount',
       inputs,
-      handler: ([secret]) => this.handlerAsTxe().createAccount(secret),
+      handler: ([secret, partialAddress]) => this.handlerAsTxe().createAccount(secret, partialAddress),
     });
   }
 
@@ -221,11 +221,21 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  aztec_txe_setTaggingSecretStrategy(...inputs: ForeignCallArgs) {
+  aztec_txe_setTaggingSecretStrategies(...inputs: ForeignCallArgs) {
     return callTxeHandler({
-      oracle: 'aztec_txe_setTaggingSecretStrategy',
+      oracle: 'aztec_txe_setTaggingSecretStrategies',
       inputs,
-      handler: ([strategy]) => this.handlerAsTxe().setTaggingSecretStrategy(strategy),
+      handler: ([unconstrainedStrategy, constrainedStrategy]) =>
+        this.handlerAsTxe().setTaggingSecretStrategies(unconstrainedStrategy, constrainedStrategy),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_txe_setAuthorizeAllUtilityCallTargets(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_setAuthorizeAllUtilityCallTargets',
+      inputs,
+      handler: ([authorizeAll]) => this.handlerAsTxe().setAuthorizeAllUtilityCallTargets(authorizeAll),
     });
   }
 
@@ -488,12 +498,12 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_getL1ToL2MembershipWitness(...inputs: ForeignCallArgs) {
+  aztec_utl_getL1ToL2MembershipWitnessV2(...inputs: ForeignCallArgs) {
     return callTxeHandler({
-      oracle: 'aztec_utl_getL1ToL2MembershipWitness',
+      oracle: 'aztec_utl_getL1ToL2MembershipWitnessV2',
       inputs,
-      handler: ([contractAddress, messageHash, secret]) =>
-        this.handlerAsUtility().getL1ToL2MembershipWitness(contractAddress, messageHash, secret),
+      handler: ([messageHash, nullifier]) =>
+        this.handlerAsUtility().getL1ToL2MembershipWitnessV2(messageHash, nullifier),
     });
   }
 
@@ -571,6 +581,16 @@ export class RPCTranslator {
     });
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_utl_areBlockHashesInArchive(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_areBlockHashesInArchive',
+      inputs,
+      handler: ([anchorBlockHash, blockHashes]) =>
+        this.handlerAsUtility().areBlockHashesInArchive(anchorBlockHash, blockHashes),
+    });
+  }
+
   // eslint-disable-next-line camelcase
   aztec_utl_getLowNullifierMembershipWitness(...inputs: ForeignCallArgs) {
     return callTxeHandler({
@@ -622,6 +642,15 @@ export class RPCTranslator {
     });
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_utl_getTxEffects(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getTxEffects',
+      inputs,
+      handler: ([txHashes]) => this.handlerAsUtility().getTxEffects(txHashes),
+    });
+  }
+
   // eslint-disable-next-line camelcase
   aztec_utl_setCapsule(...inputs: ForeignCallArgs) {
     return callTxeHandler({

package/src/txe_session.ts

@@ -20,7 +20,6 @@ import {
   RecipientTaggingStore,
   SenderTaggingStore,
   TaggingSecretSourcesStore,
-  type TaggingSecretStrategy,
   composeHooks,
 } from '@aztec/pxe/server';
 import {
@@ -58,9 +57,13 @@ import { z } from 'zod';
 
 import { DEFAULT_ADDRESS, MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY, MAX_OFFCHAIN_EFFECT_LEN } from './constants.js';
 import type { IAvmExecutionOracle, ITxeExecutionOracle } from './oracle/interfaces.js';
+import {
+  type TXETaggingSecretStrategies,
+  makeResolveTaggingSecretStrategyHook,
+} from './oracle/tagging_secret_strategy.js';
 import { TXEOraclePublicContext } from './oracle/txe_oracle_public_context.js';
 import { callTxeLegacyHandler } from './oracle/txe_oracle_registry.js';
-import { TXEOracleTopLevelContext } from './oracle/txe_oracle_top_level_context.js';
+import { TXEOracleTopLevelContext, authorizeAllUtilityCallsHook } from './oracle/txe_oracle_top_level_context.js';
 import { TXE_ORACLE_VERSION_MAJOR, TXE_ORACLE_VERSION_MINOR } from './oracle/txe_oracle_version.js';
 import { TXEPrivateExecutionOracle } from './oracle/txe_private_execution_oracle.js';
 import { RPCTranslator, UnavailableOracleError } from './rpc_translator.js';
@@ -237,7 +240,8 @@ function emptyLastCallState(): LastCallState {
 export class TXESession implements TXESessionStateHandler {
   private state: SessionState = { name: 'TOP_LEVEL' };
   private authwits: Map<string, AuthWitness> = new Map();
-  private taggingSecretStrategy: TaggingSecretStrategy | undefined = undefined;
+  private taggingSecretStrategies: TXETaggingSecretStrategies = new Map();
+  private authorizeAllUtilityCallTargets = false;
   private lastCallInfo: LastCallState = emptyLastCallState();
   private txeOracleVersion: { major: number; minor: number } | undefined;
 
@@ -365,7 +369,8 @@ export class TXESession implements TXESessionStateHandler {
       version,
       chainId,
       new Map(),
-      undefined,
+      new Map(),
+      false, // authorizeAllUtilityCallTargets
       artifactResolver,
       rootPath,
       packageName,
@@ -695,7 +700,8 @@ export class TXESession implements TXESessionStateHandler {
       this.version,
       this.chainId,
       this.authwits,
-      this.taggingSecretStrategy,
+      this.taggingSecretStrategies,
+      this.authorizeAllUtilityCallTargets,
       this.artifactResolver,
       this.rootPath,
       this.packageName,
@@ -745,7 +751,6 @@ export class TXESession implements TXESessionStateHandler {
       this.stateMachine.contractClassService,
       anchorBlock!,
     );
-    const taggingSecretStrategy = this.taggingSecretStrategy;
     this.oracleHandler = new TXEPrivateExecutionOracle({
       argsHash: Fr.ZERO,
       txContext: new TxContext(this.chainId, this.version, gasSettings),
@@ -776,7 +781,8 @@ export class TXESession implements TXESessionStateHandler {
       txResolver: this.stateMachine.txResolver,
       simulator: new WASMSimulator(),
       hooks: composeHooks({
-        resolveTaggingSecretStrategy: taggingSecretStrategy ? () => Promise.resolve(taggingSecretStrategy) : undefined,
+        resolveTaggingSecretStrategy: makeResolveTaggingSecretStrategyHook(this.taggingSecretStrategies),
+        authorizeUtilityCall: this.authorizeAllUtilityCallTargets ? authorizeAllUtilityCallsHook : undefined,
       }),
       transientArrayService,
     });
@@ -877,6 +883,9 @@ export class TXESession implements TXESessionStateHandler {
       scopes: await this.keyStore.getAccounts(),
       simulator: new WASMSimulator(),
       utilityExecutor: this.utilityExecutorForContractSync(anchorBlockHeader),
+      hooks: composeHooks({
+        authorizeUtilityCall: this.authorizeAllUtilityCallTargets ? authorizeAllUtilityCallsHook : undefined,
+      }),
       // Execution-tree root (top-level utility run): own store; nested frames inherit it.
       transientArrayService: new TransientArrayService(),
     });
@@ -899,15 +908,18 @@ export class TXESession implements TXESessionStateHandler {
     // accounts to PXE (via `addAccount`), etc. This is a slight inconsistency in the working model of this class, but
     // is not too bad. The `close` call below therefore only hands back the session-scoped values that a test
     // sets directly at the top level, outside any contract execution (e.g. via `advanceTimestampBy`,
-    // `addAuthWitness`, `setTaggingSecretStrategy`). The oracle handler is discarded on every state transition,
+    // `addAuthWitness`, `setTaggingSecretStrategies`). The oracle handler is discarded on every state transition,
     // so the session must seed these values into the contexts it creates later.
 
     // TODO: persisting authwits this way is quite unfortunate: they create a temporary utility context that would
     // otherwise reset them, 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.taggingSecretStrategy] = (
-      this.oracleHandler as TXEOracleTopLevelContext
-    ).close();
+    ({
+      nextBlockTimestamp: this.nextBlockTimestamp,
+      authwits: this.authwits,
+      taggingSecretStrategies: this.taggingSecretStrategies,
+      authorizeAllUtilityCallTargets: this.authorizeAllUtilityCallTargets,
+    } = (this.oracleHandler as TXEOracleTopLevelContext).close());
   }
 
   private async exitPrivateState() {