@aztec/pxe 0.0.1-commit.b468ad8 → 0.0.1-commit.b64cb54f6

package/dest/contract_function_simulator/oracle/utility_execution_oracle.js

@@ -1,11 +1,13 @@
 import { Aes128 } from '@aztec/foundation/crypto/aes128';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { LogLevels, applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import { LogLevels, createLogger } from '@aztec/foundation/log';
+import { isProtocolContract } from '@aztec/protocol-contracts';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import { computeAddressSecret } from '@aztec/stdlib/keys';
 import { deriveEcdhSharedSecret } from '@aztec/stdlib/logs';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { createContractLogger, logContractMessage } 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';
@@ -13,6 +15,7 @@ import { ORACLE_VERSION } from '../../oracle_version.js';
 import { EventValidationRequest } from '../noir-structs/event_validation_request.js';
 import { LogRetrievalRequest } from '../noir-structs/log_retrieval_request.js';
 import { LogRetrievalResponse } from '../noir-structs/log_retrieval_response.js';
+import { MessageTxContext } from '../noir-structs/message_tx_context.js';
 import { NoteValidationRequest } from '../noir-structs/note_validation_request.js';
 import { UtilityContext } from '../noir-structs/utility_context.js';
 import { pickNotes } from '../pick_notes.js';
@@ -20,6 +23,9 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
 /**
  * The oracle for an execution of utility contract functions.
  */ export class UtilityExecutionOracle {
+    isMisc = true;
+    isUtility = true;
+    contractLogger;
     contractAddress;
     authWitnesses;
     capsules;
@@ -33,42 +39,50 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
     senderAddressBookStore;
     capsuleStore;
     privateEventStore;
+    messageContextService;
     jobId;
-    log;
+    logger;
     scopes;
-    isMisc;
-    isUtility;
-    aztecNrDebugLog;
-    constructor(contractAddress, /** List of transient auth witnesses to be used during this simulation */ authWitnesses, capsules, anchorBlockHeader, contractStore, noteStore, keyStore, addressStore, aztecNode, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, jobId, log = createLogger('simulator:client_view_context'), scopes){
-        this.contractAddress = contractAddress;
-        this.authWitnesses = authWitnesses;
-        this.capsules = capsules;
-        this.anchorBlockHeader = anchorBlockHeader;
-        this.contractStore = contractStore;
-        this.noteStore = noteStore;
-        this.keyStore = keyStore;
-        this.addressStore = addressStore;
-        this.aztecNode = aztecNode;
-        this.recipientTaggingStore = recipientTaggingStore;
-        this.senderAddressBookStore = senderAddressBookStore;
-        this.capsuleStore = capsuleStore;
-        this.privateEventStore = privateEventStore;
-        this.jobId = jobId;
-        this.log = log;
-        this.scopes = scopes;
-        this.isMisc = true;
-        this.isUtility = true;
-        this.aztecNrDebugLog = createLogger('aztec-nr:debug_log');
+    constructor(args){
+        this.contractAddress = args.contractAddress;
+        this.authWitnesses = args.authWitnesses;
+        this.capsules = args.capsules;
+        this.anchorBlockHeader = args.anchorBlockHeader;
+        this.contractStore = args.contractStore;
+        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.capsuleStore = args.capsuleStore;
+        this.privateEventStore = args.privateEventStore;
+        this.messageContextService = args.messageContextService;
+        this.jobId = args.jobId;
+        this.logger = args.log ?? createLogger('simulator:client_view_context');
+        this.scopes = args.scopes;
     }
-    utilityAssertCompatibleOracleVersion(version) {
+    assertCompatibleOracleVersion(version) {
+        // TODO(F-416): Remove this hack on v5 when protocol contracts are redeployed.
+        // Protocol contracts/canonical contracts shipped with committed bytecode that cannot be changed. Assert they use
+        // the expected pinned version or the current one. We want to allow for both the pinned and the current versions
+        // because we want this code to work with both the pinned and unpinned version since some branches do not have the
+        // pinned contracts (like e.g. next)
+        const LEGACY_ORACLE_VERSION = 12;
+        if (isProtocolContract(this.contractAddress)) {
+            if (version !== LEGACY_ORACLE_VERSION && version !== ORACLE_VERSION) {
+                throw new Error(`Expected legacy oracle version ${LEGACY_ORACLE_VERSION} or current oracle version ${ORACLE_VERSION} for alpha payload contract at ${this.contractAddress}, got ${version}.`);
+            }
+            return;
+        }
         if (version !== ORACLE_VERSION) {
             throw new Error(`Incompatible oracle version. Expected version ${ORACLE_VERSION}, got ${version}.`);
         }
     }
-    utilityGetRandomField() {
+    getRandomField() {
         return Fr.random();
     }
-    utilityGetUtilityContext() {
+    getUtilityContext() {
         return new UtilityContext(this.anchorBlockHeader, this.contractAddress);
     }
     /**
@@ -76,7 +90,20 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @param pkMHash - The master public key hash.
    * @returns A Promise that resolves to nullifier keys.
    * @throws If the keys are not registered in the key store.
-   */ utilityGetKeyValidationRequest(pkMHash) {
+   * @throws If scopes are defined and the account is not in the scopes.
+   */ async getKeyValidationRequest(pkMHash) {
+        // If scopes are defined, check that the key belongs to an account in the scopes.
+        if (this.scopes !== 'ALL_SCOPES' && this.scopes.length > 0) {
+            let hasAccess = false;
+            for(let i = 0; i < this.scopes.length && !hasAccess; i++){
+                if (await this.keyStore.accountHasKey(this.scopes[i], pkMHash)) {
+                    hasAccess = true;
+                }
+            }
+            if (!hasAccess) {
+                throw new Error(`Key validation request denied: no scoped account has a key with hash ${pkMHash.toString()}.`);
+            }
+        }
         return this.keyStore.getKeyValidationRequest(pkMHash, this.contractAddress);
     }
     /**
@@ -85,7 +112,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * witness.
    * @param noteHash - The note hash to find in the note hash tree.
    * @returns The membership witness containing the leaf index and sibling path
-   */ utilityGetNoteHashMembershipWitness(anchorBlockHash, noteHash) {
+   */ getNoteHashMembershipWitness(anchorBlockHash, noteHash) {
         return this.aztecNode.getNoteHashMembershipWitness(anchorBlockHash, noteHash);
     }
     /**
@@ -98,7 +125,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * witness.
    * @param blockHash - The block hash to find in the archive tree.
    * @returns The membership witness containing the leaf index and sibling path
-   */ utilityGetBlockHashMembershipWitness(anchorBlockHash, blockHash) {
+   */ getBlockHashMembershipWitness(anchorBlockHash, blockHash) {
         return this.aztecNode.getBlockHashMembershipWitness(anchorBlockHash, blockHash);
     }
     /**
@@ -106,7 +133,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @param blockHash - The block hash at which to get the index.
    * @param nullifier - Nullifier we try to find witness for.
    * @returns The nullifier membership witness (if found).
-   */ utilityGetNullifierMembershipWitness(blockHash, nullifier) {
+   */ getNullifierMembershipWitness(blockHash, nullifier) {
         return this.aztecNode.getNullifierMembershipWitness(blockHash, nullifier);
     }
     /**
@@ -117,7 +144,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
    * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
    * we are trying to prove non-inclusion for.
-   */ utilityGetLowNullifierMembershipWitness(blockHash, nullifier) {
+   */ getLowNullifierMembershipWitness(blockHash, nullifier) {
         return this.aztecNode.getLowNullifierMembershipWitness(blockHash, nullifier);
     }
     /**
@@ -125,14 +152,14 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @param blockHash - The block hash at which to get the index.
    * @param leafSlot - The slot of the public data tree to get the witness for.
    * @returns - The witness
-   */ utilityGetPublicDataWitness(blockHash, leafSlot) {
+   */ getPublicDataWitness(blockHash, leafSlot) {
         return this.aztecNode.getPublicDataWitness(blockHash, leafSlot);
     }
     /**
    * Fetches a block header of a given block.
    * @param blockNumber - The number of a block of which to get the block header.
    * @returns Block extracted from a block with block number `blockNumber`.
-   */ async utilityGetBlockHeader(blockNumber) {
+   */ async getBlockHeader(blockNumber) {
         const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
         if (blockNumber > anchorBlockNumber) {
             throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
@@ -141,14 +168,20 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
         return block?.header;
     }
     /**
-   * Retrieve the complete address associated to a given address.
+   * Retrieve the public keys and partial address associated to a given address.
    * @param account - The account address.
-   * @returns A complete address associated with the input address.
-   * @throws An error if the account is not registered in the database.
-   */ utilityGetPublicKeysAndPartialAddress(account) {
-        return this.getCompleteAddress(account);
+   * @returns The public keys and partial address, or `undefined` if the account is not registered.
+   */ async tryGetPublicKeysAndPartialAddress(account) {
+        const completeAddress = await this.addressStore.getCompleteAddress(account);
+        if (!completeAddress) {
+            return undefined;
+        }
+        return {
+            publicKeys: completeAddress.publicKeys,
+            partialAddress: completeAddress.partialAddress
+        };
     }
-    async getCompleteAddress(account) {
+    async getCompleteAddressOrFail(account) {
         const completeAddress = await this.addressStore.getCompleteAddress(account);
         if (!completeAddress) {
             throw new Error(`No public key registered for address ${account}.
@@ -160,10 +193,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * Returns a contract instance associated with an address or throws if not found.
    * @param address - Address.
    * @returns A contract instance.
-   */ utilityGetContractInstance(address) {
-        return this.getContractInstance(address);
-    }
-    async getContractInstance(address) {
+   */ async getContractInstance(address) {
         const instance = await this.contractStore.getContractInstance(address);
         if (!instance) {
             throw new Error(`No contract instance found for address ${address.toString()}`);
@@ -175,7 +205,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * for this transaction first, and falls back to the local database if not found.
    * @param messageHash - Hash of the message to authenticate.
    * @returns Authentication witness for the requested message hash.
-   */ utilityGetAuthWitness(messageHash) {
+   */ getAuthWitness(messageHash) {
         return Promise.resolve(this.authWitnesses.find((w)=>w.requestHash.equals(messageHash))?.witness);
     }
     /**
@@ -199,7 +229,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @param offset - The starting index for pagination.
    * @param status - The status of notes to fetch.
    * @returns Array of note data.
-   */ async utilityGetNotes(owner, storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status) {
+   */ async getNotes(owner, storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status) {
         const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockHeader, this.jobId);
         const dbNotes = await noteService.getNotes(this.contractAddress, owner, storageSlot, status, this.scopes);
         return pickNotes(dbNotes, {
@@ -228,9 +258,12 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * Check if a nullifier exists in the nullifier tree.
    * @param innerNullifier - The inner nullifier.
    * @returns A boolean indicating whether the nullifier exists in the tree or not.
-   */ async utilityCheckNullifierExists(innerNullifier) {
-        const nullifier = await siloNullifier(this.contractAddress, innerNullifier);
-        const [leafIndex] = await this.aztecNode.findLeavesIndexes('latest', MerkleTreeId.NULLIFIER_TREE, [
+   */ async checkNullifierExists(innerNullifier) {
+        const [nullifier, anchorBlockHash] = await Promise.all([
+            siloNullifier(this.contractAddress, innerNullifier),
+            this.anchorBlockHeader.hash()
+        ]);
+        const [leafIndex] = await this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, [
             nullifier
         ]);
         return leafIndex?.data !== undefined;
@@ -242,7 +275,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @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
    * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-   */ async utilityGetL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
+   */ async getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
         const [messageIndex, siblingPath] = await getNonNullifiedL1ToL2MessageWitness(this.aztecNode, contractAddress, messageHash, secret);
         return new MessageLoadOracleInputs(messageIndex, siblingPath);
     }
@@ -252,30 +285,34 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @param contractAddress - The address to read storage from.
    * @param startStorageSlot - The starting storage slot.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
-   */ async utilityStorageRead(blockHash, contractAddress, startStorageSlot, numberOfElements) {
+   */ async storageRead(blockHash, contractAddress, startStorageSlot, numberOfElements) {
         const slots = Array(numberOfElements).fill(0).map((_, i)=>new Fr(startStorageSlot.value + BigInt(i)));
         const values = await Promise.all(slots.map((storageSlot)=>this.aztecNode.getPublicStorageAt(blockHash, contractAddress, storageSlot)));
-        this.log.debug(`Oracle storage read: slots=[${slots.map((slot)=>slot.toString()).join(', ')}] address=${contractAddress.toString()} values=[${values.join(', ')}]`);
+        this.logger.debug(`Oracle storage read: slots=[${slots.map((slot)=>slot.toString()).join(', ')}] address=${contractAddress.toString()} values=[${values.join(', ')}]`);
         return values;
     }
-    utilityDebugLog(level, message, fields) {
+    /**
+   * Returns a per-contract logger whose output is prefixed with `contract_log::<name>(<addrAbbrev>)`.
+   */ async #getContractLogger() {
+        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), {
+                instanceId: this.jobId
+            });
+        }
+        return this.contractLogger;
+    }
+    async log(level, message, fields) {
         if (!LogLevels[level]) {
-            throw new Error(`Invalid debug log level: ${level}`);
+            throw new Error(`Invalid log level: ${level}`);
         }
-        const levelName = LogLevels[level];
-        this.aztecNrDebugLog[levelName](`${applyStringFormatting(message, fields)}`);
+        const logger = await this.#getContractLogger();
+        logContractMessage(logger, LogLevels[level], message, fields);
     }
-    async utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
-        const logService = new LogService(this.aztecNode, this.anchorBlockHeader, this.keyStore, this.capsuleStore, this.recipientTaggingStore, this.senderAddressBookStore, this.addressStore, this.jobId, this.log.getBindings());
-        const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockHeader, this.jobId);
-        // It is acceptable to run the following operations in parallel for several reasons:
-        // 1. syncTaggedLogs does not write to the note store — it only stores the pending tagged logs in a capsule array,
-        //    which is then processed in Noir after this handler returns.
-        // 2. Even if syncTaggedLogs did write to the note store, it would not cause inconsistent state.
-        await Promise.all([
-            logService.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes),
-            noteService.syncNoteNullifiers(this.contractAddress)
-        ]);
+    async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
+        const logService = new LogService(this.aztecNode, this.anchorBlockHeader, this.keyStore, this.capsuleStore, this.recipientTaggingStore, this.senderAddressBookStore, this.addressStore, this.jobId, this.logger.getBindings());
+        await logService.fetchTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
     }
     /**
    * Validates all note and event validation requests enqueued via `enqueue_note_for_validation` and
@@ -286,15 +323,15 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @param contractAddress - The address of the contract that the logs are tagged for.
    * @param noteValidationRequestsArrayBaseSlot - The base slot of capsule array containing note validation requests.
    * @param eventValidationRequestsArrayBaseSlot - The base slot of capsule array containing event validation requests.
-   */ async utilityValidateAndStoreEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot) {
+   */ async validateAndStoreEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot, maxNotePackedLen, maxEventSerializedLen) {
         // TODO(#10727): allow other contracts to store notes
         if (!this.contractAddress.equals(contractAddress)) {
             throw new Error(`Got a note validation request from ${contractAddress}, expected ${this.contractAddress}`);
         }
         // We read all note and event validation requests and process them all concurrently. This makes the process much
         // faster as we don't need to wait for the network round-trip.
-        const noteValidationRequests = (await this.capsuleStore.readCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, this.jobId)).map(NoteValidationRequest.fromFields);
-        const eventValidationRequests = (await this.capsuleStore.readCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, this.jobId)).map(EventValidationRequest.fromFields);
+        const noteValidationRequests = (await this.capsuleStore.readCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, this.jobId)).map((fields)=>NoteValidationRequest.fromFields(fields, maxNotePackedLen));
+        const eventValidationRequests = (await this.capsuleStore.readCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, this.jobId)).map((fields)=>EventValidationRequest.fromFields(fields, maxEventSerializedLen));
         const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockHeader, this.jobId);
         const noteStorePromises = noteValidationRequests.map((request)=>noteService.validateAndStoreNote(request.contractAddress, request.owner, request.storageSlot, request.randomness, request.noteNonce, request.content, request.noteHash, request.nullifier, request.txHash, request.recipient));
         const eventService = new EventService(this.anchorBlockHeader, this.aztecNode, this.privateEventStore, this.jobId);
@@ -307,7 +344,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
         await this.capsuleStore.setCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, [], this.jobId);
         await this.capsuleStore.setCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, [], this.jobId);
     }
-    async utilityBulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
+    async bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
         // TODO(#10727): allow other contracts to process partial notes
         if (!this.contractAddress.equals(contractAddress)) {
             throw new Error(`Got a note validation request from ${contractAddress}, expected ${this.contractAddress}`);
@@ -315,14 +352,33 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
         // We read all log retrieval requests and process them all concurrently. This makes the process much faster as we
         // don't need to wait for the network round-trip.
         const logRetrievalRequests = (await this.capsuleStore.readCapsuleArray(contractAddress, logRetrievalRequestsArrayBaseSlot, this.jobId)).map(LogRetrievalRequest.fromFields);
-        const logService = new LogService(this.aztecNode, this.anchorBlockHeader, this.keyStore, this.capsuleStore, this.recipientTaggingStore, this.senderAddressBookStore, this.addressStore, this.jobId, this.log.getBindings());
+        const logService = new LogService(this.aztecNode, this.anchorBlockHeader, this.keyStore, this.capsuleStore, this.recipientTaggingStore, this.senderAddressBookStore, this.addressStore, this.jobId, this.logger.getBindings());
         const maybeLogRetrievalResponses = await logService.bulkRetrieveLogs(logRetrievalRequests);
         // Requests are cleared once we're done.
         await this.capsuleStore.setCapsuleArray(contractAddress, logRetrievalRequestsArrayBaseSlot, [], this.jobId);
         // The responses are stored as Option<LogRetrievalResponse> in a second CapsuleArray.
         await this.capsuleStore.setCapsuleArray(contractAddress, logRetrievalResponsesArrayBaseSlot, maybeLogRetrievalResponses.map(LogRetrievalResponse.toSerializedOption), this.jobId);
     }
-    utilityStoreCapsule(contractAddress, slot, capsule) {
+    async utilityResolveMessageContexts(contractAddress, messageContextRequestsArrayBaseSlot, messageContextResponsesArrayBaseSlot) {
+        try {
+            if (!this.contractAddress.equals(contractAddress)) {
+                throw new Error(`Got a message context request from ${contractAddress}, expected ${this.contractAddress}`);
+            }
+            const requestCapsules = await this.capsuleStore.readCapsuleArray(contractAddress, messageContextRequestsArrayBaseSlot, this.jobId);
+            const txHashes = requestCapsules.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.resolveMessageContexts(txHashes, this.anchorBlockHeader.getBlockNumber());
+            // Leave response in response capsule array.
+            await this.capsuleStore.setCapsuleArray(contractAddress, messageContextResponsesArrayBaseSlot, maybeMessageContexts.map(MessageTxContext.toSerializedOption), this.jobId);
+        } finally{
+            await this.capsuleStore.setCapsuleArray(contractAddress, messageContextRequestsArrayBaseSlot, [], this.jobId);
+        }
+    }
+    storeCapsule(contractAddress, slot, capsule) {
         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`);
@@ -330,7 +386,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
         this.capsuleStore.storeCapsule(this.contractAddress, slot, capsule, this.jobId);
         return Promise.resolve();
     }
-    async utilityLoadCapsule(contractAddress, slot) {
+    async loadCapsule(contractAddress, slot) {
         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`);
@@ -338,7 +394,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
         return(// TODO(#12425): On the following line, the pertinent capsule gets overshadowed by the transient one. Tackle this.
         this.capsules.find((c)=>c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ?? await this.capsuleStore.loadCapsule(this.contractAddress, slot, this.jobId));
     }
-    utilityDeleteCapsule(contractAddress, slot) {
+    deleteCapsule(contractAddress, slot) {
         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`);
@@ -346,7 +402,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
         this.capsuleStore.deleteCapsule(this.contractAddress, slot, this.jobId);
         return Promise.resolve();
     }
-    utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
+    copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
         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`);
@@ -354,7 +410,7 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
         return this.capsuleStore.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries, this.jobId);
     }
     // TODO(#11849): consider replacing this oracle with a pure Noir implementation of aes decryption.
-    utilityAes128Decrypt(ciphertext, iv, symKey) {
+    aes128Decrypt(ciphertext, iv, symKey) {
         const aes128 = new Aes128();
         return aes128.decryptBufferCBC(ciphertext, iv, symKey);
     }
@@ -363,12 +419,9 @@ import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
    * @param address - The address to get the secret for.
    * @param ephPk - The ephemeral public key to get the secret for.
    * @returns The secret for the given address.
-   */ utilityGetSharedSecret(address, ephPk) {
-        return this.getSharedSecret(address, ephPk);
-    }
-    async getSharedSecret(address, ephPk) {
+   */ async getSharedSecret(address, ephPk) {
         // TODO(#12656): return an app-siloed secret
-        const recipientCompleteAddress = await this.getCompleteAddress(address);
+        const recipientCompleteAddress = await this.getCompleteAddressOrFail(address);
         const ivskM = await this.keyStore.getMasterSecretKey(recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey);
         const addressSecret = await computeAddressSecret(await recipientCompleteAddress.getPreaddress(), ivskM);
         return deriveEcdhSharedSecret(addressSecret, ephPk);

package/dest/contract_logging.d.ts

@@ -0,0 +1,22 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { type LogLevel, type Logger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { DebugLog } from '@aztec/stdlib/logs';
+/** Resolves a contract address to a human-readable name, if available. */
+export type ContractNameResolver = (address: AztecAddress) => Promise<string | undefined>;
+/**
+ * Creates a logger whose output is prefixed with `contract_log::<name>(<addrAbbrev>)`.
+ */
+export declare function createContractLogger(contractAddress: AztecAddress, getContractName: ContractNameResolver, options?: {
+    instanceId?: string;
+}): Promise<Logger>;
+/**
+ * Formats and emits a single contract log message through the given logger.
+ */
+export declare function logContractMessage(logger: Logger, level: LogLevel, message: string, fields: Fr[]): void;
+/**
+ * Displays debug logs collected during public function simulation,
+ * using the `contract_log::` prefixed logger format.
+ */
+export declare function displayDebugLogs(debugLogs: DebugLog[], getContractName: ContractNameResolver): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfbG9nZ2luZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnRyYWN0X2xvZ2dpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDekQsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLEtBQUssTUFBTSxFQUF1QyxNQUFNLHVCQUF1QixDQUFDO0FBQ3hHLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRW5ELDBFQUEwRTtBQUMxRSxNQUFNLE1BQU0sb0JBQW9CLEdBQUcsQ0FBQyxPQUFPLEVBQUUsWUFBWSxLQUFLLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBQUM7QUFFMUY7O0dBRUc7QUFDSCx3QkFBc0Isb0JBQW9CLENBQ3hDLGVBQWUsRUFBRSxZQUFZLEVBQzdCLGVBQWUsRUFBRSxvQkFBb0IsRUFDckMsT0FBTyxDQUFDLEVBQUU7SUFBRSxVQUFVLENBQUMsRUFBRSxNQUFNLENBQUE7Q0FBRSxHQUNoQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBS2pCO0FBRUQ7O0dBRUc7QUFDSCx3QkFBZ0Isa0JBQWtCLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxHQUFHLElBQUksQ0FFdkc7QUFFRDs7O0dBR0c7QUFDSCx3QkFBc0IsZ0JBQWdCLENBQUMsU0FBUyxFQUFFLFFBQVEsRUFBRSxFQUFFLGVBQWUsRUFBRSxvQkFBb0IsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBS2xIIn0=

package/dest/contract_logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_logging.d.ts","sourceRoot":"","sources":["../src/contract_logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAuC,MAAM,uBAAuB,CAAC;AACxG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,0EAA0E;AAC1E,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AAE1F;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,YAAY,EAC7B,eAAe,EAAE,oBAAoB,EACrC,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAEvG;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,eAAe,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKlH"}

package/dest/contract_logging.js

@@ -0,0 +1,23 @@
+import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
+/**
+ * Creates a logger whose output is prefixed with `contract_log::<name>(<addrAbbrev>)`.
+ */ export async function createContractLogger(contractAddress, getContractName, options) {
+    const addrAbbrev = contractAddress.toString().slice(0, 10);
+    const name = await getContractName(contractAddress);
+    const module = name ? `contract_log::${name}(${addrAbbrev})` : `contract_log::Unknown(${addrAbbrev})`;
+    return createLogger(module, options);
+}
+/**
+ * Formats and emits a single contract log message through the given logger.
+ */ export function logContractMessage(logger, level, message, fields) {
+    logger[level](applyStringFormatting(message, fields));
+}
+/**
+ * Displays debug logs collected during public function simulation,
+ * using the `contract_log::` prefixed logger format.
+ */ export async function displayDebugLogs(debugLogs, getContractName) {
+    for (const log of debugLogs){
+        const logger = await createContractLogger(log.contractAddress, getContractName);
+        logContractMessage(logger, log.level, log.message, log.fields);
+    }
+}

package/dest/contract_sync/contract_sync_service.d.ts

@@ -0,0 +1,43 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { AccessScopes } from '../access_scopes.js';
+import type { StagedStore } from '../job_coordinator/job_coordinator.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
+/**
+ * Service for syncing the private state of contracts and verifying that the PXE holds the current class artifact.
+ * It uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
+ *
+ * TODO: The StagedStore naming is broken here. Figure out a better name.
+ */
+export declare class ContractSyncService implements StagedStore {
+    #private;
+    private aztecNode;
+    private contractStore;
+    private noteStore;
+    private log;
+    readonly storeName = "contract_sync";
+    private syncedContracts;
+    private overriddenContracts;
+    constructor(aztecNode: AztecNode, contractStore: ContractStore, noteStore: NoteStore, log: Logger);
+    /** Sets contracts that should be skipped during sync for a specific job. */
+    setOverriddenContracts(jobId: string, addresses: Set<string>): void;
+    /**
+     * Ensures a contract's private state is synchronized and that the PXE holds the current class artifact.
+     * Uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
+     * @param contractAddress - The address of the contract to sync.
+     * @param functionToInvokeAfterSync - The function selector that will be called after sync (used to validate it's
+     * not sync_state itself).
+     * @param utilityExecutor - Executor function for running the sync_state utility function.
+     * @param scopes - Access scopes to pass through to the utility executor (affects whose account's private state is discovered).
+     */
+    ensureContractSynced(contractAddress: AztecAddress, functionToInvokeAfterSync: FunctionSelector | null, utilityExecutor: (call: FunctionCall, scopes: AccessScopes) => Promise<any>, anchorBlockHeader: BlockHeader, jobId: string, scopes: AccessScopes): Promise<void>;
+    /** Clears sync cache. Called by BlockSynchronizer when anchor block changes. */
+    wipe(): void;
+    commit(jobId: string): Promise<void>;
+    discardStaged(jobId: string): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3Rfc3luY19zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3Rfc3luYy9jb250cmFjdF9zeW5jX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDekUsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFDakYsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFHckU7Ozs7O0dBS0c7QUFDSCxxQkFBYSxtQkFBb0IsWUFBVyxXQUFXOztJQVluRCxPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsYUFBYTtJQUNyQixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsR0FBRztJQWRiLFFBQVEsQ0FBQyxTQUFTLG1CQUFtQjtJQUtyQyxPQUFPLENBQUMsZUFBZSxDQUF5QztJQUdoRSxPQUFPLENBQUMsbUJBQW1CLENBQXVDO0lBRWxFLFlBQ1UsU0FBUyxFQUFFLFNBQVMsRUFDcEIsYUFBYSxFQUFFLGFBQWEsRUFDNUIsU0FBUyxFQUFFLFNBQVMsRUFDcEIsR0FBRyxFQUFFLE1BQU0sRUFDakI7SUFFSiw0RUFBNEU7SUFDNUUsc0JBQXNCLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FFbEU7SUFFRDs7Ozs7Ozs7T0FRRztJQUNHLG9CQUFvQixDQUN4QixlQUFlLEVBQUUsWUFBWSxFQUM3Qix5QkFBeUIsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLEVBQ2xELGVBQWUsRUFBRSxDQUFDLElBQUksRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksS0FBSyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQzNFLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsS0FBSyxFQUFFLE1BQU0sRUFDYixNQUFNLEVBQUUsWUFBWSxHQUNuQixPQUFPLENBQUMsSUFBSSxDQUFDLENBdUNmO0lBNEJELGdGQUFnRjtJQUNoRixJQUFJLElBQUksSUFBSSxDQUdYO0lBRUQsTUFBTSxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUluQztJQUVELGFBQWEsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FNMUM7Q0FDRiJ9

package/dest/contract_sync/contract_sync_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_sync_service.d.ts","sourceRoot":"","sources":["../../src/contract_sync/contract_sync_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAGrE;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,WAAW;;IAYnD,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAdb,QAAQ,CAAC,SAAS,mBAAmB;IAKrC,OAAO,CAAC,eAAe,CAAyC;IAGhE,OAAO,CAAC,mBAAmB,CAAuC;IAElE,YACU,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,aAAa,EAC5B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACjB;IAEJ,4EAA4E;IAC5E,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAElE;IAED;;;;;;;;OAQG;IACG,oBAAoB,CACxB,eAAe,EAAE,YAAY,EAC7B,yBAAyB,EAAE,gBAAgB,GAAG,IAAI,EAClD,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC,GAAG,CAAC,EAC3E,iBAAiB,EAAE,WAAW,EAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,IAAI,CAAC,CAuCf;IA4BD,gFAAgF;IAChF,IAAI,IAAI,IAAI,CAGX;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAInC;IAED,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM1C;CACF"}

package/dest/contract_sync/contract_sync_service.js

@@ -0,0 +1,97 @@
+import { syncState, verifyCurrentClassId } from './helpers.js';
+/**
+ * Service for syncing the private state of contracts and verifying that the PXE holds the current class artifact.
+ * It uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
+ *
+ * TODO: The StagedStore naming is broken here. Figure out a better name.
+ */ export class ContractSyncService {
+    aztecNode;
+    contractStore;
+    noteStore;
+    log;
+    storeName;
+    // Tracks contracts synced since last wipe. The cache is keyed per individual scope address
+    // (`contractAddress:scopeAddress`), or `contractAddress:*` for undefined scopes (all accounts).
+    // The value is a promise that resolves when the contract is synced.
+    syncedContracts;
+    // Per-job overridden contract addresses - these contracts should not be synced.
+    overriddenContracts;
+    constructor(aztecNode, contractStore, noteStore, log){
+        this.aztecNode = aztecNode;
+        this.contractStore = contractStore;
+        this.noteStore = noteStore;
+        this.log = log;
+        this.storeName = 'contract_sync';
+        this.syncedContracts = new Map();
+        this.overriddenContracts = new Map();
+    }
+    /** Sets contracts that should be skipped during sync for a specific job. */ setOverriddenContracts(jobId, addresses) {
+        this.overriddenContracts.set(jobId, addresses);
+    }
+    /**
+   * Ensures a contract's private state is synchronized and that the PXE holds the current class artifact.
+   * Uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
+   * @param contractAddress - The address of the contract to sync.
+   * @param functionToInvokeAfterSync - The function selector that will be called after sync (used to validate it's
+   * not sync_state itself).
+   * @param utilityExecutor - Executor function for running the sync_state utility function.
+   * @param scopes - Access scopes to pass through to the utility executor (affects whose account's private state is discovered).
+   */ async ensureContractSynced(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, scopes) {
+        // Skip sync if this contract has an override for this job (overrides are keyed by contract address only)
+        const overrides = this.overriddenContracts.get(jobId);
+        if (overrides?.has(contractAddress.toString())) {
+            return;
+        }
+        // Skip sync if we already synced for "all scopes", or if we have an empty list of scopes
+        const allScopesKey = toKey(contractAddress, 'ALL_SCOPES');
+        const allScopesExisting = this.syncedContracts.get(allScopesKey);
+        if (allScopesExisting || scopes !== 'ALL_SCOPES' && scopes.length == 0) {
+            return;
+        }
+        const unsyncedScopes = scopes === 'ALL_SCOPES' ? scopes : scopes.filter((scope)=>!this.syncedContracts.has(toKey(contractAddress, scope)));
+        const unsyncedScopesKeys = toKeys(contractAddress, unsyncedScopes);
+        if (unsyncedScopesKeys.length > 0) {
+            // Start sync and store the promise for all unsynced scopes
+            const promise = this.#doSync(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, unsyncedScopes).catch((err)=>{
+                // There was an error syncing the contract, so we remove it from the cache so that it can be retried.
+                unsyncedScopesKeys.forEach((key)=>this.syncedContracts.delete(key));
+                throw err;
+            });
+            unsyncedScopesKeys.forEach((key)=>this.syncedContracts.set(key, promise));
+        }
+        const promises = toKeys(contractAddress, scopes).map((key)=>this.syncedContracts.get(key));
+        await Promise.all(promises);
+    }
+    async #doSync(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, scopes) {
+        this.log.debug(`Syncing contract ${contractAddress}`);
+        await Promise.all([
+            syncState(contractAddress, this.contractStore, functionToInvokeAfterSync, utilityExecutor, this.noteStore, this.aztecNode, anchorBlockHeader, jobId, scopes),
+            verifyCurrentClassId(contractAddress, this.aztecNode, this.contractStore, anchorBlockHeader)
+        ]);
+        this.log.debug(`Contract ${contractAddress} synced`);
+    }
+    /** Clears sync cache. Called by BlockSynchronizer when anchor block changes. */ wipe() {
+        this.log.debug(`Wiping contract sync cache (${this.syncedContracts.size} entries)`);
+        this.syncedContracts.clear();
+    }
+    commit(jobId) {
+        // Clear overridden contracts for this job
+        this.overriddenContracts.delete(jobId);
+        return Promise.resolve();
+    }
+    discardStaged(jobId) {
+        // We clear the synced contracts cache here because, when the job is discarded, any associated database writes from
+        // the sync are also undone.
+        this.syncedContracts.clear();
+        this.overriddenContracts.delete(jobId);
+        return Promise.resolve();
+    }
+}
+function toKeys(contract, scopes) {
+    return scopes === 'ALL_SCOPES' ? [
+        toKey(contract, scopes)
+    ] : scopes.map((scope)=>toKey(contract, scope));
+}
+function toKey(contract, scope) {
+    return scope === 'ALL_SCOPES' ? `${contract.toString()}:*` : `${contract.toString()}:${scope.toString()}`;
+}