@aztec/pxe 6.0.0-nightly.20260821 → 6.0.0-nightly.20260823

package/dest/block_synchronizer/block_synchronizer.d.ts

@@ -6,9 +6,7 @@ import type { BlockSynchronizerConfig } from '../config/index.js';
 import type { ContractSyncService } from '../contract/contract_sync_service.js';
 import type { CachingAztecNode } from '../node/caching_aztec_node.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';
-import type { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
+import type { Rollbackable } from '../storage/rollbackable.js';
 /**
  * The BlockSynchronizer class orchestrates synchronization between PXE and Aztec node, maintaining an up-to-date
  * view of the L2 chain state. It handles block header retrieval, chain reorganizations, and provides an interface
@@ -18,9 +16,7 @@ export declare class BlockSynchronizer implements L2BlockStreamEventHandler {
     private readonly node;
     private readonly store;
     private readonly anchorBlockStore;
-    private readonly noteStore;
-    private readonly privateEventStore;
-    private readonly factStore;
+    private readonly rollbackables;
     private readonly l2TipsStore;
     private readonly contractSyncService;
     private readonly config;
@@ -28,7 +24,7 @@ export declare class BlockSynchronizer implements L2BlockStreamEventHandler {
     private isSyncing;
     private readonly eventQueue;
     protected readonly blockStream: L2BlockStream;
-    constructor(node: CachingAztecNode, store: AztecAsyncKVStore, anchorBlockStore: AnchorBlockStore, noteStore: NoteStore, privateEventStore: PrivateEventStore, factStore: FactStore, l2TipsStore: L2TipsKVStore, contractSyncService: ContractSyncService, config?: Partial<BlockSynchronizerConfig>, bindings?: LoggerBindings);
+    constructor(node: CachingAztecNode, store: AztecAsyncKVStore, anchorBlockStore: AnchorBlockStore, rollbackables: Rollbackable[], l2TipsStore: L2TipsKVStore, contractSyncService: ContractSyncService, 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 +44,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2tfc3luY2hyb25pemVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmxvY2tfc3luY2hyb25pemVyL2Jsb2NrX3N5bmNocm9uaXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQWUsS0FBSyxjQUFjLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFFdkYsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM1RCxPQUFPLEVBQWEsYUFBYSxFQUFFLEtBQUssa0JBQWtCLEVBQUUsS0FBSyx5QkFBeUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBR3hILE9BQU8sS0FBSyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNoRixPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3RFLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDL0UsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFHL0Q7Ozs7R0FJRztBQUNILHFCQUFhLGlCQUFrQixZQUFXLHlCQUF5QjtJQU8vRCxPQUFPLENBQUMsUUFBUSxDQUFDLElBQUk7SUFDckIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLO0lBQ3RCLE9BQU8sQ0FBQyxRQUFRLENBQUMsZ0JBQWdCO0lBQ2pDLE9BQU8sQ0FBQyxRQUFRLENBQUMsYUFBYTtJQUM5QixPQUFPLENBQUMsUUFBUSxDQUFDLFdBQVc7SUFDNUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxtQkFBbUI7SUFDcEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBWnpCLE9BQU8sQ0FBQyxHQUFHLENBQVM7SUFDcEIsT0FBTyxDQUFDLFNBQVMsQ0FBNEI7SUFDN0MsT0FBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQXFCO0lBQ2hELFNBQVMsQ0FBQyxRQUFRLENBQUMsV0FBVyxFQUFFLGFBQWEsQ0FBQztJQUU5QyxZQUNtQixJQUFJLEVBQUUsZ0JBQWdCLEVBQ3RCLEtBQUssRUFBRSxpQkFBaUIsRUFDeEIsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQ2xDLGFBQWEsRUFBRSxZQUFZLEVBQUUsRUFDN0IsV0FBVyxFQUFFLGFBQWEsRUFDMUIsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQ3hDLE1BQU0sR0FBRSxPQUFPLENBQUMsdUJBQXVCLENBQU0sRUFDOUQsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUsxQjtJQUVELFNBQVMsQ0FBQyxpQkFBaUIsSUFBSSxhQUFhLENBWTNDO0lBRUQsNkdBQTZHO0lBQ3RHLHNCQUFzQixDQUFDLEtBQUssRUFBRSxrQkFBa0IsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRXRFO1lBRWEsd0JBQXdCO1lBZ0d4Qix1QkFBdUI7SUFjckM7Ozs7Ozs7O09BUUc7SUFDVSxJQUFJLGtCQWlCaEI7SUFFRCxvR0FBb0c7SUFDdkYsSUFBSSxrQkFJaEI7WUFFYSxNQUFNO0NBY3JCIn0=

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;AAGxH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,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,gBAAgB,EACtB,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;YAgGxB,uBAAuB;IAcrC;;;;;;;;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;AAGxH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAG/D;;;;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,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAZzB,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,gBAAgB,EACtB,KAAK,EAAE,iBAAiB,EACxB,gBAAgB,EAAE,gBAAgB,EAClC,aAAa,EAAE,YAAY,EAAE,EAC7B,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;YAgGxB,uBAAuB;IAcrC;;;;;;;;OAQG;IACU,IAAI,kBAiBhB;IAED,oGAAoG;IACvF,IAAI,kBAIhB;YAEa,MAAM;CAcrB"}

package/dest/block_synchronizer/block_synchronizer.js

@@ -11,9 +11,7 @@ import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
     node;
     store;
     anchorBlockStore;
-    noteStore;
-    privateEventStore;
-    factStore;
+    rollbackables;
     l2TipsStore;
     contractSyncService;
     config;
@@ -21,13 +19,11 @@ import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
     isSyncing;
     eventQueue;
     blockStream;
-    constructor(node, store, anchorBlockStore, noteStore, privateEventStore, factStore, l2TipsStore, contractSyncService, config = {}, bindings){
+    constructor(node, store, anchorBlockStore, rollbackables, l2TipsStore, contractSyncService, config = {}, bindings){
         this.node = node;
         this.store = store;
         this.anchorBlockStore = anchorBlockStore;
-        this.noteStore = noteStore;
-        this.privateEventStore = privateEventStore;
-        this.factStore = factStore;
+        this.rollbackables = rollbackables;
         this.l2TipsStore = l2TipsStore;
         this.contractSyncService = contractSyncService;
         this.config = config;
@@ -121,9 +117,9 @@ import { blockStreamSourceFromAztecNode } from './block_stream_source.js';
                     }
                     // Operations are wrapped in a single transaction to ensure atomicity.
                     await this.store.transactionAsync(async ()=>{
-                        await this.noteStore.rollback(event.block.number);
-                        await this.privateEventStore.rollback(event.block.number);
-                        await this.factStore.rollback(event.block.number);
+                        for (const rollbackable of this.rollbackables){
+                            await rollbackable.rollbackToBlock(event.block.number);
+                        }
                         await this.updateAnchorBlockHeader(newAnchorBlockHeader);
                     });
                     break;

package/dest/config/index.d.ts

@@ -32,7 +32,7 @@ export interface ContractSyncConfig {
     /**
      * Whether PXE speculatively syncs contracts it predicts will follow the one requested, running them concurrently
      * with it instead of waiting for execution to reach them. When enabled, repeated flows sync faster, but a wrong
-     * prediction spends unnecessary node requests syncing contracts the job never uses.
+     * prediction spends unnecessary node requests syncing contracts the operation never uses.
      *
      * Experimental, off by default.
      */

package/dest/contract/contract_call_graph.d.ts

@@ -1,41 +1,42 @@
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ChangeSetId } from '../storage/staged_write_coordinator.js';
 /** Confidence a call must reach to be predicted. */
 export declare const PREDICTION_THRESHOLD = 2;
-/** Cap on a call's confidence, so a function called by many jobs is still dropped within a few missed ones. */
+/** Cap on a call's confidence, so a function called by many operations is still dropped within a few missed ones. */
 export declare const MAX_CONFIDENCE = 5;
 /**
- * A call graph over contract functions - who calls whom - learned from the direct calls observed in past jobs, so
+ * A call graph over contract functions - who calls whom - learned from the direct calls observed in past operations, so
  * a function's predicted callees can sync their contracts before execution reaches them.
  *
- * A function's direct calls tend to repeat across jobs: constrained delivery calls the handshake registry, a transfer
- * may call an authwit, an AMM calls its tokens. The same function does not always make the same calls, though: they
- * can depend on context or storage state. A call must therefore repeat often enough to earn confidence before it is
- * predicted. Calls are keyed per function, not per contract, since different functions of a contract call different
- * contracts. See {@link commitJob} for how each call's confidence is learned from committed jobs.
+ * A function's direct calls tend to repeat across operations: constrained delivery calls the handshake registry, a
+ * transfer may call an authwit, an AMM calls its tokens. The same function does not always make the same calls, though:
+ * they can depend on context or storage state. A call must therefore repeat often enough to earn confidence before it
+ * is predicted. Calls are keyed per function, not per contract, since different functions of a contract call different
+ * contracts. See {@link learn} for how each call's confidence is learned from committed operations.
  *
  * Purely in-memory bookkeeping: the graph is lost when PXE is rebuilt (e.g. on restart).
  */
 export declare class ContractCallGraph {
     private readonly enabled;
-    private readonly activeJobs;
+    private readonly activeChangeSets;
     private readonly callConfidence;
     constructor(enabled: boolean);
-    /** Records that `caller` directly called `callee` in the given job. */
-    recordCall({ jobId, caller, callee }: {
-        jobId: JobId;
+    /** Records that `caller` directly called `callee` in the given change set. */
+    recordCall({ changeSetId, caller, callee }: {
+        changeSetId: ChangeSetId;
         caller: ContractFunction;
         callee: ContractFunction;
     }): void;
     /** Predicts the functions `caller` will call directly. */
     predictDirectCallees(caller: ContractFunction): ContractFunction[];
     /**
-     * Commits the job so the calls it observed are recorded and learned from. A function that called nothing keeps its
-     * callees untouched, so read-only uses (e.g. reading notes or events) erode nothing.
+     * Learns from a committed change set: the calls it observed update each caller's confidence. A function that called
+     * nothing keeps its callees untouched, so read-only uses (e.g. reading notes or events) erode nothing.
      */
-    commitJob(jobId: JobId): void;
-    /** Drops a discarded job without learning. */
-    discardJob(jobId: JobId): void;
+    learn(changeSetId: ChangeSetId): void;
+    /** Drops a discarded change set without learning. */
+    discard(changeSetId: ChangeSetId): void;
 }
 /** A specific function of a contract, as observed in a call. */
 export type ContractFunction = {
@@ -44,9 +45,7 @@ export type ContractFunction = {
     /** The selector of the function. */
     selector: FunctionSelector;
 };
-type JobId = string;
 /** A {@link ContractFunction} flattened to a `contractAddress:selector` string, so maps can key on it. */
 export type CallKey = `0x${string}:${string}`;
 export declare function toCallKey({ address, selector }: ContractFunction): CallKey;
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfY2FsbF9ncmFwaC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2NvbnRyYWN0X2NhbGxfZ3JhcGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDckQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRTNELG9EQUFvRDtBQUNwRCxlQUFPLE1BQU0sb0JBQW9CLElBQUksQ0FBQztBQUV0QywrR0FBK0c7QUFDL0csZUFBTyxNQUFNLGNBQWMsSUFBSSxDQUFDO0FBRWhDOzs7Ozs7Ozs7OztHQVdHO0FBQ0gscUJBQWEsaUJBQWlCO0lBT2hCLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTztJQUxwQyxPQUFPLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBcUQ7SUFHaEYsT0FBTyxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQWlEO0lBRWhGLFlBQTZCLE9BQU8sRUFBRSxPQUFPLEVBQUk7SUFFakQsdUVBQXVFO0lBQ3ZFLFVBQVUsQ0FBQyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLEVBQUU7UUFBRSxLQUFLLEVBQUUsS0FBSyxDQUFDO1FBQUMsTUFBTSxFQUFFLGdCQUFnQixDQUFDO1FBQUMsTUFBTSxFQUFFLGdCQUFnQixDQUFBO0tBQUUsR0FBRyxJQUFJLENBaUJoSDtJQUVELDBEQUEwRDtJQUMxRCxvQkFBb0IsQ0FBQyxNQUFNLEVBQUUsZ0JBQWdCLEdBQUcsZ0JBQWdCLEVBQUUsQ0FLakU7SUFFRDs7O09BR0c7SUFDSCxTQUFTLENBQUMsS0FBSyxFQUFFLEtBQUssR0FBRyxJQUFJLENBc0I1QjtJQUVELDhDQUE4QztJQUM5QyxVQUFVLENBQUMsS0FBSyxFQUFFLEtBQUssR0FBRyxJQUFJLENBRTdCO0NBQ0Y7QUFFRCxnRUFBZ0U7QUFDaEUsTUFBTSxNQUFNLGdCQUFnQixHQUFHO0lBQzdCLDJEQUEyRDtJQUMzRCxPQUFPLEVBQUUsWUFBWSxDQUFDO0lBQ3RCLG9DQUFvQztJQUNwQyxRQUFRLEVBQUUsZ0JBQWdCLENBQUM7Q0FDNUIsQ0FBQztBQUVGLEtBQUssS0FBSyxHQUFHLE1BQU0sQ0FBQztBQUVwQiwwR0FBMEc7QUFDMUcsTUFBTSxNQUFNLE9BQU8sR0FBRyxLQUFLLE1BQU0sSUFBSSxNQUFNLEVBQUUsQ0FBQztBQUU5Qyx3QkFBZ0IsU0FBUyxDQUFDLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FFMUUifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfY2FsbF9ncmFwaC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2NvbnRyYWN0X2NhbGxfZ3JhcGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDckQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRTNELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBRTFFLG9EQUFvRDtBQUNwRCxlQUFPLE1BQU0sb0JBQW9CLElBQUksQ0FBQztBQUV0QyxxSEFBcUg7QUFDckgsZUFBTyxNQUFNLGNBQWMsSUFBSSxDQUFDO0FBRWhDOzs7Ozs7Ozs7OztHQVdHO0FBQ0gscUJBQWEsaUJBQWlCO0lBT2hCLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTztJQUxwQyxPQUFPLENBQUMsUUFBUSxDQUFDLGdCQUFnQixDQUEyRDtJQUc1RixPQUFPLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBaUQ7SUFFaEYsWUFBNkIsT0FBTyxFQUFFLE9BQU8sRUFBSTtJQUVqRCw4RUFBOEU7SUFDOUUsVUFBVSxDQUFDLEVBQ1QsV0FBVyxFQUNYLE1BQU0sRUFDTixNQUFNLEVBQ1AsRUFBRTtRQUNELFdBQVcsRUFBRSxXQUFXLENBQUM7UUFDekIsTUFBTSxFQUFFLGdCQUFnQixDQUFDO1FBQ3pCLE1BQU0sRUFBRSxnQkFBZ0IsQ0FBQztLQUMxQixHQUFHLElBQUksQ0FpQlA7SUFFRCwwREFBMEQ7SUFDMUQsb0JBQW9CLENBQUMsTUFBTSxFQUFFLGdCQUFnQixHQUFHLGdCQUFnQixFQUFFLENBS2pFO0lBRUQ7OztPQUdHO0lBQ0gsS0FBSyxDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsSUFBSSxDQXNCcEM7SUFFRCxxREFBcUQ7SUFDckQsT0FBTyxDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsSUFBSSxDQUV0QztDQUNGO0FBRUQsZ0VBQWdFO0FBQ2hFLE1BQU0sTUFBTSxnQkFBZ0IsR0FBRztJQUM3QiwyREFBMkQ7SUFDM0QsT0FBTyxFQUFFLFlBQVksQ0FBQztJQUN0QixvQ0FBb0M7SUFDcEMsUUFBUSxFQUFFLGdCQUFnQixDQUFDO0NBQzVCLENBQUM7QUFFRiwwR0FBMEc7QUFDMUcsTUFBTSxNQUFNLE9BQU8sR0FBRyxLQUFLLE1BQU0sSUFBSSxNQUFNLEVBQUUsQ0FBQztBQUU5Qyx3QkFBZ0IsU0FBUyxDQUFDLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FFMUUifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"contract_call_graph.d.ts","sourceRoot":"","sources":["../../src/contract/contract_call_graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,oDAAoD;AACpD,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,+GAA+G;AAC/G,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAiB;IAOhB,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqD;IAGhF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiD;IAEhF,YAA6B,OAAO,EAAE,OAAO,EAAI;IAEjD,uEAAuE;IACvE,UAAU,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,gBAAgB,CAAC;QAAC,MAAM,EAAE,gBAAgB,CAAA;KAAE,GAAG,IAAI,CAiBhH;IAED,0DAA0D;IAC1D,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,CAKjE;IAED;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAsB5B;IAED,8CAA8C;IAC9C,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE7B;CACF;AAED,gEAAgE;AAChE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,2DAA2D;IAC3D,OAAO,EAAE,YAAY,CAAC;IACtB,oCAAoC;IACpC,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAEF,KAAK,KAAK,GAAG,MAAM,CAAC;AAEpB,0GAA0G;AAC1G,MAAM,MAAM,OAAO,GAAG,KAAK,MAAM,IAAI,MAAM,EAAE,CAAC;AAE9C,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAE1E"}
+{"version":3,"file":"contract_call_graph.d.ts","sourceRoot":"","sources":["../../src/contract/contract_call_graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAE1E,oDAAoD;AACpD,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,qHAAqH;AACrH,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAiB;IAOhB,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA2D;IAG5F,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiD;IAEhF,YAA6B,OAAO,EAAE,OAAO,EAAI;IAEjD,8EAA8E;IAC9E,UAAU,CAAC,EACT,WAAW,EACX,MAAM,EACN,MAAM,EACP,EAAE;QACD,WAAW,EAAE,WAAW,CAAC;QACzB,MAAM,EAAE,gBAAgB,CAAC;QACzB,MAAM,EAAE,gBAAgB,CAAC;KAC1B,GAAG,IAAI,CAiBP;IAED,0DAA0D;IAC1D,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,CAKjE;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAsBpC;IAED,qDAAqD;IACrD,OAAO,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAEtC;CACF;AAED,gEAAgE;AAChE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,2DAA2D;IAC3D,OAAO,EAAE,YAAY,CAAC;IACtB,oCAAoC;IACpC,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAEF,0GAA0G;AAC1G,MAAM,MAAM,OAAO,GAAG,KAAK,MAAM,IAAI,MAAM,EAAE,CAAC;AAE9C,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAE1E"}

package/dest/contract/contract_call_graph.js

@@ -1,44 +1,44 @@
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 /** Confidence a call must reach to be predicted. */ export const PREDICTION_THRESHOLD = 2;
-/** Cap on a call's confidence, so a function called by many jobs is still dropped within a few missed ones. */ export const MAX_CONFIDENCE = 5;
+/** Cap on a call's confidence, so a function called by many operations is still dropped within a few missed ones. */ export const MAX_CONFIDENCE = 5;
 /**
- * A call graph over contract functions - who calls whom - learned from the direct calls observed in past jobs, so
+ * A call graph over contract functions - who calls whom - learned from the direct calls observed in past operations, so
  * a function's predicted callees can sync their contracts before execution reaches them.
  *
- * A function's direct calls tend to repeat across jobs: constrained delivery calls the handshake registry, a transfer
- * may call an authwit, an AMM calls its tokens. The same function does not always make the same calls, though: they
- * can depend on context or storage state. A call must therefore repeat often enough to earn confidence before it is
- * predicted. Calls are keyed per function, not per contract, since different functions of a contract call different
- * contracts. See {@link commitJob} for how each call's confidence is learned from committed jobs.
+ * A function's direct calls tend to repeat across operations: constrained delivery calls the handshake registry, a
+ * transfer may call an authwit, an AMM calls its tokens. The same function does not always make the same calls, though:
+ * they can depend on context or storage state. A call must therefore repeat often enough to earn confidence before it
+ * is predicted. Calls are keyed per function, not per contract, since different functions of a contract call different
+ * contracts. See {@link learn} for how each call's confidence is learned from committed operations.
  *
  * Purely in-memory bookkeeping: the graph is lost when PXE is rebuilt (e.g. on restart).
  */ export class ContractCallGraph {
     enabled;
-    // job -> caller function -> functions it called directly
-    activeJobs;
+    // change set -> caller function -> functions it called directly
+    activeChangeSets;
     // caller function -> function it calls directly -> confidence score
     callConfidence;
     constructor(enabled){
         this.enabled = enabled;
-        this.activeJobs = new Map();
+        this.activeChangeSets = new Map();
         this.callConfidence = new Map();
     }
-    /** Records that `caller` directly called `callee` in the given job. */ recordCall({ jobId, caller, callee }) {
+    /** Records that `caller` directly called `callee` in the given change set. */ recordCall({ changeSetId, caller, callee }) {
         // Same-contract calls are ignored: our goal is to warm a callee's contract ahead of use, and the target of such
         // a call is already warm.
         if (!this.enabled || caller.address.equals(callee.address)) {
             return;
         }
-        let callsInJob = this.activeJobs.get(jobId);
-        if (!callsInJob) {
-            callsInJob = new Map();
-            this.activeJobs.set(jobId, callsInJob);
+        let callsInChangeSet = this.activeChangeSets.get(changeSetId);
+        if (!callsInChangeSet) {
+            callsInChangeSet = new Map();
+            this.activeChangeSets.set(changeSetId, callsInChangeSet);
         }
-        let callees = callsInJob.get(toCallKey(caller));
+        let callees = callsInChangeSet.get(toCallKey(caller));
         if (!callees) {
             callees = new Set();
-            callsInJob.set(toCallKey(caller), callees);
+            callsInChangeSet.set(toCallKey(caller), callees);
         }
         callees.add(toCallKey(callee));
     }
@@ -49,15 +49,15 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
         ].filter(([, confidence])=>confidence >= PREDICTION_THRESHOLD).map(([callee])=>fromCallKey(callee));
     }
     /**
-   * Commits the job so the calls it observed are recorded and learned from. A function that called nothing keeps its
-   * callees untouched, so read-only uses (e.g. reading notes or events) erode nothing.
-   */ commitJob(jobId) {
-        const callsInJob = this.activeJobs.get(jobId);
-        this.activeJobs.delete(jobId);
-        if (!callsInJob) {
+   * Learns from a committed change set: the calls it observed update each caller's confidence. A function that called
+   * nothing keeps its callees untouched, so read-only uses (e.g. reading notes or events) erode nothing.
+   */ learn(changeSetId) {
+        const callsInChangeSet = this.activeChangeSets.get(changeSetId);
+        this.activeChangeSets.delete(changeSetId);
+        if (!callsInChangeSet) {
             return;
         }
-        for (const [caller, observed] of callsInJob){
+        for (const [caller, observed] of callsInChangeSet){
             const callees = this.callConfidence.get(caller) ?? new Map();
             for (const [callee, confidence] of callees){
                 const delta = observed.has(callee) ? 1 : -1;
@@ -75,8 +75,8 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
             this.callConfidence.set(caller, callees);
         }
     }
-    /** Drops a discarded job without learning. */ discardJob(jobId) {
-        this.activeJobs.delete(jobId);
+    /** Drops a discarded change set without learning. */ discard(changeSetId) {
+        this.activeChangeSets.delete(changeSetId);
     }
 }
 export function toCallKey({ address, selector }) {

package/dest/contract/contract_sync_service.d.ts

@@ -4,9 +4,10 @@ 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 { ContractSyncConfig } from '../config/index.js';
-import type { StagedStore } from '../job_coordinator/job_coordinator.js';
+import type { OperationContributor } from '../operation_lifecycle.js';
 import type { ContractStore } from '../storage/contract_store/contract_store.js';
 import type { NoteStore } from '../storage/note_store/note_store.js';
+import type { ChangeSetId } from '../storage/staged_write_coordinator.js';
 import { type ContractFunction } from './contract_call_graph.js';
 import type { ContractClassService } from './contract_class_service.js';
 /**
@@ -23,37 +24,36 @@ export declare const SYNC_STATE_SELECTOR: FunctionSelector;
  * 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.
+ * Contributes to every synced operation (see {@link OperationContributor}): its syncs write into the operation's change
+ * set, so it settles them before the change set is decided and releases its per-change-set state on the outcome.
  */
-export declare class ContractSyncService implements StagedStore {
+export declare class ContractSyncService implements OperationContributor {
     #private;
     private aztecNode;
     private contractStore;
     private contractClassService;
     private noteStore;
     private log;
-    readonly storeName = "contract_sync";
     private readonly syncedContracts;
-    private readonly speculationByJob;
+    private readonly speculationByChangeSet;
     private readonly callGraph;
     constructor(aztecNode: AztecNode, contractStore: ContractStore, contractClassService: ContractClassService, noteStore: NoteStore, log: Logger, { concurrentContractSyncEnabled }: ContractSyncConfig);
     /**
      * 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.
      */
-    ensureContractSynced({ contract, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, scopes, triggeredBy }: ContractSyncRequest): Promise<void>;
+    ensureContractSynced({ contract, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, changeSetId, scopes, triggeredBy }: ContractSyncRequest): Promise<void>;
     /**
-     * Waits until every speculative sync the job fired has finished, then rejects if any failed, so the job discards
-     * instead of committing. This is needed because a sync that fails midway can leave partial staged writes, and a
-     * speculative failure might not be surfaced by any request.
+     * Waits until every speculative sync the change set fired has finished, then rejects if any failed, so the change set
+     * discards instead of committing. This is needed because a sync that fails midway can leave partial staged writes,
+     * and a speculative failure might not be surfaced by any request.
      */
-    settle(jobId: JobId): Promise<void>;
+    settle(changeSetId: ChangeSetId): 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: JobId): Promise<void>;
-    discardStaged(jobId: JobId): Promise<void>;
+    onOperationEnd(changeSetId: ChangeSetId, outcome: 'committed' | 'discarded'): void;
 }
 /** A request to synchronize a contract's private state. */
 type ContractSyncRequest = {
@@ -68,16 +68,15 @@ type ContractSyncRequest = {
     utilityExecutor: (call: FunctionCall, scopes: AztecAddress[]) => Promise<any>;
     /** The anchor block to sync at. */
     anchorBlockHeader: BlockHeader;
-    /** The job requesting the sync. */
-    jobId: JobId;
+    /** The change set requesting the sync. */
+    changeSetId: ChangeSetId;
     /** Access scopes to pass through to the utility executor (affects whose account's private state is discovered). */
     scopes: AztecAddress[];
     /**
-     * The function whose execution triggered this sync request, or undefined when the request is a job's top-level use
-     * (an entry call or a direct read) rather than a nested call.
+     * The function whose execution triggered this sync request, or undefined when the request is a change set's top-level
+     * use (an entry call or a direct read) rather than a nested call.
      */
     triggeredBy: ContractFunction | undefined;
 };
-type JobId = string;
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +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,EAAE,KAAK,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,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,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,EAAmC,KAAK,gBAAgB,EAAa,MAAM,0BAA0B,CAAC;AAC7G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAGxE;;;GAGG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,kBAA4C,CAAC;AAE7E;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,WAAW;;IAcnD,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAjBb,QAAQ,CAAC,SAAS,mBAAmB;IAIrC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0C;IAG1E,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAyC;IAG1E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAE9C,YACU,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,aAAa,EAC5B,oBAAoB,EAAE,oBAAoB,EAC1C,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACnB,EAAE,6BAA6B,EAAE,EAAE,kBAAkB,EAGtD;IAED;;;OAGG;IACG,oBAAoB,CAAC,EACzB,QAAQ,EACR,yBAAyB,EACzB,eAAe,EACf,iBAAiB,EACjB,KAAK,EACL,MAAM,EACN,WAAW,EACZ,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBrC;IAED;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAexC;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,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAIlC;IAED,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAOzC;CAqJF;AAED,2DAA2D;AAC3D,KAAK,mBAAmB,GAAG;IACzB,4BAA4B;IAC5B,QAAQ,EAAE,YAAY,CAAC;IACvB;;;OAGG;IACH,yBAAyB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACnD,gHAAgH;IAChH,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAC9E,mCAAmC;IACnC,iBAAiB,EAAE,WAAW,CAAC;IAC/B,mCAAmC;IACnC,KAAK,EAAE,KAAK,CAAC;IACb,mHAAmH;IACnH,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB;;;OAGG;IACH,WAAW,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,KAAK,KAAK,GAAG,MAAM,CAAC"}
+{"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,EAAE,KAAK,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,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EAAmC,KAAK,gBAAgB,EAAa,MAAM,0BAA0B,CAAC;AAC7G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAGxE;;;GAGG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,kBAA4C,CAAC;AAE7E;;;;;;GAMG;AACH,qBAAa,mBAAoB,YAAW,oBAAoB;;IAY5D,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAbb,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0C;IAG1E,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAqD;IAG5F,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAE9C,YACU,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,aAAa,EAC5B,oBAAoB,EAAE,oBAAoB,EAC1C,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACnB,EAAE,6BAA6B,EAAE,EAAE,kBAAkB,EAGtD;IAED;;;OAGG;IACG,oBAAoB,CAAC,EACzB,QAAQ,EACR,yBAAyB,EACzB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,MAAM,EACN,WAAW,EACZ,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBrC;IAED;;;;OAIG;IACG,MAAM,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAepD;IAED,oEAAoE;IACpE,2BAA2B,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,CAKvF;IAED,gFAAgF;IAChF,IAAI,IAAI,IAAI,CAGX;IAED,cAAc,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CAUjF;CAiKF;AAED,2DAA2D;AAC3D,KAAK,mBAAmB,GAAG;IACzB,4BAA4B;IAC5B,QAAQ,EAAE,YAAY,CAAC;IACvB;;;OAGG;IACH,yBAAyB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACnD,gHAAgH;IAChH,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAC9E,mCAAmC;IACnC,iBAAiB,EAAE,WAAW,CAAC;IAC/B,0CAA0C;IAC1C,WAAW,EAAE,WAAW,CAAC;IACzB,mHAAmH;IACnH,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB;;;OAGG;IACH,WAAW,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAC3C,CAAC"}

package/dest/contract/contract_sync_service.js

@@ -17,20 +17,20 @@ import { syncScope } from './helpers.js';
  * 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.
+ * Contributes to every synced operation (see {@link OperationContributor}): its syncs write into the operation's change
+ * set, so it settles them before the change set is decided and releases its per-change-set state on the outcome.
  */ 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`). The value is a promise that resolves when the contract is synced.
     syncedContracts;
-    // Per-job speculation state, dropped when the job commits or discards.
-    speculationByJob;
-    // Predicts a function's callees from the calls observed in past jobs, driving speculative sync.
+    // Per-change-set speculation state, dropped when the change set commits or discards.
+    speculationByChangeSet;
+    // Predicts a function's callees from the calls observed in past operations, driving speculative sync.
     callGraph;
     constructor(aztecNode, contractStore, contractClassService, noteStore, log, { concurrentContractSyncEnabled }){
         this.aztecNode = aztecNode;
@@ -38,19 +38,18 @@ import { syncScope } from './helpers.js';
         this.contractClassService = contractClassService;
         this.noteStore = noteStore;
         this.log = log;
-        this.storeName = 'contract_sync';
         this.syncedContracts = new Map();
-        this.speculationByJob = new Map();
+        this.speculationByChangeSet = new Map();
         this.callGraph = new ContractCallGraph(concurrentContractSyncEnabled);
     }
     /**
    * 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.
-   */ async ensureContractSynced({ contract, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, scopes, triggeredBy }) {
+   */ async ensureContractSynced({ contract, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, changeSetId, scopes, triggeredBy }) {
         // A call is recorded only when both functions are known: the invoked callee and the caller that triggered it.
         if (functionToInvokeAfterSync && triggeredBy) {
             this.callGraph.recordCall({
-                jobId,
+                changeSetId,
                 caller: triggeredBy,
                 callee: {
                     address: contract,
@@ -58,23 +57,23 @@ import { syncScope } from './helpers.js';
                 }
             });
         }
-        await this.#startSyncIfNeeded(contract, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, scopes);
+        await this.#startSyncIfNeeded(contract, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, changeSetId, scopes);
     }
     /**
-   * Waits until every speculative sync the job fired has finished, then rejects if any failed, so the job discards
-   * instead of committing. This is needed because a sync that fails midway can leave partial staged writes, and a
-   * speculative failure might not be surfaced by any request.
-   */ async settle(jobId) {
+   * Waits until every speculative sync the change set fired has finished, then rejects if any failed, so the change set
+   * discards instead of committing. This is needed because a sync that fails midway can leave partial staged writes,
+   * and a speculative failure might not be surfaced by any request.
+   */ async settle(changeSetId) {
         // A speculative sync's execution can fire more speculative syncs mid-drain, so loop until no new promises
         // appear, and only escalate once nothing is still writing.
-        const { syncs } = this.#speculationForJob(jobId);
+        const { syncs } = this.#speculationForChangeSet(changeSetId);
         const failures = [];
         while(syncs.length > 0){
             const results = await Promise.allSettled(syncs.splice(0));
             failures.push(...results.filter((result)=>result.status === 'rejected').map((result)=>result.reason));
         }
         if (failures.length > 0) {
-            throw new AggregateError(failures, 'Speculative syncs failed, so the job must discard its staged writes instead of committing');
+            throw new AggregateError(failures, 'Speculative syncs failed, so the operation must discard its staged writes instead of committing');
         }
     }
     /** Clears sync cache entries for the given scopes of a contract. */ invalidateContractForScopes(contractAddress, scopes) {
@@ -87,18 +86,16 @@ import { syncScope } from './helpers.js';
         this.log.debug(`Wiping contract sync cache (${this.syncedContracts.size} entries)`);
         this.syncedContracts.clear();
     }
-    commit(jobId) {
-        this.callGraph.commitJob(jobId);
-        this.speculationByJob.delete(jobId);
-        return Promise.resolve();
-    }
-    discardStaged(jobId) {
-        // We clear the synced contracts cache here because, when the job is discarded, any associated database writes from
-        // the sync are also undone.
-        this.syncedContracts.clear();
-        this.callGraph.discardJob(jobId);
-        this.speculationByJob.delete(jobId);
-        return Promise.resolve();
+    onOperationEnd(changeSetId, outcome) {
+        if (outcome === 'committed') {
+            this.callGraph.learn(changeSetId);
+        } else {
+            // We clear the synced contracts cache here because, when the change set is discarded, any associated database
+            // writes from the sync are also undone.
+            this.syncedContracts.clear();
+            this.callGraph.discard(changeSetId);
+        }
+        this.speculationByChangeSet.delete(changeSetId);
     }
     /**
    * For each unsynced scope, creates a promise that waits on:
@@ -109,12 +106,12 @@ import { syncScope } from './helpers.js';
    * {@link #speculativelySync}).
    * @returns A promise that resolves once every requested scope is synced, including syncs already in flight from
    * concurrent calls. Speculative syncs are not included: those are only awaited by a later request that needs
-   * their contract, or by the job's {@link settle}.
-   */ async #startSyncIfNeeded(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, scopes) {
+   * their contract, or by the change set's {@link settle}.
+   */ async #startSyncIfNeeded(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, changeSetId, scopes) {
         const scopesToSync = scopes.filter((scope)=>!this.syncedContracts.has(toKey(contractAddress, scope)));
         if (scopesToSync.length > 0) {
             this.log.debug(`Syncing contract ${contractAddress} for ${scopesToSync.length} scope(s)`);
-            const syncNullifiersPromise = this.#syncNoteNullifiers(contractAddress, anchorBlockHeader, jobId, scopesToSync);
+            const syncNullifiersPromise = this.#syncNoteNullifiers(contractAddress, anchorBlockHeader, changeSetId, 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);
@@ -135,8 +132,8 @@ import { syncScope } from './helpers.js';
         }
         // `sync_state` itself calls other contracts (e.g. most contract syncs query the handshake registry), so its
         // predicted callees start syncing alongside the contract's own syncs.
-        this.#speculativelySync(contractAddress, SYNC_STATE_SELECTOR, utilityExecutor, anchorBlockHeader, jobId, scopes);
-        this.#speculativelySync(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, scopes);
+        this.#speculativelySync(contractAddress, SYNC_STATE_SELECTOR, utilityExecutor, anchorBlockHeader, changeSetId, scopes);
+        this.#speculativelySync(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, changeSetId, scopes);
         await this.#awaitSync(contractAddress, scopes);
     }
     /**
@@ -144,54 +141,54 @@ import { syncScope } from './helpers.js';
    * predictions are learned). Each started sync speculates from its own function in turn, so the whole predicted call
    * tree syncs in parallel with the contract instead of one contract at a time as execution reaches it.
    *
-   * A wrong prediction is cheap: the extra node requests are batched into round trips the job already makes, and the
-   * synced data simply goes unused.
-   */ #speculativelySync(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, jobId, scopes) {
+   * A wrong prediction is cheap: the extra node requests are batched into round trips the operation already makes, and
+   * the synced data simply goes unused.
+   */ #speculativelySync(contractAddress, functionToInvokeAfterSync, utilityExecutor, anchorBlockHeader, changeSetId, scopes) {
         // Without a function there is no key to predict from (the request is a direct read).
         if (!functionToInvokeAfterSync) {
             return;
         }
-        const speculation = this.#speculationForJob(jobId);
+        const speculation = this.#speculationForChangeSet(changeSetId);
         const caller = {
             address: contractAddress,
             selector: functionToInvokeAfterSync
         };
         for (const callee of this.callGraph.predictDirectCallees(caller)){
-            // The job's set of already-speculated functions stops the recursion when the predicted graph has a cycle.
+            // The change set's set of already-speculated functions stops the recursion when the predicted graph has a cycle.
             if (speculation.speculated.has(toCallKey(callee))) {
                 continue;
             }
             speculation.speculated.add(toCallKey(callee));
-            const syncPromise = this.#startSyncIfNeeded(callee.address, callee.selector, utilityExecutor, anchorBlockHeader, jobId, scopes);
+            const syncPromise = this.#startSyncIfNeeded(callee.address, callee.selector, utilityExecutor, anchorBlockHeader, changeSetId, scopes);
             speculation.syncs.push(syncPromise);
-            // `settle` only escalates these failures at the end of the job: catch here so one does not become an unhandled
-            // rejection before then, and log it.
+            // `settle` only escalates these failures at the end of the change set: catch here so one does not become an
+            // unhandled rejection before then, and log it.
             syncPromise.catch((err)=>{
                 this.log.warn(`Speculative sync of ${callee.address} failed`, {
-                    jobId,
+                    changeSetId,
                     error: err?.message
                 });
             });
         }
     }
-    /** Syncs note nullifiers across all unsynced scopes in a single batched call. */ async #syncNoteNullifiers(contractAddress, anchorBlockHeader, jobId, scopes) {
+    /** Syncs note nullifiers across all unsynced scopes in a single batched call. */ async #syncNoteNullifiers(contractAddress, anchorBlockHeader, changeSetId, 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);
+        const noteService = new NoteService(this.noteStore, this.aztecNode, anchorBlockHeader, changeSetId);
         await noteService.syncNoteNullifiers(contractAddress, scopes);
     }
-    #speculationForJob(jobId) {
-        let speculation = this.speculationByJob.get(jobId);
+    #speculationForChangeSet(changeSetId) {
+        let speculation = this.speculationByChangeSet.get(changeSetId);
         if (!speculation) {
             speculation = {
                 speculated: new Set(),
                 syncs: []
             };
-            this.speculationByJob.set(jobId, speculation);
+            this.speculationByChangeSet.set(changeSetId, speculation);
         }
         return speculation;
     }