@aztec/pxe 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/dest/storage/address_store/address_store.d.ts

@@ -0,0 +1,11 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+export declare class AddressStore {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    addCompleteAddress(completeAddress: CompleteAddress): Promise<boolean>;
+    getCompleteAddress(account: AztecAddress): Promise<CompleteAddress | undefined>;
+    getCompleteAddresses(): Promise<CompleteAddress[]>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRkcmVzc19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvYWRkcmVzc19zdG9yZS9hZGRyZXNzX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFtQixpQkFBaUIsRUFBaUIsTUFBTSxpQkFBaUIsQ0FBQztBQUN6RixPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFekQscUJBQWEsWUFBWTs7SUFLdkIsWUFBWSxLQUFLLEVBQUUsaUJBQWlCLEVBS25DO0lBRUQsa0JBQWtCLENBQUMsZUFBZSxFQUFFLGVBQWUsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBMEJyRTtJQUVELGtCQUFrQixDQUFDLE9BQU8sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLGVBQWUsR0FBRyxTQUFTLENBQUMsQ0FVOUU7SUFFRCxvQkFBb0IsSUFBSSxPQUFPLENBQUMsZUFBZSxFQUFFLENBQUMsQ0FNakQ7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"address_store.d.ts","sourceRoot":"","sources":["../../../src/storage/address_store/address_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,qBAAa,YAAY;;IAKvB,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED,kBAAkB,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CA0BrE;IAED,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAU9E;IAED,oBAAoB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAMjD;CACF"}

package/dest/storage/{address_data_provider/address_data_provider.js → address_store/address_store.js}

@@ -1,6 +1,6 @@
 import { toArray } from '@aztec/foundation/iterable';
 import { CompleteAddress } from '@aztec/stdlib/contract';
-export class AddressDataProvider {
+export class AddressStore {
     #store;
     #completeAddresses;
     #completeAddressIndex;
@@ -30,18 +30,19 @@ export class AddressDataProvider {
             }
         });
     }
-    async #getCompleteAddress(address) {
-        const index = await this.#completeAddressIndex.getAsync(address.toString());
-        if (index === undefined) {
-            return undefined;
-        }
-        const value = await this.#completeAddresses.atAsync(index);
-        return value ? await CompleteAddress.fromBuffer(value) : undefined;
-    }
     getCompleteAddress(account) {
-        return this.#getCompleteAddress(account);
+        return this.#store.transactionAsync(async ()=>{
+            const index = await this.#completeAddressIndex.getAsync(account.toString());
+            if (index === undefined) {
+                return undefined;
+            }
+            const value = await this.#completeAddresses.atAsync(index);
+            return value ? await CompleteAddress.fromBuffer(value) : undefined;
+        });
     }
-    async getCompleteAddresses() {
-        return await Promise.all((await toArray(this.#completeAddresses.valuesAsync())).map((v)=>CompleteAddress.fromBuffer(v)));
+    getCompleteAddresses() {
+        return this.#store.transactionAsync(async ()=>{
+            return await Promise.all((await toArray(this.#completeAddresses.valuesAsync())).map((v)=>CompleteAddress.fromBuffer(v)));
+        });
     }
 }

package/dest/storage/address_store/index.d.ts

@@ -0,0 +1,2 @@
+export { AddressStore } from './address_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL2FkZHJlc3Nfc3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDIn0=

package/dest/storage/address_store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/address_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dest/storage/address_store/index.js

@@ -0,0 +1 @@
+export { AddressStore } from './address_store.js';

package/dest/storage/anchor_block_store/anchor_block_store.d.ts

@@ -0,0 +1,17 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { BlockHeader } from '@aztec/stdlib/tx';
+export declare class AnchorBlockStore {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * Sets the currently synchronized block
+     *
+     * Important: this method is only called from BlockSynchronizer, and since we need it to run atomically with other
+     * stores in the case of a reorg, it MUST NOT be wrapped in a `transactionAsync` call. Doing so would result in a
+     * deadlock when the backend is IndexedDB, because `transactionAsync` is not designed to support reentrancy.
+     *
+     */
+    setHeader(header: BlockHeader): Promise<void>;
+    getBlockHeader(): Promise<BlockHeader>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5jaG9yX2Jsb2NrX3N0b3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9hbmNob3JfYmxvY2tfc3RvcmUvYW5jaG9yX2Jsb2NrX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUF1QixNQUFNLGlCQUFpQixDQUFDO0FBQzlFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUvQyxxQkFBYSxnQkFBZ0I7O0lBSTNCLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUduQztJQUVEOzs7Ozs7O09BT0c7SUFDRyxTQUFTLENBQUMsTUFBTSxFQUFFLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRWxEO0lBRUssY0FBYyxJQUFJLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FPM0M7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"anchor_block_store.d.ts","sourceRoot":"","sources":["../../../src/storage/anchor_block_store/anchor_block_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAuB,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qBAAa,gBAAgB;;IAI3B,YAAY,KAAK,EAAE,iBAAiB,EAGnC;IAED;;;;;;;OAOG;IACG,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAElD;IAEK,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC,CAO3C;CACF"}

package/dest/storage/anchor_block_store/anchor_block_store.js

@@ -0,0 +1,26 @@
+import { BlockHeader } from '@aztec/stdlib/tx';
+export class AnchorBlockStore {
+    #store;
+    #synchronizedHeader;
+    constructor(store){
+        this.#store = store;
+        this.#synchronizedHeader = this.#store.openSingleton('header');
+    }
+    /**
+   * Sets the currently synchronized block
+   *
+   * Important: this method is only called from BlockSynchronizer, and since we need it to run atomically with other
+   * stores in the case of a reorg, it MUST NOT be wrapped in a `transactionAsync` call. Doing so would result in a
+   * deadlock when the backend is IndexedDB, because `transactionAsync` is not designed to support reentrancy.
+   *
+   */ async setHeader(header) {
+        await this.#synchronizedHeader.set(header.toBuffer());
+    }
+    async getBlockHeader() {
+        const headerBuffer = await this.#store.transactionAsync(()=>this.#synchronizedHeader.getAsync());
+        if (!headerBuffer) {
+            throw new Error(`Trying to get block header with a not-yet-synchronized PXE - this should never happen`);
+        }
+        return BlockHeader.fromBuffer(headerBuffer);
+    }
+}

package/dest/storage/{sync_data_provider → anchor_block_store}/index.d.ts

@@ -1,2 +1,2 @@
-export { SyncDataProvider } from './sync_data_provider.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3N5bmNfZGF0YV9wcm92aWRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQyJ9
+export { AnchorBlockStore } from './anchor_block_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL2FuY2hvcl9ibG9ja19zdG9yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQyJ9

package/dest/storage/anchor_block_store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/anchor_block_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC"}

package/dest/storage/anchor_block_store/index.js

@@ -0,0 +1 @@
+export { AnchorBlockStore } from './anchor_block_store.js';

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

@@ -0,0 +1,21 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Capsule } from '@aztec/stdlib/tx';
+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[], jobId: string, scope: AztecAddress): void;
+    getCapsule(contractAddress: AztecAddress, slot: Fr, jobId: string, scope: AztecAddress, transientCapsules?: Capsule[]): Promise<Fr[] | null>;
+    deleteCapsule(contractAddress: AztecAddress, slot: Fr, jobId: string, scope: AztecAddress): void;
+    copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number, jobId: string, scope: AztecAddress): Promise<void>;
+    appendToCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][], jobId: string, scope: AztecAddress): Promise<void>;
+    readCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, jobId: string, scope: AztecAddress): Promise<Fr[][]>;
+    setCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][], jobId: string, scope: AztecAddress): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fwc3VsZV9zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9jYXBzdWxlX3N0b3JlL2NhcHN1bGVfc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDM0QsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFdkQ7OztHQUdHO0FBQ0gscUJBQWEsY0FBYztJQUV2QixPQUFPLENBQUMsUUFBUSxDQUFDLFlBQVk7SUFDN0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxhQUFhO0lBRmhDLFlBQ21CLFlBQVksRUFBRSxZQUFZLEVBQzFCLGFBQWEsRUFBRSxZQUFZLEVBQUUsRUFDNUM7SUFFSixVQUFVLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxZQUFZLFFBR3BHO0lBRUssVUFBVSxDQUNkLGVBQWUsRUFBRSxZQUFZLEVBQzdCLElBQUksRUFBRSxFQUFFLEVBQ1IsS0FBSyxFQUFFLE1BQU0sRUFDYixLQUFLLEVBQUUsWUFBWSxFQUNuQixpQkFBaUIsQ0FBQyxFQUFFLE9BQU8sRUFBRSxHQUM1QixPQUFPLENBQUMsRUFBRSxFQUFFLEdBQUcsSUFBSSxDQUFDLENBWXRCO0lBRUQsYUFBYSxDQUFDLGVBQWUsRUFBRSxZQUFZLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxZQUFZLFFBR3hGO0lBRUQsV0FBVyxDQUNULGVBQWUsRUFBRSxZQUFZLEVBQzdCLE9BQU8sRUFBRSxFQUFFLEVBQ1gsT0FBTyxFQUFFLEVBQUUsRUFDWCxVQUFVLEVBQUUsTUFBTSxFQUNsQixLQUFLLEVBQUUsTUFBTSxFQUNiLEtBQUssRUFBRSxZQUFZLEdBQ2xCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FHZjtJQUVELG9CQUFvQixDQUNsQixlQUFlLEVBQUUsWUFBWSxFQUM3QixRQUFRLEVBQUUsRUFBRSxFQUNaLE9BQU8sRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUNmLEtBQUssRUFBRSxNQUFNLEVBQ2IsS0FBSyxFQUFFLFlBQVksR0FDbEIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUdmO0lBRUQsZ0JBQWdCLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUdqSDtJQUVELGVBQWUsQ0FBQyxlQUFlLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsWUFBWSxpQkFHL0c7Q0FDRiJ9

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,gCAAgC,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAFhC,YACmB,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,YAAY,EAAE,EAC5C;IAEJ,UAAU,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,QAGpG;IAEK,UAAU,CACd,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,EAAE,EACR,KAAK,EAAE,MAAM,EACb,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,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,QAGxF;IAED,WAAW,CACT,eAAe,EAAE,YAAY,EAC7B,OAAO,EAAE,EAAE,EACX,OAAO,EAAE,EAAE,EACX,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,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,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CAGf;IAED,gBAAgB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAGjH;IAED,eAAe,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,iBAG/G;CACF"}

package/dest/storage/capsule_store/capsule_service.js

@@ -0,0 +1,50 @@
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * 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;
+        this.allowedScopes = allowedScopes;
+    }
+    setCapsule(contractAddress, slot, capsule, jobId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        this.capsuleStore.setCapsule(contractAddress, slot, capsule, jobId, scope);
+    }
+    async getCapsule(contractAddress, slot, jobId, 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, jobId, scope);
+    }
+    deleteCapsule(contractAddress, slot, jobId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        this.capsuleStore.deleteCapsule(contractAddress, slot, jobId, scope);
+    }
+    copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, jobId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        return this.capsuleStore.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, jobId, scope);
+    }
+    appendToCapsuleArray(contractAddress, baseSlot, content, jobId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        return this.capsuleStore.appendToCapsuleArray(contractAddress, baseSlot, content, jobId, scope);
+    }
+    readCapsuleArray(contractAddress, baseSlot, jobId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        return this.capsuleStore.readCapsuleArray(contractAddress, baseSlot, jobId, scope);
+    }
+    setCapsuleArray(contractAddress, baseSlot, content, jobId, scope) {
+        assertAllowedScope(scope, this.allowedScopes);
+        return this.capsuleStore.setCapsuleArray(contractAddress, baseSlot, content, jobId, scope);
+    }
+}
+function assertAllowedScope(scope, allowedScopes) {
+    if (scope.equals(AztecAddress.ZERO)) {
+        return;
+    }
+    if (!allowedScopes.some((allowed)=>allowed.equals(scope))) {
+        throw new Error(`Scope ${scope.toString()} is not in the allowed scopes list: [${allowedScopes.map((s)=>s.toString()).join(', ')}]. See https://docs.aztec.network/errors/10`);
+    }
+}

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

@@ -0,0 +1,72 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { StagedStore } from '../../job_coordinator/job_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 JobCoordinator when a job completes successfully.
+     * Note: JobCoordinator wraps all commits in a single transaction, so we don't
+     * need our own transactionAsync here (and using one would deadlock on IndexedDB).
+     * @param jobId - The jobId identifying which staged data to commit
+     */
+    commit(jobId: string): Promise<void>;
+    /**
+     * Discards staged data without committing.
+     */
+    discardStaged(jobId: string): Promise<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 jobId - 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[], jobId: string, 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, jobId: string, 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, jobId: string, 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, jobId: string, 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[][], jobId: string, scope: AztecAddress): Promise<void>;
+    readCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, jobId: string, scope: AztecAddress): Promise<Fr[][]>;
+    setCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][], jobId: string, 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,gCAAgC,CAAC;AACpD,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAC;AAE5E,qBAAa,YAAa,YAAW,WAAW;;IAC9C,QAAQ,CAAC,SAAS,aAAa;IAa/B,MAAM,EAAE,MAAM,CAAC;IAEf,YAAY,KAAK,EAAE,iBAAiB,EAQnC;IA+DD;;;;;;OAMG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAezC;IAED;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1C;IAED;;;;;;;;;;OAUG;IACH,UAAU,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,QAKpG;IAED;;;;;OAKG;IACH,UAAU,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAE5G;IAqBD;;;;OAIG;IACH,aAAa,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,QAGxF;IAED;;;;;;;;;;OAUG;IACH,WAAW,CACT,eAAe,EAAE,YAAY,EAC7B,OAAO,EAAE,EAAE,EACX,OAAO,EAAE,EAAE,EACX,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,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,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CAqBf;IAED,gBAAgB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CA2BjH;IAED,eAAe,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,iBA2B/G;CACF"}

package/dest/storage/capsule_store/capsule_store.js

@@ -0,0 +1,261 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+export class CapsuleStore {
+    storeName = 'capsule';
+    #store;
+    // Arbitrary data stored by contracts. Key is computed as `${contractAddress}:${scope}:${key}`, using the zero
+    // address for the global scope.
+    #capsules;
+    // jobId => `${contractAddress}:${scope}:${key}` => capsule data
+    // when `#stagedCapsules.get('some-job-id').get('${some-contract-address}:${some-scope}:${some-key}') === null`,
+    // it signals that the capsule was deleted during the job, so it needs to be deleted on commit
+    #stagedCapsules;
+    logger;
+    constructor(store){
+        this.#store = store;
+        this.#capsules = this.#store.openMap('capsules');
+        this.#stagedCapsules = new Map();
+        this.logger = createLogger('pxe:capsule-data-provider');
+    }
+    /**
+   * Given a job denoted by `jobId`, it returns the
+   * capsules that said job has interacted with.
+   *
+   * Capsules that haven't been committed to persistence KV storage
+   * are kept in-memory in `#stagedCapsules`, this method provides a convenient
+   * way to access that in-memory collection of data.
+   *
+   * @param jobId
+   * @returns
+   */ #getJobStagedCapsules(jobId) {
+        let jobStagedCapsules = this.#stagedCapsules.get(jobId);
+        if (!jobStagedCapsules) {
+            jobStagedCapsules = new Map();
+            this.#stagedCapsules.set(jobId, jobStagedCapsules);
+        }
+        return jobStagedCapsules;
+    }
+    /**
+   * Reads a capsule's slot from the staged version of the data associated to the given jobId.
+   *
+   * If it is not there, it reads it from the KV store.
+   */ async #getFromStage(jobId, dbSlotKey) {
+        const jobStagedCapsules = this.#getJobStagedCapsules(jobId);
+        const staged = jobStagedCapsules.get(dbSlotKey);
+        // Always issue DB read to keep IndexedDB transaction alive, even if the value is in the job staged data. This
+        // keeps IndexedDB transactions alive (they auto-commit when a new micro-task starts and there are no pending read
+        // requests). The staged value still takes precedence if it exists (including null for deletions).
+        const dbValue = await this.#loadCapsuleFromDb(dbSlotKey);
+        return staged !== undefined ? staged : dbValue;
+    }
+    /**
+   * Writes a capsule to the stage of a job.
+   */ #setOnStage(jobId, dbSlotKey, capsuleData) {
+        this.#getJobStagedCapsules(jobId).set(dbSlotKey, capsuleData);
+    }
+    /**
+   * Deletes a capsule on the stage of a job. Note the capsule will still
+   * exist in storage until the job is committed.
+   */ #deleteOnStage(jobId, dbSlotKey) {
+        this.#getJobStagedCapsules(jobId).set(dbSlotKey, null);
+    }
+    async #loadCapsuleFromDb(dbSlotKey) {
+        const dataBuffer = await this.#capsules.getAsync(dbSlotKey);
+        if (!dataBuffer) {
+            return null;
+        }
+        return dataBuffer;
+    }
+    /**
+   * Commits staged data to main storage.
+   * Called by JobCoordinator when a job completes successfully.
+   * Note: JobCoordinator wraps all commits in a single transaction, so we don't
+   * need our own transactionAsync here (and using one would deadlock on IndexedDB).
+   * @param jobId - The jobId identifying which staged data to commit
+   */ async commit(jobId) {
+        const jobStagedCapsules = this.#getJobStagedCapsules(jobId);
+        for (const [key, value] of jobStagedCapsules){
+            // In the write stage, we represent deleted capsules with null
+            // (as opposed to undefined, which denotes there was never a capsule there to begin with).
+            // So we delete from actual KV store here.
+            if (value === null) {
+                await this.#capsules.delete(key);
+            } else {
+                await this.#capsules.set(key, value);
+            }
+        }
+        this.#stagedCapsules.delete(jobId);
+    }
+    /**
+   * Discards staged data without committing.
+   */ discardStaged(jobId) {
+        this.#stagedCapsules.delete(jobId);
+        return Promise.resolve();
+    }
+    /**
+   * 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 jobId - 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, slot, capsule, jobId, scope) {
+        const dbSlotKey = dbSlotToKey(contractAddress, slot, scope);
+        // A store overrides any pre-existing data on the slot
+        this.#setOnStage(jobId, dbSlotKey, Buffer.concat(capsule.map((value)=>value.toBuffer())));
+    }
+    /**
+   * 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, slot, jobId, scope) {
+        return this.#store.transactionAsync(()=>this.#getCapsuleInternal(contractAddress, slot, jobId, scope));
+    }
+    /** Same as getCapsule but without its own transaction, for use inside an existing transactionAsync. */ async #getCapsuleInternal(contractAddress, slot, jobId, scope) {
+        const dataBuffer = await this.#getFromStage(jobId, dbSlotToKey(contractAddress, slot, scope));
+        if (!dataBuffer) {
+            this.logger.trace(`Data not found for contract ${contractAddress.toString()} and slot ${slot.toString()}`);
+            return null;
+        }
+        const capsule = [];
+        for(let i = 0; i < dataBuffer.length; i += Fr.SIZE_IN_BYTES){
+            capsule.push(Fr.fromBuffer(dataBuffer.subarray(i, i + Fr.SIZE_IN_BYTES)));
+        }
+        return capsule;
+    }
+    /**
+   * 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, slot, jobId, scope) {
+        // When we commit this, we will interpret null as a deletion, so we'll propagate the delete to the KV store
+        this.#deleteOnStage(jobId, dbSlotToKey(contractAddress, slot, scope));
+    }
+    /**
+   * 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, srcSlot, dstSlot, numEntries, jobId, scope) {
+        // This transactional context gives us "copy atomicity":
+        // there shouldn't be concurrent writes to what's being copied here.
+        // Equally important: this in practice is expected to perform thousands of DB operations
+        // and not using a transaction here would heavily impact performance.
+        return this.#store.transactionAsync(async ()=>{
+            // In order to support overlapping source and destination regions, we need to check the relative positions of source
+            // and destination. If destination is ahead of source, then by the time we overwrite source elements using forward
+            // indexes we'll have already read those. On the contrary, if source is ahead of destination we need to use backward
+            // indexes to avoid reading elements that've been overwritten.
+            const indexes = Array.from(Array(numEntries).keys());
+            if (srcSlot.lt(dstSlot)) {
+                indexes.reverse();
+            }
+            for (const i of indexes){
+                const currentSrcSlot = dbSlotToKey(contractAddress, srcSlot.add(new Fr(i)), scope);
+                const currentDstSlot = dbSlotToKey(contractAddress, dstSlot.add(new Fr(i)), scope);
+                const toCopy = await this.#getFromStage(jobId, currentSrcSlot);
+                if (!toCopy) {
+                    throw new Error(`Attempted to copy empty slot ${currentSrcSlot} for contract ${contractAddress.toString()}`);
+                }
+                this.#setOnStage(jobId, currentDstSlot, toCopy);
+            }
+        });
+    }
+    /**
+   * 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, baseSlot, content, jobId, scope) {
+        // We wrap this in a transaction to serialize concurrent calls from Promise.all.
+        // Without this, concurrent appends to the same array could race: both read length=0,
+        // both write at the same slots, one overwrites the other.
+        // Equally important: this in practice is expected to perform thousands of DB operations
+        // and not using a transaction here would heavily impact performance.
+        return this.#store.transactionAsync(async ()=>{
+            // Load current length, defaulting to 0 if not found
+            const lengthData = await this.#getCapsuleInternal(contractAddress, baseSlot, jobId, scope);
+            const currentLength = lengthData ? lengthData[0].toNumber() : 0;
+            // Store each capsule at consecutive slots after baseSlot + 1 + currentLength
+            for(let i = 0; i < content.length; i++){
+                const nextSlot = arraySlot(baseSlot, currentLength + i);
+                this.setCapsule(contractAddress, nextSlot, content[i], jobId, scope);
+            }
+            // Update length to include all new capsules
+            const newLength = currentLength + content.length;
+            this.setCapsule(contractAddress, baseSlot, [
+                new Fr(newLength)
+            ], jobId, scope);
+        });
+    }
+    readCapsuleArray(contractAddress, baseSlot, jobId, scope) {
+        // I'm leaving this transactional context here though because I'm assuming this
+        // gives us "read array atomicity": there shouldn't be concurrent writes to what's being copied
+        // here.
+        // This is one point we should revisit in the future if we want to relax the concurrency
+        // of jobs: different calls running concurrently on the same contract may cause trouble.
+        return this.#store.transactionAsync(async ()=>{
+            // Load length, defaulting to 0 if not found
+            const maybeLength = await this.#getCapsuleInternal(contractAddress, baseSlot, jobId, scope);
+            const length = maybeLength ? maybeLength[0].toBigInt() : 0n;
+            const values = [];
+            // Read each capsule at consecutive slots after baseSlot
+            for(let i = 0; i < length; i++){
+                const currentValue = await this.#getCapsuleInternal(contractAddress, arraySlot(baseSlot, i), jobId, scope);
+                if (currentValue == undefined) {
+                    throw new Error(`Expected non-empty value at capsule array in base slot ${baseSlot} at index ${i} for contract ${contractAddress}`);
+                }
+                values.push(currentValue);
+            }
+            return values;
+        });
+    }
+    setCapsuleArray(contractAddress, baseSlot, content, jobId, scope) {
+        // This transactional context in theory isn't so critical now because we aren't
+        // writing to DB so if there's exceptions midway and it blows up, no visible impact
+        // to persistent storage will happen.
+        // I'm leaving this transactional context here though because I'm assuming this
+        // gives us "write array atomicity": there shouldn't be concurrent writes to what's being copied
+        // here.
+        // This is one point we should revisit in the future if we want to relax the concurrency
+        // of jobs: different calls running concurrently on the same contract may cause trouble.
+        return this.#store.transactionAsync(async ()=>{
+            // Load current length, defaulting to 0 if not found
+            const maybeLength = await this.#getCapsuleInternal(contractAddress, baseSlot, jobId, scope);
+            const originalLength = maybeLength ? maybeLength[0].toNumber() : 0;
+            // Set the new length
+            this.setCapsule(contractAddress, baseSlot, [
+                new Fr(content.length)
+            ], jobId, scope);
+            // Store the new content, possibly overwriting existing values
+            for(let i = 0; i < content.length; i++){
+                this.setCapsule(contractAddress, arraySlot(baseSlot, i), content[i], jobId, scope);
+            }
+            // Clear any stragglers
+            for(let i = content.length; i < originalLength; i++){
+                this.deleteCapsule(contractAddress, arraySlot(baseSlot, i), jobId, scope);
+            }
+        });
+    }
+}
+function dbSlotToKey(contractAddress, slot, scope) {
+    return [
+        contractAddress.toString(),
+        scope.toString(),
+        slot.toString()
+    ].join(':');
+}
+function arraySlot(baseSlot, index) {
+    return baseSlot.add(new Fr(1)).add(new Fr(index));
+}

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

@@ -0,0 +1,3 @@
+export { CapsuleService } from './capsule_service.js';
+export { CapsuleStore } from './capsule_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL2NhcHN1bGVfc3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/capsule_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dest/storage/capsule_store/index.js

@@ -0,0 +1,2 @@
+export { CapsuleService } from './capsule_service.js';
+export { CapsuleStore } from './capsule_store.js';