@aztec/txe 0.0.1-commit.5de5ca79e → 0.0.1-commit.6201a7b05

package/src/rpc_translator.ts

@@ -1,6 +1,6 @@
 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 { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import {
   type IMiscOracle,
@@ -10,7 +10,6 @@ import {
 } 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 type { IAvmExecutionOracle, ITxeExecutionOracle } from './oracle/interfaces.js';
 import type { TXESessionStateHandler } from './txe_session.js';
@@ -20,6 +19,7 @@ import {
   addressFromSingle,
   arrayOfArraysToBoundedVecOfArrays,
   arrayToBoundedVec,
+  blockHashFromSingle,
   bufferToU8Array,
   fromArray,
   fromSingle,
@@ -264,10 +264,11 @@ export class RPCTranslator {
   // PXE oracles
 
   // eslint-disable-next-line camelcase
-  aztec_utl_assertCompatibleOracleVersion(foreignVersion: ForeignCallSingle) {
-    const version = fromSingle(foreignVersion).toNumber();
+  aztec_utl_assertCompatibleOracleVersionV2(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([]);
   }
@@ -297,6 +298,46 @@ export class RPCTranslator {
     ]);
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_txe_getLastCallOffchainEffects() {
+    // This oracle returns all offchain effect payloads (messages, authwit requests, etc.) emitted by the last top-level call,
+    // MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY is arbitrarily set at 64 because we need a bound. Nothing inherent about it.
+    const MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY = 64;
+    // Must match MAX_OFFCHAIN_EFFECT_LEN in txe_oracles.nr.
+    const MAX_OFFCHAIN_EFFECT_LEN = 2 + PRIVATE_LOG_CIPHERTEXT_LEN;
+
+    const { effects } = this.stateHandler.getLastCallOffchainEffects();
+
+    if (effects.length > MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY) {
+      throw new Error(`${effects.length} offchain effects exceed max ${MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY}`);
+    }
+    if (effects.some(e => e.length > MAX_OFFCHAIN_EFFECT_LEN)) {
+      throw new Error(`Some offchain effect has length larger than max ${MAX_OFFCHAIN_EFFECT_LEN}`);
+    }
+
+    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 +380,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 +419,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,7 +442,7 @@ 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);
@@ -556,10 +597,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))]);
   }
@@ -582,10 +623,10 @@ export class RPCTranslator {
   }
 
   // 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).
@@ -628,7 +669,7 @@ 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);
@@ -652,7 +693,7 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  public aztec_prv_validatePublicCalldata(_foreignCalldataHash: ForeignCallSingle) {
+  public aztec_prv_assertValidPublicCalldata(_foreignCalldataHash: ForeignCallSingle) {
     throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
   }
 
@@ -662,9 +703,9 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_prv_inRevertiblePhase(foreignSideEffectCounter: ForeignCallSingle) {
+  public async aztec_prv_isExecutionInRevertiblePhase(foreignSideEffectCounter: ForeignCallSingle) {
     const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
-    const isRevertible = await this.handlerAsPrivate().inRevertiblePhase(sideEffectCounter);
+    const isRevertible = await this.handlerAsPrivate().isExecutionInRevertiblePhase(sideEffectCounter);
     return toForeignCallResult([toSingle(new Fr(isRevertible))]);
   }
 
@@ -692,7 +733,7 @@ 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);
@@ -708,8 +749,8 @@ 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);
 
@@ -726,7 +767,7 @@ 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);
@@ -738,14 +779,25 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_fetchTaggedLogs(foreignPendingTaggedLogArrayBaseSlot: ForeignCallSingle) {
+  async aztec_utl_getPendingTaggedLogs(
+    foreignPendingTaggedLogArrayBaseSlot: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
+  ) {
     const pendingTaggedLogArrayBaseSlot = fromSingle(foreignPendingTaggedLogArrayBaseSlot);
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
 
-    await this.handlerAsUtility().fetchTaggedLogs(pendingTaggedLogArrayBaseSlot);
+    await this.handlerAsUtility().getPendingTaggedLogs(pendingTaggedLogArrayBaseSlot, scope);
 
     return toForeignCallResult([]);
   }
 
+  // eslint-disable-next-line camelcase
+  async aztec_utl_getPendingTaggedLogs_v2(foreignScope: ForeignCallSingle) {
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
+    const slot = await this.handlerAsUtility().getPendingTaggedLogsV2(scope);
+    return toForeignCallResult([toSingle(slot)]);
+  }
+
   // eslint-disable-next-line camelcase
   public async aztec_utl_validateAndStoreEnqueuedNotesAndEvents(
     foreignContractAddress: ForeignCallSingle,
@@ -753,12 +805,14 @@ export class RPCTranslator {
     foreignEventValidationRequestsArrayBaseSlot: ForeignCallSingle,
     foreignMaxNotePackedLen: ForeignCallSingle,
     foreignMaxEventSerializedLen: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
   ) {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
     const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
     const maxNotePackedLen = fromSingle(foreignMaxNotePackedLen).toNumber();
     const maxEventSerializedLen = fromSingle(foreignMaxEventSerializedLen).toNumber();
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
 
     await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEvents(
       contractAddress,
@@ -766,75 +820,125 @@ export class RPCTranslator {
       eventValidationRequestsArrayBaseSlot,
       maxNotePackedLen,
       maxEventSerializedLen,
+      scope,
+    );
+
+    return toForeignCallResult([]);
+  }
+
+  // eslint-disable-next-line camelcase
+  public async aztec_utl_validateAndStoreEnqueuedNotesAndEvents_v2(
+    foreignNoteValidationRequestsArrayBaseSlot: ForeignCallSingle,
+    foreignEventValidationRequestsArrayBaseSlot: ForeignCallSingle,
+    foreignMaxNotePackedLen: ForeignCallSingle,
+    foreignMaxEventSerializedLen: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
+  ) {
+    const noteValidationRequestsArrayBaseSlot = fromSingle(foreignNoteValidationRequestsArrayBaseSlot);
+    const eventValidationRequestsArrayBaseSlot = fromSingle(foreignEventValidationRequestsArrayBaseSlot);
+    const maxNotePackedLen = fromSingle(foreignMaxNotePackedLen).toNumber();
+    const maxEventSerializedLen = fromSingle(foreignMaxEventSerializedLen).toNumber();
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
+
+    await this.handlerAsUtility().validateAndStoreEnqueuedNotesAndEventsV2(
+      noteValidationRequestsArrayBaseSlot,
+      eventValidationRequestsArrayBaseSlot,
+      maxNotePackedLen,
+      maxEventSerializedLen,
+      scope,
     );
 
     return toForeignCallResult([]);
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_utl_bulkRetrieveLogs(
+  public async aztec_utl_getLogsByTag(
     foreignContractAddress: ForeignCallSingle,
     foreignLogRetrievalRequestsArrayBaseSlot: ForeignCallSingle,
     foreignLogRetrievalResponsesArrayBaseSlot: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
   ) {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const logRetrievalRequestsArrayBaseSlot = fromSingle(foreignLogRetrievalRequestsArrayBaseSlot);
     const logRetrievalResponsesArrayBaseSlot = fromSingle(foreignLogRetrievalResponsesArrayBaseSlot);
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
 
-    await this.handlerAsUtility().bulkRetrieveLogs(
+    await this.handlerAsUtility().getLogsByTag(
       contractAddress,
       logRetrievalRequestsArrayBaseSlot,
       logRetrievalResponsesArrayBaseSlot,
+      scope,
     );
 
     return toForeignCallResult([]);
   }
 
   // eslint-disable-next-line camelcase
-  public async aztec_utl_utilityResolveMessageContexts(
+  public async aztec_utl_getMessageContextsByTxHash(
     foreignContractAddress: ForeignCallSingle,
     foreignMessageContextRequestsArrayBaseSlot: ForeignCallSingle,
     foreignMessageContextResponsesArrayBaseSlot: ForeignCallSingle,
+    foreignScope: ForeignCallSingle,
   ) {
     const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
     const messageContextRequestsArrayBaseSlot = fromSingle(foreignMessageContextRequestsArrayBaseSlot);
     const messageContextResponsesArrayBaseSlot = fromSingle(foreignMessageContextResponsesArrayBaseSlot);
+    const scope = AztecAddress.fromField(fromSingle(foreignScope));
 
-    await this.handlerAsUtility().utilityResolveMessageContexts(
+    await this.handlerAsUtility().getMessageContextsByTxHash(
       contractAddress,
       messageContextRequestsArrayBaseSlot,
       messageContextResponsesArrayBaseSlot,
+      scope,
     );
 
     return toForeignCallResult([]);
   }
 
   // eslint-disable-next-line camelcase
-  async aztec_utl_storeCapsule(
+  async aztec_utl_getLogsByTag_v2(foreignRequestArrayBaseSlot: ForeignCallSingle) {
+    const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
+    const responseSlot = await this.handlerAsUtility().getLogsByTagV2(requestArrayBaseSlot);
+    return toForeignCallResult([toSingle(responseSlot)]);
+  }
+
+  // eslint-disable-next-line camelcase
+  async aztec_utl_getMessageContextsByTxHash_v2(foreignRequestArrayBaseSlot: ForeignCallSingle) {
+    const requestArrayBaseSlot = fromSingle(foreignRequestArrayBaseSlot);
+    const responseSlot = await this.handlerAsUtility().getMessageContextsByTxHashV2(requestArrayBaseSlot);
+    return toForeignCallResult([toSingle(responseSlot)]);
+  }
+
+  // eslint-disable-next-line camelcase
+  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 values = await this.handlerAsUtility().getCapsule(contractAddress, slot, 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).
@@ -848,11 +952,16 @@ export class RPCTranslator {
   }
 
   // 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([]);
   }
@@ -863,14 +972,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([]);
   }
 
@@ -879,7 +1048,7 @@ 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_tryAes128Decrypt(
+  async aztec_utl_decryptAes128(
     foreignCiphertextBVecStorage: ForeignCallArray,
     foreignCiphertextLength: ForeignCallSingle,
     foreignIv: ForeignCallArray,
@@ -891,7 +1060,7 @@ export class RPCTranslator {
 
     // Noir Option<BoundedVec> is encoded as [is_some: Field, storage: Field[], length: Field].
     try {
-      const plaintextBuffer = await this.handlerAsUtility().aes128Decrypt(ciphertext, iv, symKey);
+      const plaintextBuffer = await this.handlerAsUtility().decryptAes128(ciphertext, iv, symKey);
       const [storage, length] = arrayToBoundedVec(
         bufferToU8Array(plaintextBuffer),
         foreignCiphertextBVecStorage.length,
@@ -909,6 +1078,7 @@ export class RPCTranslator {
     foreignEphPKField0: ForeignCallSingle,
     foreignEphPKField1: ForeignCallSingle,
     foreignEphPKField2: ForeignCallSingle,
+    foreignContractAddress: ForeignCallSingle,
   ) {
     const address = AztecAddress.fromField(fromSingle(foreignAddress));
     const ephPK = Point.fromFields([
@@ -916,14 +1086,15 @@ export class RPCTranslator {
       fromSingle(foreignEphPKField1),
       fromSingle(foreignEphPKField2),
     ]);
+    const contractAddress = AztecAddress.fromField(fromSingle(foreignContractAddress));
 
-    const secret = await this.handlerAsUtility().getSharedSecret(address, ephPK);
+    const secret = await this.handlerAsUtility().getSharedSecret(address, ephPK, contractAddress);
 
-    return toForeignCallResult(secret.toFields().map(toSingle));
+    return toForeignCallResult([toSingle(secret)]);
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_invalidateContractSyncCache(
+  aztec_utl_setContractSyncCacheInvalid(
     foreignContractAddress: ForeignCallSingle,
     foreignScopes: ForeignCallArray,
     foreignScopeCount: ForeignCallSingle,
@@ -934,14 +1105,19 @@ export class RPCTranslator {
       .slice(0, count)
       .map(f => new AztecAddress(f));
 
-    this.handlerAsUtility().invalidateContractSyncCache(contractAddress, scopes);
+    this.handlerAsUtility().setContractSyncCacheInvalid(contractAddress, scopes);
 
     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
@@ -1150,18 +1326,38 @@ export class RPCTranslator {
     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 returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
+      const { returnValues, offchainEffects } = await this.handlerAsTxe().privateCallNewFlow(
+        from,
+        targetContractAddress,
+        functionSelector,
+        args,
+        argsHash,
+        isStaticCall,
+        this.stateHandler.getCurrentJob(),
+      );
+
+      // 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)]);
   }
 
@@ -1175,15 +1371,20 @@ export class RPCTranslator {
     const functionSelector = FunctionSelector.fromField(fromSingle(foreignFunctionSelector));
     const args = fromArray(foreignArgs);
 
-    const returnValues = await this.handlerAsTxe().executeUtilityFunction(
-      targetContractAddress,
-      functionSelector,
-      args,
-      this.stateHandler.getCurrentJob(),
-    );
+    const returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
+      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();
+
+      return { result: returnValues };
+    });
 
-    // TODO(F-335): Avoid doing the following call here.
-    await this.stateHandler.cycleJob();
     return toForeignCallResult([toArray(returnValues)]);
   }
 
@@ -1199,10 +1400,20 @@ export class RPCTranslator {
     const calldata = fromArray(foreignCalldata);
     const isStaticCall = fromSingle(foreignIsStaticCall).toBool();
 
-    const returnValues = await this.handlerAsTxe().publicCallNewFlow(from, address, calldata, isStaticCall);
+    const returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
+      const returnValues = await this.handlerAsTxe().publicCallNewFlow(from, address, calldata, isStaticCall);
+
+      // 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 };
+    });
 
-    // TODO(F-335): Avoid doing the following call here.
-    await this.stateHandler.cycleJob();
     return toForeignCallResult([toArray(returnValues)]);
   }
 

package/src/state_machine/archiver.ts

@@ -76,6 +76,7 @@ export class TXEArchiver extends ArchiverDataSourceBase {
       proven: tipId,
       finalized: tipId,
       checkpointed: tipId,
+      proposedCheckpoint: tipId,
     };
   }