@aztec/pxe 0.77.1 → 0.78.1

package/dest/storage/sync_data_provider/sync_data_provider.js

@@ -0,0 +1,29 @@
+import { BlockHeader } from '@aztec/stdlib/tx';
+export class SyncDataProvider {
+    #store;
+    #synchronizedHeader;
+    constructor(store){
+        this.#store = store;
+        this.#synchronizedHeader = this.#store.openSingleton('header');
+    }
+    async setHeader(header) {
+        await this.#synchronizedHeader.set(header.toBuffer());
+    }
+    async getBlockNumber() {
+        const headerBuffer = await this.#synchronizedHeader.getAsync();
+        if (!headerBuffer) {
+            return undefined;
+        }
+        return Number(BlockHeader.fromBuffer(headerBuffer).globalVariables.blockNumber.toBigInt());
+    }
+    async getBlockHeader() {
+        const headerBuffer = await this.#synchronizedHeader.getAsync();
+        if (!headerBuffer) {
+            throw new Error(`Header not set`);
+        }
+        return BlockHeader.fromBuffer(headerBuffer);
+    }
+    async getSize() {
+        return (await this.#synchronizedHeader.getAsync())?.length ?? 0;
+    }
+}

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

@@ -0,0 +1,2 @@
+export { TaggingDataProvider } from './tagging_data_provider.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dest/storage/tagging_data_provider/index.js

@@ -0,0 +1 @@
+export { TaggingDataProvider } from './tagging_data_provider.js';

package/dest/storage/tagging_data_provider/tagging_data_provider.d.ts

@@ -0,0 +1,18 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { IndexedTaggingSecret } from '@aztec/stdlib/logs';
+export declare class TaggingDataProvider {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[]): Promise<void>;
+    setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[]): Promise<void>;
+    getTaggingSecretsIndexesAsRecipient(appTaggingSecrets: Fr[]): Promise<number[]>;
+    getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[]): Promise<number[]>;
+    resetNoteSyncData(): Promise<void>;
+    addSenderAddress(address: AztecAddress): Promise<boolean>;
+    getSenderAddresses(): Promise<AztecAddress[]>;
+    removeSenderAddress(address: AztecAddress): Promise<boolean>;
+    getSize(): Promise<number>;
+}
+//# sourceMappingURL=tagging_data_provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tagging_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_data_provider/tagging_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,qBAAa,mBAAmB;;gBAUlB,KAAK,EAAE,iBAAiB;IAS9B,gCAAgC,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvF,mCAAmC,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAY1F,mCAAmC,CAAC,iBAAiB,EAAE,EAAE,EAAE;IAI3D,gCAAgC,CAAC,iBAAiB,EAAE,EAAE,EAAE;IAQ9D,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAUzD,kBAAkB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAI7C,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAU5D,OAAO;CAKd"}

package/dest/storage/tagging_data_provider/tagging_data_provider.js

@@ -0,0 +1,65 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+export class TaggingDataProvider {
+    #store;
+    #addressBook;
+    // Stores the last index used for each tagging secret, taking direction into account
+    // This is necessary to avoid reusing the same index for the same secret, which happens if
+    // sender and recipient are the same
+    #taggingSecretIndexesForSenders;
+    #taggingSecretIndexesForRecipients;
+    constructor(store){
+        this.#store = store;
+        this.#addressBook = this.#store.openMap('address_book');
+        this.#taggingSecretIndexesForSenders = this.#store.openMap('tagging_secret_indexes_for_senders');
+        this.#taggingSecretIndexesForRecipients = this.#store.openMap('tagging_secret_indexes_for_recipients');
+    }
+    async setTaggingSecretsIndexesAsSender(indexedSecrets) {
+        await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders);
+    }
+    async setTaggingSecretsIndexesAsRecipient(indexedSecrets) {
+        await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients);
+    }
+    async #setTaggingSecretsIndexes(indexedSecrets, storageMap) {
+        await Promise.all(indexedSecrets.map((indexedSecret)=>storageMap.set(indexedSecret.appTaggingSecret.toString(), indexedSecret.index)));
+    }
+    async getTaggingSecretsIndexesAsRecipient(appTaggingSecrets) {
+        return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForRecipients);
+    }
+    async getTaggingSecretsIndexesAsSender(appTaggingSecrets) {
+        return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders);
+    }
+    #getTaggingSecretsIndexes(appTaggingSecrets, storageMap) {
+        return Promise.all(appTaggingSecrets.map(async (secret)=>await storageMap.getAsync(`${secret.toString()}`) ?? 0));
+    }
+    resetNoteSyncData() {
+        return this.#store.transactionAsync(async ()=>{
+            const recipients = await toArray(this.#taggingSecretIndexesForRecipients.keysAsync());
+            await Promise.all(recipients.map((recipient)=>this.#taggingSecretIndexesForRecipients.delete(recipient)));
+            const senders = await toArray(this.#taggingSecretIndexesForSenders.keysAsync());
+            await Promise.all(senders.map((sender)=>this.#taggingSecretIndexesForSenders.delete(sender)));
+        });
+    }
+    async addSenderAddress(address) {
+        if (await this.#addressBook.hasAsync(address.toString())) {
+            return false;
+        }
+        await this.#addressBook.set(address.toString(), true);
+        return true;
+    }
+    async getSenderAddresses() {
+        return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
+    }
+    async removeSenderAddress(address) {
+        if (!await this.#addressBook.hasAsync(address.toString())) {
+            return false;
+        }
+        await this.#addressBook.delete(address.toString());
+        return true;
+    }
+    async getSize() {
+        const addressesCount = (await toArray(this.#addressBook.keysAsync())).length;
+        // All keys are addresses
+        return 3 * addressesCount * AztecAddress.SIZE_IN_BYTES;
+    }
+}

package/dest/synchronizer/synchronizer.d.ts

@@ -3,7 +3,9 @@ import type { L2TipsStore } from '@aztec/kv-store/stores';
 import { L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { PXEConfig } from '../config/index.js';
-import type { PxeDatabase } from '../database/index.js';
+import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
+import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
+import type { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
 /**
  * The Synchronizer class manages the synchronization with the aztec node, allowing PXE to retrieve the
  * latest block header and handle reorgs.
@@ -12,13 +14,15 @@ import type { PxeDatabase } from '../database/index.js';
  */
 export declare class Synchronizer implements L2BlockStreamEventHandler {
     private node;
-    private db;
+    private syncDataProvider;
+    private noteDataProvider;
+    private taggingDataProvider;
     private l2TipsStore;
     private initialSyncBlockNumber;
     private log;
     private isSyncing;
     protected readonly blockStream: L2BlockStream;
-    constructor(node: AztecNode, db: PxeDatabase, l2TipsStore: L2TipsStore, config?: Partial<Pick<PXEConfig, 'l2StartingBlock'>>, loggerOrSuffix?: string | Logger);
+    constructor(node: AztecNode, syncDataProvider: SyncDataProvider, noteDataProvider: NoteDataProvider, taggingDataProvider: TaggingDataProvider, l2TipsStore: L2TipsStore, config?: Partial<Pick<PXEConfig, 'l2StartingBlock'>>, loggerOrSuffix?: string | Logger);
     protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2StartingBlock'>>): L2BlockStream;
     /** Handle events emitted by the block stream. */
     handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;

package/dest/synchronizer/synchronizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/synchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC7G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;GAKG;AACH,qBAAa,YAAa,YAAW,yBAAyB;IAO1D,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,WAAW;IARrB,OAAO,CAAC,sBAAsB,CAA4B;IAC1D,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAA4B;IAC7C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;gBAGpC,IAAI,EAAE,SAAS,EACf,EAAE,EAAE,WAAW,EACf,WAAW,EAAE,WAAW,EAChC,MAAM,GAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAM,EACxD,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM;IASlC,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;IAM/E,iDAAiD;IACpC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkC7E;;;OAGG;IACU,IAAI;YAiBH,MAAM;IAeP,qBAAqB;CAGnC"}
+{"version":3,"file":"synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/synchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC7G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2DAA2D,CAAC;AAErG;;;;;GAKG;AACH,qBAAa,YAAa,YAAW,yBAAyB;IAO1D,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,WAAW;IAVrB,OAAO,CAAC,sBAAsB,CAA4B;IAC1D,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAA4B;IAC7C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;gBAGpC,IAAI,EAAE,SAAS,EACf,gBAAgB,EAAE,gBAAgB,EAClC,gBAAgB,EAAE,gBAAgB,EAClC,mBAAmB,EAAE,mBAAmB,EACxC,WAAW,EAAE,WAAW,EAChC,MAAM,GAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAM,EACxD,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM;IASlC,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;IAM/E,iDAAiD;IACpC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmC7E;;;OAGG;IACU,IAAI;YAiBH,MAAM;IAeP,qBAAqB;CAGnC"}

package/dest/synchronizer/synchronizer.js

@@ -8,15 +8,19 @@ import { L2BlockStream } from '@aztec/stdlib/block';
  * details, and fetch transactions by hash.
  */ export class Synchronizer {
     node;
-    db;
+    syncDataProvider;
+    noteDataProvider;
+    taggingDataProvider;
     l2TipsStore;
     initialSyncBlockNumber;
     log;
     isSyncing;
     blockStream;
-    constructor(node, db, l2TipsStore, config = {}, loggerOrSuffix){
+    constructor(node, syncDataProvider, noteDataProvider, taggingDataProvider, l2TipsStore, config = {}, loggerOrSuffix){
         this.node = node;
-        this.db = db;
+        this.syncDataProvider = syncDataProvider;
+        this.noteDataProvider = noteDataProvider;
+        this.taggingDataProvider = taggingDataProvider;
         this.l2TipsStore = l2TipsStore;
         this.initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
         this.log = !loggerOrSuffix || typeof loggerOrSuffix === 'string' ? createLogger(loggerOrSuffix ? `pxe:synchronizer:${loggerOrSuffix}` : `pxe:synchronizer`) : loggerOrSuffix;
@@ -38,24 +42,25 @@ import { L2BlockStream } from '@aztec/stdlib/block';
                         archive: lastBlock.archive.root.toString(),
                         header: lastBlock.header.toInspect()
                     });
-                    await this.db.setHeader(lastBlock.header);
+                    await this.syncDataProvider.setHeader(lastBlock.header);
                     break;
                 }
             case 'chain-pruned':
                 {
                     this.log.warn(`Pruning data after block ${event.blockNumber} due to reorg`);
                     // We first unnullify and then remove so that unnullified notes that were created after the block number end up deleted.
-                    await this.db.unnullifyNotesAfter(event.blockNumber);
-                    await this.db.removeNotesAfter(event.blockNumber);
+                    const lastSynchedBlockNumber = await this.syncDataProvider.getBlockNumber();
+                    await this.noteDataProvider.unnullifyNotesAfter(event.blockNumber, lastSynchedBlockNumber);
+                    await this.noteDataProvider.removeNotesAfter(event.blockNumber);
                     // Remove all note tagging indexes to force a full resync. This is suboptimal, but unless we track the
                     // block number in which each index is used it's all we can do.
-                    await this.db.resetNoteSyncData();
+                    await this.taggingDataProvider.resetNoteSyncData();
                     // Update the header to the last block.
                     const newHeader = await this.node.getBlockHeader(event.blockNumber);
                     if (!newHeader) {
                         this.log.error(`Block header not found for block number ${event.blockNumber} during chain prune`);
                     } else {
-                        await this.db.setHeader(newHeader);
+                        await this.syncDataProvider.setHeader(newHeader);
                     }
                     break;
                 }
@@ -82,17 +87,17 @@ import { L2BlockStream } from '@aztec/stdlib/block';
     async doSync() {
         let currentHeader;
         try {
-            currentHeader = await this.db.getBlockHeader();
+            currentHeader = await this.syncDataProvider.getBlockHeader();
         } catch (e) {
             this.log.debug('Header is not set, requesting from the node');
         }
         if (!currentHeader) {
             // REFACTOR: We should know the header of the genesis block without having to request it from the node.
-            await this.db.setHeader(await this.node.getBlockHeader(0));
+            await this.syncDataProvider.setHeader(await this.node.getBlockHeader(0));
         }
         await this.blockStream.sync();
     }
     async getSynchedBlockNumber() {
-        return await this.db.getBlockNumber() ?? this.initialSyncBlockNumber;
+        return await this.syncDataProvider.getBlockNumber() ?? this.initialSyncBlockNumber;
     }
 }

package/dest/test/pxe_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pxe_test_suite.d.ts","sourceRoot":"","sources":["../../src/test/pxe_test_suite.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAS3D,eAAO,MAAM,YAAY,aAAc,MAAM,YAAY,MAAM,QAAQ,GAAG,CAAC,SAiG1E,CAAC"}

package/dest/{pxe_service/test → test}/pxe_test_suite.js

@@ -69,7 +69,7 @@ export const pxeTestSuite = (testName, pxeSetup)=>{
             const instance = await randomContractInstanceWithAddress();
             await expect(pxe.registerContract({
                 instance
-            })).rejects.toThrow(/Missing contract artifact/i);
+            })).rejects.toThrow(/DB has no contract class with id/i);
         });
         it('refuses to register a contract with an artifact with mismatching class id', async ()=>{
             const artifact = randomContractArtifact();
@@ -81,11 +81,7 @@ export const pxeTestSuite = (testName, pxeSetup)=>{
         });
         // Note: Not testing a successful run of `proveTx`, `sendTx`, `getTxReceipt` and `simulateUnconstrained` here as it requires
         //       a larger setup and it's sufficiently tested in the e2e tests.
-        it('throws when getting public storage for non-existent contract', async ()=>{
-            const contract = await AztecAddress.random();
-            await expect(async ()=>await pxe.getPublicStorageAt(contract, new Fr(0n))).rejects.toThrow(`Contract ${contract.toString()} is not deployed`);
-        });
-        // Note: Not testing `getContractData` and `getPublicLogs` here as these
+        // Note: Not testing `getContractData`, `getPublicLogs` and `getPublicStorageAt` here as these
         //       functions only call AztecNode and these methods are frequently used by the e2e tests.
         it('successfully gets a block number', async ()=>{
             const blockNum = await pxe.getBlockNumber();

package/package.json

@@ -1,22 +1,15 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.77.1",
+  "version": "0.78.1",
   "type": "module",
   "exports": {
-    ".": "./dest/index.js",
-    "./service": "./dest/pxe_service/index.js",
+    "./server": "./dest/entrypoints/server/index.js",
+    "./client/lazy": "./dest/entrypoints/client/lazy/index.js",
+    "./client/bundle": "./dest/entrypoints/client/bundle/index.js",
     "./config": "./dest/config/index.js",
-    "./database": "./dest/database/index.js",
-    "./kernel_prover": "./dest/kernel_prover/index.js"
+    "./testing": "./dest/test/pxe_test_suite.js"
   },
   "bin": "./dest/bin/index.js",
-  "typedocOptions": {
-    "entryPoints": [
-      "./src/index.ts"
-    ],
-    "name": "Wallet",
-    "tsconfig": "./tsconfig.json"
-  },
   "scripts": {
     "build": "yarn clean && yarn generate && tsc -b",
     "build:dev": "tsc -b --watch",
@@ -66,18 +59,18 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.77.1",
-    "@aztec/bb.js": "0.77.1",
-    "@aztec/builder": "0.77.1",
-    "@aztec/constants": "0.77.1",
-    "@aztec/ethereum": "0.77.1",
-    "@aztec/foundation": "0.77.1",
-    "@aztec/key-store": "0.77.1",
-    "@aztec/kv-store": "0.77.1",
-    "@aztec/noir-protocol-circuits-types": "0.77.1",
-    "@aztec/protocol-contracts": "0.77.1",
-    "@aztec/simulator": "0.77.1",
-    "@aztec/stdlib": "0.77.1",
+    "@aztec/bb-prover": "0.78.1",
+    "@aztec/bb.js": "0.78.1",
+    "@aztec/builder": "0.78.1",
+    "@aztec/constants": "0.78.1",
+    "@aztec/ethereum": "0.78.1",
+    "@aztec/foundation": "0.78.1",
+    "@aztec/key-store": "0.78.1",
+    "@aztec/kv-store": "0.78.1",
+    "@aztec/noir-protocol-circuits-types": "0.78.1",
+    "@aztec/protocol-contracts": "0.78.1",
+    "@aztec/simulator": "0.78.1",
+    "@aztec/stdlib": "0.78.1",
     "@msgpack/msgpack": "^3.0.0-beta2",
     "koa": "^2.14.2",
     "koa-router": "^12.0.0",
@@ -85,10 +78,10 @@
     "sha3": "^2.1.4",
     "tslib": "^2.4.0",
     "viem": "2.22.8",
-    "@aztec/noir-types": "0.77.1"
+    "@aztec/noir-types": "0.78.1"
   },
   "devDependencies": {
-    "@aztec/noir-contracts.js": "0.77.1",
+    "@aztec/noir-contracts.js": "0.78.1",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/lodash.omit": "^4.5.7",

package/src/bin/index.ts

@@ -3,8 +3,8 @@ import { createLogger } from '@aztec/foundation/log';
 import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
 
 import { getPXEServiceConfig } from '../config/index.js';
+import { createPXEService } from '../entrypoints/server/utils.js';
 import { startPXEHttpServer } from '../pxe_http/index.js';
-import { createPXEService } from '../utils/create_pxe_service.js';
 
 const { PXE_PORT = 8080, AZTEC_NODE_URL = 'http://localhost:8079' } = process.env;
 

package/src/config/index.ts

@@ -10,6 +10,8 @@ import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config
 import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
 import type { Network } from '@aztec/stdlib/network';
 
+export { getPackageInfo } from './package_info.js';
+
 /**
  * Temporary configuration until WASM can be used instead of native
  */

package/src/entrypoints/client/bundle/index.ts

@@ -0,0 +1,5 @@
+export * from '../../../pxe_service/index.js';
+export * from '../../../config/index.js';
+export * from '../../../storage/index.js';
+export * from './utils.js';
+export { PXEOracleInterface } from '../../../pxe_oracle_interface/index.js';

package/src/entrypoints/client/bundle/utils.ts

@@ -0,0 +1,58 @@
+import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/indexeddb';
+import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { WASMSimulator } from '@aztec/simulator/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+import type { PXEServiceConfig } from '../../../config/index.js';
+import { PXEService } from '../../../pxe_service/pxe_service.js';
+import type { PXECreationOptions } from '../pxe_creation_options.js';
+
+/**
+ * Create and start an PXEService instance with the given AztecNode.
+ * If no keyStore or database is provided, it will use KeyStore and MemoryDB as default values.
+ * Returns a Promise that resolves to the started PXEService instance.
+ *
+ * @param aztecNode - The AztecNode instance to be used by the server.
+ * @param config - The PXE Service Config to use
+ * @param options - (Optional) Optional information for creating an PXEService.
+ * @returns A Promise that resolves to the started PXEService instance.
+ */
+export async function createPXEService(
+  aztecNode: AztecNode,
+  config: PXEServiceConfig,
+  options: PXECreationOptions = { loggers: {} },
+) {
+  const l1Contracts = await aztecNode.getL1ContractAddresses();
+  const configWithContracts = {
+    ...config,
+    l1Contracts,
+  } as PXEServiceConfig;
+
+  const store = await createStore(
+    'pxe_data',
+    configWithContracts,
+    options.loggers.store ?? createLogger('pxe:data:indexeddb'),
+  );
+
+  const simulationProvider = new WASMSimulator();
+  const prover =
+    options.prover ??
+    new BBWASMBundlePrivateKernelProver(
+      simulationProvider,
+      16,
+      options.loggers.prover ?? createLogger('bb:wasm:bundle'),
+    );
+  const protocolContractsProvider = new BundledProtocolContractsProvider();
+  const pxe = await PXEService.create(
+    aztecNode,
+    store,
+    prover,
+    simulationProvider,
+    protocolContractsProvider,
+    config,
+    options.loggers.pxe ?? createLogger('pxe:service'),
+  );
+  return pxe;
+}

package/src/entrypoints/client/lazy/index.ts

@@ -0,0 +1,5 @@
+export * from '../../../pxe_service/index.js';
+export * from '../../../config/index.js';
+export * from '../../../storage/index.js';
+export * from './utils.js';
+export { PXEOracleInterface } from '../../../pxe_oracle_interface/index.js';

package/src/entrypoints/client/lazy/utils.ts

@@ -0,0 +1,53 @@
+import { BBWASMLazyPrivateKernelProver } from '@aztec/bb-prover/wasm/lazy';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/indexeddb';
+import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/providers/lazy';
+import { WASMSimulator } from '@aztec/simulator/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+import type { PXEServiceConfig } from '../../../config/index.js';
+import { PXEService } from '../../../pxe_service/pxe_service.js';
+import type { PXECreationOptions } from '../pxe_creation_options.js';
+
+/**
+ * Create and start an PXEService instance with the given AztecNode.
+ * Returns a Promise that resolves to the started PXEService instance.
+ *
+ * @param aztecNode - The AztecNode instance to be used by the server.
+ * @param config - The PXE Service Config to use
+ * @param
+ * @returns A Promise that resolves to the started PXEService instance.
+ */
+export async function createPXEService(
+  aztecNode: AztecNode,
+  config: PXEServiceConfig,
+  options: PXECreationOptions = { loggers: {} },
+) {
+  const l1Contracts = await aztecNode.getL1ContractAddresses();
+  const configWithContracts = {
+    ...config,
+    l1Contracts,
+  } as PXEServiceConfig;
+
+  const store = await createStore(
+    'pxe_data',
+    configWithContracts,
+    options.loggers.store ?? createLogger('pxe:data:indexeddb'),
+  );
+
+  const simulationProvider = new WASMSimulator();
+  const prover =
+    options.prover ??
+    new BBWASMLazyPrivateKernelProver(simulationProvider, 16, options.loggers.prover ?? createLogger('bb:wasm:lazy'));
+  const protocolContractsProvider = new LazyProtocolContractsProvider();
+  const pxe = await PXEService.create(
+    aztecNode,
+    store,
+    prover,
+    simulationProvider,
+    protocolContractsProvider,
+    config,
+    options.loggers.pxe ?? createLogger('pxe:service'),
+  );
+  return pxe;
+}

package/src/entrypoints/client/pxe_creation_options.ts

@@ -0,0 +1,7 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
+
+export type PXECreationOptions = {
+  loggers: { store?: Logger; pxe?: Logger; prover?: Logger };
+  prover?: PrivateKernelProver;
+};

package/src/entrypoints/server/index.ts

@@ -0,0 +1,6 @@
+export * from '../../pxe_service/index.js';
+export * from '../../pxe_http/index.js';
+export * from '../../config/index.js';
+export * from '../../storage/index.js';
+export * from './utils.js';
+export { PXEOracleInterface } from '../../pxe_oracle_interface/index.js';

package/src/{utils/create_pxe_service.ts → entrypoints/server/utils.ts}

@@ -2,16 +2,14 @@ import { BBNativePrivateKernelProver } from '@aztec/bb-prover';
 import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
-import { KeyStore } from '@aztec/key-store';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
-import { L2TipsStore } from '@aztec/kv-store/stores';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { type SimulationProvider, WASMSimulator } from '@aztec/simulator/client';
 import type { AztecNode, PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 
-import type { PXEServiceConfig } from '../config/index.js';
-import { KVPxeDatabase } from '../database/kv_pxe_database.js';
-import { PXEService } from '../pxe_service/pxe_service.js';
+import type { PXEServiceConfig } from '../../config/index.js';
+import { PXEService } from '../../pxe_service/pxe_service.js';
+import { PXE_DATA_SCHEMA_VERSION } from './index.js';
 
 /**
  * Create and start an PXEService instance with the given AztecNode.
@@ -20,7 +18,7 @@ import { PXEService } from '../pxe_service/pxe_service.js';
  *
  * @param aztecNode - The AztecNode instance to be used by the server.
  * @param config - The PXE Service Config to use
- * @param options - (Optional) Optional information for creating an PXEService.
+ * @param useLogSuffix - (Optional) Log suffix for PXE's logger.
  * @param proofCreator - An optional proof creator to use in place of any other configuration
  * @returns A Promise that resolves to the started PXEService instance.
  */
@@ -39,34 +37,25 @@ export async function createPXEService(
     l1Contracts,
   } as PXEServiceConfig;
 
-  const keyStore = new KeyStore(
-    await createStore('pxe_key_store', KeyStore.SCHEMA_VERSION, configWithContracts, createLogger('pxe:keystore:lmdb')),
-  );
-
   const store = await createStore(
     'pxe_data',
-    KVPxeDatabase.SCHEMA_VERSION,
+    PXE_DATA_SCHEMA_VERSION,
     configWithContracts,
     createLogger('pxe:data:lmdb'),
   );
 
-  const db = await KVPxeDatabase.create(store);
-  const tips = new L2TipsStore(store, 'pxe');
   const simulationProvider = new WASMSimulator();
   const prover = proofCreator ?? (await createProver(config, simulationProvider, logSuffix));
   const protocolContractsProvider = new BundledProtocolContractsProvider();
-  const pxe = new PXEService(
-    keyStore,
+  const pxe = await PXEService.create(
     aztecNode,
-    db,
-    tips,
+    store,
     prover,
     simulationProvider,
     protocolContractsProvider,
     config,
     logSuffix,
   );
-  await pxe.init();
   return pxe;
 }
 

package/src/kernel_oracle/index.ts

@@ -17,7 +17,7 @@ import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/
 import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 
-import type { ContractDataProvider } from '../contract_data_provider/index.js';
+import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
 import type { ProvingDataOracle } from './../kernel_prover/proving_data_oracle.js';
 
 // TODO: Block number should not be "latest".