@aztec/pxe 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

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
  */
@@ -17,6 +18,12 @@ export interface BlockSynchronizerConfig {
     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 = {
@@ -34,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBS3hCLE1BQU0sMEJBQTBCLENBQUM7QUFDbEMsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFzQixNQUFNLHdCQUF3QixDQUFDO0FBQ2xGLE9BQU8sRUFBRSxLQUFLLFdBQVcsRUFBdUIsTUFBTSxzQkFBc0IsQ0FBQztBQUU3RSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbkQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLDhDQUE4QztJQUM5QyxhQUFhLENBQUMsRUFBRSxPQUFPLENBQUM7Q0FDekI7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyx1QkFBdUI7SUFDdEMseUZBQXlGO0lBQ3pGLGdCQUFnQixFQUFFLE1BQU0sQ0FBQztJQUN6Qiw2RUFBNkU7SUFDN0UsWUFBWSxDQUFDLEVBQUUsVUFBVSxHQUFHLGNBQWMsR0FBRyxRQUFRLEdBQUcsV0FBVyxDQUFDO0NBQ3JFO0FBRUQsTUFBTSxNQUFNLFNBQVMsR0FBRyxrQkFBa0IsR0FBRyxlQUFlLEdBQUcsV0FBVyxHQUFHLHVCQUF1QixDQUFDO0FBRXJHLE1BQU0sTUFBTSxhQUFhLEdBQUc7SUFDMUIsMkNBQTJDO0lBQzNDLE9BQU8sQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNsQixDQUFDO0FBRUYsZUFBTyxNQUFNLGlCQUFpQixFQUFFLGtCQUFrQixDQUFDLFNBQVMsQ0FnQzNELENBQUM7QUFFRjs7R0FFRztBQUNILHdCQUFnQixZQUFZLElBQUksU0FBUyxDQUV4QztBQUVELGVBQU8sTUFBTSxvQkFBb0IsRUFBRSxrQkFBa0IsQ0FBQyxhQUFhLENBS2xFLENBQUM7QUFFRixlQUFPLE1BQU0sb0JBQW9CLEVBQUUsa0JBQWtCLENBQUMsYUFBYSxHQUFHLFNBQVMsQ0FXOUUsQ0FBQztBQUVGOztHQUVHO0FBQ0gsd0JBQWdCLGdCQUFnQixJQUFJLGFBQWEsR0FBRyxTQUFTLENBUTVEIn0=
+//# 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;IACzB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,UAAU,GAAG,cAAc,GAAG,QAAQ,GAAG,WAAW,CAAC;CACrE;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,CAgC3D,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,
@@ -25,19 +26,17 @@ export const pxeConfigMappings = {
     syncChainTip: {
         env: 'PXE_SYNC_CHAIN_TIP',
         description: 'Which chain tip to sync to (proposed, checkpointed, proven, finalized)',
-        defaultValue: 'proposed',
-        parseEnv: (val)=>{
-            const allowedValues = [
-                'proposed',
-                'checkpointed',
-                'proven',
-                'finalized'
-            ];
-            if (allowedValues.includes(val)) {
-                return val;
-            }
-            throw new Error(`Invalid value for PXE_SYNC_CHAIN_TIP: ${val}. Allowed values are: ${allowedValues.join(', ')}`);
-        }
+        ...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: '5.2.0',
         name: '@aztec/pxe'
     };
 }

package/dest/contract/contract_class_service.d.ts

@@ -0,0 +1,24 @@
+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 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>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfY2xhc3Nfc2VydmljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2NvbnRyYWN0X2NsYXNzX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFekQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFFakY7Ozs7OztHQU1HO0FBQ0gscUJBQWEsb0JBQW9CO0lBRTdCLE9BQU8sQ0FBQyxJQUFJO0lBQ1osT0FBTyxDQUFDLGFBQWE7SUFGdkIsWUFDVSxJQUFJLEVBQUUsU0FBUyxFQUNmLGFBQWEsRUFBRSxhQUFhLEVBQ2xDO0lBRUo7Ozs7T0FJRztJQUNHLGlCQUFpQixDQUFDLE9BQU8sRUFBRSxZQUFZLEVBQUUsaUJBQWlCLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxFQUFFLEdBQUcsU0FBUyxDQUFDLENBaUJ0RztDQUNGIn0=

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;IAE7B,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,CAiBtG;CACF"}

package/dest/contract/contract_class_service.js

@@ -0,0 +1,36 @@
+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;
+    constructor(node, contractStore){
+        this.node = node;
+        this.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.
+   */ 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;
+        }
+        // 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;
+        }
+        return (await this.contractStore.getContractInstance(address))?.originalContractClassId;
+    }
+}

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

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;AAIpD,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;CAiEF"}

package/dest/contract/contract_sync_service.js

@@ -0,0 +1,119 @@
+import { allToCompletion } from '@aztec/foundation/promise';
+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);
+            // This cached promise is what every later request for this scope awaits, and both branches write staged data,
+            // so it must run both to completion even when one fails.
+            const promise = allToCompletion([
+                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 allToCompletion(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==

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

@@ -0,0 +1 @@
+{"version":3,"file":"skip_sync_contracts.d.ts","sourceRoot":"","sources":["../../src/contract/skip_sync_contracts.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,YAAY,EAK3C,CAAC;AAEF,iGAAiG;AACjG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAEjE"}

package/dest/contract/skip_sync_contracts.js

@@ -0,0 +1,18 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { STANDARD_AUTH_REGISTRY_ADDRESS } from '@aztec/standard-contracts/auth-registry/constants';
+import { STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS } from '@aztec/standard-contracts/multi-call-entrypoint/constants';
+import { STANDARD_PUBLIC_CHECKS_ADDRESS } from '@aztec/standard-contracts/public-checks/constants';
+/**
+ * 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 const skipSyncContracts = [
+    ...Object.values(ProtocolContractAddress),
+    STANDARD_AUTH_REGISTRY_ADDRESS,
+    STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS,
+    STANDARD_PUBLIC_CHECKS_ADDRESS
+];
+/** Returns whether the given contract should be skipped during private state synchronization. */ export function isSkipSyncContract(address) {
+    return skipSyncContracts.some((a)=>a.equals(address));
+}

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}`;
+    }
+}