@aztec/pxe 5.0.0-rc.2 → 5.0.1

package/dest/block_synchronizer/block_synchronizer.d.ts

@@ -4,7 +4,8 @@ import type { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { BlockSynchronizerConfig } from '../config/index.js';
-import type { ContractSyncService } from '../contract_sync/contract_sync_service.js';
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractSyncService } from '../contract/contract_sync_service.js';
 import type { AnchorBlockStore } from '../storage/anchor_block_store/index.js';
 import type { FactStore } from '../storage/fact_store/fact_store.js';
 import type { NoteStore } from '../storage/note_store/index.js';
@@ -23,12 +24,13 @@ export declare class BlockSynchronizer implements L2BlockStreamEventHandler {
     private readonly factStore;
     private readonly l2TipsStore;
     private readonly contractSyncService;
+    private readonly contractClassService;
     private readonly config;
     private log;
     private isSyncing;
     private readonly eventQueue;
     protected readonly blockStream: L2BlockStream;
-    constructor(node: AztecNode, store: AztecAsyncKVStore, anchorBlockStore: AnchorBlockStore, noteStore: NoteStore, privateEventStore: PrivateEventStore, factStore: FactStore, l2TipsStore: L2TipsKVStore, contractSyncService: ContractSyncService, config?: Partial<BlockSynchronizerConfig>, bindings?: LoggerBindings);
+    constructor(node: AztecNode, store: AztecAsyncKVStore, anchorBlockStore: AnchorBlockStore, noteStore: NoteStore, privateEventStore: PrivateEventStore, factStore: FactStore, l2TipsStore: L2TipsKVStore, contractSyncService: ContractSyncService, contractClassService: ContractClassService, config?: Partial<BlockSynchronizerConfig>, bindings?: LoggerBindings);
     protected createBlockStream(): L2BlockStream;
     /** Handle events emitted by the block stream. Serialized to prevent concurrent mutations to anchor state. */
     handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
@@ -48,4 +50,4 @@ export declare class BlockSynchronizer implements L2BlockStreamEventHandler {
     stop(): Promise<void>;
     private doSync;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/block_synchronizer/block_synchronizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_synchronizer.d.ts","sourceRoot":"","sources":["../../src/block_synchronizer/block_synchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAa,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACxH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAGjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uDAAuD,CAAC;AAG/F;;;;GAIG;AACH,qBAAa,iBAAkB,YAAW,yBAAyB;IAO/D,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAdzB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;IAE9C,YACmB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,iBAAiB,EACxB,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,iBAAiB,EACpC,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,aAAa,EAC1B,mBAAmB,EAAE,mBAAmB,EACxC,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM,EAC9D,QAAQ,CAAC,EAAE,cAAc,EAK1B;IAED,SAAS,CAAC,iBAAiB,IAAI,aAAa,CAY3C;IAED,6GAA6G;IACtG,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtE;YAEa,wBAAwB;YA8GxB,uBAAuB;IASrC;;;;;;;;OAQG;IACU,IAAI,kBAiBhB;IAED,oGAAoG;IACvF,IAAI,kBAIhB;YAEa,MAAM;CAcrB"}
+{"version":3,"file":"block_synchronizer.d.ts","sourceRoot":"","sources":["../../src/block_synchronizer/block_synchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAa,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACxH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAGjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uDAAuD,CAAC;AAG/F;;;;GAIG;AACH,qBAAa,iBAAkB,YAAW,yBAAyB;IAO/D,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAfzB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;IAE9C,YACmB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,iBAAiB,EACxB,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,iBAAiB,EACpC,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,aAAa,EAC1B,mBAAmB,EAAE,mBAAmB,EACxC,oBAAoB,EAAE,oBAAoB,EAC1C,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM,EAC9D,QAAQ,CAAC,EAAE,cAAc,EAK1B;IAED,SAAS,CAAC,iBAAiB,IAAI,aAAa,CAY3C;IAED,6GAA6G;IACtG,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtE;YAEa,wBAAwB;YA8GxB,uBAAuB;IAerC;;;;;;;;OAQG;IACU,IAAI,kBAiBhB;IAED,oGAAoG;IACvF,IAAI,kBAIhB;YAEa,MAAM;CAcrB"}

package/dest/block_synchronizer/block_synchronizer.js

@@ -16,12 +16,13 @@ import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
     factStore;
     l2TipsStore;
     contractSyncService;
+    contractClassService;
     config;
     log;
     isSyncing;
     eventQueue;
     blockStream;
-    constructor(node, store, anchorBlockStore, noteStore, privateEventStore, factStore, l2TipsStore, contractSyncService, config = {}, bindings){
+    constructor(node, store, anchorBlockStore, noteStore, privateEventStore, factStore, l2TipsStore, contractSyncService, contractClassService, config = {}, bindings){
         this.node = node;
         this.store = store;
         this.anchorBlockStore = anchorBlockStore;
@@ -30,6 +31,7 @@ import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
         this.factStore = factStore;
         this.l2TipsStore = l2TipsStore;
         this.contractSyncService = contractSyncService;
+        this.contractClassService = contractClassService;
         this.config = config;
         this.eventQueue = new SerialQueue();
         this.log = createLogger('pxe:block_synchronizer', bindings);
@@ -154,6 +156,10 @@ import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
         // 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);
     }

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_sync → contract}/contract_sync_service.d.ts

@@ -6,14 +6,15 @@ 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 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.
+ * 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.
  */
@@ -21,14 +22,14 @@ export declare class ContractSyncService implements StagedStore {
     #private;
     private aztecNode;
     private contractStore;
+    private contractClassService;
     private noteStore;
     private log;
     readonly storeName = "contract_sync";
     private syncedContracts;
-    private classIdVerificationCache;
-    constructor(aztecNode: AztecNode, contractStore: ContractStore, noteStore: NoteStore, log: Logger);
+    constructor(aztecNode: AztecNode, contractStore: ContractStore, contractClassService: ContractClassService, noteStore: NoteStore, log: Logger);
     /**
-     * Ensures a contract's private state is synchronized and that the PXE holds the current class artifact.
+     * 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
@@ -44,4 +45,4 @@ export declare class ContractSyncService implements StagedStore {
     commit(_jobId: string): Promise<void>;
     discardStaged(_jobId: string): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3Rfc3luY19zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3Rfc3luYy9jb250cmFjdF9zeW5jX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHcEQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFFekUsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFDakYsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFHckU7OztHQUdHO0FBQ0gsZUFBTyxNQUFNLDBCQUEwQixJQUFJLENBQUM7QUFFNUM7Ozs7O0dBS0c7QUFDSCxxQkFBYSxtQkFBb0IsWUFBVyxXQUFXOztJQWFuRCxPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsYUFBYTtJQUNyQixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsR0FBRztJQWZiLFFBQVEsQ0FBQyxTQUFTLG1CQUFtQjtJQUtyQyxPQUFPLENBQUMsZUFBZSxDQUF5QztJQUloRSxPQUFPLENBQUMsd0JBQXdCLENBQXlDO0lBRXpFLFlBQ1UsU0FBUyxFQUFFLFNBQVMsRUFDcEIsYUFBYSxFQUFFLGFBQWEsRUFDNUIsU0FBUyxFQUFFLFNBQVMsRUFDcEIsR0FBRyxFQUFFLE1BQU0sRUFDakI7SUFFSjs7Ozs7Ozs7T0FRRztJQUNHLG9CQUFvQixDQUN4QixlQUFlLEVBQUUsWUFBWSxFQUM3Qix5QkFBeUIsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLEVBQ2xELGVBQWUsRUFBRSxDQUFDLElBQUksRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxLQUFLLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFDN0UsaUJBQWlCLEVBQUUsV0FBVyxFQUM5QixLQUFLLEVBQUUsTUFBTSxFQUNiLE1BQU0sRUFBRSxZQUFZLEVBQUUsR0FDckIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQU1mO0lBRUQsb0VBQW9FO0lBQ3BFLDJCQUEyQixDQUFDLGVBQWUsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxHQUFHLElBQUksQ0FLdkY7SUFFRCxnRkFBZ0Y7SUFDaEYsSUFBSSxJQUFJLElBQUksQ0FJWDtJQUVELE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFcEM7SUFFRCxhQUFhLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBTTNDO0NBc0ZGIn0=
+//# 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_sync → contract}/contract_sync_service.js

@@ -1,19 +1,20 @@
 import { Semaphore } from '@aztec/foundation/queue';
 import { isProtocolContract } from '@aztec/protocol-contracts';
 import { NoteService } from '../notes/note_service.js';
-import { syncScope, verifyCurrentClassId } from './helpers.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 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.
+ * 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;
@@ -21,20 +22,17 @@ import { syncScope, verifyCurrentClassId } from './helpers.js';
     // (`contractAddress:scopeAddress`), or `contractAddress:*` for all scopes (all accounts).
     // The value is a promise that resolves when the contract is synced.
     syncedContracts;
-    // Tracks class ID verification per contract. Keyed by contract address only (no scope), since
-    // class ID verification is scope-independent. Cleared on wipe/discard.
-    classIdVerificationCache;
-    constructor(aztecNode, contractStore, noteStore, log){
+    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();
-        this.classIdVerificationCache = new Map();
     }
     /**
-   * Ensures a contract's private state is synchronized and that the PXE holds the current class artifact.
+   * 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
@@ -42,7 +40,7 @@ import { syncScope, verifyCurrentClassId } from './helpers.js';
    * @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, functionToInvokeAfterSync, utilityExecutor, scope));
+        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) {
@@ -54,7 +52,6 @@ import { syncScope, verifyCurrentClassId } from './helpers.js';
     /** 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();
-        this.classIdVerificationCache.clear();
     }
     commit(_jobId) {
         return Promise.resolve();
@@ -63,21 +60,18 @@ import { syncScope, verifyCurrentClassId } from './helpers.js';
         // 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.classIdVerificationCache.clear();
         return Promise.resolve();
     }
     /**
    * For each unsynced scope, creates a promise that waits on:
-   *  1. Class ID verification (cached per contract, scope-independent).
-   *  2. Note nullifier sync (shared, batched across all unsynced scopes).
-   *  3. Per-scope sync (individual, semaphore-bounded).
+   *  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 verifyPromise = this.#verifyClassId(contractAddress, anchorBlockHeader);
         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.
@@ -85,7 +79,6 @@ import { syncScope, verifyCurrentClassId } from './helpers.js';
         for (const scope of scopesToSync){
             const key = toKey(contractAddress, scope);
             const promise = Promise.all([
-                verifyPromise,
                 syncNullifiersPromise,
                 runBounded(syncSlot, ()=>syncScopeFn(scope))
             ]).then(()=>{}).catch((err)=>{
@@ -95,19 +88,6 @@ import { syncScope, verifyCurrentClassId } from './helpers.js';
             this.syncedContracts.set(key, promise);
         }
     }
-    /** Verifies the local class ID matches the on-chain value (cached, evicts on failure so retries re-verify). */ #verifyClassId(contractAddress, anchorBlockHeader) {
-        const contractKey = contractAddress.toString();
-        const cached = this.classIdVerificationCache.get(contractKey);
-        if (cached) {
-            return cached;
-        }
-        const promise = verifyCurrentClassId(contractAddress, this.aztecNode, this.contractStore, anchorBlockHeader).catch((err)=>{
-            this.classIdVerificationCache.delete(contractKey);
-            throw err;
-        });
-        this.classIdVerificationCache.set(contractKey, promise);
-        return 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)) {

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2hlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFDakYsT0FBTyxLQUFLLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUV4RSx3QkFBc0IsU0FBUyxDQUM3QixlQUFlLEVBQUUsWUFBWSxFQUM3QixhQUFhLEVBQUUsYUFBYSxFQUM1QixvQkFBb0IsRUFBRSxvQkFBb0IsRUFDMUMsaUJBQWlCLEVBQUUsV0FBVyxFQUM5Qix5QkFBeUIsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLEVBQ2xELGVBQWUsRUFBRSxDQUFDLGVBQWUsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxLQUFLLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFDeEYsS0FBSyxFQUFFLFlBQVksaUJBbUJwQiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/contract/helpers.ts"],"names":[],"mappings":"AACA,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;AAExE,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 { isProtocolContract } from '@aztec/protocol-contracts';
+export async function syncScope(contractAddress, contractStore, contractClassService, anchorBlockHeader, functionToInvokeAfterSync, utilityExecutor, scope) {
+    // Protocol contracts don't have private state to sync
+    if (isProtocolContract(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_function_simulator/anchored_contract_data.d.ts

@@ -0,0 +1,36 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstancePreimageWithAddress } from '@aztec/stdlib/contract';
+import type { BlockHeader, ContractOverrides } from '@aztec/stdlib/tx';
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+/**
+ * Per-run view of contract data for a single simulation, bound to its anchor block.
+ *
+ * The {@link ContractStore} is pure class-id-keyed storage and has no notion of which class an address runs. This
+ * class bridges that gap: it resolves an address to its current class id (via the {@link ContractClassService}
+ * at the run's anchor block) and then serves artifacts from the store. It is also the single place contract
+ * overrides are applied — when an address is overridden, both its instance and its class id come from the override
+ * rather than the chain, so a simulation can execute different bytecode at that address. Overrides are only set for
+ * `simulateTx` (which skips the kernels), so the override path never reaches proving.
+ */
+export declare class AnchoredContractData {
+    private readonly store;
+    private readonly contractClassService;
+    private readonly anchorBlockHeader;
+    private readonly overrides?;
+    constructor(store: ContractStore, contractClassService: ContractClassService, anchorBlockHeader: BlockHeader, overrides?: ContractOverrides | undefined);
+    /** Returns the address preimage of the instance at `address`, from the override if any, else from storage. */
+    getContractInstance(address: AztecAddress): Promise<ContractInstancePreimageWithAddress | undefined>;
+    /**
+     * Resolves the class id `address` runs in this simulation: the override's class if overridden, else resolved against
+     * the chain at the anchor block.
+     */
+    getCurrentClassId(address: AztecAddress): Promise<Fr | undefined>;
+    getFunctionArtifact(address: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifactWithContractName | undefined>;
+    getFunctionArtifactWithDebugMetadata(address: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifactWithContractName | undefined>;
+    getDebugContractName(address: AztecAddress): Promise<string | undefined>;
+    getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5jaG9yZWRfY29udHJhY3RfZGF0YS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0X2Z1bmN0aW9uX3NpbXVsYXRvci9hbmNob3JlZF9jb250cmFjdF9kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLGdDQUFnQyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDNUYsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsbUNBQW1DLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNsRixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUV2RSxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQ2xGLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBRWpGOzs7Ozs7Ozs7R0FTRztBQUNILHFCQUFhLG9CQUFvQjtJQUU3QixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUs7SUFDdEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxvQkFBb0I7SUFDckMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUM7SUFKN0IsWUFDbUIsS0FBSyxFQUFFLGFBQWEsRUFDcEIsb0JBQW9CLEVBQUUsb0JBQW9CLEVBQzFDLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsU0FBUyxDQUFDLCtCQUFtQixFQUM1QztJQUVKLDhHQUE4RztJQUM5RyxtQkFBbUIsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxtQ0FBbUMsR0FBRyxTQUFTLENBQUMsQ0FNbkc7SUFFRDs7O09BR0c7SUFDSCxpQkFBaUIsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxFQUFFLEdBQUcsU0FBUyxDQUFDLENBTWhFO0lBRUssbUJBQW1CLENBQ3ZCLE9BQU8sRUFBRSxZQUFZLEVBQ3JCLFFBQVEsRUFBRSxnQkFBZ0IsR0FDekIsT0FBTyxDQUFDLGdDQUFnQyxHQUFHLFNBQVMsQ0FBQyxDQUd2RDtJQUVLLG9DQUFvQyxDQUN4QyxPQUFPLEVBQUUsWUFBWSxFQUNyQixRQUFRLEVBQUUsZ0JBQWdCLEdBQ3pCLE9BQU8sQ0FBQyxnQ0FBZ0MsR0FBRyxTQUFTLENBQUMsQ0FHdkQ7SUFFSyxvQkFBb0IsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRzdFO0lBRUssb0JBQW9CLENBQUMsT0FBTyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUc3RjtDQUNGIn0=

package/dest/contract_function_simulator/anchored_contract_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchored_contract_data.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/anchored_contract_data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,gCAAgC,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC5F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,wBAAwB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAEvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAEjF;;;;;;;;;GASG;AACH,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;IAJ7B,YACmB,KAAK,EAAE,aAAa,EACpB,oBAAoB,EAAE,oBAAoB,EAC1C,iBAAiB,EAAE,WAAW,EAC9B,SAAS,CAAC,+BAAmB,EAC5C;IAEJ,8GAA8G;IAC9G,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,mCAAmC,GAAG,SAAS,CAAC,CAMnG;IAED;;;OAGG;IACH,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAMhE;IAEK,mBAAmB,CACvB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,gCAAgC,GAAG,SAAS,CAAC,CAGvD;IAEK,oCAAoC,CACxC,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,gCAAgC,GAAG,SAAS,CAAC,CAGvD;IAEK,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAG7E;IAEK,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAG7F;CACF"}

package/dest/contract_function_simulator/anchored_contract_data.js

@@ -0,0 +1,54 @@
+/**
+ * Per-run view of contract data for a single simulation, bound to its anchor block.
+ *
+ * The {@link ContractStore} is pure class-id-keyed storage and has no notion of which class an address runs. This
+ * class bridges that gap: it resolves an address to its current class id (via the {@link ContractClassService}
+ * at the run's anchor block) and then serves artifacts from the store. It is also the single place contract
+ * overrides are applied — when an address is overridden, both its instance and its class id come from the override
+ * rather than the chain, so a simulation can execute different bytecode at that address. Overrides are only set for
+ * `simulateTx` (which skips the kernels), so the override path never reaches proving.
+ */ export class AnchoredContractData {
+    store;
+    contractClassService;
+    anchorBlockHeader;
+    overrides;
+    constructor(store, contractClassService, anchorBlockHeader, overrides){
+        this.store = store;
+        this.contractClassService = contractClassService;
+        this.anchorBlockHeader = anchorBlockHeader;
+        this.overrides = overrides;
+    }
+    /** Returns the address preimage of the instance at `address`, from the override if any, else from storage. */ getContractInstance(address) {
+        const override = this.overrides?.[address.toString()];
+        if (override) {
+            return Promise.resolve(override.instance);
+        }
+        return this.store.getContractInstance(address);
+    }
+    /**
+   * Resolves the class id `address` runs in this simulation: the override's class if overridden, else resolved against
+   * the chain at the anchor block.
+   */ getCurrentClassId(address) {
+        const override = this.overrides?.[address.toString()];
+        if (override) {
+            return Promise.resolve(override.instance.currentContractClassId);
+        }
+        return this.contractClassService.getCurrentClassId(address, this.anchorBlockHeader);
+    }
+    async getFunctionArtifact(address, selector) {
+        const classId = await this.getCurrentClassId(address);
+        return classId ? this.store.getFunctionArtifact(classId, selector) : undefined;
+    }
+    async getFunctionArtifactWithDebugMetadata(address, selector) {
+        const classId = await this.getCurrentClassId(address);
+        return classId ? this.store.getFunctionArtifactWithDebugMetadata(classId, selector) : undefined;
+    }
+    async getDebugContractName(address) {
+        const classId = await this.getCurrentClassId(address);
+        return classId ? this.store.getDebugContractName(classId) : undefined;
+    }
+    async getDebugFunctionName(address, selector) {
+        const classId = await this.getCurrentClassId(address);
+        return classId ? this.store.getDebugFunctionName(classId, selector) : `${address}:${selector}`;
+    }
+}

package/dest/contract_function_simulator/aztec_node_read_cache.d.ts

@@ -0,0 +1,39 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash, BlockParameter } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { TxHash } from '@aztec/stdlib/tx';
+/**
+ * Per-execution cache for immutable Aztec node reads.
+ */
+export declare class AztecNodeReadCache {
+    #private;
+    private readonly aztecNode;
+    private readonly cache;
+    constructor(aztecNode: AztecNode);
+    /** Fetches a block without reissuing the same node request. */
+    getBlock(block: BlockParameter): Promise<{
+        header: import("@aztec/stdlib/tx").BlockHeader;
+        archive: import("@aztec/stdlib/trees").AppendOnlyTreeSnapshot;
+        hash: BlockHash;
+        checkpointNumber: import("@aztec/foundation/branded-types").CheckpointNumber;
+        indexWithinCheckpoint: import("@aztec/foundation/branded-types").IndexWithinCheckpoint;
+        number: import("@aztec/foundation/branded-types").BlockNumber;
+        body?: import("@aztec/stdlib/block").Body | undefined;
+        l1?: import("@aztec/stdlib/interfaces/server").L1PublishInfo | undefined;
+        attestations?: import("@aztec/stdlib/block").CommitteeAttestation[] | undefined;
+    } | undefined>;
+    /** Fetches a transaction receipt with its effect attached. */
+    getTxReceiptWithEffect(txHash: TxHash): Promise<import("@aztec/stdlib/tx").TxReceipt<{
+        readonly includeTxEffect: true;
+    }>>;
+    /** Fetches an archive-tree witness for a block hash. */
+    getBlockHashMembershipWitness(referenceBlock: BlockParameter, blockHash: BlockHash): Promise<import("@aztec/foundation/trees").MembershipWitness<30> | undefined>;
+    /** Fetches a public-data-tree witness for a leaf slot. */
+    getPublicDataWitness(referenceBlock: BlockParameter, leafSlot: Fr): Promise<import("@aztec/stdlib/trees").PublicDataWitness | undefined>;
+    /** Fetches public storage for a single slot. */
+    getPublicStorageAt(referenceBlock: BlockParameter, contractAddress: AztecAddress, storageSlot: Fr): Promise<Fr>;
+    /** Fetches a contiguous public storage range, reusing cached reads for overlapping slots. */
+    getPublicStorageRange(referenceBlock: BlockParameter, contractAddress: AztecAddress, startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXp0ZWNfbm9kZV9yZWFkX2NhY2hlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3RfZnVuY3Rpb25fc2ltdWxhdG9yL2F6dGVjX25vZGVfcmVhZF9jYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLGNBQWMsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRS9DOztHQUVHO0FBQ0gscUJBQWEsa0JBQWtCOztJQUdqQixPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFGdEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQXVDO0lBRTdELFlBQTZCLFNBQVMsRUFBRSxTQUFTLEVBQUk7SUFFckQsK0RBQStEO0lBQ3hELFFBQVEsQ0FBQyxLQUFLLEVBQUUsY0FBYzs7Ozs7Ozs7OzttQkFFcEM7SUFFRCw4REFBOEQ7SUFDdkQsc0JBQXNCLENBQUMsTUFBTSxFQUFFLE1BQU07O1FBSTNDO0lBRUQsd0RBQXdEO0lBQ2pELDZCQUE2QixDQUFDLGNBQWMsRUFBRSxjQUFjLEVBQUUsU0FBUyxFQUFFLFNBQVMsZ0ZBS3hGO0lBRUQsMERBQTBEO0lBQ25ELG9CQUFvQixDQUFDLGNBQWMsRUFBRSxjQUFjLEVBQUUsUUFBUSxFQUFFLEVBQUUsd0VBSXZFO0lBRUQsZ0RBQWdEO0lBQ3pDLGtCQUFrQixDQUFDLGNBQWMsRUFBRSxjQUFjLEVBQUUsZUFBZSxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsRUFBRSxlQUt2RztJQUVELDZGQUE2RjtJQUN0RixxQkFBcUIsQ0FDMUIsY0FBYyxFQUFFLGNBQWMsRUFDOUIsZUFBZSxFQUFFLFlBQVksRUFDN0IsZ0JBQWdCLEVBQUUsRUFBRSxFQUNwQixnQkFBZ0IsRUFBRSxNQUFNLGlCQU96QjtDQTJCRiJ9

package/dest/contract_function_simulator/aztec_node_read_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aztec_node_read_cache.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/aztec_node_read_cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;GAEG;AACH,qBAAa,kBAAkB;;IAGjB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAFtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAE7D,YAA6B,SAAS,EAAE,SAAS,EAAI;IAErD,+DAA+D;IACxD,QAAQ,CAAC,KAAK,EAAE,cAAc;;;;;;;;;;mBAEpC;IAED,8DAA8D;IACvD,sBAAsB,CAAC,MAAM,EAAE,MAAM;;QAI3C;IAED,wDAAwD;IACjD,6BAA6B,CAAC,cAAc,EAAE,cAAc,EAAE,SAAS,EAAE,SAAS,gFAKxF;IAED,0DAA0D;IACnD,oBAAoB,CAAC,cAAc,EAAE,cAAc,EAAE,QAAQ,EAAE,EAAE,wEAIvE;IAED,gDAAgD;IACzC,kBAAkB,CAAC,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE,eAKvG;IAED,6FAA6F;IACtF,qBAAqB,CAC1B,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,YAAY,EAC7B,gBAAgB,EAAE,EAAE,EACpB,gBAAgB,EAAE,MAAM,iBAOzB;CA2BF"}

package/dest/contract_function_simulator/aztec_node_read_cache.js

@@ -0,0 +1,60 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+/**
+ * Per-execution cache for immutable Aztec node reads.
+ */ export class AztecNodeReadCache {
+    aztecNode;
+    cache;
+    constructor(aztecNode){
+        this.aztecNode = aztecNode;
+        this.cache = new Map();
+    }
+    /** Fetches a block without reissuing the same node request. */ getBlock(block) {
+        return this.#cachedRead(`block:${this.#keyPart(block)}`, ()=>this.aztecNode.getBlock(block));
+    }
+    /** Fetches a transaction receipt with its effect attached. */ getTxReceiptWithEffect(txHash) {
+        return this.#cachedRead(`tx-receipt-with-effect:${txHash.toString()}`, ()=>this.aztecNode.getTxReceipt(txHash, {
+                includeTxEffect: true
+            }));
+    }
+    /** Fetches an archive-tree witness for a block hash. */ getBlockHashMembershipWitness(referenceBlock, blockHash) {
+        return this.#cachedRead(`block-hash-membership-witness:${this.#keyPart(referenceBlock)}:${blockHash.toString()}`, ()=>this.aztecNode.getBlockHashMembershipWitness(referenceBlock, blockHash));
+    }
+    /** Fetches a public-data-tree witness for a leaf slot. */ getPublicDataWitness(referenceBlock, leafSlot) {
+        return this.#cachedRead(`public-data-witness:${this.#keyPart(referenceBlock)}:${leafSlot.toString()}`, ()=>this.aztecNode.getPublicDataWitness(referenceBlock, leafSlot));
+    }
+    /** Fetches public storage for a single slot. */ getPublicStorageAt(referenceBlock, contractAddress, storageSlot) {
+        return this.#cachedRead(`public-storage:${this.#keyPart(referenceBlock)}:${contractAddress.toString()}:${storageSlot.toString()}`, ()=>this.aztecNode.getPublicStorageAt(referenceBlock, contractAddress, storageSlot));
+    }
+    /** Fetches a contiguous public storage range, reusing cached reads for overlapping slots. */ getPublicStorageRange(referenceBlock, contractAddress, startStorageSlot, numberOfElements) {
+        const slots = Array(numberOfElements).fill(0).map((_, i)=>new Fr(startStorageSlot.value + BigInt(i)));
+        return Promise.all(slots.map((storageSlot)=>this.getPublicStorageAt(referenceBlock, contractAddress, storageSlot)));
+    }
+    #cachedRead(key, fetch) {
+        const cached = this.cache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const promise = fetch();
+        promise.catch(()=>this.cache.delete(key));
+        this.cache.set(key, promise);
+        return promise;
+    }
+    #keyPart(value) {
+        if ([
+            'string',
+            'number',
+            'bigint',
+            'boolean'
+        ].includes(typeof value)) {
+            return String(value);
+        }
+        if (value && typeof value === 'object') {
+            const toString = value.toString;
+            if (toString && toString !== Object.prototype.toString) {
+                return toString.call(value);
+            }
+            return JSON.stringify(value, (_key, nested)=>typeof nested === 'bigint' ? nested.toString() : nested);
+        }
+        return String(value);
+    }
+}