@aztec/pxe 0.8.6

package/dest/simulator/index.d.ts

@@ -0,0 +1,9 @@
+import { AcirSimulator } from '@aztec/acir-simulator';
+import { KeyStore, StateInfoProvider } from '@aztec/types';
+import { ContractDataOracle } from '../contract_data_oracle/index.js';
+import { Database } from '../database/database.js';
+/**
+ * Helper method to create an instance of the acir simulator.
+ */
+export declare function getAcirSimulator(db: Database, stateInfoProvider: StateInfoProvider, keyStore: KeyStore, contractDataOracle?: ContractDataOracle): AcirSimulator;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/simulator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAE3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGnD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,QAAQ,EACZ,iBAAiB,EAAE,iBAAiB,EACpC,QAAQ,EAAE,QAAQ,EAClB,kBAAkB,CAAC,EAAE,kBAAkB,iBASxC"}

package/dest/simulator/index.js

@@ -0,0 +1,11 @@
+import { AcirSimulator } from '@aztec/acir-simulator';
+import { ContractDataOracle } from '../contract_data_oracle/index.js';
+import { SimulatorOracle } from '../simulator_oracle/index.js';
+/**
+ * Helper method to create an instance of the acir simulator.
+ */
+export function getAcirSimulator(db, stateInfoProvider, keyStore, contractDataOracle) {
+    const simulatorOracle = new SimulatorOracle(contractDataOracle ?? new ContractDataOracle(db, stateInfoProvider), db, keyStore, stateInfoProvider);
+    return new AcirSimulator(simulatorOracle);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2ltdWxhdG9yL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUd0RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUV0RSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFL0Q7O0dBRUc7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQzlCLEVBQVksRUFDWixpQkFBb0MsRUFDcEMsUUFBa0IsRUFDbEIsa0JBQXVDO0lBRXZDLE1BQU0sZUFBZSxHQUFHLElBQUksZUFBZSxDQUN6QyxrQkFBa0IsSUFBSSxJQUFJLGtCQUFrQixDQUFDLEVBQUUsRUFBRSxpQkFBaUIsQ0FBQyxFQUNuRSxFQUFFLEVBQ0YsUUFBUSxFQUNSLGlCQUFpQixDQUNsQixDQUFDO0lBQ0YsT0FBTyxJQUFJLGFBQWEsQ0FBQyxlQUFlLENBQUMsQ0FBQztBQUM1QyxDQUFDIn0=

package/dest/simulator_oracle/index.d.ts

@@ -0,0 +1,53 @@
+import { DBOracle, FunctionAbiWithDebugMetadata, MessageLoadOracleInputs } from '@aztec/acir-simulator';
+import { AztecAddress, CompleteAddress, EthAddress, Fr, FunctionSelector, GrumpkinPrivateKey, HistoricBlockData, PublicKey } from '@aztec/circuits.js';
+import { KeyStore, StateInfoProvider } from '@aztec/types';
+import { ContractDataOracle } from '../contract_data_oracle/index.js';
+import { Database } from '../database/index.js';
+/**
+ * A data oracle that provides information needed for simulating a transaction.
+ */
+export declare class SimulatorOracle implements DBOracle {
+    private contractDataOracle;
+    private db;
+    private keyStore;
+    private stateInfoProvider;
+    constructor(contractDataOracle: ContractDataOracle, db: Database, keyStore: KeyStore, stateInfoProvider: StateInfoProvider);
+    getSecretKey(_contractAddress: AztecAddress, pubKey: PublicKey): Promise<GrumpkinPrivateKey>;
+    getCompleteAddress(address: AztecAddress): Promise<CompleteAddress>;
+    getAuthWitness(messageHash: Fr): Promise<Fr[]>;
+    getNotes(contractAddress: AztecAddress, storageSlot: Fr): Promise<{
+        contractAddress: AztecAddress;
+        storageSlot: Fr;
+        nonce: Fr;
+        preimage: Fr[];
+        innerNoteHash: Fr;
+        siloedNullifier: Fr;
+        index: bigint;
+    }[]>;
+    getFunctionABI(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionAbiWithDebugMetadata>;
+    getPortalContractAddress(contractAddress: AztecAddress): Promise<EthAddress>;
+    /**
+     * Retrieves the L1ToL2Message associated with a specific message key
+     * Throws an error if the message key is not found
+     *
+     * @param msgKey - The key of the message to be retrieved
+     * @returns A promise that resolves to the message data, a sibling path and the
+     *          index of the message in the l1ToL2MessagesTree
+     */
+    getL1ToL2Message(msgKey: Fr): Promise<MessageLoadOracleInputs>;
+    /**
+     * Gets the index of a commitment in the private data tree.
+     * @param commitment - The commitment.
+     * @returns - The index of the commitment. Undefined if it does not exist in the tree.
+     */
+    getCommitmentIndex(commitment: Fr): Promise<bigint | undefined>;
+    getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
+    /**
+     * Retrieve the databases view of the Historic Block Data object.
+     * This structure is fed into the circuits simulator and is used to prove against certain historic roots.
+     *
+     * @returns A Promise that resolves to a HistoricBlockData object.
+     */
+    getHistoricBlockData(): Promise<HistoricBlockData>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/simulator_oracle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,4BAA4B,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AACxG,OAAO,EACL,YAAY,EACZ,eAAe,EACf,UAAU,EACV,EAAE,EACF,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,SAAS,EACV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,QAAQ,EAAgB,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD;;GAEG;AACH,qBAAa,eAAgB,YAAW,QAAQ;IAE5C,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,iBAAiB;gBAHjB,kBAAkB,EAAE,kBAAkB,EACtC,EAAE,EAAE,QAAQ,EACZ,QAAQ,EAAE,QAAQ,EAClB,iBAAiB,EAAE,iBAAiB;IAG9C,YAAY,CAAC,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAItF,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC;IASnE,cAAc,CAAC,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC;IAM9C,QAAQ,CAAC,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;;;;;;;;;IAgBvD,cAAc,CAClB,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,4BAA4B,CAAC;IASlC,wBAAwB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;IAIlF;;;;;;;OAOG;IACG,gBAAgB,CAAC,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAYpE;;;;OAIG;IACG,kBAAkB,CAAC,UAAU,EAAE,EAAE;IAIjC,iBAAiB,CAAC,SAAS,EAAE,EAAE;IAIrC;;;;;OAKG;IACH,oBAAoB,IAAI,OAAO,CAAC,iBAAiB,CAAC;CAGnD"}

package/dest/simulator_oracle/index.js

@@ -0,0 +1,91 @@
+import { MerkleTreeId } from '@aztec/types';
+/**
+ * A data oracle that provides information needed for simulating a transaction.
+ */
+export class SimulatorOracle {
+    constructor(contractDataOracle, db, keyStore, stateInfoProvider) {
+        this.contractDataOracle = contractDataOracle;
+        this.db = db;
+        this.keyStore = keyStore;
+        this.stateInfoProvider = stateInfoProvider;
+    }
+    getSecretKey(_contractAddress, pubKey) {
+        return this.keyStore.getAccountPrivateKey(pubKey);
+    }
+    async getCompleteAddress(address) {
+        const completeAddress = await this.db.getCompleteAddress(address);
+        if (!completeAddress)
+            throw new Error(`Unknown complete address for address ${address.toString()}. Add the information to PXE Service by calling server.registerRecipient(...) or server.registerAccount(...)`);
+        return completeAddress;
+    }
+    async getAuthWitness(messageHash) {
+        const witness = await this.db.getAuthWitness(messageHash);
+        if (!witness)
+            throw new Error(`Unknown auth witness for message hash ${messageHash.toString(true)}`);
+        return witness;
+    }
+    async getNotes(contractAddress, storageSlot) {
+        const noteDaos = await this.db.getNoteSpendingInfo(contractAddress, storageSlot);
+        return noteDaos.map(({ contractAddress, storageSlot, nonce, notePreimage, innerNoteHash, siloedNullifier, index }) => ({
+            contractAddress,
+            storageSlot,
+            nonce,
+            preimage: notePreimage.items,
+            innerNoteHash,
+            siloedNullifier,
+            // PXE can use this index to get full MembershipWitness
+            index,
+        }));
+    }
+    async getFunctionABI(contractAddress, selector) {
+        const abi = await this.contractDataOracle.getFunctionAbi(contractAddress, selector);
+        const debug = await this.contractDataOracle.getFunctionDebugMetadata(contractAddress, selector);
+        return {
+            ...abi,
+            debug,
+        };
+    }
+    async getPortalContractAddress(contractAddress) {
+        return await this.contractDataOracle.getPortalContractAddress(contractAddress);
+    }
+    /**
+     * Retrieves the L1ToL2Message associated with a specific message key
+     * Throws an error if the message key is not found
+     *
+     * @param msgKey - The key of the message to be retrieved
+     * @returns A promise that resolves to the message data, a sibling path and the
+     *          index of the message in the l1ToL2MessagesTree
+     */
+    async getL1ToL2Message(msgKey) {
+        const messageAndIndex = await this.stateInfoProvider.getL1ToL2MessageAndIndex(msgKey);
+        const message = messageAndIndex.message.toFieldArray();
+        const index = messageAndIndex.index;
+        const siblingPath = await this.stateInfoProvider.getL1ToL2MessagesTreePath(index);
+        return {
+            message,
+            siblingPath: siblingPath.toFieldArray(),
+            index,
+        };
+    }
+    /**
+     * Gets the index of a commitment in the private data tree.
+     * @param commitment - The commitment.
+     * @returns - The index of the commitment. Undefined if it does not exist in the tree.
+     */
+    async getCommitmentIndex(commitment) {
+        return await this.stateInfoProvider.findLeafIndex(MerkleTreeId.PRIVATE_DATA_TREE, commitment.toBuffer());
+    }
+    async getNullifierIndex(nullifier) {
+        return await this.stateInfoProvider.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    }
+    /**
+     * Retrieve the databases view of the Historic Block Data object.
+     * This structure is fed into the circuits simulator and is used to prove against certain historic roots.
+     *
+     * @returns A Promise that resolves to a HistoricBlockData object.
+     */
+    getHistoricBlockData() {
+        return Promise.resolve(this.db.getHistoricBlockData());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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,2 @@
+export * from './synchronizer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3luY2hyb25pemVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUMifQ==

package/dest/synchronizer/synchronizer.d.ts

@@ -0,0 +1,82 @@
+import { AztecAddress, PublicKey } from '@aztec/circuits.js';
+import { AztecNode, KeyStore } from '@aztec/types';
+import { Database } from '../database/index.js';
+/**
+ * The Synchronizer class manages the synchronization of note processors and interacts with the Aztec node
+ * to obtain encrypted logs, blocks, and other necessary information for the accounts.
+ * It provides methods to start or stop the synchronization process, add new accounts, retrieve account
+ * details, and fetch transactions by hash. The Synchronizer ensures that it maintains the note processors
+ * in sync with the blockchain while handling retries and errors gracefully.
+ */
+export declare class Synchronizer {
+    private node;
+    private db;
+    private runningPromise?;
+    private noteProcessors;
+    private interruptableSleep;
+    private running;
+    private initialSyncBlockNumber;
+    private synchedToBlock;
+    private log;
+    private noteProcessorsToCatchUp;
+    constructor(node: AztecNode, db: Database, logSuffix?: string);
+    /**
+     * Starts the synchronisation process by fetching encrypted logs and blocks from a specified position.
+     * Continuously processes the fetched data for all note processors until stopped. If there is no data
+     * available, it retries after a specified interval.
+     *
+     * @param from - The starting position for fetching encrypted logs and blocks.
+     * @param limit - The maximum number of encrypted, unencrypted logs and blocks to fetch in each iteration.
+     * @param retryInterval - The time interval (in ms) to wait before retrying if no data is available.
+     */
+    start(from?: number, limit?: number, retryInterval?: number): Promise<void>;
+    protected initialSync(): Promise<void>;
+    protected work(limit?: number, retryInterval?: number): Promise<void>;
+    protected workNoteProcessorCatchUp(limit?: number, retryInterval?: number): Promise<void>;
+    private setBlockDataFromBlock;
+    /**
+     * Stops the synchronizer gracefully, interrupting any ongoing sleep and waiting for the current
+     * iteration to complete before setting the running state to false. Once stopped, the synchronizer
+     * will no longer process blocks or encrypted logs and must be restarted using the start method.
+     *
+     * @returns A promise that resolves when the synchronizer has successfully stopped.
+     */
+    stop(): Promise<void>;
+    /**
+     * Add a new account to the Synchronizer with the specified private key.
+     * Creates a NoteProcessor instance for the account and pushes it into the noteProcessors array.
+     * The method resolves immediately after pushing the new note processor.
+     *
+     * @param publicKey - The public key for the account.
+     * @param keyStore - The key store.
+     * @returns A promise that resolves once the account is added to the Synchronizer.
+     */
+    addAccount(publicKey: PublicKey, keyStore: KeyStore): void;
+    /**
+     * Checks if the specified account is synchronized.
+     * @param account - The aztec address for which to query the sync status.
+     * @returns True if the account is fully synched, false otherwise.
+     * @remarks Checks whether all the notes from all the blocks have been processed. If it is not the case, the
+     *          retrieved information from contracts might be old/stale (e.g. old token balance).
+     * @throws If checking a sync status of account which is not registered.
+     */
+    isAccountStateSynchronized(account: AztecAddress): Promise<boolean>;
+    /**
+     * Checks whether all the blocks were processed (tree roots updated, txs updated with block info, etc.).
+     * @returns True if there are no outstanding blocks to be synched.
+     * @remarks This indicates that blocks and transactions are synched even if notes are not.
+     * @remarks Compares local block number with the block number from aztec node.
+     */
+    isGlobalStateSynchronized(): Promise<boolean>;
+    /**
+     * Returns the latest block that has been synchronized by the synchronizer and each account.
+     * @returns The latest block synchronized for blocks, and the latest block synched for notes for each public key being tracked.
+     */
+    getSyncStatus(): {
+        blocks: number;
+        notes: {
+            [k: string]: 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":"AAAA,OAAO,EAAE,YAAY,EAAuC,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAIlG,OAAO,EAAE,SAAS,EAAwB,QAAQ,EAA2B,MAAM,cAAc,CAAC;AAElG,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGhD;;;;;;GAMG;AACH,qBAAa,YAAY;IAUX,OAAO,CAAC,IAAI;IAAa,OAAO,CAAC,EAAE;IAT/C,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,kBAAkB,CAA4B;IACtD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,sBAAsB,CAAK;IACnC,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,uBAAuB,CAAuB;gBAElC,IAAI,EAAE,SAAS,EAAU,EAAE,EAAE,QAAQ,EAAE,SAAS,SAAK;IAIzE;;;;;;;;OAQG;IACU,KAAK,CAAC,IAAI,SAAuB,EAAE,KAAK,SAAI,EAAE,aAAa,SAAO;cA2B/D,WAAW;cAUX,IAAI,CAAC,KAAK,SAAI,EAAE,aAAa,SAAO,GAAG,OAAO,CAAC,IAAI,CAAC;cA2DpD,wBAAwB,CAAC,KAAK,SAAI,EAAE,aAAa,SAAO,GAAG,OAAO,CAAC,IAAI,CAAC;YAsD1E,qBAAqB;IAoBnC;;;;;;OAMG;IACU,IAAI;IAOjB;;;;;;;;OAQG;IACI,UAAU,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ;IAS1D;;;;;;;OAOG;IACU,0BAA0B,CAAC,OAAO,EAAE,YAAY;IAc7D;;;;;OAKG;IACU,yBAAyB;IAKtC;;;OAGG;IACI,aAAa;;;;;;CAMrB"}

package/dest/synchronizer/synchronizer.js

@@ -0,0 +1,241 @@
+import { CircuitsWasm, Fr, HistoricBlockData } from '@aztec/circuits.js';
+import { computeGlobalsHash } from '@aztec/circuits.js/abis';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { InterruptableSleep } from '@aztec/foundation/sleep';
+import { INITIAL_L2_BLOCK_NUM, L2BlockContext, LogType } from '@aztec/types';
+import { NoteProcessor } from '../note_processor/index.js';
+/**
+ * The Synchronizer class manages the synchronization of note processors and interacts with the Aztec node
+ * to obtain encrypted logs, blocks, and other necessary information for the accounts.
+ * It provides methods to start or stop the synchronization process, add new accounts, retrieve account
+ * details, and fetch transactions by hash. The Synchronizer ensures that it maintains the note processors
+ * in sync with the blockchain while handling retries and errors gracefully.
+ */
+export class Synchronizer {
+    constructor(node, db, logSuffix = '') {
+        this.node = node;
+        this.db = db;
+        this.noteProcessors = [];
+        this.interruptableSleep = new InterruptableSleep();
+        this.running = false;
+        this.initialSyncBlockNumber = 0;
+        this.synchedToBlock = 0;
+        this.noteProcessorsToCatchUp = [];
+        this.log = createDebugLogger(logSuffix ? `aztec:pxe_synchronizer_${logSuffix}` : 'aztec:pxe_synchronizer');
+    }
+    /**
+     * Starts the synchronisation process by fetching encrypted logs and blocks from a specified position.
+     * Continuously processes the fetched data for all note processors until stopped. If there is no data
+     * available, it retries after a specified interval.
+     *
+     * @param from - The starting position for fetching encrypted logs and blocks.
+     * @param limit - The maximum number of encrypted, unencrypted logs and blocks to fetch in each iteration.
+     * @param retryInterval - The time interval (in ms) to wait before retrying if no data is available.
+     */
+    async start(from = INITIAL_L2_BLOCK_NUM, limit = 1, retryInterval = 1000) {
+        if (this.running)
+            return;
+        this.running = true;
+        if (from < this.synchedToBlock + 1) {
+            throw new Error(`From block ${from} is smaller than the currently synched block ${this.synchedToBlock}`);
+        }
+        this.synchedToBlock = from - 1;
+        await this.initialSync();
+        const run = async () => {
+            while (this.running) {
+                if (this.noteProcessorsToCatchUp.length > 0) {
+                    // There is a note processor that needs to catch up. We hijack the main loop to catch up the note processor.
+                    await this.workNoteProcessorCatchUp(limit, retryInterval);
+                }
+                else {
+                    // No note processor needs to catch up. We continue with the normal flow.
+                    await this.work(limit, retryInterval);
+                }
+            }
+        };
+        this.runningPromise = run();
+        this.log('Started');
+    }
+    async initialSync() {
+        const [blockNumber, historicBlockData] = await Promise.all([
+            this.node.getBlockNumber(),
+            this.node.getHistoricBlockData(),
+        ]);
+        this.initialSyncBlockNumber = blockNumber;
+        this.synchedToBlock = this.initialSyncBlockNumber;
+        await this.db.setHistoricBlockData(historicBlockData);
+    }
+    async work(limit = 1, retryInterval = 1000) {
+        const from = this.synchedToBlock + 1;
+        try {
+            let encryptedLogs = await this.node.getLogs(from, limit, LogType.ENCRYPTED);
+            if (!encryptedLogs.length) {
+                await this.interruptableSleep.sleep(retryInterval);
+                return;
+            }
+            let unencryptedLogs = await this.node.getLogs(from, limit, LogType.UNENCRYPTED);
+            if (!unencryptedLogs.length) {
+                await this.interruptableSleep.sleep(retryInterval);
+                return;
+            }
+            // Note: If less than `limit` encrypted logs is returned, then we fetch only that number of blocks.
+            const blocks = await this.node.getBlocks(from, encryptedLogs.length);
+            if (!blocks.length) {
+                await this.interruptableSleep.sleep(retryInterval);
+                return;
+            }
+            if (blocks.length !== encryptedLogs.length) {
+                // "Trim" the encrypted logs to match the number of blocks.
+                encryptedLogs = encryptedLogs.slice(0, blocks.length);
+            }
+            if (blocks.length !== unencryptedLogs.length) {
+                // "Trim" the unencrypted logs to match the number of blocks.
+                unencryptedLogs = unencryptedLogs.slice(0, blocks.length);
+            }
+            // attach logs to blocks
+            blocks.forEach((block, i) => {
+                block.attachLogs(encryptedLogs[i], LogType.ENCRYPTED);
+                block.attachLogs(unencryptedLogs[i], LogType.UNENCRYPTED);
+            });
+            // Wrap blocks in block contexts.
+            const blockContexts = blocks.map(block => new L2BlockContext(block));
+            // Update latest tree roots from the most recent block
+            const latestBlock = blockContexts[blockContexts.length - 1];
+            await this.setBlockDataFromBlock(latestBlock);
+            this.log(`Forwarding ${encryptedLogs.length} encrypted logs and blocks to ${this.noteProcessors.length} note processors`);
+            for (const noteProcessor of this.noteProcessors) {
+                await noteProcessor.process(blockContexts, encryptedLogs);
+            }
+            this.synchedToBlock = latestBlock.block.number;
+        }
+        catch (err) {
+            this.log.error(`Error in synchronizer work`, err);
+            await this.interruptableSleep.sleep(retryInterval);
+        }
+    }
+    async workNoteProcessorCatchUp(limit = 1, retryInterval = 1000) {
+        const noteProcessor = this.noteProcessorsToCatchUp[0];
+        if (noteProcessor.status.syncedToBlock === this.synchedToBlock) {
+            // Note processor already synched, nothing to do
+            this.noteProcessorsToCatchUp.shift();
+            this.noteProcessors.push(noteProcessor);
+            return;
+        }
+        const from = noteProcessor.status.syncedToBlock + 1;
+        // Ensuring that the note processor does not sync further than the main sync.
+        limit = Math.min(limit, this.synchedToBlock - from + 1);
+        if (limit < 1) {
+            throw new Error(`Unexpected limit ${limit} for note processor catch up`);
+        }
+        try {
+            let encryptedLogs = await this.node.getLogs(from, limit, LogType.ENCRYPTED);
+            if (!encryptedLogs.length) {
+                // This should never happen because this function should only be called when the note processor is lagging
+                // behind main sync.
+                throw new Error('No encrypted logs in processor catch up mode');
+            }
+            // Note: If less than `limit` encrypted logs is returned, then we fetch only that number of blocks.
+            const blocks = await this.node.getBlocks(from, encryptedLogs.length);
+            if (!blocks.length) {
+                // This should never happen because this function should only be called when the note processor is lagging
+                // behind main sync.
+                throw new Error('No blocks in processor catch up mode');
+            }
+            if (blocks.length !== encryptedLogs.length) {
+                // "Trim" the encrypted logs to match the number of blocks.
+                encryptedLogs = encryptedLogs.slice(0, blocks.length);
+            }
+            const blockContexts = blocks.map(block => new L2BlockContext(block));
+            this.log(`Forwarding ${encryptedLogs.length} encrypted logs and blocks to note processor in catch up mode`);
+            await noteProcessor.process(blockContexts, encryptedLogs);
+            if (noteProcessor.status.syncedToBlock === this.synchedToBlock) {
+                // Note processor caught up, move it to `noteProcessors` from `noteProcessorsToCatchUp`.
+                this.noteProcessorsToCatchUp.shift();
+                this.noteProcessors.push(noteProcessor);
+            }
+        }
+        catch (err) {
+            this.log.error(`Error in synchronizer workNoteProcessorCatchUp`, err);
+            await this.interruptableSleep.sleep(retryInterval);
+        }
+    }
+    async setBlockDataFromBlock(latestBlock) {
+        const { block } = latestBlock;
+        if (block.number < this.initialSyncBlockNumber)
+            return;
+        const wasm = await CircuitsWasm.get();
+        const globalsHash = computeGlobalsHash(wasm, latestBlock.block.globalVariables);
+        const blockData = new HistoricBlockData(block.endPrivateDataTreeSnapshot.root, block.endNullifierTreeSnapshot.root, block.endContractTreeSnapshot.root, block.endL1ToL2MessagesTreeSnapshot.root, block.endHistoricBlocksTreeSnapshot.root, Fr.ZERO, // todo: private kernel vk tree root
+        block.endPublicDataTreeRoot, globalsHash);
+        await this.db.setHistoricBlockData(blockData);
+    }
+    /**
+     * Stops the synchronizer gracefully, interrupting any ongoing sleep and waiting for the current
+     * iteration to complete before setting the running state to false. Once stopped, the synchronizer
+     * will no longer process blocks or encrypted logs and must be restarted using the start method.
+     *
+     * @returns A promise that resolves when the synchronizer has successfully stopped.
+     */
+    async stop() {
+        this.running = false;
+        this.interruptableSleep.interrupt();
+        await this.runningPromise;
+        this.log('Stopped');
+    }
+    /**
+     * Add a new account to the Synchronizer with the specified private key.
+     * Creates a NoteProcessor instance for the account and pushes it into the noteProcessors array.
+     * The method resolves immediately after pushing the new note processor.
+     *
+     * @param publicKey - The public key for the account.
+     * @param keyStore - The key store.
+     * @returns A promise that resolves once the account is added to the Synchronizer.
+     */
+    addAccount(publicKey, keyStore) {
+        const processor = this.noteProcessors.find(x => x.publicKey.equals(publicKey));
+        if (processor) {
+            return;
+        }
+        this.noteProcessorsToCatchUp.push(new NoteProcessor(publicKey, keyStore, this.db, this.node));
+    }
+    /**
+     * Checks if the specified account is synchronized.
+     * @param account - The aztec address for which to query the sync status.
+     * @returns True if the account is fully synched, false otherwise.
+     * @remarks Checks whether all the notes from all the blocks have been processed. If it is not the case, the
+     *          retrieved information from contracts might be old/stale (e.g. old token balance).
+     * @throws If checking a sync status of account which is not registered.
+     */
+    async isAccountStateSynchronized(account) {
+        const completeAddress = await this.db.getCompleteAddress(account);
+        if (!completeAddress) {
+            throw new Error(`Checking if account is synched is not possible for ${account} because it is not registered.`);
+        }
+        const processor = this.noteProcessors.find(x => x.publicKey.equals(completeAddress.publicKey));
+        if (!processor) {
+            throw new Error(`Checking if account is synched is not possible for ${account} because it is only registered as a recipient.`);
+        }
+        return await processor.isSynchronized();
+    }
+    /**
+     * Checks whether all the blocks were processed (tree roots updated, txs updated with block info, etc.).
+     * @returns True if there are no outstanding blocks to be synched.
+     * @remarks This indicates that blocks and transactions are synched even if notes are not.
+     * @remarks Compares local block number with the block number from aztec node.
+     */
+    async isGlobalStateSynchronized() {
+        const latest = await this.node.getBlockNumber();
+        return latest <= this.synchedToBlock;
+    }
+    /**
+     * Returns the latest block that has been synchronized by the synchronizer and each account.
+     * @returns The latest block synchronized for blocks, and the latest block synched for notes for each public key being tracked.
+     */
+    getSyncStatus() {
+        return {
+            blocks: this.synchedToBlock,
+            notes: Object.fromEntries(this.noteProcessors.map(n => [n.publicKey.toString(), n.status.syncedToBlock])),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synchronizer.js","sourceRoot":"","sources":["../../src/synchronizer/synchronizer.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@aztec/pxe",
+  "version": "0.8.6",
+  "type": "module",
+  "exports": "./dest/index.js",
+  "bin": "./dest/bin/index.js",
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Wallet",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T prettier -w ./src",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --passWithNoTests",
+    "start": "DEBUG='aztec:*' && node ./dest/bin/index.js"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "preset": "ts-jest/presets/default-esm",
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.m?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src"
+  },
+  "dependencies": {
+    "@aztec/acir-simulator": "0.8.6",
+    "@aztec/circuits.js": "0.8.6",
+    "@aztec/ethereum": "0.8.6",
+    "@aztec/foundation": "0.8.6",
+    "@aztec/key-store": "0.8.6",
+    "@aztec/noir-compiler": "0.8.6",
+    "@aztec/types": "0.8.6",
+    "koa": "^2.14.2",
+    "koa-router": "^12.0.0",
+    "lodash.omit": "^4.5.0",
+    "lodash.partition": "^4.6.0",
+    "lodash.times": "^4.3.2",
+    "sha3": "^2.1.4",
+    "tslib": "^2.4.0",
+    "viem": "^1.2.5"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@rushstack/eslint-patch": "^1.1.4",
+    "@types/jest": "^29.5.0",
+    "@types/lodash.omit": "^4.5.7",
+    "@types/lodash.partition": "^4.6.0",
+    "@types/lodash.times": "^4.3.7",
+    "@types/node": "^18.7.23",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}