@aztec-labs/pxe 6.0.0-nightly.20260829

package/dest/storage/backwards_compatibility_tests/store_spy.d.ts

@@ -0,0 +1,19 @@
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+/** The kind of named sub-store opened on an `AztecAsyncKVStore`. */
+export type StoreKind = 'map' | 'multimap' | 'array' | 'singleton' | 'set' | 'counter';
+/** A single recorded `open*()` call against a spied store. */
+export interface OpenedStoreEntry {
+    name: string;
+    kind: StoreKind;
+}
+/** A spied `AztecAsyncKVStore` together with a function that returns the sorted log of `open*()` calls. */
+export interface StoreSpy {
+    store: AztecAsyncKVStore;
+    getOpenedStores: () => OpenedStoreEntry[];
+}
+/**
+ * Wraps an `AztecAsyncKVStore` so every `openMap`/`openMultiMap`/`openArray`/`openSingleton`/`openSet`/`openCounter`
+ * call is recorded before being delegated to the inner store.
+ */
+export declare function createStoreSpy(inner: AztecAsyncKVStore): StoreSpy;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmVfc3B5LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9iYWNrd2FyZHNfY29tcGF0aWJpbGl0eV90ZXN0cy9zdG9yZV9zcHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBR1YsaUJBQWlCLEVBTWxCLE1BQU0sc0JBQXNCLENBQUM7QUFJOUIsb0VBQW9FO0FBQ3BFLE1BQU0sTUFBTSxTQUFTLEdBQUcsS0FBSyxHQUFHLFVBQVUsR0FBRyxPQUFPLEdBQUcsV0FBVyxHQUFHLEtBQUssR0FBRyxTQUFTLENBQUM7QUFFdkYsOERBQThEO0FBQzlELE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0IsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLElBQUksRUFBRSxTQUFTLENBQUM7Q0FDakI7QUFFRCwyR0FBMkc7QUFDM0csTUFBTSxXQUFXLFFBQVE7SUFDdkIsS0FBSyxFQUFFLGlCQUFpQixDQUFDO0lBQ3pCLGVBQWUsRUFBRSxNQUFNLGdCQUFnQixFQUFFLENBQUM7Q0FDM0M7QUFFRDs7O0dBR0c7QUFDSCx3QkFBZ0IsY0FBYyxDQUFDLEtBQUssRUFBRSxpQkFBaUIsR0FBRyxRQUFRLENBd0NqRSJ9

package/dest/storage/backwards_compatibility_tests/store_spy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store_spy.d.ts","sourceRoot":"","sources":["../../../src/storage/backwards_compatibility_tests/store_spy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,iBAAiB,EAMlB,MAAM,sBAAsB,CAAC;AAI9B,oEAAoE;AACpE,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,GAAG,KAAK,GAAG,SAAS,CAAC;AAEvF,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,2GAA2G;AAC3G,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,iBAAiB,CAAC;IACzB,eAAe,EAAE,MAAM,gBAAgB,EAAE,CAAC;CAC3C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,QAAQ,CAwCjE"}

package/dest/storage/backwards_compatibility_tests/store_spy.js

@@ -0,0 +1,63 @@
+/**
+ * Wraps an `AztecAsyncKVStore` so every `openMap`/`openMultiMap`/`openArray`/`openSingleton`/`openSet`/`openCounter`
+ * call is recorded before being delegated to the inner store.
+ */ export function createStoreSpy(inner) {
+    const entries = [];
+    const store = {
+        openMap (name) {
+            entries.push({
+                name,
+                kind: 'map'
+            });
+            return inner.openMap(name);
+        },
+        openMultiMap (name) {
+            entries.push({
+                name,
+                kind: 'multimap'
+            });
+            return inner.openMultiMap(name);
+        },
+        openArray (name) {
+            entries.push({
+                name,
+                kind: 'array'
+            });
+            return inner.openArray(name);
+        },
+        openSingleton (name) {
+            entries.push({
+                name,
+                kind: 'singleton'
+            });
+            return inner.openSingleton(name);
+        },
+        openSet (name) {
+            entries.push({
+                name,
+                kind: 'set'
+            });
+            return inner.openSet(name);
+        },
+        openCounter (name) {
+            entries.push({
+                name,
+                kind: 'counter'
+            });
+            return inner.openCounter(name);
+        },
+        transactionAsync: (callback)=>inner.transactionAsync(callback),
+        clear: ()=>inner.clear(),
+        delete: ()=>inner.delete(),
+        estimateSize: ()=>inner.estimateSize(),
+        close: ()=>inner.close(),
+        backupTo: (dstPath, compact)=>inner.backupTo(dstPath, compact)
+    };
+    const getOpenedStores = ()=>[
+            ...entries
+        ].sort((a, b)=>a.name === b.name ? a.kind.localeCompare(b.kind) : a.name.localeCompare(b.name));
+    return {
+        store,
+        getOpenedStores
+    };
+}

package/dest/storage/base_staging_store.d.ts

@@ -0,0 +1,110 @@
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import type { Rollbackable } from './rollbackable.js';
+import type { ChangeSetId, StagedStore } from './staged_write_coordinator.js';
+/**
+ * Base class for stores that stage their writes per change set, flushing them on commit and dropping them on abort.
+ *
+ * A change set's staged data exists only between {@link beginChangeSet} and {@link commitChangeSet}/
+ * {@link discardChangeSet}. An operation arriving on behalf of a change set that already ended (e.g. one discarded on
+ * abort) finds no matching change set and throws, so it cannot stage new data for a dead one.
+ *
+ * The staged data and the store's kv handles live in this base class and are only reachable through
+ * {@link withChangeSet} (change set operations, staged data only), {@link withChangeSetAndDb} (change set operations
+ * that also read the DB), {@link flushChangeSet} (the commit-time write-back) and {@link applyRollback} (the reorg
+ * truncation).
+ *
+ * The class is thread safe: an internal lock serializes the operations run through {@link withChangeSet} and
+ * {@link withChangeSetAndDb}, so two of them issued concurrently (e.g. under `Promise.all`) never interleave across
+ * awaits. Subclasses can therefore read staged data and write it back without handling atomicity themselves.
+ *
+ * @typeParam TChangeSet - The in-memory buffer a change set accumulates its writes in, built empty by `buildChangeSet`
+ * on every {@link beginChangeSet} and dropped when the change set ends. A store keyed by id might stage
+ * `{ items: Map<string, Item> }`.
+ * @typeParam TDb - The store's kv handles, opened once at construction by `buildDb` and shared by every change set.
+ * That same store would open `{ items: AztecAsyncMap<string, Buffer>; itemsByBlockNumber: AztecAsyncMultiMap }`.
+ */
+export declare abstract class BaseStagingStore<TChangeSet, TDb> implements StagedStore, Rollbackable {
+    #private;
+    readonly storeName: string;
+    protected constructor({ storeName, store, buildChangeSet, buildDb }: {
+        /** Unique name identifying this store, used in error messages and for registration with StagedWriteCoordinator. */
+        storeName: string;
+        /** The backing kv store; the runners open their transactions on it. */
+        store: AztecAsyncKVStore;
+        /** Creates the empty staged data a change set starts with. */
+        buildChangeSet: () => TChangeSet;
+        /** Opens the store's kv handles. */
+        buildDb: (store: AztecAsyncKVStore) => TDb;
+    });
+    /**
+     * Opens the change set, so its operations are accepted until {@link commitChangeSet} or {@link discardChangeSet}.
+     *
+     * @throws If a change set is already open.
+     */
+    beginChangeSet(changeSetId: ChangeSetId): void;
+    /**
+     * Commits the change set's staged data: flushes it via {@link flushChangeSet}, then closes the change set. Runs
+     * inside the transaction owned by the caller.
+     *
+     * Not meant to be overridden: subclasses implement {@link flushChangeSet}.
+     *
+     * @throws If the change set is not open, or still has operations in flight.
+     */
+    commitChangeSet(changeSetId: ChangeSetId): Promise<void>;
+    /** Closes the change set, discarding any staged data without committing. A no-op if it is not open. */
+    discardChangeSet(changeSetId: ChangeSetId): void;
+    /**
+     * Rolls the store back to `toBlock` via {@link applyRollback}.
+     *
+     * Must be called inside a transaction owned by the caller, since it opens none of its own.
+     *
+     * Not meant to be overridden: subclasses implement {@link applyRollback}.
+     *
+     * @throws If a change set is open, since its staged writes could later be committed anchored to deleted blocks.
+     */
+    rollbackToBlock(toBlock: number): Promise<void>;
+    /**
+     * Writes the change set's staged data to persistent storage. Runs inside the caller's transaction: it must not
+     * open a transaction of its own or call {@link withChangeSetAndDb}.
+     */
+    protected abstract flushChangeSet(changeSet: TChangeSet, db: TDb): Promise<void>;
+    /**
+     * Deletes the state originating from blocks strictly above `toBlock`. Runs inside the transaction owned by
+     * {@link rollbackToBlock}'s caller: it must not open a transaction of its own or call {@link withChangeSetAndDb}.
+     */
+    protected abstract applyRollback(toBlock: number, db: TDb): Promise<void>;
+    /**
+     * Runs a change set operation that reads the DB. Takes the store's lock, opens a transaction, and calls `fn` with
+     * the change set's staged data and a read-only view of the DB (writes are staged in memory until
+     * {@link flushChangeSet} runs on commit).
+     *
+     * Prefer {@link withChangeSet} unless `fn` actually reads the DB.
+     *
+     * The lock makes the store thread safe: two operations issued concurrently (e.g. under `Promise.all`) cannot
+     * interleave across awaits, so `fn` can read staged data and write it back without handling atomicity itself.
+     *
+     * @throws If the change set is not open.
+     */
+    protected withChangeSetAndDb<R>(changeSetId: ChangeSetId, fn: (changeSet: TChangeSet, db: ReadonlyDb<TDb>) => Promise<R>): Promise<R>;
+    /**
+     * Runs a change set operation over the staged data alone: takes the store's lock and calls `fn` with the change
+     * set's staged data, opening no db transaction.
+     *
+     * Use {@link withChangeSetAndDb} instead when `fn` reads the DB.
+     *
+     * @throws If the change set is not open.
+     */
+    protected withChangeSet<R>(changeSetId: ChangeSetId, fn: (changeSet: TChangeSet) => R | Promise<R>): Promise<R>;
+}
+/**
+ * View of a store's kv handles restricted to the kv interfaces' read methods. Change set operations receive this view:
+ * while a change set is open the DB is read-only, since all writes are staged in memory until
+ * {@link BaseStagingStore.flushChangeSet} runs on commit.
+ */
+export type ReadonlyDb<T> = {
+    readonly [K in keyof T]: Pick<T[K], Extract<keyof T[K], ReadMethod>>;
+};
+/** The kv read surface staging stores use: what {@link ReadonlyDb} exposes while a change set is open. */
+type ReadMethod = 'getAsync' | 'hasAsync' | 'entriesAsync' | 'valuesAsync' | 'keysAsync' | 'sizeAsync' | 'getValuesAsync' | 'getValueCountAsync';
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dest/storage/base_staging_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_staging_store.d.ts","sourceRoot":"","sources":["../../src/storage/base_staging_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8BAAsB,gBAAgB,CAAC,UAAU,EAAE,GAAG,CAAE,YAAW,WAAW,EAAE,YAAY;;IAC1F,SAAgB,SAAS,EAAE,MAAM,CAAC;IAUlC,SAAS,aAAa,EACpB,SAAS,EACT,KAAK,EACL,cAAc,EACd,OAAO,EACR,EAAE;QACD,mHAAmH;QACnH,SAAS,EAAE,MAAM,CAAC;QAClB,uEAAuE;QACvE,KAAK,EAAE,iBAAiB,CAAC;QACzB,8DAA8D;QAC9D,cAAc,EAAE,MAAM,UAAU,CAAC;QACjC,oCAAoC;QACpC,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,GAAG,CAAC;KAC5C,EAKA;IAED;;;;OAIG;IACH,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAQ7C;IAED;;;;;;;OAOG;IACG,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAU7D;IAED,uGAAuG;IACvG,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAE/C;IAED;;;;;;;;OAQG;IACG,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOpD;IAED;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,SAAS,EAAE,UAAU,EAAE,EAAE,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjF;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1E;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,kBAAkB,CAAC,CAAC,EAC5B,WAAW,EAAE,WAAW,EACxB,EAAE,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CASZ;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,aAAa,CAAC,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAM9G;CA8BF;AAED;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;CACrE,CAAC;AAEF,0GAA0G;AAC1G,KAAK,UAAU,GACX,UAAU,GACV,UAAU,GACV,cAAc,GACd,aAAa,GACb,WAAW,GACX,WAAW,GACX,gBAAgB,GAChB,oBAAoB,CAAC"}

package/dest/storage/base_staging_store.js

@@ -0,0 +1,141 @@
+import { Semaphore } from '@aztec-labs/foundation/queue';
+/**
+ * Base class for stores that stage their writes per change set, flushing them on commit and dropping them on abort.
+ *
+ * A change set's staged data exists only between {@link beginChangeSet} and {@link commitChangeSet}/
+ * {@link discardChangeSet}. An operation arriving on behalf of a change set that already ended (e.g. one discarded on
+ * abort) finds no matching change set and throws, so it cannot stage new data for a dead one.
+ *
+ * The staged data and the store's kv handles live in this base class and are only reachable through
+ * {@link withChangeSet} (change set operations, staged data only), {@link withChangeSetAndDb} (change set operations
+ * that also read the DB), {@link flushChangeSet} (the commit-time write-back) and {@link applyRollback} (the reorg
+ * truncation).
+ *
+ * The class is thread safe: an internal lock serializes the operations run through {@link withChangeSet} and
+ * {@link withChangeSetAndDb}, so two of them issued concurrently (e.g. under `Promise.all`) never interleave across
+ * awaits. Subclasses can therefore read staged data and write it back without handling atomicity themselves.
+ *
+ * @typeParam TChangeSet - The in-memory buffer a change set accumulates its writes in, built empty by `buildChangeSet`
+ * on every {@link beginChangeSet} and dropped when the change set ends. A store keyed by id might stage
+ * `{ items: Map<string, Item> }`.
+ * @typeParam TDb - The store's kv handles, opened once at construction by `buildDb` and shared by every change set.
+ * That same store would open `{ items: AztecAsyncMap<string, Buffer>; itemsByBlockNumber: AztecAsyncMultiMap }`.
+ */ export class BaseStagingStore {
+    storeName;
+    #store;
+    #db;
+    #buildChangeSet;
+    #lock = new Semaphore(1);
+    /** The change set currently open, if any. */ #current;
+    constructor({ storeName, store, buildChangeSet, buildDb }){
+        this.storeName = storeName;
+        this.#store = store;
+        this.#buildChangeSet = buildChangeSet;
+        this.#db = buildDb(store);
+    }
+    /**
+   * Opens the change set, so its operations are accepted until {@link commitChangeSet} or {@link discardChangeSet}.
+   *
+   * @throws If a change set is already open.
+   */ beginChangeSet(changeSetId) {
+        if (this.#current !== undefined) {
+            throw new Error(`Store "${this.storeName}": cannot open change set "${changeSetId}" because change set ` + `"${this.#current.changeSetId}" is already open`);
+        }
+        this.#current = {
+            changeSetId,
+            changeSet: this.#buildChangeSet(),
+            inFlight: 0
+        };
+    }
+    /**
+   * Commits the change set's staged data: flushes it via {@link flushChangeSet}, then closes the change set. Runs
+   * inside the transaction owned by the caller.
+   *
+   * Not meant to be overridden: subclasses implement {@link flushChangeSet}.
+   *
+   * @throws If the change set is not open, or still has operations in flight.
+   */ async commitChangeSet(changeSetId) {
+        const current = this.#currentOrThrow(changeSetId);
+        if (current.inFlight > 0) {
+            throw new Error(`Store "${this.storeName}": cannot commit change set "${changeSetId}" while ${current.inFlight} of its ` + `operations are in flight`);
+        }
+        await this.flushChangeSet(current.changeSet, this.#db);
+        this.#closeChangeSet(changeSetId);
+    }
+    /** Closes the change set, discarding any staged data without committing. A no-op if it is not open. */ discardChangeSet(changeSetId) {
+        this.#closeChangeSet(changeSetId);
+    }
+    /**
+   * Rolls the store back to `toBlock` via {@link applyRollback}.
+   *
+   * Must be called inside a transaction owned by the caller, since it opens none of its own.
+   *
+   * Not meant to be overridden: subclasses implement {@link applyRollback}.
+   *
+   * @throws If a change set is open, since its staged writes could later be committed anchored to deleted blocks.
+   */ async rollbackToBlock(toBlock) {
+        if (this.#current !== undefined) {
+            throw new Error(`Store "${this.storeName}": cannot roll back while change set "${this.#current.changeSetId}" is open`);
+        }
+        await this.applyRollback(toBlock, this.#db);
+    }
+    /**
+   * Runs a change set operation that reads the DB. Takes the store's lock, opens a transaction, and calls `fn` with
+   * the change set's staged data and a read-only view of the DB (writes are staged in memory until
+   * {@link flushChangeSet} runs on commit).
+   *
+   * Prefer {@link withChangeSet} unless `fn` actually reads the DB.
+   *
+   * The lock makes the store thread safe: two operations issued concurrently (e.g. under `Promise.all`) cannot
+   * interleave across awaits, so `fn` can read staged data and write it back without handling atomicity itself.
+   *
+   * @throws If the change set is not open.
+   */ withChangeSetAndDb(changeSetId, fn) {
+        return this.#runLocked(changeSetId, ()=>this.#store.transactionAsync(()=>{
+                // Re-resolve after the wait: the change set may have been discarded while this operation queued on the lock
+                // or on the store's transaction queue.
+                const current = this.#currentOrThrow(changeSetId);
+                return fn(current.changeSet, this.#db);
+            }));
+    }
+    /**
+   * Runs a change set operation over the staged data alone: takes the store's lock and calls `fn` with the change
+   * set's staged data, opening no db transaction.
+   *
+   * Use {@link withChangeSetAndDb} instead when `fn` reads the DB.
+   *
+   * @throws If the change set is not open.
+   */ withChangeSet(changeSetId, fn) {
+        return this.#runLocked(changeSetId, async ()=>{
+            // Re-resolve after the wait: the change set may have been discarded while this operation queued on the lock.
+            const current = this.#currentOrThrow(changeSetId);
+            return await fn(current.changeSet);
+        });
+    }
+    async #runLocked(changeSetId, run) {
+        const entered = this.#currentOrThrow(changeSetId);
+        entered.inFlight++;
+        try {
+            await this.#lock.acquire();
+            try {
+                return await run();
+            } finally{
+                this.#lock.release();
+            }
+        } finally{
+            // Count down on the change set this operation entered, which may no longer be the open one.
+            entered.inFlight--;
+        }
+    }
+    #currentOrThrow(changeSetId) {
+        if (this.#current?.changeSetId !== changeSetId) {
+            throw new Error(`Store "${this.storeName}": change set "${changeSetId}" is not open`);
+        }
+        return this.#current;
+    }
+    #closeChangeSet(changeSetId) {
+        if (this.#current?.changeSetId === changeSetId) {
+            this.#current = undefined;
+        }
+    }
+}

package/dest/storage/capsule_store/capsule_service.d.ts

@@ -0,0 +1,22 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Capsule } from '@aztec-labs/stdlib/tx';
+import type { ChangeSetId } from '../staged_write_coordinator.js';
+import type { CapsuleStore } from './capsule_store.js';
+/**
+ * Wraps a CapsuleStore with scope-based access control. Each operation asserts that the requested scope is in the
+ * allowed scopes list before delegating to the underlying store.
+ */
+export declare class CapsuleService {
+    private readonly capsuleStore;
+    private readonly allowedScopes;
+    constructor(capsuleStore: CapsuleStore, allowedScopes: AztecAddress[]);
+    setCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[], changeSetId: ChangeSetId, scope: AztecAddress): void;
+    getCapsule(contractAddress: AztecAddress, slot: Fr, changeSetId: ChangeSetId, scope: AztecAddress, transientCapsules?: Capsule[]): Promise<Fr[] | null>;
+    deleteCapsule(contractAddress: AztecAddress, slot: Fr, changeSetId: ChangeSetId, scope: AztecAddress): void;
+    copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number, changeSetId: ChangeSetId, scope: AztecAddress): Promise<void>;
+    appendToCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][], changeSetId: ChangeSetId, scope: AztecAddress): Promise<void>;
+    readCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, changeSetId: ChangeSetId, scope: AztecAddress): Promise<Fr[][]>;
+    setCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][], changeSetId: ChangeSetId, scope: AztecAddress): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/storage/capsule_store/capsule_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capsule_service.d.ts","sourceRoot":"","sources":["../../../src/storage/capsule_store/capsule_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAGrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,qBAAa,cAAc;IAIvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAH/B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiB;IAE/C,YACmB,YAAY,EAAE,YAAY,EAC3C,aAAa,EAAE,YAAY,EAAE,EAI9B;IAED,UAAU,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,QAG/G;IAEK,UAAU,CACd,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,EAAE,EACR,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,EACnB,iBAAiB,CAAC,EAAE,OAAO,EAAE,GAC5B,OAAO,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAYtB;IAED,aAAa,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,QAGnG;IAED,WAAW,CACT,eAAe,EAAE,YAAY,EAC7B,OAAO,EAAE,EAAE,EACX,OAAO,EAAE,EAAE,EACX,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CAGf;IAED,oBAAoB,CAClB,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,EAAE,EACZ,OAAO,EAAE,EAAE,EAAE,EAAE,EACf,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CAGf;IAED,gBAAgB,CACd,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,EAAE,EACZ,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAGjB;IAED,eAAe,CACb,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,EAAE,EACZ,OAAO,EAAE,EAAE,EAAE,EAAE,EACf,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,iBAIpB;CACF"}

package/dest/storage/capsule_store/capsule_service.js

@@ -0,0 +1,47 @@
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { assertAllowedScope } from '../allowed_scopes.js';
+/**
+ * Wraps a CapsuleStore with scope-based access control. Each operation asserts that the requested scope is in the
+ * allowed scopes list before delegating to the underlying store.
+ */ export class CapsuleService {
+    capsuleStore;
+    allowedScopes;
+    constructor(capsuleStore, allowedScopes){
+        this.capsuleStore = capsuleStore;
+        // The zero address denotes the global capsule scope, which is always permitted.
+        this.allowedScopes = [
+            ...allowedScopes,
+            AztecAddress.ZERO
+        ];
+    }
+    setCapsule(contractAddress, slot, capsule, changeSetId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        this.capsuleStore.setCapsule(contractAddress, slot, capsule, changeSetId, scope);
+    }
+    async getCapsule(contractAddress, slot, changeSetId, scope, transientCapsules) {
+        assertAllowedScope(scope, this.allowedScopes);
+        // TODO(#12425): On the following line, the pertinent capsule gets overshadowed by the transient one. Tackle this.
+        const maybeTransientCapsule = transientCapsules?.find((c)=>c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot) && (c.scope ?? AztecAddress.ZERO).equals(scope))?.data;
+        return maybeTransientCapsule ?? await this.capsuleStore.getCapsule(contractAddress, slot, changeSetId, scope);
+    }
+    deleteCapsule(contractAddress, slot, changeSetId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        this.capsuleStore.deleteCapsule(contractAddress, slot, changeSetId, scope);
+    }
+    copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, changeSetId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        return this.capsuleStore.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, changeSetId, scope);
+    }
+    appendToCapsuleArray(contractAddress, baseSlot, content, changeSetId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        return this.capsuleStore.appendToCapsuleArray(contractAddress, baseSlot, content, changeSetId, scope);
+    }
+    readCapsuleArray(contractAddress, baseSlot, changeSetId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        return this.capsuleStore.readCapsuleArray(contractAddress, baseSlot, changeSetId, scope);
+    }
+    setCapsuleArray(contractAddress, baseSlot, content, changeSetId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        return this.capsuleStore.setCapsuleArray(contractAddress, baseSlot, content, changeSetId, scope);
+    }
+}

package/dest/storage/capsule_store/capsule_store.d.ts

@@ -0,0 +1,72 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type Logger } from '@aztec-labs/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { ChangeSetId, StagedStore } from '../staged_write_coordinator.js';
+export declare class CapsuleStore implements StagedStore {
+    #private;
+    readonly storeName = "capsule";
+    logger: Logger;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * Commits staged data to main storage. Called by StagedWriteCoordinator when an operation completes successfully.
+     * Note: StagedWriteCoordinator wraps all commits in a single transaction, so we don't need our own transactionAsync
+     * here (and using one would deadlock on IndexedDB).
+     * @param changeSetId - The changeSetId identifying which staged data to commit
+     */
+    commitChangeSet(changeSetId: ChangeSetId): Promise<void>;
+    /**
+     * Discards staged data without committing.
+     */
+    discardChangeSet(changeSetId: ChangeSetId): void;
+    /**
+     * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `loadCapsule`.
+     * * If data was already stored at this slot, it is overwritten.
+     * @param contractAddress - The contract address to scope the data under.
+     * @param slot - The slot in the database in which to store the value. Slots need not be contiguous.
+     * @param capsule - An array of field elements representing the capsule.
+     * @param changeSetId - The context in which this store will be visible until PXE decides to persist it to underlying
+     * KV store
+     * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle. It works similarly
+     * to public contract storage in that it's indexed by the contract address and storage slot but instead of the global
+     * network state it's backed by local PXE db.
+     */
+    setCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[], changeSetId: ChangeSetId, scope: AztecAddress): void;
+    /**
+     * Returns data previously stored via `storeCapsule` in the per-contract non-volatile database.
+     * @param contractAddress - The contract address under which the data is scoped.
+     * @param slot - The slot in the database to read.
+     * @returns The stored data or `null` if no data is stored under the slot.
+     */
+    getCapsule(contractAddress: AztecAddress, slot: Fr, changeSetId: ChangeSetId, scope: AztecAddress): Promise<Fr[] | null>;
+    /**
+     * Deletes data in the per-contract non-volatile database. Does nothing if no data was present.
+     * @param contractAddress - The contract address under which the data is scoped.
+     * @param slot - The slot in the database to delete.
+     */
+    deleteCapsule(contractAddress: AztecAddress, slot: Fr, changeSetId: ChangeSetId, scope: AztecAddress): void;
+    /**
+     * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
+     * structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.
+     * Supports overlapping source and destination regions (which will result in the overlapped source values being
+     * overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)
+     *
+     * @param contractAddress - The contract address under which the data is scoped.
+     * @param srcSlot - The first slot to copy from.
+     * @param dstSlot - The first slot to copy to.
+     * @param numEntries - The number of entries to copy.
+     */
+    copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number, changeSetId: ChangeSetId, scope: AztecAddress): Promise<void>;
+    /**
+     * Appends multiple capsules to a capsule array stored at the base slot.
+     * The array length is stored at the base slot, and elements are stored in consecutive slots after it.
+     * All operations are performed in a single transaction.
+     * @param contractAddress - The contract address that owns the capsule array
+     * @param baseSlot - The slot where the array length is stored
+     * @param content - Array of capsule data to append
+     */
+    appendToCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][], changeSetId: ChangeSetId, scope: AztecAddress): Promise<void>;
+    readCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, changeSetId: ChangeSetId, scope: AztecAddress): Promise<Fr[][]>;
+    setCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][], changeSetId: ChangeSetId, scope: AztecAddress): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/storage/capsule_store/capsule_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capsule_store.d.ts","sourceRoot":"","sources":["../../../src/storage/capsule_store/capsule_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAE/E,qBAAa,YAAa,YAAW,WAAW;;IAC9C,QAAQ,CAAC,SAAS,aAAa;IAa/B,MAAM,EAAE,MAAM,CAAC;IAEf,YAAY,KAAK,EAAE,iBAAiB,EAQnC;IA8DD;;;;;OAKG;IACG,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAe7D;IAED;;OAEG;IACH,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAE/C;IAED;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,QAK/G;IAED;;;;;OAKG;IACH,UAAU,CACR,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,EAAE,EACR,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAEtB;IAqBD;;;;OAIG;IACH,aAAa,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,QAGnG;IAED;;;;;;;;;;OAUG;IACH,WAAW,CACT,eAAe,EAAE,YAAY,EAC7B,OAAO,EAAE,EAAE,EACX,OAAO,EAAE,EAAE,EACX,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CA2Bf;IAED;;;;;;;OAOG;IACH,oBAAoB,CAClB,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,EAAE,EACZ,OAAO,EAAE,EAAE,EAAE,EAAE,EACf,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CAqBf;IAED,gBAAgB,CACd,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,EAAE,EACZ,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CA+BjB;IAED,eAAe,CACb,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,EAAE,EACZ,OAAO,EAAE,EAAE,EAAE,EAAE,EACf,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,YAAY,iBA0BpB;CACF"}