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

package/dest/rpc_translator.js

@@ -1,11 +1,13 @@
-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 { packAsHintedNote } from '@aztec/pxe/simulator';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import { BoundedVec, Option, packAsHintedNote } from '@aztec/pxe/simulator';
 import { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { BlockHash } from '@aztec/stdlib/block';
-import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle } from './util/encoding.js';
+import { GasSettings } from '@aztec/stdlib/gas';
+import { MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY, MAX_OFFCHAIN_EFFECT_LEN } from './constants.js';
+import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, blockHashFromSingle, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle } 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;
 export class UnavailableOracleError extends Error {
@@ -60,6 +62,13 @@ export class RPCTranslator {
         }
         return this.oracleHandler;
     }
+    // eslint-disable-next-line camelcase
+    aztec_txe_assertCompatibleOracleVersion(foreignMajor, foreignMinor) {
+        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
     async aztec_txe_setTopLevelTXEContext() {
@@ -67,10 +76,11 @@ export class RPCTranslator {
         return toForeignCallResult([]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_txe_setPrivateTXEContext(foreignContractAddressIsSome, foreignContractAddressValue, foreignAnchorBlockNumberIsSome, foreignAnchorBlockNumberValue) {
+    async aztec_txe_setPrivateTXEContext(foreignContractAddressIsSome, foreignContractAddressValue, foreignAnchorBlockNumberIsSome, foreignAnchorBlockNumberValue, foreignGasSettings) {
         const contractAddress = fromSingle(foreignContractAddressIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignContractAddressValue)) : undefined;
         const anchorBlockNumber = fromSingle(foreignAnchorBlockNumberIsSome).toBool() ? 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));
     }
     // eslint-disable-next-line camelcase
@@ -130,6 +140,7 @@ export class RPCTranslator {
                 instance.deployer.toField(),
                 instance.currentContractClassId,
                 instance.initializationHash,
+                instance.immutablesHash,
                 ...instance.publicKeys.toFields()
             ])
         ]);
@@ -161,9 +172,10 @@ export class RPCTranslator {
     }
     // PXE oracles
     // eslint-disable-next-line camelcase
-    aztec_utl_assertCompatibleOracleVersion(foreignVersion) {
-        const version = fromSingle(foreignVersion).toNumber();
-        this.handlerAsMisc().assertCompatibleOracleVersion(version);
+    aztec_utl_assertCompatibleOracleVersion(foreignMajor, foreignMinor) {
+        const major = fromSingle(foreignMajor).toNumber();
+        const minor = fromSingle(foreignMinor).toNumber();
+        this.handlerAsMisc().assertCompatibleOracleVersion(major, minor);
         return toForeignCallResult([]);
     }
     // eslint-disable-next-line camelcase
@@ -182,11 +194,44 @@ 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)
+            ...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
@@ -219,16 +264,16 @@ export class RPCTranslator {
         ]);
     }
     // eslint-disable-next-line camelcase
-    aztec_prv_storeInExecutionCache(foreignValues, foreignHash) {
+    aztec_prv_setHashPreimage(foreignValues, foreignHash) {
         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) {
+    async aztec_prv_getHashPreimage(foreignHash) {
         const hash = fromSingle(foreignHash);
-        const returns = await this.handlerAsPrivate().loadFromExecutionCache(hash);
+        const returns = await this.handlerAsPrivate().getHashPreimage(hash);
         return toForeignCallResult([
             toArray(returns)
         ]);
@@ -244,30 +289,27 @@ export class RPCTranslator {
         return toForeignCallResult([]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_storageRead(foreignBlockHash, foreignContractAddress, foreignStartStorageSlot, foreignNumberOfElements) {
-        const blockHash = new BlockHash(fromSingle(foreignBlockHash));
+    async aztec_utl_getFromPublicStorage(foreignBlockHash, foreignContractAddress, foreignStartStorageSlot, foreignNumberOfElements) {
+        const blockHash = blockHashFromSingle(foreignBlockHash);
         const contractAddress = addressFromSingle(foreignContractAddress);
         const startStorageSlot = fromSingle(foreignStartStorageSlot);
         const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
-        const values = await this.handlerAsUtility().storageRead(blockHash, contractAddress, startStorageSlot, numberOfElements);
+        const values = await this.handlerAsUtility().getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements);
         return toForeignCallResult([
             toArray(values)
         ]);
     }
     // eslint-disable-next-line camelcase
     async aztec_utl_getPublicDataWitness(foreignBlockHash, foreignLeafSlot) {
-        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());
     }
     // eslint-disable-next-line camelcase
     async aztec_utl_getNotes(foreignOwnerIsSome, foreignOwnerValue, foreignStorageSlot, foreignNumSelects, foreignSelectByIndexes, foreignSelectByOffsets, foreignSelectByLengths, foreignSelectValues, foreignSelectComparators, foreignSortByIndexes, foreignSortByOffsets, foreignSortByLengths, foreignSortOrder, foreignLimit, foreignOffset, foreignStatus, foreignMaxNotes, foreignPackedHintedNoteLength) {
         // Parse Option<AztecAddress>: ownerIsSome is 0 for None, 1 for Some
-        const owner = fromSingle(foreignOwnerIsSome).toBool() ? AztecAddress.fromField(fromSingle(foreignOwnerValue)) : undefined;
+        const owner = fromSingle(foreignOwnerIsSome).toBool() ? 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());
@@ -284,8 +326,8 @@ export class RPCTranslator {
         const status = fromSingle(foreignStatus).toNumber();
         const maxNotes = fromSingle(foreignMaxNotes).toNumber();
         const packedHintedNoteLength = fromSingle(foreignPackedHintedNoteLength).toNumber();
-        const noteDatas = await this.handlerAsUtility().getNotes(owner, storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status);
-        const returnDataAsArrayOfArrays = noteDatas.map((noteData)=>packAsHintedNote({
+        const noteVec = await this.handlerAsUtility().getNotes(owner, storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status, maxNotes, packedHintedNoteLength);
+        const returnDataAsArrayOfArrays = Array.from(noteVec.data).map((noteData)=>packAsHintedNote({
                 contractAddress: noteData.contractAddress,
                 owner: noteData.owner,
                 randomness: noteData.randomness,
@@ -294,9 +336,7 @@ export class RPCTranslator {
                 isPending: noteData.isPending,
                 note: noteData.note
             }));
-        // 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));
     }
     // eslint-disable-next-line camelcase
@@ -335,9 +375,9 @@ export class RPCTranslator {
         ]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_checkNullifierExists(foreignInnerNullifier) {
+    async aztec_utl_doesNullifierExist(foreignInnerNullifier) {
         const innerNullifier = fromSingle(foreignInnerNullifier);
-        const exists = await this.handlerAsUtility().checkNullifierExists(innerNullifier);
+        const exists = await this.handlerAsUtility().doesNullifierExist(innerNullifier);
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
@@ -351,28 +391,40 @@ 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) {
+    async aztec_utl_getPublicKeysAndPartialAddress(foreignAddress) {
         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.
+            // 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(13).fill(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
+                    publicKeys.npkMHash,
+                    publicKeys.ivpkM.x,
+                    publicKeys.ivpkM.y,
+                    publicKeys.ovpkMHash,
+                    publicKeys.tpkMHash,
+                    publicKeys.mspkMHash,
+                    publicKeys.fbpkMHash,
+                    partialAddress
                 ])
             ]);
         }
@@ -384,46 +436,51 @@ export class RPCTranslator {
         return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
     }
     // eslint-disable-next-line camelcase
-    aztec_prv_callPrivateFunction(_foreignTargetContractAddress, _foreignFunctionSelector, _foreignArgsHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
-        throw new Error('Contract calls are forbidden inside a `TestEnvironment::private_context`, use `private_call` instead');
+    async aztec_prv_callPrivateFunction(foreignTargetContractAddress, foreignFunctionSelector, foreignArgsHash, foreignSideEffectCounter, foreignIsStaticCall) {
+        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
     async aztec_utl_getNullifierMembershipWitness(foreignBlockHash, foreignNullifier) {
-        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());
     }
     // eslint-disable-next-line camelcase
     async aztec_utl_getAuthWitness(foreignMessageHash) {
         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
-    aztec_prv_notifyEnqueuedPublicFunctionCall(_foreignTargetContractAddress, _foreignCalldataHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
-        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
-    }
-    // eslint-disable-next-line camelcase
-    aztec_prv_notifySetPublicTeardownFunctionCall(_foreignTargetContractAddress, _foreignCalldataHash, _foreignSideEffectCounter, _foreignIsStaticCall) {
-        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
+    async aztec_prv_assertValidPublicCalldata(foreignCalldataHash) {
+        const calldataHash = fromSingle(foreignCalldataHash);
+        await this.handlerAsPrivate().assertValidPublicCalldata(calldataHash);
+        return toForeignCallResult([]);
     }
     // eslint-disable-next-line camelcase
-    aztec_prv_notifySetMinRevertibleSideEffectCounter(_foreignMinRevertibleSideEffectCounter) {
-        throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
+    async aztec_prv_notifyRevertiblePhaseStart(foreignMinRevertibleSideEffectCounter) {
+        const minRevertibleSideEffectCounter = fromSingle(foreignMinRevertibleSideEffectCounter).toNumber();
+        await this.handlerAsPrivate().notifyRevertiblePhaseStart(minRevertibleSideEffectCounter);
+        return toForeignCallResult([]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_isSideEffectCounterRevertible(foreignSideEffectCounter) {
+    async aztec_prv_isExecutionInRevertiblePhase(foreignSideEffectCounter) {
         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))
         ]);
@@ -437,107 +494,168 @@ export class RPCTranslator {
     async aztec_utl_getBlockHeader(foreignBlockNumber) {
         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));
     }
     // eslint-disable-next-line camelcase
     async aztec_utl_getNoteHashMembershipWitness(foreignAnchorBlockHash, foreignNoteHash) {
-        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());
     }
     // eslint-disable-next-line camelcase
     async aztec_utl_getBlockHashMembershipWitness(foreignAnchorBlockHash, foreignBlockHash) {
-        const anchorBlockHash = new BlockHash(fromSingle(foreignAnchorBlockHash));
-        const blockHash = new BlockHash(fromSingle(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 anchorBlockHash = blockHashFromSingle(foreignAnchorBlockHash);
+        const blockHash = blockHashFromSingle(foreignBlockHash);
+        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
     async aztec_utl_getLowNullifierMembershipWitness(foreignBlockHash, foreignNullifier) {
-        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) {
-        const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
-        await this.handlerAsUtility().fetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
-        return toForeignCallResult([]);
+    async aztec_utl_getPendingTaggedLogs(foreignScope) {
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        const slot = await this.handlerAsUtility().getPendingTaggedLogs(scope);
+        return toForeignCallResult([
+            toSingle(slot)
+        ]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(foreignContractAddress, foreignNoteValidationRequestsArrayBaseSlot, foreignEventValidationRequestsArrayBaseSlot) {
-        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
+    async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(foreignNoteValidationRequestsArrayBaseSlot, foreignEventValidationRequestsArrayBaseSlot, foreignScope) {
         const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
         const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
-        await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot, scope);
         return toForeignCallResult([]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_bulkRetrieveLogs(foreignContractAddress, foreignLogRetrievalRequestsArrayBaseSlot, foreignLogRetrievalResponsesArrayBaseSlot) {
-        const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
-        const logRetrievalRequestsArrayBaseSlot = fromSingle(foreignLogRetrievalRequestsArrayBaseSlot);
-        const logRetrievalResponsesArrayBaseSlot = fromSingle(foreignLogRetrievalResponsesArrayBaseSlot);
-        await this.handlerAsUtility().bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot);
-        return toForeignCallResult([]);
+    async aztec_utl_getLogsByTag(foreignRequestArrayBaseSlot) {
+        const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
+        const responseSlot = await this.handlerAsUtility().getLogsByTag(requestArrayBaseSlot);
+        return toForeignCallResult([
+            toSingle(responseSlot)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    async aztec_utl_getMessageContextsByTxHash(foreignRequestArrayBaseSlot) {
+        const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
+        const responseSlot = await this.handlerAsUtility().getMessageContextsByTxHash(requestArrayBaseSlot);
+        return toForeignCallResult([
+            toSingle(responseSlot)
+        ]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_storeCapsule(foreignContractAddress, foreignSlot, foreignCapsule) {
+    aztec_utl_setCapsule(foreignContractAddress, foreignSlot, foreignCapsule, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const slot = fromSingle(foreignSlot);
         const capsule = fromArray(foreignCapsule);
-        await this.handlerAsUtility().storeCapsule(contractAddress, slot, capsule);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        this.handlerAsUtility().setCapsule(contractAddress, slot, capsule, scope);
         return toForeignCallResult([]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_loadCapsule(foreignContractAddress, foreignSlot, foreignTSize) {
+    async aztec_utl_getCapsule(foreignContractAddress, foreignSlot, foreignTSize, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const slot = fromSingle(foreignSlot);
         const tSize = fromSingle(foreignTSize).toNumber();
-        const values = await this.handlerAsUtility().loadCapsule(contractAddress, slot);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        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) {
-            // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
+        if (opt.isSome()) {
+            // Data was found so we set `some` to 1 and return it along with `value`.
             return toForeignCallResult([
-                toSingle(new Fr(0)),
-                toArray(Array(tSize).fill(new Fr(0)))
+                toSingle(new Fr(1)),
+                toArray(Array.from(opt.value))
             ]);
         } else {
-            // Data was found so we set `some` to 1 and return it along with `value`.
+            // 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(1)),
-                toArray(values)
+                toSingle(new Fr(0)),
+                toArray(Array(tSize).fill(new Fr(0)))
             ]);
         }
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_deleteCapsule(foreignContractAddress, foreignSlot) {
+    aztec_utl_deleteCapsule(foreignContractAddress, foreignSlot, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const slot = fromSingle(foreignSlot);
-        await this.handlerAsUtility().deleteCapsule(contractAddress, slot);
+        const scope = AztecAddress.fromField(fromSingle(foreignScope));
+        this.handlerAsUtility().deleteCapsule(contractAddress, slot, scope);
         return toForeignCallResult([]);
     }
     // eslint-disable-next-line camelcase
-    async aztec_utl_copyCapsule(foreignContractAddress, foreignSrcSlot, foreignDstSlot, foreignNumEntries) {
+    async aztec_utl_copyCapsule(foreignContractAddress, foreignSrcSlot, foreignDstSlot, foreignNumEntries, foreignScope) {
         const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
         const srcSlot = fromSingle(foreignSrcSlot);
         const dstSlot = fromSingle(foreignDstSlot);
         const numEntries = fromSingle(foreignNumEntries).toNumber();
-        await this.handlerAsUtility().copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
+        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, foreignElements) {
+        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) {
+        const slot = fromSingle(foreignSlot);
+        const element = this.handlerAsUtility().popEphemeral(slot);
+        return toForeignCallResult([
+            toArray(element)
+        ]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getEphemeral(foreignSlot, foreignIndex) {
+        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, foreignIndex, foreignElements) {
+        const slot = fromSingle(foreignSlot);
+        const index = fromSingle(foreignIndex).toNumber();
+        const elements = fromArray(foreignElements);
+        this.handlerAsUtility().setEphemeral(slot, index, elements);
+        return toForeignCallResult([]);
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_getEphemeralLen(foreignSlot) {
+        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, foreignIndex) {
+        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) {
+        const slot = fromSingle(foreignSlot);
+        this.handlerAsUtility().clearEphemeral(slot);
         return toForeignCallResult([]);
     }
     // TODO: I forgot to add a corresponding function here, when I introduced an oracle method to txe_oracle.ts.
@@ -545,27 +663,65 @@ 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(foreignCiphertextBVecStorage, foreignCiphertextLength, foreignIv, foreignSymKey) {
-        const ciphertext = fromUintBoundedVec(foreignCiphertextBVecStorage, foreignCiphertextLength, 8);
+    async aztec_utl_decryptAes128(foreignCiphertextBVecStorage, foreignCiphertextLength, foreignIv, foreignSymKey) {
+        const capacity = foreignCiphertextBVecStorage.length;
+        const ciphertextBuf = fromUintBoundedVec(foreignCiphertextBVecStorage, foreignCiphertextLength, 8);
+        const ciphertext = BoundedVec.from({
+            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(foreignAddress, foreignEphPKField0, foreignEphPKField1, foreignEphPKField2) {
+    async aztec_utl_getSharedSecrets(foreignAddress, foreignEphPksSlot, foreignContractAddress) {
         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)
         ]);
-        const secret = await this.handlerAsUtility().getSharedSecret(address, ephPK);
-        return toForeignCallResult(secret.toFields().map(toSingle));
     }
     // eslint-disable-next-line camelcase
-    aztec_utl_emitOffchainEffect(_foreignData) {
-        throw new Error('Offchain effects are not yet supported in the TestEnvironment');
+    aztec_utl_setContractSyncCacheInvalid(foreignContractAddress, foreignScopes, foreignScopeCount) {
+        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
+        });
+        this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes);
+        return Promise.resolve(toForeignCallResult([]));
+    }
+    // eslint-disable-next-line camelcase
+    aztec_utl_emitOffchainEffect(foreignData) {
+        // 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
     // eslint-disable-next-line camelcase
@@ -620,6 +776,16 @@ export class RPCTranslator {
         ]);
     }
     // eslint-disable-next-line camelcase
+    async aztec_avm_getContractInstanceImmutablesHash(foreignAddress) {
+        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();
         return toForeignCallResult([
@@ -689,90 +855,159 @@ 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, _foreignCopySize) {
-        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
+    async aztec_avm_returndataCopy(foreignRdOffset, foreignCopySize) {
+        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, _foreignDaGas, _foreignAddress, _foreignLength, _foreignArgs) {
-        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
+    async aztec_avm_call(foreignL2Gas, foreignDaGas, foreignAddress, foreignLength, foreignArgs) {
+        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, _foreignDaGas, _foreignAddress, _foreignLength, _foreignArgs) {
-        throw new Error('Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead');
+    async aztec_avm_staticCall(foreignL2Gas, foreignDaGas, foreignAddress, foreignLength, foreignArgs) {
+        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, foreignTargetContractAddress, foreignFunctionSelector, foreignArgs, foreignArgsHash, foreignIsStaticCall) {
-        const from = addressFromSingle(foreignFrom);
+    async aztec_txe_privateCallNewFlow(foreignFromIsSome, foreignFromValue, foreignTargetContractAddress, foreignFunctionSelector, foreignArgs, foreignArgsHash, foreignIsStaticCall, foreignAdditionalScopes, foreignAuthorizedUtilityCallTargets, foreignGasSettings) {
+        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());
-        // TODO(F-335): Avoid doing the following call here.
-        await this.stateHandler.cycleJob();
+        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
+            };
+        });
         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, foreignFunctionSelector, foreignArgs) {
+    async aztec_txe_executeUtilityFunction(foreignTargetContractAddress, foreignFunctionSelector, foreignArgs, foreignAuthorizedUtilityCallTargets) {
         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());
-        // TODO(F-335): Avoid doing the following call here.
-        await this.stateHandler.cycleJob();
+        const authorizedUtilityCallTargets = fromArray(foreignAuthorizedUtilityCallTargets).map((field)=>AztecAddress.fromField(field));
+        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, foreignAddress, foreignCalldata, foreignIsStaticCall) {
-        const from = addressFromSingle(foreignFrom);
+    async aztec_txe_publicCallNewFlow(foreignFromIsSome, foreignFromValue, foreignAddress, foreignCalldata, foreignIsStaticCall, foreignGasSettings) {
+        const from = fromSingle(foreignFromIsSome).toBool() ? addressFromSingle(foreignFromValue) : undefined;
         const address = addressFromSingle(foreignAddress);
         const calldata = fromArray(foreignCalldata);
         const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
-        const returnValues = await this.handlerAsTxe().publicCallNewFlow(from, address, calldata, isStaticCall);
-        // TODO(F-335): Avoid doing the following call here.
-        await this.stateHandler.cycleJob();
+        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();
+            if (isStaticCall) {
+                // See equivalent branch in `aztec_txe_privateCallNewFlow`.
+                return {
+                    result: returnValues
+                };
+            }
+            const { txHash } = await this.handlerAsTxe().getLastTxEffects();
+            return {
+                result: returnValues,
+                txHash: txHash.hash
+            };
+        });
         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) {
-            // No sender found, return Option with some=0 and value=0
+        if (senderOpt.isSome()) {
+            // Sender found, return Option with some=1 and value=sender address
             return toForeignCallResult([
-                toSingle(0),
-                toSingle(0)
+                toSingle(1),
+                toSingle(senderOpt.value)
             ]);
         } else {
-            // Sender found, return Option with some=1 and value=sender address
+            // No sender found, return Option with some=0 and value=0
             return toForeignCallResult([
-                toSingle(1),
-                toSingle(sender)
+                toSingle(0),
+                toSingle(0)
             ]);
         }
     }
     // eslint-disable-next-line camelcase
-    async aztec_prv_setSenderForTags(foreignSenderForTags) {
-        const senderForTags = AztecAddress.fromField(fromSingle(foreignSenderForTags));
-        await this.handlerAsPrivate().setSenderForTags(senderForTags);
-        return toForeignCallResult([]);
-    }
-    // eslint-disable-next-line camelcase
     async aztec_prv_getNextAppTagAsSender(foreignSender, foreignRecipient) {
         const sender = AztecAddress.fromField(fromSingle(foreignSender));
         const recipient = AztecAddress.fromField(fromSingle(foreignRecipient));
@@ -781,4 +1016,12 @@ export class RPCTranslator {
             toSingle(nextAppTag.value)
         ]);
     }
+    // eslint-disable-next-line camelcase
+    async aztec_prv_getNextConstrainedTaggingIndex(foreignAppSiloedSecret) {
+        const appSiloedSecret = fromSingle(foreignAppSiloedSecret);
+        const index = await this.handlerAsPrivate().getNextConstrainedTaggingIndex(appSiloedSecret);
+        return toForeignCallResult([
+            toSingle(new Fr(index))
+        ]);
+    }
 }