@aztec/txe 0.0.1-commit.04852196a → 0.0.1-commit.04d373f

package/src/rpc_translator.ts

@@ -1,17 +1,27 @@
 import type { ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
-import { Fr, Point } from '@aztec/aztec.js/fields';
-import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
+import { Fr } from '@aztec/aztec.js/fields';
+import {
+  ARCHIVE_HEIGHT,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_PRIVATE_LOGS_PER_TX,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+} from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
+import { MembershipWitness } from '@aztec/foundation/trees';
 import {
+  BoundedVec,
   type IMiscOracle,
   type IPrivateExecutionOracle,
   type IUtilityExecutionOracle,
+  Option,
   packAsHintedNote,
 } from '@aztec/pxe/simulator';
 import { type ContractArtifact, EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { BlockHash } from '@aztec/stdlib/block';
+import { GasSettings } from '@aztec/stdlib/gas';
 
+import { MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY, MAX_OFFCHAIN_EFFECT_LEN } from './constants.js';
 import type { IAvmExecutionOracle, ITxeExecutionOracle } from './oracle/interfaces.js';
 import type { TXESessionStateHandler } from './txe_session.js';
 import {
@@ -20,6 +30,7 @@ import {
   addressFromSingle,
   arrayOfArraysToBoundedVecOfArrays,
   arrayToBoundedVec,
+  blockHashFromSingle,
   bufferToU8Array,
   fromArray,
   fromSingle,
@@ -28,7 +39,7 @@ import {
   toArray,
   toForeignCallResult,
   toSingle,
-} from './util/encoding.js';
+} from './utils/encoding.js';
 
 const MAX_EVENT_LEN = 10; // This is MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN
 const MAX_PRIVATE_EVENTS_PER_TXE_QUERY = 5;
@@ -102,6 +113,16 @@ export class RPCTranslator {
     return this.oracleHandler;
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_txe_assertCompatibleOracleVersion(foreignMajor: ForeignCallSingle, foreignMinor: ForeignCallSingle) {
+    const major = fromSingle(foreignMajor).toNumber();
+    const minor = fromSingle(foreignMinor).toNumber();
+
+    this.stateHandler.setTxeOracleVersion(major, minor);
+
+    return toForeignCallResult([]);
+  }
+
   // TXE session state transition functions - these get handled by the state handler
 
   // eslint-disable-next-line camelcase
@@ -117,6 +138,7 @@ export class RPCTranslator {
     foreignContractAddressValue: ForeignCallSingle,
     foreignAnchorBlockNumberIsSome: ForeignCallSingle,
     foreignAnchorBlockNumberValue: ForeignCallSingle,
+    foreignGasSettings: ForeignCallArray,
   ) {
     const contractAddress = fromSingle(foreignContractAddressIsSome).toBool()
       ? AztecAddress.fromField(fromSingle(foreignContractAddressValue))
@@ -126,7 +148,13 @@ export class RPCTranslator {
       ? BlockNumber(fromSingle(foreignAnchorBlockNumberValue).toNumber())
       : undefined;
 
-    const privateContextInputs = await this.stateHandler.enterPrivateState(contractAddress, anchorBlockNumber);
+    const gasSettings = GasSettings.fromFields(fromArray(foreignGasSettings));
+
+    const privateContextInputs = await this.stateHandler.enterPrivateState(
+      contractAddress,
+      anchorBlockNumber,
+      gasSettings,
+    );
 
     return toForeignCallResult(privateContextInputs.toFields().map(toSingle));
   }
@@ -218,6 +246,7 @@ export class RPCTranslator {
         instance.deployer.toField(),
         instance.currentContractClassId,
         instance.initializationHash,
+        instance.immutablesHash,
         ...instance.publicKeys.toFields(),
       ]),
     ]);
@@ -264,10 +293,11 @@ export class RPCTranslator {
   // PXE oracles
 
   // eslint-disable-next-line camelcase
-  aztec_utl_assertCompatibleOracleVersion(foreignVersion: ForeignCallSingle) {
-    const version = fromSingle(foreignVersion).toNumber();
+  aztec_utl_assertCompatibleOracleVersion(foreignMajor: ForeignCallSingle, foreignMinor: ForeignCallSingle) {
+    const major = fromSingle(foreignMajor).toNumber();
+    const minor = fromSingle(foreignMinor).toNumber();
 
-    this.handlerAsMisc().assertCompatibleOracleVersion(version);
+    this.handlerAsMisc().assertCompatibleOracleVersion(major, minor);
 
     return toForeignCallResult([]);
   }
@@ -288,15 +318,64 @@ export class RPCTranslator {
 
   // eslint-disable-next-line camelcase
   async aztec_txe_getLastTxEffects() {
-    const { txHash, noteHashes, nullifiers } = await this.handlerAsTxe().getLastTxEffects();
+    const { txHash, noteHashes, nullifiers, privateLogs } = await this.handlerAsTxe().getLastTxEffects();
+
+    // Same workaround as `aztec_txe_getPrivateEvents`: Noir cannot yet return nested structs with arrays, so we return
+    // a flat multidimensional array plus per-log lengths and the total count, and reassemble into a
+    // `BoundedVec<BoundedVec<T>>` on the Noir side. Each log contributes only its emitted fields. The rest
+    // is zero-padded to `PRIVATE_LOG_SIZE_IN_FIELDS`.
+    const emittedLogs = privateLogs.map(log => log.getEmittedFields());
+
+    const rawLogStorage = emittedLogs
+      .map(fields => fields.concat(Array(PRIVATE_LOG_SIZE_IN_FIELDS - fields.length).fill(new Fr(0))))
+      .concat(
+        Array(MAX_PRIVATE_LOGS_PER_TX - emittedLogs.length).fill(Array(PRIVATE_LOG_SIZE_IN_FIELDS).fill(new Fr(0))),
+      )
+      .flat();
+
+    const logLengths = emittedLogs
+      .map(fields => new Fr(fields.length))
+      .concat(Array(MAX_PRIVATE_LOGS_PER_TX - emittedLogs.length).fill(new Fr(0)));
+
+    const logCount = new Fr(emittedLogs.length);
 
     return toForeignCallResult([
       toSingle(txHash.hash),
       ...arrayToBoundedVec(toArray(noteHashes), MAX_NOTE_HASHES_PER_TX),
       ...arrayToBoundedVec(toArray(nullifiers), MAX_NULLIFIERS_PER_TX),
+      toArray(rawLogStorage),
+      toArray(logLengths),
+      toSingle(logCount),
     ]);
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_txe_getLastCallOffchainEffects() {
+    const { effects } = this.stateHandler.getLastCallOffchainEffects();
+
+    const rawArrayStorage = effects
+      .map(e => e.concat(Array(MAX_OFFCHAIN_EFFECT_LEN - e.length).fill(new Fr(0))))
+      .concat(
+        Array(MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY - effects.length).fill(Array(MAX_OFFCHAIN_EFFECT_LEN).fill(new Fr(0))),
+      )
+      .flat();
+
+    const effectLengths = effects
+      .map(e => new Fr(e.length))
+      .concat(Array(MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY - effects.length).fill(new Fr(0)));
+
+    const count = new Fr(effects.length);
+
+    return toForeignCallResult([toArray(rawArrayStorage), toArray(effectLengths), toSingle(count)]);
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_txe_getLastCallContext() {
+    const { txHash, anchorBlockTimestamp } = this.stateHandler.getLastCallContext();
+    const isSome = txHash.isZero() ? 0 : 1;
+    return toForeignCallResult([toSingle(isSome), toSingle(txHash), toSingle(new Fr(anchorBlockTimestamp))]);
+  }
+
   // eslint-disable-next-line camelcase
   async aztec_txe_getPrivateEvents(
     foreignSelector: ForeignCallSingle,
@@ -339,20 +418,20 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  aztec_prv_storeInExecutionCache(foreignValues: ForeignCallArray, foreignHash: ForeignCallSingle) {
+  aztec_prv_setHashPreimage(foreignValues: ForeignCallArray, foreignHash: ForeignCallSingle) {
     const values = fromArray(foreignValues);
     const hash = fromSingle(foreignHash);
 
-    this.handlerAsPrivate().storeInExecutionCache(values, hash);
+    this.handlerAsPrivate().setHashPreimage(values, hash);
 
     return toForeignCallResult([]);
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_prv_loadFromExecutionCache(foreignHash: ForeignCallSingle) {
+  async aztec_prv_getHashPreimage(foreignHash: ForeignCallSingle) {
     const hash = fromSingle(foreignHash);
 
-    const returns = await this.handlerAsPrivate().loadFromExecutionCache(hash);
+    const returns = await this.handlerAsPrivate().getHashPreimage(hash);
 
     return toForeignCallResult([toArray(returns)]);
   }
@@ -378,18 +457,18 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_storageRead(
+  async aztec_utl_getFromPublicStorage(
     foreignBlockHash: ForeignCallSingle,
     foreignContractAddress: ForeignCallSingle,
     foreignStartStorageSlot: ForeignCallSingle,
     foreignNumberOfElements: ForeignCallSingle,
   ) {
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
+    const blockHash = blockHashFromSingle(foreignBlockHash);
     const contractAddress = addressFromSingle(foreignContractAddress);
     const startStorageSlot = fromSingle(foreignStartStorageSlot);
     const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
 
-    const values = await this.handlerAsUtility().storageRead(
+    const values = await this.handlerAsUtility().getFromPublicStorage(
       blockHash,
       contractAddress,
       startStorageSlot,
@@ -401,14 +480,10 @@ export class RPCTranslator {
 
   // eslint-disable-next-line camelcase
   async aztec_utl_getPublicDataWitness(foreignBlockHash: ForeignCallSingle, foreignLeafSlot: ForeignCallSingle) {
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
+    const blockHash = blockHashFromSingle(foreignBlockHash);
     const leafSlot = fromSingle(foreignLeafSlot);
 
     const witness = await this.handlerAsUtility().getPublicDataWitness(blockHash, leafSlot);
-
-    if (!witness) {
-      throw new Error(`Public data witness not found for slot ${leafSlot} at block ${blockHash.toString()}.`);
-    }
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
@@ -435,8 +510,8 @@ export class RPCTranslator {
   ) {
     // Parse Option<AztecAddress>: ownerIsSome is 0 for None, 1 for Some
     const owner = fromSingle(foreignOwnerIsSome).toBool()
-      ? AztecAddress.fromField(fromSingle(foreignOwnerValue))
-      : undefined;
+      ? Option.some(AztecAddress.fromField(fromSingle(foreignOwnerValue)))
+      : Option.none(AztecAddress.ZERO);
     const storageSlot = fromSingle(foreignStorageSlot);
     const numSelects = fromSingle(foreignNumSelects).toNumber();
     const selectByIndexes = fromArray(foreignSelectByIndexes).map(fr => fr.toNumber());
@@ -454,7 +529,7 @@ export class RPCTranslator {
     const maxNotes = fromSingle(foreignMaxNotes).toNumber();
     const packedHintedNoteLength = fromSingle(foreignPackedHintedNoteLength).toNumber();
 
-    const noteDatas = await this.handlerAsUtility().getNotes(
+    const noteVec = await this.handlerAsUtility().getNotes(
       owner,
       storageSlot,
       numSelects,
@@ -470,9 +545,11 @@ export class RPCTranslator {
       limit,
       offset,
       status,
+      maxNotes,
+      packedHintedNoteLength,
     );
 
-    const returnDataAsArrayOfArrays = noteDatas.map(noteData =>
+    const returnDataAsArrayOfArrays = Array.from(noteVec.data).map(noteData =>
       packAsHintedNote({
         contractAddress: noteData.contractAddress,
         owner: noteData.owner,
@@ -484,12 +561,10 @@ export class RPCTranslator {
       }),
     );
 
-    // Now we convert each sub-array to an array of ForeignCallSingles
     const returnDataAsArrayOfForeignCallSingleArrays = returnDataAsArrayOfArrays.map(subArray =>
       subArray.map(toSingle),
     );
 
-    // At last we convert the array of arrays to a bounded vec of arrays
     return toForeignCallResult(
       arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfForeignCallSingleArrays, maxNotes, packedHintedNoteLength),
     );
@@ -556,10 +631,10 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_checkNullifierExists(foreignInnerNullifier: ForeignCallSingle) {
+  async aztec_utl_doesNullifierExist(foreignInnerNullifier: ForeignCallSingle) {
     const innerNullifier = fromSingle(foreignInnerNullifier);
 
-    const exists = await this.handlerAsUtility().checkNullifierExists(innerNullifier);
+    const exists = await this.handlerAsUtility().doesNullifierExist(innerNullifier);
 
     return toForeignCallResult([toSingle(new Fr(exists))]);
   }
@@ -576,27 +651,42 @@ export class RPCTranslator {
         instance.deployer.toField(),
         instance.currentContractClassId,
         instance.initializationHash,
+        instance.immutablesHash,
         ...instance.publicKeys.toFields(),
       ].map(toSingle),
     );
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_tryGetPublicKeysAndPartialAddress(foreignAddress: ForeignCallSingle) {
+  async aztec_utl_getPublicKeysAndPartialAddress(foreignAddress: ForeignCallSingle) {
     const address = addressFromSingle(foreignAddress);
 
-    const result = await this.handlerAsUtility().tryGetPublicKeysAndPartialAddress(address);
+    const result = await this.handlerAsUtility().getPublicKeysAndPartialAddress(address);
 
     // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
     // with two fields: `some` (a boolean) and `value` (a field array in this case).
-    if (result === undefined) {
+    if (!result.isSome()) {
       // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
-      return toForeignCallResult([toSingle(new Fr(0)), toArray(Array(13).fill(new Fr(0)))]);
+      // Wire shape: [npk_m_hash, ivpk_m.x, ivpk_m.y, ovpk_m_hash, tpk_m_hash, mspk_m_hash, fbpk_m_hash, partial_address] = 8 fields.
+      return toForeignCallResult([toSingle(new Fr(0)), toArray(Array(8).fill(new Fr(0)))]);
     } else {
-      // Data was found so we set `some` to 1 and return it along with `value`.
+      // The Noir side hand-decodes a `[Field; 8]` here (see aztec-nr/aztec/src/oracle/keys.nr), so we
+      // emit the 7-field PublicKeys shape + partial_address explicitly
+      // rather than going through `publicKeys.toFields()` (which is the struct-flattened 8-field
+      // wire for oracle returns that decode via struct shape).
+      const { publicKeys, partialAddress } = result.value;
       return toForeignCallResult([
         toSingle(new Fr(1)),
-        toArray([...result.publicKeys.toFields(), result.partialAddress]),
+        toArray([
+          publicKeys.npkMHash,
+          publicKeys.ivpkM.x,
+          publicKeys.ivpkM.y,
+          publicKeys.ovpkMHash,
+          publicKeys.tpkMHash,
+          publicKeys.mspkMHash,
+          publicKeys.fbpkMHash,
+          partialAddress,
+        ]),
       ]);
     }
   }
@@ -611,16 +701,27 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  aztec_prv_callPrivateFunction(
-    _foreignTargetContractAddress: ForeignCallSingle,
-    _foreignFunctionSelector: ForeignCallSingle,
-    _foreignArgsHash: ForeignCallSingle,
-    _foreignSideEffectCounter: ForeignCallSingle,
-    _foreignIsStaticCall: ForeignCallSingle,
+  async aztec_prv_callPrivateFunction(
+    foreignTargetContractAddress: ForeignCallSingle,
+    foreignFunctionSelector: ForeignCallSingle,
+    foreignArgsHash: ForeignCallSingle,
+    foreignSideEffectCounter: ForeignCallSingle,
+    foreignIsStaticCall: ForeignCallSingle,
   ) {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::private_context`, use `private_call` instead',
+    const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
+    const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
+    const argsHash = fromSingle(foreignArgsHash);
+    const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
+    const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
+
+    const { endSideEffectCounter, returnsHash } = await this.handlerAsPrivate().callPrivateFunction(
+      targetContractAddress,
+      functionSelector,
+      argsHash,
+      sideEffectCounter,
+      isStaticCall,
     );
+    return toForeignCallResult([[endSideEffectCounter, returnsHash].map(toSingle)]);
   }
 
   // eslint-disable-next-line camelcase
@@ -628,14 +729,10 @@ export class RPCTranslator {
     foreignBlockHash: ForeignCallSingle,
     foreignNullifier: ForeignCallSingle,
   ) {
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
+    const blockHash = blockHashFromSingle(foreignBlockHash);
     const nullifier = fromSingle(foreignNullifier);
 
     const witness = await this.handlerAsUtility().getNullifierMembershipWitness(blockHash, nullifier);
-
-    if (!witness) {
-      throw new Error(`Nullifier membership witness not found at block ${blockHash}.`);
-    }
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
@@ -644,42 +741,27 @@ export class RPCTranslator {
     const messageHash = fromSingle(foreignMessageHash);
 
     const authWitness = await this.handlerAsUtility().getAuthWitness(messageHash);
-
-    if (!authWitness) {
-      throw new Error(`Auth witness not found for message hash ${messageHash}.`);
-    }
     return toForeignCallResult([toArray(authWitness)]);
   }
 
   // eslint-disable-next-line camelcase
-  public aztec_prv_notifyEnqueuedPublicFunctionCall(
-    _foreignTargetContractAddress: ForeignCallSingle,
-    _foreignCalldataHash: ForeignCallSingle,
-    _foreignSideEffectCounter: ForeignCallSingle,
-    _foreignIsStaticCall: ForeignCallSingle,
-  ) {
-    throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
-  }
-
-  // eslint-disable-next-line camelcase
-  public aztec_prv_notifySetPublicTeardownFunctionCall(
-    _foreignTargetContractAddress: ForeignCallSingle,
-    _foreignCalldataHash: ForeignCallSingle,
-    _foreignSideEffectCounter: ForeignCallSingle,
-    _foreignIsStaticCall: ForeignCallSingle,
-  ) {
-    throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
+  public async aztec_prv_assertValidPublicCalldata(foreignCalldataHash: ForeignCallSingle) {
+    const calldataHash = fromSingle(foreignCalldataHash);
+    await this.handlerAsPrivate().assertValidPublicCalldata(calldataHash);
+    return toForeignCallResult([]);
   }
 
   // eslint-disable-next-line camelcase
-  public aztec_prv_notifySetMinRevertibleSideEffectCounter(_foreignMinRevertibleSideEffectCounter: ForeignCallSingle) {
-    throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
+  public async aztec_prv_notifyRevertiblePhaseStart(foreignMinRevertibleSideEffectCounter: ForeignCallSingle) {
+    const minRevertibleSideEffectCounter = fromSingle(foreignMinRevertibleSideEffectCounter).toNumber();
+    await this.handlerAsPrivate().notifyRevertiblePhaseStart(minRevertibleSideEffectCounter);
+    return toForeignCallResult([]);
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_prv_isSideEffectCounterRevertible(foreignSideEffectCounter: ForeignCallSingle) {
+  public async aztec_prv_isExecutionInRevertiblePhase(foreignSideEffectCounter: ForeignCallSingle) {
     const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
-    const isRevertible = await this.handlerAsPrivate().isSideEffectCounterRevertible(sideEffectCounter);
+    const isRevertible = await this.handlerAsPrivate().isExecutionInRevertiblePhase(sideEffectCounter);
     return toForeignCallResult([toSingle(new Fr(isRevertible))]);
   }
 
@@ -695,10 +777,6 @@ export class RPCTranslator {
     const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
 
     const header = await this.handlerAsUtility().getBlockHeader(blockNumber);
-
-    if (!header) {
-      throw new Error(`Block header not found for block ${blockNumber}.`);
-    }
     return toForeignCallResult(header.toFields().map(toSingle));
   }
 
@@ -707,14 +785,10 @@ export class RPCTranslator {
     foreignAnchorBlockHash: ForeignCallSingle,
     foreignNoteHash: ForeignCallSingle,
   ) {
-    const blockHash = new BlockHash(fromSingle(foreignAnchorBlockHash));
+    const blockHash = blockHashFromSingle(foreignAnchorBlockHash);
     const noteHash = fromSingle(foreignNoteHash);
 
     const witness = await this.handlerAsUtility().getNoteHashMembershipWitness(blockHash, noteHash);
-
-    if (!witness) {
-      throw new Error(`Note hash ${noteHash} not found in the note hash tree at block ${blockHash.toString()}.`);
-    }
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
@@ -723,17 +797,12 @@ export class RPCTranslator {
     foreignAnchorBlockHash: ForeignCallSingle,
     foreignBlockHash: ForeignCallSingle,
   ) {
-    const anchorBlockHash = new BlockHash(fromSingle(foreignAnchorBlockHash));
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
+    const anchorBlockHash = blockHashFromSingle(foreignAnchorBlockHash);
+    const blockHash = blockHashFromSingle(foreignBlockHash);
 
-    const witness = await this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash);
-
-    if (!witness) {
-      throw new Error(
-        `Block hash ${blockHash.toString()} not found in the archive tree at anchor block ${anchorBlockHash.toString()}.`,
-      );
-    }
-    return toForeignCallResult(witness.toNoirRepresentation());
+    const witnessOpt = await this.handlerAsUtility().getBlockHashMembershipWitness(anchorBlockHash, blockHash);
+    const effective = witnessOpt.value ?? MembershipWitness.empty(ARCHIVE_HEIGHT);
+    return toForeignCallResult([toSingle(new Fr(witnessOpt.isSome() ? 1 : 0)), ...effective.toNoirRepresentation()]);
   }
 
   // eslint-disable-next-line camelcase
@@ -741,108 +810,106 @@ export class RPCTranslator {
     foreignBlockHash: ForeignCallSingle,
     foreignNullifier: ForeignCallSingle,
   ) {
-    const blockHash = new BlockHash(fromSingle(foreignBlockHash));
+    const blockHash = blockHashFromSingle(foreignBlockHash);
     const nullifier = fromSingle(foreignNullifier);
 
     const witness = await this.handlerAsUtility().getLowNullifierMembershipWitness(blockHash, nullifier);
-
-    if (!witness) {
-      throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${blockHash}.`);
-    }
     return toForeignCallResult(witness.toNoirRepresentation());
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_fetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot: ForeignCallSingle) {
-    const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
-
-    await this.handlerAsUtility().fetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
-
-    return toForeignCallResult([]);
+  async aztec_utl_getPendingTaggedLogs(foreignScope: ForeignCallSingle) {
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
+    const slot = await this.handlerAsUtility().getPendingTaggedLogs(scope);
+    return toForeignCallResult([toSingle(slot)]);
   }
 
   // eslint-disable-next-line camelcase
   public async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(
-    foreignContractAddress: ForeignCallSingle,
     foreignNoteValidationRequestsArrayBaseSlot: ForeignCallSingle,
     foreignEventValidationRequestsArrayBaseSlot: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
   ) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
     const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
 
     await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(
-      contractAddress,
       noteValidationRequestsArrayBaseSlot,
       eventValidationRequestsArrayBaseSlot,
+      scope,
     );
 
     return toForeignCallResult([]);
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_utl_bulkRetrieveLogs(
-    foreignContractAddress: ForeignCallSingle,
-    foreignLogRetrievalRequestsArrayBaseSlot: ForeignCallSingle,
-    foreignLogRetrievalResponsesArrayBaseSlot: ForeignCallSingle,
-  ) {
-    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-    const logRetrievalRequestsArrayBaseSlot = fromSingle(foreignLogRetrievalRequestsArrayBaseSlot);
-    const logRetrievalResponsesArrayBaseSlot = fromSingle(foreignLogRetrievalResponsesArrayBaseSlot);
-
-    await this.handlerAsUtility().bulkRetrieveLogs(
-      contractAddress,
-      logRetrievalRequestsArrayBaseSlot,
-      logRetrievalResponsesArrayBaseSlot,
-    );
+  async aztec_utl_getLogsByTag(foreignRequestArrayBaseSlot: ForeignCallSingle) {
+    const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
+    const responseSlot = await this.handlerAsUtility().getLogsByTag(requestArrayBaseSlot);
+    return toForeignCallResult([toSingle(responseSlot)]);
+  }
 
-    return toForeignCallResult([]);
+  // eslint-disable-next-line camelcase
+  async aztec_utl_getMessageContextsByTxHash(foreignRequestArrayBaseSlot: ForeignCallSingle) {
+    const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
+    const responseSlot = await this.handlerAsUtility().getMessageContextsByTxHash(requestArrayBaseSlot);
+    return toForeignCallResult([toSingle(responseSlot)]);
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_storeCapsule(
+  aztec_utl_setCapsule(
     foreignContractAddress: ForeignCallSingle,
     foreignSlot: ForeignCallSingle,
     foreignCapsule: ForeignCallArray,
+    foreignScope: ForeignCallSingle,
   ) {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const slot = fromSingle(foreignSlot);
     const capsule = fromArray(foreignCapsule);
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
 
-    await this.handlerAsUtility().storeCapsule(contractAddress, slot, capsule);
+    this.handlerAsUtility().setCapsule(contractAddress, slot, capsule, scope);
 
     return toForeignCallResult([]);
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_loadCapsule(
+  async aztec_utl_getCapsule(
     foreignContractAddress: ForeignCallSingle,
     foreignSlot: ForeignCallSingle,
     foreignTSize: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
   ) {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const slot = fromSingle(foreignSlot);
     const tSize = fromSingle(foreignTSize).toNumber();
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
 
-    const values = await this.handlerAsUtility().loadCapsule(contractAddress, slot);
+    const opt = await this.handlerAsUtility().getCapsule(contractAddress, slot, tSize, scope);
 
     // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
     // with two fields: `some` (a boolean) and `value` (a field array in this case).
-    if (values === null) {
+    if (opt.isSome()) {
+      // Data was found so we set `some` to 1 and return it along with `value`.
+      return toForeignCallResult([toSingle(new Fr(1)), toArray(Array.from(opt.value))]);
+    } else {
       // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
       return toForeignCallResult([toSingle(new Fr(0)), toArray(Array(tSize).fill(new Fr(0)))]);
-    } else {
-      // Data was found so we set `some` to 1 and return it along with `value`.
-      return toForeignCallResult([toSingle(new Fr(1)), toArray(values)]);
     }
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_deleteCapsule(foreignContractAddress: ForeignCallSingle, foreignSlot: ForeignCallSingle) {
+  aztec_utl_deleteCapsule(
+    foreignContractAddress: ForeignCallSingle,
+    foreignSlot: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
+  ) {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const slot = fromSingle(foreignSlot);
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
 
-    await this.handlerAsUtility().deleteCapsule(contractAddress, slot);
+    this.handlerAsUtility().deleteCapsule(contractAddress, slot, scope);
 
     return toForeignCallResult([]);
   }
@@ -853,14 +920,74 @@ export class RPCTranslator {
     foreignSrcSlot: ForeignCallSingle,
     foreignDstSlot: ForeignCallSingle,
     foreignNumEntries: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
   ) {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const srcSlot = fromSingle(foreignSrcSlot);
     const dstSlot = fromSingle(foreignDstSlot);
     const numEntries = fromSingle(foreignNumEntries).toNumber();
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
+
+    await this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, scope);
+
+    return toForeignCallResult([]);
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_pushEphemeral(foreignSlot: ForeignCallSingle, foreignElements: ForeignCallArray) {
+    const slot = fromSingle(foreignSlot);
+    const elements = fromArray(foreignElements);
+    const newLen = this.handlerAsUtility().pushEphemeral(slot, elements);
+    return toForeignCallResult([toSingle(new Fr(newLen))]);
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_popEphemeral(foreignSlot: ForeignCallSingle) {
+    const slot = fromSingle(foreignSlot);
+    const element = this.handlerAsUtility().popEphemeral(slot);
+    return toForeignCallResult([toArray(element)]);
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_getEphemeral(foreignSlot: ForeignCallSingle, foreignIndex: ForeignCallSingle) {
+    const slot = fromSingle(foreignSlot);
+    const index = fromSingle(foreignIndex).toNumber();
+    const element = this.handlerAsUtility().getEphemeral(slot, index);
+    return toForeignCallResult([toArray(element)]);
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_setEphemeral(
+    foreignSlot: ForeignCallSingle,
+    foreignIndex: ForeignCallSingle,
+    foreignElements: ForeignCallArray,
+  ) {
+    const slot = fromSingle(foreignSlot);
+    const index = fromSingle(foreignIndex).toNumber();
+    const elements = fromArray(foreignElements);
+    this.handlerAsUtility().setEphemeral(slot, index, elements);
+    return toForeignCallResult([]);
+  }
 
-    await this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
+  // eslint-disable-next-line camelcase
+  aztec_utl_getEphemeralLen(foreignSlot: ForeignCallSingle) {
+    const slot = fromSingle(foreignSlot);
+    const len = this.handlerAsUtility().getEphemeralLen(slot);
+    return toForeignCallResult([toSingle(new Fr(len))]);
+  }
 
+  // eslint-disable-next-line camelcase
+  aztec_utl_removeEphemeral(foreignSlot: ForeignCallSingle, foreignIndex: ForeignCallSingle) {
+    const slot = fromSingle(foreignSlot);
+    const index = fromSingle(foreignIndex).toNumber();
+    this.handlerAsUtility().removeEphemeral(slot, index);
+    return toForeignCallResult([]);
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_clearEphemeral(foreignSlot: ForeignCallSingle) {
+    const slot = fromSingle(foreignSlot);
+    this.handlerAsUtility().clearEphemeral(slot);
     return toForeignCallResult([]);
   }
 
@@ -869,45 +996,71 @@ export class RPCTranslator {
   // to implement this function here. Isn't there a way to programmatically identify that this is missing, given the
   // existence of a txe_oracle method?
   // eslint-disable-next-line camelcase
-  async aztec_utl_aes128Decrypt(
+  async aztec_utl_decryptAes128(
     foreignCiphertextBVecStorage: ForeignCallArray,
     foreignCiphertextLength: ForeignCallSingle,
     foreignIv: ForeignCallArray,
     foreignSymKey: ForeignCallArray,
   ) {
-    const ciphertext = fromUintBoundedVec(foreignCiphertextBVecStorage, foreignCiphertextLength, 8);
+    const capacity = foreignCiphertextBVecStorage.length;
+    const ciphertextBuf = fromUintBoundedVec(foreignCiphertextBVecStorage, foreignCiphertextLength, 8);
+    const ciphertext = BoundedVec.from<number>({ data: [...ciphertextBuf], maxLength: capacity });
     const iv = fromUintArray(foreignIv, 8);
     const symKey = fromUintArray(foreignSymKey, 8);
 
-    const plaintextBuffer = await this.handlerAsUtility().aes128Decrypt(ciphertext, iv, symKey);
-
-    return toForeignCallResult(
-      arrayToBoundedVec(bufferToU8Array(plaintextBuffer), foreignCiphertextBVecStorage.length),
-    );
+    // Noir Option<BoundedVec> is encoded as [is_some: Field, storage: Field[], length: Field].
+    const plaintextOpt = await this.handlerAsUtility().decryptAes128(ciphertext, iv, symKey);
+    if (plaintextOpt.isSome()) {
+      const [storage, length] = arrayToBoundedVec(bufferToU8Array(Buffer.from(plaintextOpt.value.data)), capacity);
+      return toForeignCallResult([toSingle(new Fr(1)), storage, length]);
+    } else {
+      const zeroStorage = toArray(Array(capacity).fill(new Fr(0)));
+      return toForeignCallResult([toSingle(new Fr(0)), zeroStorage, toSingle(new Fr(0))]);
+    }
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_getSharedSecret(
+  async aztec_utl_getSharedSecrets(
     foreignAddress: ForeignCallSingle,
-    foreignEphPKField0: ForeignCallSingle,
-    foreignEphPKField1: ForeignCallSingle,
-    foreignEphPKField2: ForeignCallSingle,
+    foreignEphPksSlot: ForeignCallSingle,
+    foreignContractAddress: ForeignCallSingle,
   ) {
     const address = AztecAddress.fromField(fromSingle(foreignAddress));
-    const ephPK = Point.fromFields([
-      fromSingle(foreignEphPKField0),
-      fromSingle(foreignEphPKField1),
-      fromSingle(foreignEphPKField2),
-    ]);
+    const ephPksSlot = fromSingle(foreignEphPksSlot);
+    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+
+    const responseSlot = await this.handlerAsUtility().getSharedSecrets(address, ephPksSlot, contractAddress);
+
+    return toForeignCallResult([toSingle(responseSlot)]);
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_setContractSyncCacheInvalid(
+    foreignContractAddress: ForeignCallSingle,
+    foreignScopes: ForeignCallArray,
+    foreignScopeCount: ForeignCallSingle,
+  ) {
+    const contractAddress = addressFromSingle(foreignContractAddress);
+    const allFields = fromArray(foreignScopes);
+    const count = fromSingle(foreignScopeCount).toNumber();
+    const scopes = BoundedVec.from({
+      data: allFields.slice(0, count).map(f => new AztecAddress(f)),
+      maxLength: allFields.length,
+    });
 
-    const secret = await this.handlerAsUtility().getSharedSecret(address, ephPK);
+    this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes);
 
-    return toForeignCallResult(secret.toFields().map(toSingle));
+    return Promise.resolve(toForeignCallResult([]));
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_emitOffchainEffect(_foreignData: ForeignCallArray) {
-    throw new Error('Offchain effects are not yet supported in the TestEnvironment');
+  aztec_utl_emitOffchainEffect(foreignData: ForeignCallArray) {
+    // Record the raw payload against the currently-executing top-level call. The Noir side
+    // (via `env.offchain_messages()`) is responsible for decoding the protocol-reserved prefix
+    // (`OFFCHAIN_MESSAGE_IDENTIFIER`, recipient) and turning each payload into an `OffchainMessage` struct suitable
+    // for `offchain_receive`.
+    this.stateHandler.recordOffchainEffect(fromArray(foreignData));
+    return Promise.resolve(toForeignCallResult([]));
   }
 
   // AVM opcodes
@@ -977,6 +1130,19 @@ export class RPCTranslator {
     ]);
   }
 
+  // eslint-disable-next-line camelcase
+  async aztec_avm_getContractInstanceImmutablesHash(foreignAddress: ForeignCallSingle) {
+    const address = addressFromSingle(foreignAddress);
+
+    const instance = await this.handlerAsUtility().getContractInstance(address);
+
+    return toForeignCallResult([
+      toSingle(instance.immutablesHash),
+      // AVM requires an extra boolean indicating the instance was found
+      toSingle(new Fr(1)),
+    ]);
+  }
+
   // eslint-disable-next-line camelcase
   async aztec_avm_sender() {
     const sender = await this.handlerAsAvm().sender();
@@ -1054,147 +1220,209 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_returndataSize() {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+  async aztec_avm_returndataSize() {
+    const result = await this.handlerAsAvm().returndataSize();
+    return toForeignCallResult([toSingle(result)]);
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_returndataCopy(_foreignRdOffset: ForeignCallSingle, _foreignCopySize: ForeignCallSingle) {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+  async aztec_avm_returndataCopy(foreignRdOffset: ForeignCallSingle, foreignCopySize: ForeignCallSingle) {
+    const rdOffset = fromSingle(foreignRdOffset).toNumber();
+    const copySize = fromSingle(foreignCopySize).toNumber();
+    const result = await this.handlerAsAvm().returndataCopy(rdOffset, copySize);
+    return toForeignCallResult([toArray(result)]);
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_call(
-    _foreignL2Gas: ForeignCallSingle,
-    _foreignDaGas: ForeignCallSingle,
-    _foreignAddress: ForeignCallSingle,
-    _foreignLength: ForeignCallSingle,
-    _foreignArgs: ForeignCallArray,
+  async aztec_avm_call(
+    foreignL2Gas: ForeignCallSingle,
+    foreignDaGas: ForeignCallSingle,
+    foreignAddress: ForeignCallSingle,
+    foreignLength: ForeignCallSingle,
+    foreignArgs: ForeignCallArray,
   ) {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+    const l2Gas = fromSingle(foreignL2Gas).toNumber();
+    const daGas = fromSingle(foreignDaGas).toNumber();
+    const address = addressFromSingle(foreignAddress);
+    const argsLength = fromSingle(foreignLength).toNumber();
+    const args = fromArray(foreignArgs);
+    const result = await this.handlerAsAvm().call(l2Gas, daGas, address, argsLength, args);
+    return toForeignCallResult([toArray(result)]);
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_staticCall(
-    _foreignL2Gas: ForeignCallSingle,
-    _foreignDaGas: ForeignCallSingle,
-    _foreignAddress: ForeignCallSingle,
-    _foreignLength: ForeignCallSingle,
-    _foreignArgs: ForeignCallArray,
+  async aztec_avm_staticCall(
+    foreignL2Gas: ForeignCallSingle,
+    foreignDaGas: ForeignCallSingle,
+    foreignAddress: ForeignCallSingle,
+    foreignLength: ForeignCallSingle,
+    foreignArgs: ForeignCallArray,
   ) {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+    const l2Gas = fromSingle(foreignL2Gas).toNumber();
+    const daGas = fromSingle(foreignDaGas).toNumber();
+    const address = addressFromSingle(foreignAddress);
+    const argsLength = fromSingle(foreignLength).toNumber();
+    const args = fromArray(foreignArgs);
+    const result = await this.handlerAsAvm().staticCall(l2Gas, daGas, address, argsLength, args);
+    return toForeignCallResult([toArray(result)]);
   }
 
   // eslint-disable-next-line camelcase
-  aztec_avm_successCopy() {
-    throw new Error(
-      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
-    );
+  async aztec_avm_successCopy() {
+    const result = await this.handlerAsAvm().successCopy();
+    return toForeignCallResult([toSingle(result)]);
   }
 
+  // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize→delegate→deserialize.
   // eslint-disable-next-line camelcase
   async aztec_txe_privateCallNewFlow(
-    foreignFrom: ForeignCallSingle,
+    foreignFromIsSome: ForeignCallSingle,
+    foreignFromValue: ForeignCallSingle,
     foreignTargetContractAddress: ForeignCallSingle,
     foreignFunctionSelector: ForeignCallSingle,
     foreignArgs: ForeignCallArray,
     foreignArgsHash: ForeignCallSingle,
     foreignIsStaticCall: ForeignCallSingle,
+    foreignAdditionalScopes: ForeignCallArray,
+    foreignAuthorizedUtilityCallTargets: ForeignCallArray,
+    foreignGasSettings: ForeignCallArray,
   ) {
-    const from = addressFromSingle(foreignFrom);
+    const from = fromSingle(foreignFromIsSome).toBool() ? addressFromSingle(foreignFromValue) : undefined;
     const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
     const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
     const args = fromArray(foreignArgs);
     const argsHash = fromSingle(foreignArgsHash);
     const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-
-    const returnValues = await this.handlerAsTxe().privateCallNewFlow(
-      from,
-      targetContractAddress,
-      functionSelector,
-      args,
-      argsHash,
-      isStaticCall,
-      this.stateHandler.getCurrentJob(),
+    const additionalScopes = fromArray(foreignAdditionalScopes).map(field => AztecAddress.fromField(field));
+    const authorizedUtilityCallTargets = fromArray(foreignAuthorizedUtilityCallTargets).map(field =>
+      AztecAddress.fromField(field),
     );
+    const gasSettings = GasSettings.fromFields(fromArray(foreignGasSettings));
+
+    const returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
+      const { returnValues, offchainEffects } = await this.handlerAsTxe().privateCallNewFlow(
+        from,
+        targetContractAddress,
+        functionSelector,
+        args,
+        argsHash,
+        isStaticCall,
+        additionalScopes,
+        this.stateHandler.getCurrentJob(),
+        authorizedUtilityCallTargets,
+        gasSettings,
+      );
+
+      // Private execution collects offchain effects inside PXE's PrivateExecutionOracle rather than
+      // round-tripping them through `aztec_utl_emitOffchainEffect`, so the session buffer is empty
+      // at this point. Drain the effects from the execution tree into the session buffer so the
+      // next `env.offchain_messages()` call in the test sees them.
+      for (const data of offchainEffects) {
+        this.stateHandler.recordOffchainEffect(data);
+      }
+
+      // TODO(F-335): Avoid doing the following call here.
+      await this.stateHandler.cycleJob();
+
+      if (isStaticCall) {
+        // Static calls revert their checkpoint and mine no block, so there is no tx hash to tag
+        // offchain effects with. Querying `getLastTxEffects()` here would return an unrelated
+        // predecessor tx.
+        return { result: returnValues };
+      }
+      const { txHash } = await this.handlerAsTxe().getLastTxEffects();
+      return { result: returnValues, txHash: txHash.hash };
+    });
 
-    // TODO(F-335): Avoid doing the following call here.
-    await this.stateHandler.cycleJob();
     return toForeignCallResult([toArray(returnValues)]);
   }
 
+  // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize→delegate→deserialize.
   // eslint-disable-next-line camelcase
   async aztec_txe_executeUtilityFunction(
     foreignTargetContractAddress: ForeignCallSingle,
     foreignFunctionSelector: ForeignCallSingle,
     foreignArgs: ForeignCallArray,
+    foreignAuthorizedUtilityCallTargets: ForeignCallArray,
   ) {
     const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
     const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
     const args = fromArray(foreignArgs);
-
-    const returnValues = await this.handlerAsTxe().executeUtilityFunction(
-      targetContractAddress,
-      functionSelector,
-      args,
-      this.stateHandler.getCurrentJob(),
+    const authorizedUtilityCallTargets = fromArray(foreignAuthorizedUtilityCallTargets).map(field =>
+      AztecAddress.fromField(field),
     );
 
-    // TODO(F-335): Avoid doing the following call here.
-    await this.stateHandler.cycleJob();
+    const returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
+      const returnValues = await this.handlerAsTxe().executeUtilityFunction(
+        targetContractAddress,
+        functionSelector,
+        args,
+        this.stateHandler.getCurrentJob(),
+        authorizedUtilityCallTargets,
+      );
+
+      // TODO(F-335): Avoid doing the following call here.
+      await this.stateHandler.cycleJob();
+
+      return { result: returnValues };
+    });
+
     return toForeignCallResult([toArray(returnValues)]);
   }
 
+  // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize→delegate→deserialize.
   // eslint-disable-next-line camelcase
   async aztec_txe_publicCallNewFlow(
-    foreignFrom: ForeignCallSingle,
+    foreignFromIsSome: ForeignCallSingle,
+    foreignFromValue: ForeignCallSingle,
     foreignAddress: ForeignCallSingle,
     foreignCalldata: ForeignCallArray,
     foreignIsStaticCall: ForeignCallSingle,
+    foreignGasSettings: ForeignCallArray,
   ) {
-    const from = addressFromSingle(foreignFrom);
+    const from = fromSingle(foreignFromIsSome).toBool() ? addressFromSingle(foreignFromValue) : undefined;
     const address = addressFromSingle(foreignAddress);
     const calldata = fromArray(foreignCalldata);
     const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
+    const gasSettings = GasSettings.fromFields(fromArray(foreignGasSettings));
+
+    const returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
+      const returnValues = await this.handlerAsTxe().publicCallNewFlow(
+        from,
+        address,
+        calldata,
+        isStaticCall,
+        gasSettings,
+      );
+
+      // TODO(F-335): Avoid doing the following call here.
+      await this.stateHandler.cycleJob();
 
-    const returnValues = await this.handlerAsTxe().publicCallNewFlow(from, address, calldata, isStaticCall);
+      if (isStaticCall) {
+        // See equivalent branch in `aztec_txe_privateCallNewFlow`.
+        return { result: returnValues };
+      }
+      const { txHash } = await this.handlerAsTxe().getLastTxEffects();
+      return { result: returnValues, txHash: txHash.hash };
+    });
 
-    // TODO(F-335): Avoid doing the following call here.
-    await this.stateHandler.cycleJob();
     return toForeignCallResult([toArray(returnValues)]);
   }
 
   // eslint-disable-next-line camelcase
   async aztec_prv_getSenderForTags() {
-    const sender = await this.handlerAsPrivate().getSenderForTags();
+    const senderOpt = await this.handlerAsPrivate().getSenderForTags();
 
     // Return a Noir Option struct with `some` and `value` fields
-    if (sender === undefined) {
+    if (senderOpt.isSome()) {
+      // Sender found, return Option with some=1 and value=sender address
+      return toForeignCallResult([toSingle(1), toSingle(senderOpt.value)]);
+    } else {
       // No sender found, return Option with some=0 and value=0
       return toForeignCallResult([toSingle(0), toSingle(0)]);
-    } else {
-      // Sender found, return Option with some=1 and value=sender address
-      return toForeignCallResult([toSingle(1), toSingle(sender)]);
     }
   }
 
-  // eslint-disable-next-line camelcase
-  async aztec_prv_setSenderForTags(foreignSenderForTags: ForeignCallSingle) {
-    const senderForTags = AztecAddress.fromField(fromSingle(foreignSenderForTags));
-
-    await this.handlerAsPrivate().setSenderForTags(senderForTags);
-
-    return toForeignCallResult([]);
-  }
-
   // eslint-disable-next-line camelcase
   async aztec_prv_getNextAppTagAsSender(foreignSender: ForeignCallSingle, foreignRecipient: ForeignCallSingle) {
     const sender = AztecAddress.fromField(fromSingle(foreignSender));
@@ -1204,4 +1432,13 @@ export class RPCTranslator {
 
     return toForeignCallResult([toSingle(nextAppTag.value)]);
   }
+
+  // eslint-disable-next-line camelcase
+  async aztec_prv_getNextConstrainedTaggingIndex(foreignAppSiloedSecret: ForeignCallSingle) {
+    const appSiloedSecret = fromSingle(foreignAppSiloedSecret);
+
+    const index = await this.handlerAsPrivate().getNextConstrainedTaggingIndex(appSiloedSecret);
+
+    return toForeignCallResult([toSingle(new Fr(index))]);
+  }
 }