@aztec/pxe 0.0.0-test.0

package/dest/storage/sync_data_provider/index.js

@@ -0,0 +1 @@
+export { SyncDataProvider } from './sync_data_provider.js';

package/dest/storage/sync_data_provider/sync_data_provider.d.ts

@@ -0,0 +1,12 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { BlockHeader } from '@aztec/stdlib/tx';
+import type { DataProvider } from '../data_provider.js';
+export declare class SyncDataProvider implements DataProvider {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    setHeader(header: BlockHeader): Promise<void>;
+    getBlockNumber(): Promise<number | undefined>;
+    getBlockHeader(): Promise<BlockHeader>;
+    getSize(): Promise<number>;
+}
+//# sourceMappingURL=sync_data_provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/sync_data_provider/sync_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAuB,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,gBAAiB,YAAW,YAAY;;gBAIvC,KAAK,EAAE,iBAAiB;IAK9B,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7C,cAAc,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAS7C,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC;IAStC,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;CAGjC"}

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/index.d.ts

@@ -0,0 +1,2 @@
+export * from './synchronizer.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/synchronizer/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dest/synchronizer/index.js

@@ -0,0 +1 @@
+export * from './synchronizer.js';

package/dest/synchronizer/synchronizer.d.ts

@@ -0,0 +1,37 @@
+import { type Logger } from '@aztec/foundation/log';
+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 { 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.
+ * It provides methods to trigger a sync and get the block number we are syncec to
+ * details, and fetch transactions by hash.
+ */
+export declare class Synchronizer implements L2BlockStreamEventHandler {
+    private node;
+    private syncDataProvider;
+    private noteDataProvider;
+    private taggingDataProvider;
+    private l2TipsStore;
+    private initialSyncBlockNumber;
+    private log;
+    private isSyncing;
+    protected readonly blockStream: L2BlockStream;
+    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>;
+    /**
+     * Syncs PXE and the node by dowloading the metadata of the latest blocks, allowing simulations to use
+     * recent data (e.g. notes), and handling any reorgs that might have occurred.
+     */
+    sync(): Promise<void>;
+    private doSync;
+    getSynchedBlockNumber(): Promise<number>;
+}
+//# sourceMappingURL=synchronizer.d.ts.map

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

@@ -0,0 +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,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

@@ -0,0 +1,103 @@
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { createLogger } from '@aztec/foundation/log';
+import { L2BlockStream } from '@aztec/stdlib/block';
+/**
+ * The Synchronizer class manages the synchronization with the aztec node, allowing PXE to retrieve the
+ * latest block header and handle reorgs.
+ * It provides methods to trigger a sync and get the block number we are syncec to
+ * details, and fetch transactions by hash.
+ */ export class Synchronizer {
+    node;
+    syncDataProvider;
+    noteDataProvider;
+    taggingDataProvider;
+    l2TipsStore;
+    initialSyncBlockNumber;
+    log;
+    isSyncing;
+    blockStream;
+    constructor(node, syncDataProvider, noteDataProvider, taggingDataProvider, l2TipsStore, config = {}, loggerOrSuffix){
+        this.node = node;
+        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;
+        this.blockStream = this.createBlockStream(config);
+    }
+    createBlockStream(config) {
+        return new L2BlockStream(this.node, this.l2TipsStore, this, createLogger('pxe:block_stream'), {
+            startingBlock: config.l2StartingBlock
+        });
+    }
+    /** Handle events emitted by the block stream. */ async handleBlockStreamEvent(event) {
+        await this.l2TipsStore.handleBlockStreamEvent(event);
+        switch(event.type){
+            case 'blocks-added':
+                {
+                    const lastBlock = event.blocks.at(-1);
+                    this.log.verbose(`Updated pxe last block to ${lastBlock.number}`, {
+                        blockHash: lastBlock.hash(),
+                        archive: lastBlock.archive.root.toString(),
+                        header: lastBlock.header.toInspect()
+                    });
+                    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.
+                    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.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.syncDataProvider.setHeader(newHeader);
+                    }
+                    break;
+                }
+        }
+    }
+    /**
+   * Syncs PXE and the node by dowloading the metadata of the latest blocks, allowing simulations to use
+   * recent data (e.g. notes), and handling any reorgs that might have occurred.
+   */ async sync() {
+        if (this.isSyncing !== undefined) {
+            this.log.debug(`Waiting for the ongoing sync to finish`);
+            await this.isSyncing;
+            return;
+        }
+        this.log.debug(`Syncing PXE with the node`);
+        const isSyncing = this.doSync();
+        this.isSyncing = isSyncing;
+        try {
+            await isSyncing;
+        } finally{
+            this.isSyncing = undefined;
+        }
+    }
+    async doSync() {
+        let currentHeader;
+        try {
+            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.syncDataProvider.setHeader(await this.node.getBlockHeader(0));
+        }
+        await this.blockStream.sync();
+    }
+    async getSynchedBlockNumber() {
+        return await this.syncDataProvider.getBlockNumber() ?? this.initialSyncBlockNumber;
+    }
+}

package/dest/test/pxe_test_suite.d.ts

@@ -0,0 +1,3 @@
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+export declare const pxeTestSuite: (testName: string, pxeSetup: () => Promise<PXE>) => void;
+//# sourceMappingURL=pxe_test_suite.d.ts.map

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/test/pxe_test_suite.js

@@ -0,0 +1,97 @@
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { randomContractArtifact, randomContractInstanceWithAddress, randomDeployedContract } from '@aztec/stdlib/testing';
+import omit from 'lodash.omit';
+export const pxeTestSuite = (testName, pxeSetup)=>{
+    describe(testName, ()=>{
+        let pxe;
+        beforeAll(async ()=>{
+            pxe = await pxeSetup();
+        }, 120_000);
+        it('registers an account and returns it as an account only and not as a recipient', async ()=>{
+            const randomSecretKey = Fr.random();
+            const randomPartialAddress = Fr.random();
+            const completeAddress = await pxe.registerAccount(randomSecretKey, randomPartialAddress);
+            // Check that the account is correctly registered using the getAccounts and getRecipients methods
+            const accounts = await pxe.getRegisteredAccounts();
+            expect(accounts).toContainEqual(completeAddress);
+        });
+        it('does not throw when registering the same account twice (just ignores the second attempt)', async ()=>{
+            const randomSecretKey = Fr.random();
+            const randomPartialAddress = Fr.random();
+            await pxe.registerAccount(randomSecretKey, randomPartialAddress);
+            await pxe.registerAccount(randomSecretKey, randomPartialAddress);
+        });
+        it('successfully adds a contract', async ()=>{
+            const contracts = await Promise.all([
+                randomDeployedContract(),
+                randomDeployedContract()
+            ]);
+            for (const contract of contracts){
+                await pxe.registerContract(contract);
+            }
+            const expectedContractAddresses = contracts.map((contract)=>contract.instance.address);
+            const contractAddresses = await pxe.getContracts();
+            expect(contractAddresses).toEqual(expect.arrayContaining(expectedContractAddresses));
+        });
+        it('registers a class and adds a contract for it', async ()=>{
+            const artifact = randomContractArtifact();
+            const contractClass = await getContractClassFromArtifact(artifact);
+            const contractClassId = contractClass.id;
+            const instance = await randomContractInstanceWithAddress({
+                contractClassId
+            });
+            await pxe.registerContractClass(artifact);
+            expect((await pxe.getContractClassMetadata(contractClassId)).contractClass).toMatchObject(omit(contractClass, 'privateFunctionsRoot', 'publicBytecodeCommitment'));
+            await pxe.registerContract({
+                instance
+            });
+            expect((await pxe.getContractMetadata(instance.address)).contractInstance).toEqual(instance);
+        });
+        it('refuses to register a class with a mismatched address', async ()=>{
+            const artifact = randomContractArtifact();
+            const contractClass = await getContractClassFromArtifact(artifact);
+            const contractClassId = contractClass.id;
+            const instance = await randomContractInstanceWithAddress({
+                contractClassId
+            });
+            await expect(pxe.registerContract({
+                instance: {
+                    ...instance,
+                    address: await AztecAddress.random()
+                },
+                artifact
+            })).rejects.toThrow(/Added a contract in which the address does not match the contract instance./);
+        });
+        it('refuses to register a contract with a class that has not been registered', async ()=>{
+            const instance = await randomContractInstanceWithAddress();
+            await expect(pxe.registerContract({
+                instance
+            })).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();
+            const instance = await randomContractInstanceWithAddress();
+            await expect(pxe.registerContract({
+                instance,
+                artifact
+            })).rejects.toThrow(/Artifact does not match/i);
+        });
+        // 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.
+        // 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();
+            expect(blockNum).toBeGreaterThanOrEqual(INITIAL_L2_BLOCK_NUM);
+        });
+        it('successfully gets node info', async ()=>{
+            const nodeInfo = await pxe.getNodeInfo();
+            expect(typeof nodeInfo.protocolVersion).toEqual('number');
+            expect(typeof nodeInfo.l1ChainId).toEqual('number');
+            expect(nodeInfo.l1ContractAddresses.rollupAddress.toString()).toMatch(/0x[a-fA-F0-9]+/);
+        });
+    });
+};

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@aztec/pxe",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    "./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",
+    "./testing": "./dest/test/pxe_test_suite.js"
+  },
+  "bin": "./dest/bin/index.js",
+  "scripts": {
+    "build": "yarn clean && yarn generate && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo ./src/config/package_info.ts",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "start": "LOG_LEVEL=${LOG_LEVEL:-debug} && node ./dest/bin/index.js",
+    "generate": "node ./scripts/generate_package_info.js"
+  },
+  "inherits": [
+    "../package.common.json",
+    "./package.local.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "workerThreads": true,
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/bb-prover": "0.0.0-test.0",
+    "@aztec/bb.js": "0.0.0-test.0",
+    "@aztec/builder": "0.0.0-test.0",
+    "@aztec/constants": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/key-store": "0.0.0-test.0",
+    "@aztec/kv-store": "0.0.0-test.0",
+    "@aztec/noir-protocol-circuits-types": "0.0.0-test.0",
+    "@aztec/protocol-contracts": "0.0.0-test.0",
+    "@aztec/simulator": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "@msgpack/msgpack": "^3.0.0-beta2",
+    "koa": "^2.14.2",
+    "koa-router": "^12.0.0",
+    "lodash.omit": "^4.5.0",
+    "sha3": "^2.1.4",
+    "tslib": "^2.4.0",
+    "viem": "2.22.8",
+    "@aztec/noir-types": "0.0.0-test.0"
+  },
+  "devDependencies": {
+    "@aztec/noir-contracts.js": "0.0.0-test.0",
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/lodash.omit": "^4.5.7",
+    "@types/lodash.times": "^4.3.9",
+    "@types/node": "^18.7.23",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "lodash.times": "^4.3.2",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/bin/index.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env -S node --no-warnings
+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';
+
+const { PXE_PORT = 8080, AZTEC_NODE_URL = 'http://localhost:8079' } = process.env;
+
+const logger = createLogger('pxe:service');
+
+/**
+ * Create and start a new PXE HTTP Server
+ */
+async function main() {
+  logger.info(`Setting up PXE...`);
+
+  const pxeConfig = getPXEServiceConfig();
+  const nodeRpcClient = createAztecNodeClient(AZTEC_NODE_URL, {});
+  const pxeService = await createPXEService(nodeRpcClient, pxeConfig);
+
+  const shutdown = () => {
+    logger.info('Shutting down...');
+    process.exit(0);
+  };
+
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+
+  startPXEHttpServer(pxeService, PXE_PORT);
+  logger.info(`PXE listening on port ${PXE_PORT}`);
+}
+
+main().catch(err => {
+  logger.error(err);
+  process.exit(1);
+});