@aztec/pxe 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/dest/block_synchronizer/block_synchronizer.js

@@ -1,6 +1,8 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
-import { L2BlockHash, L2BlockStream } from '@aztec/stdlib/block';
+import { SerialQueue } from '@aztec/foundation/queue';
+import { BlockHash, L2BlockStream } from '@aztec/stdlib/block';
+import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
 /**
  * The BlockSynchronizer class orchestrates synchronization between PXE and Aztec node, maintaining an up-to-date
  * view of the L2 chain state. It handles block header retrieval, chain reorganizations, and provides an interface
@@ -11,62 +13,155 @@ import { L2BlockHash, L2BlockStream } from '@aztec/stdlib/block';
     anchorBlockStore;
     noteStore;
     privateEventStore;
+    factStore;
     l2TipsStore;
+    contractSyncService;
+    contractClassService;
+    config;
     log;
     isSyncing;
+    eventQueue;
     blockStream;
-    constructor(node, store, anchorBlockStore, noteStore, privateEventStore, l2TipsStore, config = {}, loggerOrSuffix){
+    constructor(node, store, anchorBlockStore, noteStore, privateEventStore, factStore, l2TipsStore, contractSyncService, contractClassService, config = {}, bindings){
         this.node = node;
         this.store = store;
         this.anchorBlockStore = anchorBlockStore;
         this.noteStore = noteStore;
         this.privateEventStore = privateEventStore;
+        this.factStore = factStore;
         this.l2TipsStore = l2TipsStore;
-        this.log = !loggerOrSuffix || typeof loggerOrSuffix === 'string' ? createLogger(loggerOrSuffix ? `pxe:block_synchronizer:${loggerOrSuffix}` : `pxe:block_synchronizer`) : loggerOrSuffix;
-        this.blockStream = this.createBlockStream(config);
+        this.contractSyncService = contractSyncService;
+        this.contractClassService = contractClassService;
+        this.config = config;
+        this.eventQueue = new SerialQueue();
+        this.log = createLogger('pxe:block_synchronizer', bindings);
+        this.blockStream = this.createBlockStream();
+        this.eventQueue.start();
     }
-    createBlockStream(config) {
-        return new L2BlockStream(this.node, this.l2TipsStore, this, createLogger('pxe:block_stream'), {
-            batchSize: config.l2BlockBatchSize,
-            // Skipping finalized blocks makes us sync much faster - we only need to download blocks other than the latest one
-            // in order to detect reorgs, and there can be no reorgs on finalized block, making this safe.
-            skipFinalized: true
+    createBlockStream() {
+        return new L2BlockStream(blockStreamSourceFromAztecNode(this.node), this.l2TipsStore, this, createLogger('pxe:block_stream', this.log.getBindings()), {
+            // PXE only tracks chain tips (it anchors on tip events and never replays payloads), so the stream runs
+            // in tips-only mode: no block downloads, just the tip events that move the anchor and detect reorgs.
+            tipsOnly: true
         });
     }
-    /** Handle events emitted by the block stream. */ async handleBlockStreamEvent(event) {
-        await this.l2TipsStore.handleBlockStreamEvent(event);
+    /** Handle events emitted by the block stream. Serialized to prevent concurrent mutations to anchor state. */ handleBlockStreamEvent(event) {
+        return this.eventQueue.put(()=>this.doHandleBlockStreamEvent(event));
+    }
+    async doHandleBlockStreamEvent(event) {
         switch(event.type){
+            case 'chain-proposed':
+                {
+                    if (this.config.syncChainTip === undefined || this.config.syncChainTip === 'proposed') {
+                        // Fetch the proposed tip header by hash. By-hash is safer than by-number against a same-height reorg.
+                        const block = await this.node.getBlockData(BlockHash.fromString(event.block.hash));
+                        if (!block) {
+                            // The node served a proposed tip whose block data it cannot return — a node inconsistency, since the
+                            // stream events and the block data come from the same node (same reasoning as the chain-pruned throw
+                            // below). Throwing here propagates before the tips-store cursor advances, so the cursor stays put and the
+                            // next sync re-emits chain-proposed (at-least-once). Were we to warn-and-skip, the cursor would advance and
+                            // a quiet chain would never re-emit, leaving the anchor stale indefinitely.
+                            throw new Error(`Block header for proposed block ${event.block.number} and hash ${event.block.hash} not found. This ` + `likely indicates a bug in the node, as we receive block stream events and fetch block headers from ` + `the same node.`);
+                        }
+                        await this.updateAnchorBlockHeader(block.header);
+                    }
+                    break;
+                }
+            // Never emitted in tips-only mode; PXE anchors on chain-proposed instead. Kept for union exhaustiveness.
             case 'blocks-added':
+                break;
+            case 'chain-checkpointed':
                 {
-                    const lastBlock = event.blocks.at(-1);
-                    this.log.verbose(`Updated pxe last block to ${lastBlock.number}`, {
-                        blockHash: lastBlock.hash(),
-                        archive: lastBlock.archive.root.toString(),
-                        header: lastBlock.header.toInspect()
-                    });
-                    await this.anchorBlockStore.setHeader(lastBlock.header);
+                    if (this.config.syncChainTip === 'checkpointed') {
+                        // Fetch the checkpointed tip header by hash. By-hash is safer than by-number against a
+                        // same-height reorg; a missing result means the block was reorged out between the event
+                        // and this fetch, so we skip the anchor update and let a later event correct it.
+                        const block = await this.node.getBlockData(BlockHash.fromString(event.block.hash));
+                        if (block) {
+                            await this.updateAnchorBlockHeader(block.header);
+                        } else {
+                            this.log.warn(`Block header not found for checkpointed block ${event.block.number}, skipping anchor update`);
+                        }
+                    }
+                    break;
+                }
+            case 'chain-proven':
+                {
+                    if (this.config.syncChainTip === 'proven') {
+                        const block = await this.node.getBlock(BlockNumber(event.block.number));
+                        if (block) {
+                            await this.updateAnchorBlockHeader(block.header);
+                        } else {
+                            this.log.warn(`Block header not found for proven block ${event.block.number}, skipping anchor update`);
+                        }
+                    }
+                    break;
+                }
+            case 'chain-finalized':
+                {
+                    if (this.config.syncChainTip === 'finalized') {
+                        const block = await this.node.getBlock(BlockNumber(event.block.number));
+                        if (block) {
+                            await this.updateAnchorBlockHeader(block.header);
+                        } else {
+                            this.log.warn(`Block header not found for finalized block ${event.block.number}, skipping anchor update`);
+                        }
+                    }
                     break;
                 }
             case 'chain-pruned':
                 {
-                    this.log.warn(`Pruning data after block ${event.block.number} due to reorg`);
-                    const oldAnchorBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
+                    const currentAnchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+                    const currentAnchorBlockNumber = currentAnchorBlockHeader.getBlockNumber();
+                    if (currentAnchorBlockNumber <= event.block.number) {
+                        this.log.verbose(`Ignoring prune event to block ${event.block.number} greater than current anchor block ${currentAnchorBlockNumber}`, {
+                            pruneEvent: event,
+                            currentAnchorBlockHeader: currentAnchorBlockHeader.toInspect()
+                        });
+                        break;
+                    }
+                    this.log.warn(`Pruning data after block ${event.block.number} due to reorg`, {
+                        pruneBlock: event.block
+                    });
                     // Note that the following is not necessarily the anchor block that will be used in the transaction - if
                     // the chain has already moved past the reorg, we'll also see blocks-added events that will push the anchor
                     // forward.
-                    const newAnchorBlockHeader = await this.node.getBlockHeader(L2BlockHash.fromString(event.block.hash));
+                    const newAnchorBlock = await this.node.getBlock(BlockHash.fromString(event.block.hash));
+                    const newAnchorBlockHeader = newAnchorBlock?.header;
                     if (!newAnchorBlockHeader) {
                         throw new Error(`Block header for block number ${event.block.number} and hash ${event.block.hash} not found during chain prune. This likely indicates a bug in the node, as we receive block stream events and fetch block headers from the same node.`);
                     }
                     // Operations are wrapped in a single transaction to ensure atomicity.
                     await this.store.transactionAsync(async ()=>{
-                        await this.noteStore.rollback(event.block.number, oldAnchorBlockNumber);
-                        await this.privateEventStore.rollback(event.block.number, oldAnchorBlockNumber);
-                        await this.anchorBlockStore.setHeader(newAnchorBlockHeader);
+                        await this.noteStore.rollback(event.block.number);
+                        await this.privateEventStore.rollback(event.block.number);
+                        await this.factStore.rollback(event.block.number);
+                        await this.updateAnchorBlockHeader(newAnchorBlockHeader);
                     });
                     break;
                 }
+            default:
+                {
+                    const _ = event;
+                    break;
+                }
         }
+        // Advance the tips store cursor only after the anchor update / prune rollback above succeeds. If that work
+        // throws, the cursor stays put and the stream re-emits this event on the next sync pass (at-least-once),
+        // matching the prover-node's handle-first/tips-last ordering. The SerialQueue makes this reorder safe.
+        await this.l2TipsStore.handleBlockStreamEvent(event);
+    }
+    /** Updates the anchor block header to the target block */ async updateAnchorBlockHeader(blockHeader) {
+        // Whenever the anchor block header is updated, we need to synchronize the private state of contracts again.
+        // Therefore, we clear the contract synchronization cache here such that the sync is re-triggered upon new
+        // execution.
+        this.contractSyncService.wipe();
+        // The contract class service keeps a per-block cache - since updating our anchor means it is very unlikely we'd
+        // ever re-simulate at past anchors, we wipe its cache to prevent runaway memory growth on very long-lived PXE
+        // instances.
+        this.contractClassService.wipe();
+        this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
+        await this.anchorBlockStore.setHeader(blockHeader);
     }
     /**
    * Syncs PXE and the node by downloading the metadata of the latest blocks, allowing simulations to use
@@ -83,6 +178,8 @@ import { L2BlockHash, L2BlockStream } from '@aztec/stdlib/block';
             return;
         }
         this.log.debug(`Syncing PXE with the node`);
+        // Capture the promise locally so we always await the exact promise we created, even if this.isSyncing is modified
+        // between assignment and await (e.g. due to future refactors introducing a yield point).
         const isSyncing = this.doSync();
         this.isSyncing = isSyncing;
         try {
@@ -91,6 +188,11 @@ import { L2BlockHash, L2BlockStream } from '@aztec/stdlib/block';
             this.isSyncing = undefined;
         }
     }
+    /** Stops the block synchronizer, waiting for any in-progress sync and queued events to complete. */ async stop() {
+        await this.isSyncing;
+        await this.blockStream.stop();
+        await this.eventQueue.end();
+    }
     async doSync() {
         let currentHeader;
         try {
@@ -100,7 +202,7 @@ import { L2BlockHash, L2BlockStream } from '@aztec/stdlib/block';
         }
         if (!currentHeader) {
             // REFACTOR: We should know the header of the genesis block without having to request it from the node.
-            await this.anchorBlockStore.setHeader(await this.node.getBlockHeader(BlockNumber.ZERO));
+            await this.anchorBlockStore.setHeader((await this.node.getBlockData(BlockNumber.ZERO)).header);
         }
         await this.blockStream.sync();
     }

package/dest/config/index.d.ts

@@ -1,7 +1,8 @@
 import { type ConfigMappingsType } from '@aztec/foundation/config';
-import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { type ChainConfig } from '@aztec/stdlib/config';
+import { type DataStoreConfig } from '@aztec/stdlib/kv-store';
 export { getPackageInfo } from './package_info.js';
+export * from '../hooks/index.js';
 /**
  * Configuration settings for the prover factory
  */
@@ -15,6 +16,14 @@ export interface KernelProverConfig {
 export interface BlockSynchronizerConfig {
     /** Maximum amount of blocks to pull from the stream in one request when synchronizing */
     l2BlockBatchSize: number;
+    /** Which chain tip to sync to (proposed, checkpointed, proven, finalized) */
+    syncChainTip?: 'proposed' | 'checkpointed' | 'proven' | 'finalized';
+    /**
+     * Whether PXE should automatically sync with the node before each operation (simulate, prove, profile,
+     * execute utility, get private events, update contract). When disabled, callers (e.g. wallets) are
+     * responsible for calling `pxe.sync()` explicitly
+     */
+    autoSync: boolean;
 }
 export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & BlockSynchronizerConfig;
 export type CliPXEOptions = {
@@ -32,4 +41,4 @@ export declare const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PX
  * Creates an instance of CliPxeOptions out of environment variables
  */
 export declare function getCliPXEOptions(): CliPXEOptions & PXEConfig;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBS3hCLE1BQU0sMEJBQTBCLENBQUM7QUFDbEMsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFzQixNQUFNLHdCQUF3QixDQUFDO0FBQ2xGLE9BQU8sRUFBRSxLQUFLLFdBQVcsRUFBdUIsTUFBTSxzQkFBc0IsQ0FBQztBQUU3RSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbkQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLDhDQUE4QztJQUM5QyxhQUFhLENBQUMsRUFBRSxPQUFPLENBQUM7Q0FDekI7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyx1QkFBdUI7SUFDdEMseUZBQXlGO0lBQ3pGLGdCQUFnQixFQUFFLE1BQU0sQ0FBQztDQUMxQjtBQUVELE1BQU0sTUFBTSxTQUFTLEdBQUcsa0JBQWtCLEdBQUcsZUFBZSxHQUFHLFdBQVcsR0FBRyx1QkFBdUIsQ0FBQztBQUVyRyxNQUFNLE1BQU0sYUFBYSxHQUFHO0lBQzFCLDJDQUEyQztJQUMzQyxPQUFPLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDbEIsQ0FBQztBQUVGLGVBQU8sTUFBTSxpQkFBaUIsRUFBRSxrQkFBa0IsQ0FBQyxTQUFTLENBb0IzRCxDQUFDO0FBRUY7O0dBRUc7QUFDSCx3QkFBZ0IsWUFBWSxJQUFJLFNBQVMsQ0FFeEM7QUFFRCxlQUFPLE1BQU0sb0JBQW9CLEVBQUUsa0JBQWtCLENBQUMsYUFBYSxDQUtsRSxDQUFDO0FBRUYsZUFBTyxNQUFNLG9CQUFvQixFQUFFLGtCQUFrQixDQUFDLGFBQWEsR0FBRyxTQUFTLENBVzlFLENBQUM7QUFFRjs7R0FFRztBQUNILHdCQUFnQixnQkFBZ0IsSUFBSSxhQUFhLEdBQUcsU0FBUyxDQVE1RCJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBTXhCLE1BQU0sMEJBQTBCLENBQUM7QUFDbEMsT0FBTyxFQUFFLEtBQUssV0FBVyxFQUF1QixNQUFNLHNCQUFzQixDQUFDO0FBQzdFLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx3QkFBd0IsQ0FBQztBQUVsRixPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDbkQsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQzs7R0FFRztBQUNILE1BQU0sV0FBVyxrQkFBa0I7SUFDakMsOENBQThDO0lBQzlDLGFBQWEsQ0FBQyxFQUFFLE9BQU8sQ0FBQztDQUN6QjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxXQUFXLHVCQUF1QjtJQUN0Qyx5RkFBeUY7SUFDekYsZ0JBQWdCLEVBQUUsTUFBTSxDQUFDO0lBQ3pCLDZFQUE2RTtJQUM3RSxZQUFZLENBQUMsRUFBRSxVQUFVLEdBQUcsY0FBYyxHQUFHLFFBQVEsR0FBRyxXQUFXLENBQUM7SUFDcEU7Ozs7T0FJRztJQUNILFFBQVEsRUFBRSxPQUFPLENBQUM7Q0FDbkI7QUFFRCxNQUFNLE1BQU0sU0FBUyxHQUFHLGtCQUFrQixHQUFHLGVBQWUsR0FBRyxXQUFXLEdBQUcsdUJBQXVCLENBQUM7QUFFckcsTUFBTSxNQUFNLGFBQWEsR0FBRztJQUMxQiwyQ0FBMkM7SUFDM0MsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2xCLENBQUM7QUFFRixlQUFPLE1BQU0saUJBQWlCLEVBQUUsa0JBQWtCLENBQUMsU0FBUyxDQStCM0QsQ0FBQztBQUVGOztHQUVHO0FBQ0gsd0JBQWdCLFlBQVksSUFBSSxTQUFTLENBRXhDO0FBRUQsZUFBTyxNQUFNLG9CQUFvQixFQUFFLGtCQUFrQixDQUFDLGFBQWEsQ0FLbEUsQ0FBQztBQUVGLGVBQU8sTUFBTSxvQkFBb0IsRUFBRSxrQkFBa0IsQ0FBQyxhQUFhLEdBQUcsU0FBUyxDQVc5RSxDQUFDO0FBRUY7O0dBRUc7QUFDSCx3QkFBZ0IsZ0JBQWdCLElBQUksYUFBYSxHQUFHLFNBQVMsQ0FRNUQifQ==

package/dest/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,yFAAyF;IACzF,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,SAAS,GAAG,kBAAkB,GAAG,eAAe,GAAG,WAAW,GAAG,uBAAuB,CAAC;AAErG,MAAM,MAAM,aAAa,GAAG;IAC1B,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,SAAS,CAoB3D,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAED,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,CAKlE,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,GAAG,SAAS,CAW9E,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,SAAS,CAQ5D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAMxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAElF,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,cAAc,mBAAmB,CAAC;AAElC;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,yFAAyF;IACzF,gBAAgB,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,UAAU,GAAG,cAAc,GAAG,QAAQ,GAAG,WAAW,CAAC;IACpE;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,SAAS,GAAG,kBAAkB,GAAG,eAAe,GAAG,WAAW,GAAG,uBAAuB,CAAC;AAErG,MAAM,MAAM,aAAa,GAAG;IAC1B,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,SAAS,CA+B3D,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAED,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,CAKlE,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,aAAa,GAAG,SAAS,CAW9E,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,SAAS,CAQ5D"}

package/dest/config/index.js

@@ -1,7 +1,8 @@
-import { booleanConfigHelper, getConfigFromMappings, numberConfigHelper, parseBooleanEnv } from '@aztec/foundation/config';
-import { dataConfigMappings } from '@aztec/kv-store/config';
+import { booleanConfigHelper, enumConfigHelper, getConfigFromMappings, numberConfigHelper, parseBooleanEnv } from '@aztec/foundation/config';
 import { chainConfigMappings } from '@aztec/stdlib/config';
+import { dataConfigMappings } from '@aztec/stdlib/kv-store';
 export { getPackageInfo } from './package_info.js';
+export * from '../hooks/index.js';
 export const pxeConfigMappings = {
     ...dataConfigMappings,
     ...chainConfigMappings,
@@ -21,6 +22,21 @@ export const pxeConfigMappings = {
         env: 'PXE_PROVER_ENABLED',
         description: 'Enable real proofs',
         ...booleanConfigHelper(true)
+    },
+    syncChainTip: {
+        env: 'PXE_SYNC_CHAIN_TIP',
+        description: 'Which chain tip to sync to (proposed, checkpointed, proven, finalized)',
+        ...enumConfigHelper([
+            'proposed',
+            'checkpointed',
+            'proven',
+            'finalized'
+        ], 'proposed')
+    },
+    autoSync: {
+        env: 'PXE_AUTO_SYNC',
+        description: 'Whether PXE syncs with the node automatically before each operation. Disable to let the caller (e.g. a wallet) drive syncs explicitly via pxe.sync().',
+        ...booleanConfigHelper(true)
     }
 };
 /**

package/dest/config/package_info.js

@@ -1,6 +1,6 @@
 export function getPackageInfo() {
     return {
-        version: '4.0.0',
+        version: '6.0.0',
         name: '@aztec/pxe'
     };
 }

package/dest/contract/contract_class_service.d.ts

@@ -0,0 +1,31 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+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 { ContractStore } from '../storage/contract_store/contract_store.js';
+/**
+ * Resolves the contract class id that an address runs at a given anchor block, as tracked by the chain.
+ *
+ * PXE does not store a contract's current class id: it is mutable, chain-derived state that changes when a contract is
+ * upgraded and can be undone by a reorg. Instead this service asks the node for the current class at an anchor block,
+ * falling back to a local instance if no upgrades were scheduled.
+ */
+export declare class ContractClassService {
+    #private;
+    private node;
+    private contractStore;
+    constructor(node: AztecNode, contractStore: ContractStore);
+    /**
+     * Returns the class id that corresponds to `address` as of `anchorBlockHeader`, or `undefined` if no instance is
+     * registered for `address`. A missing instance is an absence the caller decides how to handle, not an error; genuine
+     * failures (e.g. the node being unreachable) still throw.
+     */
+    getCurrentClassId(address: AztecAddress, anchorBlockHeader: BlockHeader): Promise<Fr | undefined>;
+    /**
+     * Clears the cache.
+     *
+     * This is not required for correctness, only to limit how much memory the cache uses. The cache is resilient against
+     * reorgs etc. as it is based on block hashes, not block numbers. */
+    wipe(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfY2xhc3Nfc2VydmljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2NvbnRyYWN0X2NsYXNzX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFekQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFFakY7Ozs7OztHQU1HO0FBQ0gscUJBQWEsb0JBQW9COztJQVU3QixPQUFPLENBQUMsSUFBSTtJQUNaLE9BQU8sQ0FBQyxhQUFhO0lBRnZCLFlBQ1UsSUFBSSxFQUFFLFNBQVMsRUFDZixhQUFhLEVBQUUsYUFBYSxFQUNsQztJQUVKOzs7O09BSUc7SUFDRyxpQkFBaUIsQ0FBQyxPQUFPLEVBQUUsWUFBWSxFQUFFLGlCQUFpQixFQUFFLFdBQVcsR0FBRyxPQUFPLENBQUMsRUFBRSxHQUFHLFNBQVMsQ0FBQyxDQXNDdEc7SUFFRDs7Ozt3RUFJb0U7SUFDcEUsSUFBSSxJQUFJLElBQUksQ0FFWDtDQUNGIn0=

package/dest/contract/contract_class_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_class_service.d.ts","sourceRoot":"","sources":["../../src/contract/contract_class_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,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,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAEjF;;;;;;GAMG;AACH,qBAAa,oBAAoB;;IAU7B,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,aAAa;IAFvB,YACU,IAAI,EAAE,SAAS,EACf,aAAa,EAAE,aAAa,EAClC;IAEJ;;;;OAIG;IACG,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAsCtG;IAED;;;;wEAIoE;IACpE,IAAI,IAAI,IAAI,CAEX;CACF"}

package/dest/contract/contract_class_service.js

@@ -0,0 +1,68 @@
+import { isProtocolContract } from '@aztec/protocol-contracts';
+/**
+ * Resolves the contract class id that an address runs at a given anchor block, as tracked by the chain.
+ *
+ * PXE does not store a contract's current class id: it is mutable, chain-derived state that changes when a contract is
+ * upgraded and can be undone by a reorg. Instead this service asks the node for the current class at an anchor block,
+ * falling back to a local instance if no upgrades were scheduled.
+ */ export class ContractClassService {
+    node;
+    contractStore;
+    /**
+   * Class ids are cached per `(address, anchorHash)`. This avoid unnecessary network roundtrips in scenarios where
+   * multiple executions are done on the same anchor block (e.g. simulation followed by witgen), or when the same
+   * contract is invoked multiple times in an execution (e.g. authwit checks).
+   * It also means the callers don't need to worry about caching this service's return values, simplifying callsites.
+   */ #cache;
+    constructor(node, contractStore){
+        this.node = node;
+        this.contractStore = contractStore;
+        this.#cache = new Map();
+    }
+    /**
+   * Returns the class id that corresponds to `address` as of `anchorBlockHeader`, or `undefined` if no instance is
+   * registered for `address`. A missing instance is an absence the caller decides how to handle, not an error; genuine
+   * failures (e.g. the node being unreachable) still throw.
+   */ async getCurrentClassId(address, anchorBlockHeader) {
+        // Protocol contracts are not in the registry and cannot be upgraded, so their original class is always current.
+        // Short-circuiting avoids a node round-trip.
+        if (isProtocolContract(address)) {
+            const instance = await this.contractStore.getContractInstance(address);
+            return instance?.originalContractClassId;
+        }
+        const key = `${address.toString()}:${(await anchorBlockHeader.hash()).toString()}`;
+        let promise = this.#cache.get(key);
+        if (!promise) {
+            promise = (async ()=>{
+                // The node resolves the current class from the same scheduled value change the AVM enforces against the public
+                // data tree. If the contract was upgraded the node returns a non-undefined instance; an undefined result means
+                // no upgrade happened (or the node has no record of it, e.g. it was never publicly deployed), so the original
+                // class is current.
+                const nodeInstance = await this.node.getContract(address, await anchorBlockHeader.hash());
+                if (nodeInstance) {
+                    return nodeInstance.currentContractClassId;
+                } else {
+                    return (await this.contractStore.getContractInstance(address))?.originalContractClassId;
+                }
+            })().catch((err)=>{
+                this.#cache.delete(key);
+                throw err;
+            });
+            this.#cache.set(key, promise);
+        }
+        const classId = await promise;
+        if (classId === undefined) {
+            // Don't memoize a missing instance: it may be registered later in this PXE (e.g. via contract sync
+            // mid-execution), and a cached miss would then hide it. Only successful resolutions stay cached.
+            this.#cache.delete(key);
+        }
+        return classId;
+    }
+    /**
+   * Clears the cache.
+   *
+   * This is not required for correctness, only to limit how much memory the cache uses. The cache is resilient against
+   * reorgs etc. as it is based on block hashes, not block numbers. */ wipe() {
+        this.#cache.clear();
+    }
+}

package/dest/contract/contract_sync_service.d.ts

@@ -0,0 +1,48 @@
+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 { 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';
+import type { ContractClassService } from './contract_class_service.js';
+/**
+ * Maximum number of scope syncs running concurrently within a single sync call. Sized to trade off parallelism
+ * on non-ACIR work (node RPC, note store reads) against memory pressure from concurrent circuit execution.
+ */
+export declare const MAX_CONCURRENT_SCOPE_SYNCS = 5;
+/**
+ * Service for syncing the private state of contracts. 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 contractClassService;
+    private noteStore;
+    private log;
+    readonly storeName = "contract_sync";
+    private syncedContracts;
+    constructor(aztecNode: AztecNode, contractStore: ContractStore, contractClassService: ContractClassService, noteStore: NoteStore, log: Logger);
+    /**
+     * Ensures a contract's private state is synchronized.
+     * 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: AztecAddress[]) => Promise<any>, anchorBlockHeader: BlockHeader, jobId: string, scopes: AztecAddress[]): Promise<void>;
+    /** Clears sync cache entries for the given scopes of a contract. */
+    invalidateContractForScopes(contractAddress: AztecAddress, scopes: AztecAddress[]): 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3Rfc3luY19zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3QvY29udHJhY3Rfc3luY19zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBR3BELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3hFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBRXpFLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFHeEU7OztHQUdHO0FBQ0gsZUFBTyxNQUFNLDBCQUEwQixJQUFJLENBQUM7QUFFNUM7Ozs7O0dBS0c7QUFDSCxxQkFBYSxtQkFBb0IsWUFBVyxXQUFXOztJQVNuRCxPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsYUFBYTtJQUNyQixPQUFPLENBQUMsb0JBQW9CO0lBQzVCLE9BQU8sQ0FBQyxTQUFTO0lBQ2pCLE9BQU8sQ0FBQyxHQUFHO0lBWmIsUUFBUSxDQUFDLFNBQVMsbUJBQW1CO0lBS3JDLE9BQU8sQ0FBQyxlQUFlLENBQXlDO0lBRWhFLFlBQ1UsU0FBUyxFQUFFLFNBQVMsRUFDcEIsYUFBYSxFQUFFLGFBQWEsRUFDNUIsb0JBQW9CLEVBQUUsb0JBQW9CLEVBQzFDLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLEdBQUcsRUFBRSxNQUFNLEVBQ2pCO0lBRUo7Ozs7Ozs7O09BUUc7SUFDRyxvQkFBb0IsQ0FDeEIsZUFBZSxFQUFFLFlBQVksRUFDN0IseUJBQXlCLEVBQUUsZ0JBQWdCLEdBQUcsSUFBSSxFQUNsRCxlQUFlLEVBQUUsQ0FBQyxJQUFJLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxZQUFZLEVBQUUsS0FBSyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQzdFLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsS0FBSyxFQUFFLE1BQU0sRUFDYixNQUFNLEVBQUUsWUFBWSxFQUFFLEdBQ3JCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FjZjtJQUVELG9FQUFvRTtJQUNwRSwyQkFBMkIsQ0FBQyxlQUFlLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxZQUFZLEVBQUUsR0FBRyxJQUFJLENBS3ZGO0lBRUQsZ0ZBQWdGO0lBQ2hGLElBQUksSUFBSSxJQUFJLENBR1g7SUFFRCxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRXBDO0lBRUQsYUFBYSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUszQztDQStERiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_sync_service.d.ts","sourceRoot":"","sources":["../../src/contract/contract_sync_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,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,WAAW,EAAE,MAAM,uCAAuC,CAAC;AAEzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAGxE;;;GAGG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,WAAW;;IASnD,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAZb,QAAQ,CAAC,SAAS,mBAAmB;IAKrC,OAAO,CAAC,eAAe,CAAyC;IAEhE,YACU,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,aAAa,EAC5B,oBAAoB,EAAE,oBAAoB,EAC1C,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACjB;IAEJ;;;;;;;;OAQG;IACG,oBAAoB,CACxB,eAAe,EAAE,YAAY,EAC7B,yBAAyB,EAAE,gBAAgB,GAAG,IAAI,EAClD,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EAC7E,iBAAiB,EAAE,WAAW,EAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,YAAY,EAAE,GACrB,OAAO,CAAC,IAAI,CAAC,CAcf;IAED,oEAAoE;IACpE,2BAA2B,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,CAKvF;IAED,gFAAgF;IAChF,IAAI,IAAI,IAAI,CAGX;IAED,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpC;IAED,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAK3C;CA+DF"}

package/dest/contract/contract_sync_service.js

@@ -0,0 +1,116 @@
+import { Semaphore } from '@aztec/foundation/queue';
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import { NoteService } from '../notes/note_service.js';
+import { syncScope } from './helpers.js';
+/**
+ * Maximum number of scope syncs running concurrently within a single sync call. Sized to trade off parallelism
+ * on non-ACIR work (node RPC, note store reads) against memory pressure from concurrent circuit execution.
+ */ export const MAX_CONCURRENT_SCOPE_SYNCS = 5;
+/**
+ * Service for syncing the private state of contracts. 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;
+    contractClassService;
+    noteStore;
+    log;
+    storeName;
+    // Tracks contracts synced since last wipe. The cache is keyed per individual scope address
+    // (`contractAddress:scopeAddress`), or `contractAddress:*` for all scopes (all accounts).
+    // The value is a promise that resolves when the contract is synced.
+    syncedContracts;
+    constructor(aztecNode, contractStore, contractClassService, noteStore, log){
+        this.aztecNode = aztecNode;
+        this.contractStore = contractStore;
+        this.contractClassService = contractClassService;
+        this.noteStore = noteStore;
+        this.log = log;
+        this.storeName = 'contract_sync';
+        this.syncedContracts = new Map();
+    }
+    /**
+   * Ensures a contract's private state is synchronized.
+   * 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) {
+        this.#startSyncIfNeeded(contractAddress, scopes, anchorBlockHeader, jobId, (scope)=>syncScope(contractAddress, this.contractStore, this.contractClassService, anchorBlockHeader, functionToInvokeAfterSync, utilityExecutor, scope));
+        await this.#awaitSync(contractAddress, scopes);
+    }
+    /** Clears sync cache entries for the given scopes of a contract. */ invalidateContractForScopes(contractAddress, scopes) {
+        if (scopes.length === 0) {
+            return;
+        }
+        scopes.forEach((scope)=>this.syncedContracts.delete(toKey(contractAddress, scope)));
+    }
+    /** 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) {
+        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();
+        return Promise.resolve();
+    }
+    /**
+   * For each unsynced scope, creates a promise that waits on:
+   *  1. Note nullifier sync (shared, batched across all unsynced scopes).
+   *  2. Per-scope sync (individual, semaphore-bounded).
+   */ #startSyncIfNeeded(contractAddress, scopes, anchorBlockHeader, jobId, syncScopeFn) {
+        const scopesToSync = scopes.filter((scope)=>!this.syncedContracts.has(toKey(contractAddress, scope)));
+        if (scopesToSync.length === 0) {
+            return;
+        }
+        this.log.debug(`Syncing contract ${contractAddress} for ${scopesToSync.length} scope(s)`);
+        const syncNullifiersPromise = this.#syncNoteNullifiers(contractAddress, anchorBlockHeader, jobId, scopesToSync);
+        // We build a new semaphore for each sync call, so it rate-limits the scopes within that single call. We do
+        // this so that if these scope syncs trigger nested syncs, the nested ones can execute without causing a deadlock.
+        const syncSlot = new Semaphore(MAX_CONCURRENT_SCOPE_SYNCS);
+        for (const scope of scopesToSync){
+            const key = toKey(contractAddress, scope);
+            const promise = Promise.all([
+                syncNullifiersPromise,
+                runBounded(syncSlot, ()=>syncScopeFn(scope))
+            ]).then(()=>{}).catch((err)=>{
+                this.syncedContracts.delete(key);
+                throw err;
+            });
+            this.syncedContracts.set(key, promise);
+        }
+    }
+    /** Syncs note nullifiers across all unsynced scopes in a single batched call. */ async #syncNoteNullifiers(contractAddress, anchorBlockHeader, jobId, scopes) {
+        // Protocol contracts don't have private state to sync
+        if (isProtocolContract(contractAddress)) {
+            return;
+        }
+        // This runs in parallel with per-scope sync (which also writes to the note store). That's safe because
+        // the note store handles concurrent operations.
+        const noteService = new NoteService(this.noteStore, this.aztecNode, anchorBlockHeader, jobId);
+        await noteService.syncNoteNullifiers(contractAddress, scopes);
+    }
+    /** Collects all relevant scope promises (including in-flight ones from concurrent calls) and awaits them. */ async #awaitSync(contractAddress, scopes) {
+        const promises = scopes.map((scope)=>this.syncedContracts.get(toKey(contractAddress, scope))).filter((p)=>p !== undefined);
+        await Promise.all(promises);
+    }
+}
+function toKey(contract, scope) {
+    return `${contract.toString()}:${scope.toString()}`;
+}
+/** Runs fn while holding a slot in the given semaphore, bounding concurrent scope syncs within a single call. */ async function runBounded(syncSlot, fn) {
+    await syncSlot.acquire();
+    try {
+        return await fn();
+    } finally{
+        syncSlot.release();
+    }
+}

package/dest/contract/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { ContractClassService } from './contract_class_service.js';
+export declare function syncScope(contractAddress: AztecAddress, contractStore: ContractStore, contractClassService: ContractClassService, anchorBlockHeader: BlockHeader, functionToInvokeAfterSync: FunctionSelector | null, utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>, scope: AztecAddress): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2hlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFDakYsT0FBTyxLQUFLLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUd4RSx3QkFBc0IsU0FBUyxDQUM3QixlQUFlLEVBQUUsWUFBWSxFQUM3QixhQUFhLEVBQUUsYUFBYSxFQUM1QixvQkFBb0IsRUFBRSxvQkFBb0IsRUFDMUMsaUJBQWlCLEVBQUUsV0FBVyxFQUM5Qix5QkFBeUIsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLEVBQ2xELGVBQWUsRUFBRSxDQUFDLGVBQWUsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxLQUFLLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFDeEYsS0FBSyxFQUFFLFlBQVksaUJBbUJwQiJ9

package/dest/contract/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/contract/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAGxE,wBAAsB,SAAS,CAC7B,eAAe,EAAE,YAAY,EAC7B,aAAa,EAAE,aAAa,EAC5B,oBAAoB,EAAE,oBAAoB,EAC1C,iBAAiB,EAAE,WAAW,EAC9B,yBAAyB,EAAE,gBAAgB,GAAG,IAAI,EAClD,eAAe,EAAE,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EACxF,KAAK,EAAE,YAAY,iBAmBpB"}

package/dest/contract/helpers.js

@@ -0,0 +1,20 @@
+import { isSkipSyncContract } from './skip_sync_contracts.js';
+export async function syncScope(contractAddress, contractStore, contractClassService, anchorBlockHeader, functionToInvokeAfterSync, utilityExecutor, scope) {
+    // Some canonical contracts hold no private state, so there is nothing to sync (see `skipSyncContracts`).
+    if (isSkipSyncContract(contractAddress)) {
+        return;
+    }
+    const classId = await contractClassService.getCurrentClassId(contractAddress, anchorBlockHeader);
+    if (!classId) {
+        throw new Error(`Cannot sync contract ${contractAddress}: its instance is not registered nor published.`);
+    }
+    const syncStateFunctionCall = await contractStore.getFunctionCall('sync_state', [
+        scope
+    ], contractAddress, classId);
+    if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncStateFunctionCall.selector)) {
+        throw new Error('Forbidden `sync_state` invocation. `sync_state` can only be invoked by PXE, manual execution can lead to inconsistencies.');
+    }
+    await utilityExecutor(syncStateFunctionCall, [
+        scope
+    ]);
+}

package/dest/contract/skip_sync_contracts.d.ts

@@ -0,0 +1,11 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * Canonical contracts that hold no private state and are therefore never synced.
+ *
+ * The protocol contracts (registries, fee juice) plus the standard AuthRegistry, MultiCallEntrypoint and PublicChecks
+ * declare no notes and no events, so their macro-generated `sync_state` has nothing to discover.
+ */
+export declare const skipSyncContracts: AztecAddress[];
+/** Returns whether the given contract should be skipped during private state synchronization. */
+export declare function isSkipSyncContract(address: AztecAddress): boolean;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2tpcF9zeW5jX2NvbnRyYWN0cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L3NraXBfc3luY19jb250cmFjdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFaEU7Ozs7O0dBS0c7QUFDSCxlQUFPLE1BQU0saUJBQWlCLEVBQUUsWUFBWSxFQUszQyxDQUFDO0FBRUYsaUdBQWlHO0FBQ2pHLHdCQUFnQixrQkFBa0IsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FFakUifQ==