@aztec/pxe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/contract_function_simulator/oracle/utility_execution_oracle.js

@@ -1,31 +1,32 @@
-import { ARCHIVE_HEIGHT } from '@aztec/constants';
+import { PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { uniqueBy } from '@aztec/foundation/collection';
 import { Aes128 } from '@aztec/foundation/crypto/aes128';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import { LogLevels, createLogger } from '@aztec/foundation/log';
-import { MembershipWitness } from '@aztec/foundation/trees';
 import { ExecutionError, extractCallStack, resolveAssertionMessageFromError, toACVMWitness, witnessMapToFields } from '@aztec/simulator/client';
+import { STANDARD_HANDSHAKE_REGISTRY_ADDRESS } from '@aztec/standard-contracts/handshake-registry/constants';
+import { FunctionSelector } from '@aztec/stdlib/abi';
 import { siloNullifier } from '@aztec/stdlib/hash';
-import { PublicKey, PublicKeys, computeAddressSecret, hashPublicKey } from '@aztec/stdlib/keys';
-import { MessageContext, deriveAppSiloedSharedSecret } from '@aztec/stdlib/logs';
-import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
+import { computeAddressSecret, hashPublicKey } from '@aztec/stdlib/keys';
+import { AppTaggingSecret, FlatPublicLogs, appSiloEcdhSharedSecret } from '@aztec/stdlib/logs';
+import { getL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { TxEffect } from '@aztec/stdlib/tx';
+import { CallContext } from '@aztec/stdlib/tx';
 import { createContractLogger, logContractMessage, stripAztecnrLogPrefix } from '../../contract_logging.js';
 import { EventService } from '../../events/event_service.js';
 import { LogService } from '../../logs/log_service.js';
 import { NoteService } from '../../notes/note_service.js';
 import { ORACLE_VERSION_MAJOR } from '../../oracle_version.js';
+import { assertAllowedScope } from '../../storage/allowed_scopes.js';
+import { FactCollectionKey, FactCollectionTypeKey, anchoredTipBlockNumbers } from '../../storage/fact_store/index.js';
 import { EphemeralArrayService } from '../ephemeral_array_service.js';
 import { BoundedVec } from '../noir-structs/bounded_vec.js';
-import { EventValidationRequest } from '../noir-structs/event_validation_request.js';
-import { LogRetrievalRequest } from '../noir-structs/log_retrieval_request.js';
-import { NoteValidationRequest } from '../noir-structs/note_validation_request.js';
+import { EphemeralArray } from '../noir-structs/ephemeral_array.js';
+import { emptyFactCollection, toNoirFactCollection } from '../noir-structs/fact_collection.js';
 import { Option } from '../noir-structs/option.js';
-import { UtilityContext } from '../noir-structs/utility_context.js';
 import { pickNotes } from '../pick_notes.js';
-import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
-import { Oracle } from './oracle.js';
+import { buildACIRCallback } from './acir_callback.js';
 /**
  * The oracle for an execution of utility contract functions.
  */ export class UtilityExecutionOracle {
@@ -35,22 +36,31 @@ import { Oracle } from './oracle.js';
     aztecnrLogger;
     offchainEffects = [];
     ephemeralArrayService = new EphemeralArrayService();
+    transientArrayService;
+    /** Keyed by tx hash string. */ txReceiptsCache = new Map();
+    /**
+   * Information that can be used to validate the existence of a note or an event, keyed by tx hash string. It is
+   * populated by the node queries that precede validation (tagged log retrieval, tx resolution), which already return
+   * everything validation needs, so validating a note or event created in one of those txs costs no node roundtrip.
+   * Notes and events reached through other paths (e.g. offchain inbox messages) still need a receipt.
+   */ validationTxDataCache = new Map();
     // We store oracle version to be able to show a nice error message when an oracle handler is missing.
     contractOracleVersion;
-    contractAddress;
+    callContext;
     authWitnesses;
     capsules;
     anchorBlockHeader;
-    contractStore;
+    anchoredContractData;
     noteStore;
     keyStore;
     addressStore;
     aztecNode;
     recipientTaggingStore;
-    senderAddressBookStore;
+    taggingSecretSourcesStore;
     capsuleService;
+    factService;
     privateEventStore;
-    messageContextService;
+    txResolver;
     contractSyncService;
     l2TipsStore;
     jobId;
@@ -60,20 +70,21 @@ import { Oracle } from './oracle.js';
     hooks;
     utilityExecutor;
     constructor(args){
-        this.contractAddress = args.contractAddress;
+        this.callContext = args.callContext;
         this.authWitnesses = args.authWitnesses;
         this.capsules = args.capsules;
         this.anchorBlockHeader = args.anchorBlockHeader;
-        this.contractStore = args.contractStore;
+        this.anchoredContractData = args.anchoredContractData;
         this.noteStore = args.noteStore;
         this.keyStore = args.keyStore;
         this.addressStore = args.addressStore;
         this.aztecNode = args.aztecNode;
         this.recipientTaggingStore = args.recipientTaggingStore;
-        this.senderAddressBookStore = args.senderAddressBookStore;
+        this.taggingSecretSourcesStore = args.taggingSecretSourcesStore;
         this.capsuleService = args.capsuleService;
+        this.factService = args.factService;
         this.privateEventStore = args.privateEventStore;
-        this.messageContextService = args.messageContextService;
+        this.txResolver = args.txResolver;
         this.contractSyncService = args.contractSyncService;
         this.l2TipsStore = args.l2TipsStore;
         this.jobId = args.jobId;
@@ -82,6 +93,7 @@ import { Oracle } from './oracle.js';
         this.simulator = args.simulator;
         this.hooks = args.hooks;
         this.utilityExecutor = args.utilityExecutor;
+        this.transientArrayService = args.transientArrayService;
     }
     assertCompatibleOracleVersion(major, minor) {
         if (major !== ORACLE_VERSION_MAJOR) {
@@ -101,15 +113,20 @@ import { Oracle } from './oracle.js';
         return Fr.random();
     }
     getUtilityContext() {
-        return new UtilityContext(this.anchorBlockHeader, this.contractAddress);
+        return {
+            blockHeader: this.anchorBlockHeader,
+            contractAddress: this.callContext.contractAddress,
+            msgSender: this.callContext.msgSender
+        };
     }
     /**
    * Retrieve keys associated with a specific master public key and app address.
    * @param pkMHash - The master public key hash.
+   * @param _keyIndex - Sent by the Noir oracle caller but unused here; kept to match the oracle signature.
    * @returns A Promise that resolves to nullifier keys.
    * @throws If the keys are not registered in the key store.
    * @throws If scopes are defined and the account is not in the scopes.
-   */ async getKeyValidationRequest(pkMHash) {
+   */ async getKeyValidationRequest(pkMHash, _keyIndex) {
         let hasAccess = false;
         for(let i = 0; i < this.scopes.length && !hasAccess; i++){
             if (await this.keyStore.accountHasKey(this.scopes[i], pkMHash)) {
@@ -149,7 +166,12 @@ import { Oracle } from './oracle.js';
         // hash at all. If the block hash did not exist by the reference block hash, then the node will not return the
         // membership witness as there is none.
         const witness = await this.#queryWithBlockHashNotAfterAnchor(referenceBlockHash, ()=>this.aztecNode.getBlockHashMembershipWitness(referenceBlockHash, blockHash));
-        return witness ? Option.some(witness) : Option.none(MembershipWitness.empty(ARCHIVE_HEIGHT));
+        return witness ? Option.some(witness) : Option.none();
+    }
+    /** Returns whether each block hash is present in the archive tree at the referenced block. */ async areBlockHashesInArchive(referenceBlockHash, blockHashes) {
+        const hashes = blockHashes.readAll(this.ephemeralArrayService);
+        const memberships = await this.#queryWithBlockHashNotAfterAnchor(referenceBlockHash, ()=>Promise.all(hashes.map((blockHash)=>this.aztecNode.getBlockHashMembershipWitness(referenceBlockHash, blockHash).then(Boolean))));
+        return EphemeralArray.fromValues(this.ephemeralArrayService, memberships);
     }
     /**
    * Returns a nullifier membership witness for a given nullifier at a given block.
@@ -216,10 +238,7 @@ import { Oracle } from './oracle.js';
    */ async getPublicKeysAndPartialAddress(account) {
         const completeAddress = await this.addressStore.getCompleteAddress(account);
         if (!completeAddress) {
-            return Option.none({
-                publicKeys: PublicKeys.default(),
-                partialAddress: Fr.ZERO
-            });
+            return Option.none();
         }
         return Option.some({
             publicKeys: completeAddress.publicKeys,
@@ -230,7 +249,7 @@ import { Oracle } from './oracle.js';
         const completeAddress = await this.addressStore.getCompleteAddress(account);
         if (!completeAddress) {
             throw new Error(`No public key registered for address ${account}.
-        Register it by calling pxe.addAccount(...).\nSee docs for context: https://docs.aztec.network/developers/resources/debugging/aztecnr-errors#simulation-error-no-public-key-registered-for-address-0x0-register-it-by-calling-pxeregisterrecipient-or-pxeregisteraccount`);
+        Register it by calling wallet.registerSender(...).\nSee docs for context: https://docs.aztec.network/errors/14`);
         }
         return completeAddress;
     }
@@ -239,7 +258,7 @@ import { Oracle } from './oracle.js';
    * @param address - Address.
    * @returns A contract instance.
    */ async getContractInstance(address) {
-        const instance = await this.contractStore.getContractInstance(address);
+        const instance = await this.anchoredContractData.getContractInstance(address);
         if (!instance) {
             throw new Error(`No contract instance found for address ${address.toString()}`);
         }
@@ -322,15 +341,17 @@ import { Oracle } from './oracle.js';
         return leafIndex?.data !== undefined;
     }
     /**
-   * Returns the membership witness of an un-nullified L1 to L2 message.
-   * @param contractAddress - Address of a contract by which the message was emitted.
+   * Returns the membership witness of an L1 to L2 message.
    * @param messageHash - Hash of the message.
-   * @param secret - Secret used to compute a nullifier.
-   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @param nullifier - When present, the unsiloed nullifier of the message and the address to silo it with. The witness
+   * is only returned if the siloed nullifier is absent from the nullifier tree, i.e. the message has not been consumed.
    * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-   */ async getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
-        const [messageIndex, siblingPath] = await getNonNullifiedL1ToL2MessageWitness(this.aztecNode, contractAddress, messageHash, secret, await this.anchorBlockHeader.hash());
-        return new MessageLoadOracleInputs(messageIndex, siblingPath);
+   */ async getL1ToL2MembershipWitnessV2(messageHash, nullifier) {
+        const [messageIndex, siblingPath] = await getL1ToL2MessageWitness(this.aztecNode, messageHash, nullifier.value, await this.anchorBlockHeader.hash());
+        return {
+            index: messageIndex,
+            siblingPath
+        };
     }
     /**
    * Read the public storage data.
@@ -340,9 +361,9 @@ import { Oracle } from './oracle.js';
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */ getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements) {
         return this.#queryWithBlockHashNotAfterAnchor(blockHash, async ()=>{
-            const slots = Array(numberOfElements).fill(0).map((_, i)=>new Fr(startStorageSlot.value + BigInt(i)));
+            const slots = Array(numberOfElements).fill(0).map((_, i)=>new Fr(startStorageSlot.toBigInt() + BigInt(i)));
             const values = await Promise.all(slots.map((storageSlot)=>this.aztecNode.getPublicStorageAt(blockHash, contractAddress, storageSlot)));
-            this.logger.debug(`Oracle storage read: slots=[${slots.map((slot)=>slot.toString()).join(', ')}] address=${contractAddress.toString()} values=[${values.join(', ')}]`);
+            this.logger.debug(`Oracle storage read: start=${startStorageSlot.toString()} count=${numberOfElements} ` + `address=${contractAddress.toString()} values=[${values.join(', ')}]`);
             return values;
         });
     }
@@ -352,7 +373,7 @@ import { Oracle } from './oracle.js';
         if (!this.contractLogger) {
             // Purpose of instanceId is to distinguish logs from different instances of the same component. It makes sense
             // to re-use jobId as instanceId here as executions of different PXE jobs are isolated.
-            this.contractLogger = await createContractLogger(this.contractAddress, (addr)=>this.contractStore.getDebugContractName(addr), 'user', {
+            this.contractLogger = await createContractLogger(this.contractAddress, (addr)=>this.anchoredContractData.getDebugContractName(addr), 'user', {
                 instanceId: this.jobId
             });
         }
@@ -364,13 +385,13 @@ import { Oracle } from './oracle.js';
         if (!this.aztecnrLogger) {
             // Purpose of instanceId is to distinguish logs from different instances of the same component. It makes sense
             // to re-use jobId as instanceId here as executions of different PXE jobs are isolated.
-            this.aztecnrLogger = await createContractLogger(this.contractAddress, (addr)=>this.contractStore.getDebugContractName(addr), 'aztecnr', {
+            this.aztecnrLogger = await createContractLogger(this.contractAddress, (addr)=>this.anchoredContractData.getDebugContractName(addr), 'aztecnr', {
                 instanceId: this.jobId
             });
         }
         return this.aztecnrLogger;
     }
-    async log(level, message, fields) {
+    async log(level, message, _fieldsSize, fields) {
         if (!LogLevels[level]) {
             throw new Error(`Invalid log level: ${level}`);
         }
@@ -378,51 +399,46 @@ import { Oracle } from './oracle.js';
         const logger = kind == 'aztecnr' ? await this.#getAztecnrLogger() : await this.#getContractLogger();
         logContractMessage(logger, LogLevels[level], strippedMessage, fields);
     }
-    /** Fetches pending tagged logs into a freshly allocated ephemeral array and returns its base slot. */ async getPendingTaggedLogs(scope) {
+    /** Fetches pending tagged logs into a freshly allocated ephemeral array and returns it. */ async getPendingTaggedLogsV2(scope, providedSecrets) {
+        const secrets = providedSecrets.readAll(this.ephemeralArrayService).map((ps)=>new AppTaggingSecret(ps.secret, this.contractAddress, ps.mode));
         const logService = this.#createLogService();
-        const logs = await logService.fetchTaggedLogs(this.contractAddress, scope);
-        return this.ephemeralArrayService.newArray(logs.map((log)=>log.toFields()));
+        const retrievedLogs = await logService.fetchTaggedLogs(this.contractAddress, scope, secrets);
+        this.#cacheValidationTxData(retrievedLogs);
+        return EphemeralArray.fromValues(this.ephemeralArrayService, retrievedLogs.map(toPendingTaggedLog));
     }
     #createLogService() {
-        return new LogService(this.aztecNode, this.anchorBlockHeader, this.l2TipsStore, this.keyStore, this.recipientTaggingStore, this.senderAddressBookStore, this.addressStore, this.jobId, this.logger.getBindings());
+        return new LogService(this.aztecNode, this.anchorBlockHeader, this.l2TipsStore, this.keyStore, this.recipientTaggingStore, this.taggingSecretSourcesStore, this.addressStore, this.scopes, this.jobId, this.logger.getBindings());
     }
-    async validateAndStoreEnqueuedNotesAndEvents(noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot, scope) {
-        const noteValidationRequests = this.ephemeralArrayService.readArrayAt(noteValidationRequestsArrayBaseSlot).map((fields)=>NoteValidationRequest.fromFields(fields));
-        const eventValidationRequests = this.ephemeralArrayService.readArrayAt(eventValidationRequestsArrayBaseSlot).map((fields)=>EventValidationRequest.fromFields(fields));
-        await this.#processValidationRequests(noteValidationRequests, eventValidationRequests, scope);
+    async validateAndStoreEnqueuedNotesAndEvents(noteValidationRequests, eventValidationRequests, scope) {
+        await this.#processValidationRequests(noteValidationRequests.readAll(this.ephemeralArrayService), eventValidationRequests.readAll(this.ephemeralArrayService), scope);
     }
     async #processValidationRequests(noteValidationRequests, eventValidationRequests, scope) {
-        const txEffects = await this.#fetchTxEffects([
+        const validationTxData = await this.#getValidationTxData([
             ...noteValidationRequests.map((r)=>r.txHash),
             ...eventValidationRequests.map((r)=>r.txHash)
         ]);
         const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockHeader, this.jobId);
         const eventService = new EventService(this.anchorBlockHeader, this.aztecNode, this.privateEventStore, this.jobId);
         await Promise.all([
-            noteService.validateAndStoreNotes(noteValidationRequests, scope, txEffects),
-            eventService.validateAndStoreEvents(eventValidationRequests, scope, txEffects)
+            noteService.validateAndStoreNotes(noteValidationRequests, scope, validationTxData),
+            eventService.validateAndStoreEvents(eventValidationRequests, scope, validationTxData)
         ]);
     }
-    async getLogsByTag(requestArrayBaseSlot) {
-        const logRetrievalRequests = this.ephemeralArrayService.readArrayAt(requestArrayBaseSlot).map(LogRetrievalRequest.fromFields);
+    async getLogsByTagV2(requests) {
+        const logRetrievalRequests = requests.readAll(this.ephemeralArrayService);
         const logService = this.#createLogService();
-        const logRetrievalResponses = await logService.fetchLogsByTag(this.contractAddress, logRetrievalRequests);
+        const retrievedLogsPerRequest = await logService.fetchLogsByTag(this.contractAddress, logRetrievalRequests);
+        this.#cacheValidationTxData(retrievedLogsPerRequest.flat());
         // Create an inner ephemeral array for each request's matching logs, then wrap all slots in an outer array.
-        const innerSlots = logRetrievalResponses.map((responses)=>this.ephemeralArrayService.newArray(responses.map((r)=>r.toFields())));
-        return this.ephemeralArrayService.newArray(innerSlots.map((slot)=>[
-                slot
-            ]));
+        const innerArrays = retrievedLogsPerRequest.map((retrievedLogs)=>EphemeralArray.fromValues(this.ephemeralArrayService, retrievedLogs.map(toLogRetrievalResponse)));
+        return EphemeralArray.fromValues(this.ephemeralArrayService, innerArrays);
     }
-    /** Reads tx hash requests from an ephemeral array, resolves their contexts, and returns the response slot. */ async getMessageContextsByTxHash(requestArrayBaseSlot) {
-        const requestFields = this.ephemeralArrayService.readArrayAt(requestArrayBaseSlot);
-        const txHashes = requestFields.map((fields, i)=>{
-            if (fields.length !== 1) {
-                throw new Error(`Malformed message context request at index ${i}: expected 1 field (tx hash), got ${fields.length}`);
-            }
-            return fields[0];
-        });
-        const maybeMessageContexts = await this.messageContextService.getMessageContextsByTxHash(txHashes, this.anchorBlockHeader.getBlockNumber());
-        return this.ephemeralArrayService.newArray(maybeMessageContexts.map(MessageContext.toSerializedOption));
+    /** Given an array of tx hashes, returns an aligned array of tx info if the tx is available. */ async getResolvedTxs(requests) {
+        const txHashes = requests.readAll(this.ephemeralArrayService);
+        const resolved = await this.txResolver.resolveTxs(txHashes, this.anchorBlockHeader.getBlockNumber());
+        this.#cacheValidationTxData(resolved.filter((tx)=>tx !== null));
+        const options = resolved.map((tx)=>tx ? Option.some(toResolvedTx(tx)) : Option.none());
+        return EphemeralArray.fromValues(this.ephemeralArrayService, options);
     }
     /**
    * Fetches the effects of a transaction by its hash. Returns null if the tx is not found or is beyond the anchor
@@ -431,40 +447,74 @@ import { Oracle } from './oracle.js';
         if (txHash.hash.isZero()) {
             throw new Error('Invalid tx hash passed into aztec_utl_getTxEffect oracle handler');
         }
-        const txEffect = await this.aztecNode.getTxEffect(txHash);
-        if (!txEffect || txEffect.l2BlockNumber > this.anchorBlockHeader.getBlockNumber()) {
-            return Option.none(TxEffect.empty());
+        return await this.#getTxEffectOption(txHash);
+    }
+    /** Fetches transaction effects for all hashes, preserving request order. */ async getTxEffects(txHashes) {
+        const hashes = txHashes.readAll(this.ephemeralArrayService);
+        const invalidHash = hashes.find((txHash)=>txHash.hash.isZero());
+        if (invalidHash) {
+            throw new Error('Invalid tx hash passed into aztec_utl_getTxEffects oracle handler');
         }
-        return Option.some(txEffect.data);
+        const uniqueTxHashes = uniqueBy(hashes, (h)=>h.toString());
+        const options = await Promise.all(uniqueTxHashes.map((txHash)=>this.#getTxEffectOption(txHash)));
+        const optionsByHash = new Map(uniqueTxHashes.map((txHash, i)=>[
+                txHash.toString(),
+                options[i]
+            ]));
+        return EphemeralArray.fromValues(this.ephemeralArrayService, hashes.map((txHash)=>optionsByHash.get(txHash.toString())));
     }
     setCapsule(contractAddress, slot, capsule, scope) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
+        this.#assertOwnContract(contractAddress);
         this.capsuleService.setCapsule(contractAddress, slot, capsule, this.jobId, scope);
     }
     async getCapsule(contractAddress, slot, tSize, scope) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
+        this.#assertOwnContract(contractAddress);
         const values = await this.capsuleService.getCapsule(contractAddress, slot, this.jobId, scope, this.capsules);
-        return values ? Option.some(values) : Option.none(new Array(tSize).fill(Fr.ZERO));
+        return values ? Option.some(values) : Option.none({
+            length: tSize
+        });
     }
     deleteCapsule(contractAddress, slot, scope) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
+        this.#assertOwnContract(contractAddress);
         this.capsuleService.deleteCapsule(contractAddress, slot, this.jobId, scope);
     }
     copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, scope) {
+        this.#assertOwnContract(contractAddress);
+        return this.capsuleService.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, this.jobId, scope);
+    }
+    /**
+   * Asserts the executing contract may only access its own slice of PXE DB.
+   */ #assertOwnContract(contractAddress) {
         if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
             throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
         }
-        return this.capsuleService.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, this.jobId, scope);
+    }
+    /**
+   * Records a fact into a collection. A `Some` origin block makes the fact retractable (pruned on reorg of that
+   * block), a `None` origin block makes it non-retractable, surviving reorgs.
+   */ recordFact(contractAddress, scope, factCollectionTypeId, factCollectionId, factTypeId, payload, originBlock) {
+        this.#assertOwnContract(contractAddress);
+        return this.factService.recordFact(new FactCollectionKey(contractAddress, scope, factCollectionTypeId, factCollectionId), factTypeId, payload.readAll(this.ephemeralArrayService), originBlock.isSome() ? originBlock.value : undefined, this.jobId);
+    }
+    /**
+   * Deletes a fact collection, removing all its facts. A no-op if no such collection exists.
+   */ deleteFactCollection(contractAddress, scope, factCollectionTypeId, factCollectionId) {
+        this.#assertOwnContract(contractAddress);
+        return this.factService.deleteFactCollection(new FactCollectionKey(contractAddress, scope, factCollectionTypeId, factCollectionId), this.jobId);
+    }
+    /**
+   * Returns a fact collection.
+   */ async getFactCollection(contractAddress, scope, factCollectionTypeId, factCollectionId) {
+        this.#assertOwnContract(contractAddress);
+        const tips = anchoredTipBlockNumbers(await this.l2TipsStore.getL2Tips(), this.anchorBlockHeader.getBlockNumber());
+        const collection = await this.factService.getFactCollection(new FactCollectionKey(contractAddress, scope, factCollectionTypeId, factCollectionId), tips, this.jobId);
+        return collection ? Option.some(toNoirFactCollection(this.ephemeralArrayService, contractAddress, scope, factCollectionTypeId, factCollectionId, collection.facts)) : Option.none(emptyFactCollection(this.ephemeralArrayService));
+    }
+    /** Returns every fact collection of `factCollectionTypeId`. */ async getFactCollectionsByType(contractAddress, scope, factCollectionTypeId) {
+        this.#assertOwnContract(contractAddress);
+        const tips = anchoredTipBlockNumbers(await this.l2TipsStore.getL2Tips(), this.anchorBlockHeader.getBlockNumber());
+        const collections = await this.factService.getFactCollectionsByType(new FactCollectionTypeKey(contractAddress, scope, factCollectionTypeId), tips, this.jobId);
+        return EphemeralArray.fromValues(this.ephemeralArrayService, collections.map((collection)=>toNoirFactCollection(this.ephemeralArrayService, collection.key.contractAddress, collection.key.scope, collection.key.factCollectionTypeId, collection.key.factCollectionId, collection.facts)));
     }
     /**
    * Clears cached sync state for a contract for a set of scopes, forcing re-sync on the next query so that newly
@@ -480,7 +530,7 @@ import { Oracle } from './oracle.js';
         const capacity = ciphertext.maxLength;
         try {
             const aes128 = new Aes128();
-            const plaintext = await aes128.decryptBufferCBC(Buffer.from(ciphertext.data), iv, symKey);
+            const plaintext = await aes128.decryptBufferCBC(Buffer.from(ciphertext.data), Buffer.from(iv), Buffer.from(symKey));
             return Option.some(BoundedVec.from({
                 data: [
                     ...plaintext
@@ -488,30 +538,40 @@ import { Oracle } from './oracle.js';
                 maxLength: capacity
             }));
         } catch  {
-            return Option.none(BoundedVec.empty({
+            return Option.none({
                 maxLength: capacity
-            }));
+            });
         }
     }
     /**
    * Retrieves app-siloed shared secrets for multiple ephemeral public keys stored in an ephemeral array.
    * @param address - The recipient address.
-   * @param ephPksSlot - Ephemeral array slot containing the serialized Points.
+   * @param ephPks - Ephemeral array containing the serialized Points.
    * @param contractAddress - The contract address for app-siloing (validated against execution context).
-   * @returns The slot of a new ephemeral array containing the computed shared secrets.
-   */ async getSharedSecrets(address, ephPksSlot, contractAddress) {
+   * @returns A new ephemeral array containing the computed shared secrets, or an empty array when the PXE does not
+   * hold the keys for `address`.
+   * @throws If `address` is not in the execution's allowed scopes.
+   */ async getSharedSecrets(address, ephPks, contractAddress) {
         if (!contractAddress.equals(this.contractAddress)) {
             throw new Error(`getSharedSecrets called with contract address ${contractAddress}, expected ${this.contractAddress}`);
         }
-        const recipientCompleteAddress = await this.getCompleteAddressOrFail(address);
+        assertAllowedScope(address, this.scopes);
+        // An address can be in scope without the PXE holding its keys (e.g. syncing a registered but non-owned account),
+        // in which case no secrets can be derived and we return an empty array rather than failing.
+        const recipientCompleteAddress = await this.addressStore.getCompleteAddress(address);
+        if (!recipientCompleteAddress) {
+            this.logger.warn(`Computing shared secrets for address ${address} whose keys are not held - returning no secrets`, {
+                address,
+                contractAddress: this.contractAddress
+            });
+            return EphemeralArray.fromValues(this.ephemeralArrayService, []);
+        }
         const ivpkMHash = await hashPublicKey(recipientCompleteAddress.publicKeys.ivpkM);
         const ivskM = await this.keyStore.getMasterSecretKey(ivpkMHash);
         const addressSecret = await computeAddressSecret(await recipientCompleteAddress.getPreaddress(), ivskM);
-        const ephPkFields = this.ephemeralArrayService.readArrayAt(ephPksSlot);
-        const secrets = await Promise.all(ephPkFields.map((fields)=>deriveAppSiloedSharedSecret(addressSecret, PublicKey.fromFields(fields), this.contractAddress)));
-        return this.ephemeralArrayService.newArray(secrets.map((s)=>[
-                s
-            ]));
+        const ephPkPoints = ephPks.readAll(this.ephemeralArrayService);
+        const secrets = await Promise.all(ephPkPoints.map(({ x, y })=>appSiloEcdhSharedSecret(addressSecret, new Point(x, y), this.contractAddress)));
+        return EphemeralArray.fromValues(this.ephemeralArrayService, secrets);
     }
     pushEphemeral(slot, elements) {
         return this.ephemeralArrayService.push(slot, elements);
@@ -534,6 +594,27 @@ import { Oracle } from './oracle.js';
     clearEphemeral(slot) {
         this.ephemeralArrayService.clear(slot);
     }
+    pushTransient(slot, elements) {
+        return this.transientArrayService.push(this.contractAddress, slot, elements);
+    }
+    popTransient(slot) {
+        return this.transientArrayService.pop(this.contractAddress, slot);
+    }
+    getTransient(slot, index) {
+        return this.transientArrayService.get(this.contractAddress, slot, index);
+    }
+    setTransient(slot, index, elements) {
+        this.transientArrayService.set(this.contractAddress, slot, index, elements);
+    }
+    getTransientLen(slot) {
+        return this.transientArrayService.len(this.contractAddress, slot);
+    }
+    removeTransient(slot, index) {
+        this.transientArrayService.remove(this.contractAddress, slot, index);
+    }
+    clearTransient(slot) {
+        this.transientArrayService.clear(this.contractAddress, slot);
+    }
     emitOffchainEffect(data) {
         this.offchainEffects.push({
             data,
@@ -542,48 +623,63 @@ import { Oracle } from './oracle.js';
         return Promise.resolve();
     }
     /** Executes another utility function from within this one and returns its serialized return values. */ async callUtilityFunction(targetContractAddress, functionSelector, args) {
-        const targetArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(targetContractAddress, functionSelector);
+        const targetArtifact = await this.anchoredContractData.getFunctionArtifactWithDebugMetadata(targetContractAddress, functionSelector);
+        if (!targetArtifact) {
+            throw new Error(`Cannot call ${targetContractAddress}:${functionSelector}: the contract is not registered. ` + `Register it via wallet.registerContract(...).`);
+        }
         if (!targetContractAddress.equals(this.contractAddress)) {
-            const [callerInstance, targetInstance] = await Promise.all([
-                this.getContractInstance(this.contractAddress),
-                this.getContractInstance(targetContractAddress)
-            ]);
-            const request = {
-                caller: this.contractAddress,
-                callerClassId: callerInstance.currentContractClassId,
-                target: targetContractAddress,
-                targetClassId: targetInstance.currentContractClassId,
-                functionSelector,
-                functionName: targetArtifact.name,
-                args,
-                callerContext: this.callerContext
-            };
-            const response = this.hooks ? await this.hooks.authorizeUtilityCall(request) : {
-                authorized: false,
-                reason: 'No execution hooks configured'
-            };
-            if (!response.authorized) {
-                const reason = response.reason ? `: ${response.reason}` : '';
-                throw new Error(`Cross-contract utility call denied${reason}. ${this.contractAddress} attempted to call ` + `${targetContractAddress}:${functionSelector} (${targetArtifact.name}). ` + `See https://docs.aztec.network/errors/11`);
+            // Standard handshake registry reads are authorized by default; every other cross-contract call needs the hook.
+            if (!await isStandardHandshakeRegistryUtilityRead(targetContractAddress, functionSelector)) {
+                const [callerClassId, targetClassId] = await Promise.all([
+                    this.anchoredContractData.getCurrentClassId(this.contractAddress),
+                    this.anchoredContractData.getCurrentClassId(targetContractAddress)
+                ]);
+                if (!callerClassId || !targetClassId) {
+                    throw new Error(`Cannot authorize utility call from ${this.contractAddress} to ${targetContractAddress}: ` + `${!callerClassId ? this.contractAddress : targetContractAddress} is not registered.`);
+                }
+                const request = {
+                    caller: this.contractAddress,
+                    callerClassId,
+                    target: targetContractAddress,
+                    targetClassId,
+                    functionSelector,
+                    functionName: targetArtifact.name,
+                    args,
+                    callerContext: this.callerContext
+                };
+                const response = this.hooks?.authorizeUtilityCall ? await this.hooks.authorizeUtilityCall(request) : {
+                    authorized: false,
+                    reason: 'No authorizeUtilityCall hook configured'
+                };
+                if (!response.authorized) {
+                    const reason = response.reason ? `: ${response.reason}` : '';
+                    throw new Error(`Cross-contract utility call denied${reason}. ${this.contractAddress} attempted to call ` + `${targetContractAddress}:${functionSelector} (${targetArtifact.name}). ` + `See https://docs.aztec.network/errors/11`);
+                }
             }
             await this.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, this.utilityExecutor, this.anchorBlockHeader, this.jobId, this.scopes);
         }
         this.logger.debug(`Calling nested utility function ${targetContractAddress}:${functionSelector} from ${this.contractAddress}`);
         const nestedOracle = new UtilityExecutionOracle({
-            contractAddress: targetContractAddress,
+            callContext: CallContext.from({
+                msgSender: this.contractAddress,
+                contractAddress: targetContractAddress,
+                functionSelector,
+                isStaticCall: true
+            }),
             authWitnesses: this.authWitnesses,
             capsules: this.capsules,
             anchorBlockHeader: this.anchorBlockHeader,
-            contractStore: this.contractStore,
+            anchoredContractData: this.anchoredContractData,
             noteStore: this.noteStore,
             keyStore: this.keyStore,
             addressStore: this.addressStore,
             aztecNode: this.aztecNode,
             recipientTaggingStore: this.recipientTaggingStore,
-            senderAddressBookStore: this.senderAddressBookStore,
+            taggingSecretSourcesStore: this.taggingSecretSourcesStore,
             capsuleService: this.capsuleService,
+            factService: this.factService,
             privateEventStore: this.privateEventStore,
-            messageContextService: this.messageContextService,
+            txResolver: this.txResolver,
             contractSyncService: this.contractSyncService,
             l2TipsStore: this.l2TipsStore,
             jobId: this.jobId,
@@ -591,11 +687,12 @@ import { Oracle } from './oracle.js';
             simulator: this.simulator,
             hooks: this.hooks,
             utilityExecutor: this.utilityExecutor,
-            log: this.logger
+            log: this.logger,
+            // Shared across the whole execution tree: nested utility frames inherit the caller's transient-array store.
+            transientArrayService: this.transientArrayService
         });
         const initialWitness = toACVMWitness(0, args);
-        const acvmCallback = new Oracle(nestedOracle);
-        const acirExecutionResult = await this.simulator.executeUserCircuit(initialWitness, targetArtifact, acvmCallback.toACIRCallback()).catch((err)=>{
+        const acirExecutionResult = await this.simulator.executeUserCircuit(initialWitness, targetArtifact, buildACIRCallback(nestedOracle)).catch((err)=>{
             err.message = resolveAssertionMessageFromError(err, targetArtifact);
             throw new ExecutionError(err.message, {
                 contractAddress: targetContractAddress,
@@ -609,16 +706,91 @@ import { Oracle } from './oracle.js';
     /** Returns offchain effects collected during execution. */ getOffchainEffects() {
         return this.offchainEffects;
     }
+    /** Stores the onchain context of the given txs, so that validating the notes and events they created is free. */ #cacheValidationTxData(txs) {
+        txs.forEach((tx)=>this.validationTxDataCache.set(tx.txHash.toString(), toValidationTxData(tx)));
+    }
     /**
-   * Fetches tx effects for the given hashes in parallel, deduplicating repeated hashes so each tx is only requested
-   * once. Returns a map keyed by `TxHash.toString()`; hashes for which the node has no tx effect are omitted.
-   */ async #fetchTxEffects(txHashes) {
-        const uniqueTxHashes = uniqueBy(txHashes, (h)=>h.toString());
-        const fetched = await Promise.all(uniqueTxHashes.map((h)=>this.aztecNode.getTxEffect(h)));
-        return new Map(uniqueTxHashes.map((h, i)=>[
-                h.toString(),
-                fetched[i]
-            ]).filter((entry)=>entry[1] !== undefined));
+   * Returns the information needed to validate the notes and events created in the given txs, keyed by
+   * `TxHash.toString()`. Txs already in {@link validationTxDataCache} cost no node request, and the rest are read from
+   * the node. Txs with no tx effect are absent from the returned map.
+   */ async #getValidationTxData(txHashes) {
+        const known = [];
+        const misses = [];
+        for (const txHash of uniqueBy(txHashes, (h)=>h.toString())){
+            const key = txHash.toString();
+            const cached = this.validationTxDataCache.get(key);
+            if (cached) {
+                known.push([
+                    key,
+                    cached
+                ]);
+            } else {
+                misses.push(txHash);
+            }
+        }
+        const fetched = await Promise.all(misses.map((h)=>this.#getTxReceiptWithEffect(h)));
+        return new Map([
+            ...known,
+            ...misses.map((h, i)=>{
+                const receipt = fetched[i];
+                if (!receipt.isMined() || !receipt.txEffect) {
+                    return [
+                        h.toString(),
+                        undefined
+                    ];
+                }
+                return [
+                    h.toString(),
+                    {
+                        noteHashes: receipt.txEffect.noteHashes,
+                        nullifiers: receipt.txEffect.nullifiers,
+                        l2BlockNumber: receipt.blockNumber,
+                        l2BlockHash: receipt.blockHash,
+                        txIndexInBlock: receipt.txIndexInBlock
+                    }
+                ];
+            }).filter((entry)=>entry[1] !== undefined)
+        ]);
+    }
+    /**
+   * Reads a receipt with its effect, at most once per tx for the lifetime of this execution.
+   *
+   * A receipt is not cacheable in general, since pending, mined and dropped are all correct answers to the same call
+   * over time. Within one execution it is: the execution is anchored at a fixed block, and validation runs in several
+   * batches that name overlapping tx hashes, so re-reading would both cost extra requests and let one execution see a
+   * tx as included in one batch and absent in the next.
+   */ #getTxReceiptWithEffect(txHash) {
+        const key = txHash.toString();
+        let receipt = this.txReceiptsCache.get(key);
+        if (!receipt) {
+            receipt = this.aztecNode.getTxReceipt(txHash, {
+                includeTxEffect: true
+            }).catch((err)=>{
+                this.txReceiptsCache.delete(key);
+                throw err;
+            });
+            this.txReceiptsCache.set(key, receipt);
+        }
+        return receipt;
+    }
+    async #getTxEffectOption(txHash) {
+        const receipt = await this.#getTxReceiptWithEffect(txHash);
+        if (!receipt.isMined() || !receipt.txEffect || receipt.blockNumber > this.anchorBlockHeader.getBlockNumber()) {
+            return Option.none();
+        }
+        return Option.some(this.#toTxEffectData(receipt.txEffect));
+    }
+    #toTxEffectData(txEffect) {
+        return {
+            ...txEffect,
+            revertCode: txEffect.revertCode.getCode(),
+            publicLogs: FlatPublicLogs.fromLogs(txEffect.publicLogs),
+            contractClassLogs: txEffect.contractClassLogs.map((log)=>({
+                    contractAddress: log.contractAddress,
+                    fields: log.fields.toFields(),
+                    emittedLength: log.emittedLength
+                }))
+        };
     }
     /** Runs a query concurrently with a validation that the block hash is not ahead of the anchor block. */ async #queryWithBlockHashNotAfterAnchor(blockHash, query) {
         // Most contracts query state at the "current" block, which is the anchor. Skip the validation when we can.
@@ -644,4 +816,70 @@ import { Oracle } from './oracle.js';
     /** The execution context of the current call. */ get callerContext() {
         return 'utility';
     }
+    /** The address of the contract whose function is being executed, from the call context. */ get contractAddress() {
+        return this.callContext.contractAddress;
+    }
+}
+// Registry reads that any contract may issue without an `authorizeUtilityCall` hook. The constrained-delivery
+// library calls these implicitly for the app, and they are safe to default-authorize: `get_app_siloed_secrets`
+// siloes every returned secret to `msg_sender`, and `get_non_interactive_handshakes` only exposes ephemeral public
+// keys, from which the shared secret cannot be derived without the recipient's secret keys.
+const STANDARD_HANDSHAKE_REGISTRY_DEFAULT_AUTHORIZED_READ_SIGNATURES = [
+    'get_non_interactive_handshakes((Field),u32)',
+    'get_app_siloed_secrets((Field),(Field))'
+];
+async function doesSelectorHaveSignature(functionSelector, signature) {
+    return functionSelector.equals(await FunctionSelector.fromSignature(signature));
+}
+/**
+ * Whether a cross-contract utility call targets one of the standard handshake registry's read functions.
+ *
+ * These reads are authorized by PXE for every wallet, without consulting the `authorizeUtilityCall` hook, so that
+ * wallets don't need to know the handshake registry exists in order to deliver and discover messages through it.
+ */ async function isStandardHandshakeRegistryUtilityRead(targetContractAddress, functionSelector) {
+    if (!targetContractAddress.equals(STANDARD_HANDSHAKE_REGISTRY_ADDRESS)) {
+        return false;
+    }
+    const matches = await Promise.all(STANDARD_HANDSHAKE_REGISTRY_DEFAULT_AUTHORIZED_READ_SIGNATURES.map((signature)=>doesSelectorHaveSignature(functionSelector, signature)));
+    return matches.some(Boolean);
+}
+function toPendingTaggedLog(retrievedLog) {
+    return {
+        log: retrievedLog.logData,
+        context: toResolvedTx(retrievedLog)
+    };
+}
+function toResolvedTx(tx) {
+    const { txHash, blockNumber, blockHash, noteHashes, nullifiers } = tx;
+    return {
+        txHash,
+        uniqueNoteHashesInTx: noteHashes,
+        firstNullifierInTx: nullifiers[0],
+        blockNumber,
+        blockHash: blockHash.toFr()
+    };
+}
+function toLogRetrievalResponse(retrievedLog) {
+    const { logData, txHash, blockNumber, blockHash, blockTimestamp, noteHashes, nullifiers } = retrievedLog;
+    return {
+        // Skip the tag, and clip to the wire cap: public logs can exceed PRIVATE_LOG_CIPHERTEXT_LEN, which is the fixed
+        // size of the oracle's BoundedVec slot. A no-op for private logs, which are already within the cap.
+        logPayload: logData.slice(1, 1 + PRIVATE_LOG_CIPHERTEXT_LEN),
+        txHash,
+        uniqueNoteHashesInTx: noteHashes,
+        firstNullifierInTx: nullifiers[0],
+        blockNumber,
+        blockTimestamp,
+        blockHash
+    };
+}
+function toValidationTxData(tx) {
+    const { blockNumber, blockHash, txIndexInBlock, noteHashes, nullifiers } = tx;
+    return {
+        noteHashes,
+        nullifiers,
+        l2BlockNumber: blockNumber,
+        l2BlockHash: blockHash,
+        txIndexInBlock
+    };
 }