@aztec/pxe 0.16.3 → 0.16.5

package/src/pxe_service/test/pxe_test_suite.ts

@@ -1,132 +0,0 @@
-import { AztecAddress, CompleteAddress, Fr, FunctionData, Point, TxContext } from '@aztec/circuits.js';
-import { Grumpkin } from '@aztec/circuits.js/barretenberg';
-import { ConstantKeyPair } from '@aztec/key-store';
-import { DeployedContract, INITIAL_L2_BLOCK_NUM, PXE, TxExecutionRequest, randomDeployedContract } from '@aztec/types';
-
-export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) => {
-  describe(testName, () => {
-    let pxe: 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 keyPair = ConstantKeyPair.random(new Grumpkin());
-      const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(keyPair.getPrivateKey(), Fr.random());
-
-      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
-
-      // Check that the account is correctly registered using the getAccounts and getRecipients methods
-      const accounts = await pxe.getRegisteredAccounts();
-      const recipients = await pxe.getRecipients();
-      expect(accounts).toContainEqual(completeAddress);
-      expect(recipients).not.toContainEqual(completeAddress);
-
-      // Check that the account is correctly registered using the getAccount and getRecipient methods
-      const account = await pxe.getRegisteredAccount(completeAddress.address);
-      const recipient = await pxe.getRecipient(completeAddress.address);
-      expect(account).toEqual(completeAddress);
-      expect(recipient).toBeUndefined();
-    });
-
-    it('registers a recipient and returns it as a recipient only and not as an account', async () => {
-      const completeAddress = CompleteAddress.random();
-
-      await pxe.registerRecipient(completeAddress);
-
-      // Check that the recipient is correctly registered using the getAccounts and getRecipients methods
-      const accounts = await pxe.getRegisteredAccounts();
-      const recipients = await pxe.getRecipients();
-      expect(accounts).not.toContainEqual(completeAddress);
-      expect(recipients).toContainEqual(completeAddress);
-
-      // Check that the recipient is correctly registered using the getAccount and getRecipient methods
-      const account = await pxe.getRegisteredAccount(completeAddress.address);
-      const recipient = await pxe.getRecipient(completeAddress.address);
-      expect(account).toBeUndefined();
-      expect(recipient).toEqual(completeAddress);
-    });
-
-    it('does not throw when registering the same account twice (just ignores the second attempt)', async () => {
-      const keyPair = ConstantKeyPair.random(new Grumpkin());
-      const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(keyPair.getPrivateKey(), Fr.random());
-
-      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
-      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
-    });
-
-    it('cannot register a recipient with the same aztec address but different pub key or partial address', async () => {
-      const recipient1 = CompleteAddress.random();
-      const recipient2 = new CompleteAddress(recipient1.address, Point.random(), Fr.random());
-
-      await pxe.registerRecipient(recipient1);
-      await expect(() => pxe.registerRecipient(recipient2)).rejects.toThrow(
-        `Complete address with aztec address ${recipient1.address}`,
-      );
-    });
-
-    it('does not throw when registering the same recipient twice (just ignores the second attempt)', async () => {
-      const completeAddress = CompleteAddress.random();
-
-      await pxe.registerRecipient(completeAddress);
-      await pxe.registerRecipient(completeAddress);
-    });
-
-    it('successfully adds a contract', async () => {
-      const contracts: DeployedContract[] = [randomDeployedContract(), randomDeployedContract()];
-      await pxe.addContracts(contracts);
-
-      const expectedContractAddresses = contracts.map(contract => contract.completeAddress.address);
-      const contractAddresses = await pxe.getContracts();
-
-      // check if all the contracts were returned
-      expect(contractAddresses).toEqual(expect.arrayContaining(expectedContractAddresses));
-    });
-
-    it('throws when simulating a tx targeting public entrypoint', async () => {
-      const functionData = FunctionData.empty();
-      functionData.isPrivate = false;
-      const txExecutionRequest = TxExecutionRequest.from({
-        origin: AztecAddress.random(),
-        argsHash: new Fr(0),
-        functionData,
-        txContext: TxContext.empty(),
-        packedArguments: [],
-        authWitnesses: [],
-      });
-
-      await expect(async () => await pxe.simulateTx(txExecutionRequest, false)).rejects.toThrow(
-        'Public entrypoints are not allowed',
-      );
-    });
-
-    // Note: Not testing a successful run of `simulateTx`, `sendTx`, `getTxReceipt` and `viewTx` 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 = AztecAddress.random();
-      await expect(async () => await pxe.getPublicStorageAt(contract, new Fr(0n))).rejects.toThrow(
-        `Contract ${contract.toString()} is not deployed`,
-      );
-    });
-
-    // Note: Not testing `getExtendedContractData`, `getContractData` and `getUnencryptedLogs` 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.chainId).toEqual('number');
-      expect(nodeInfo.l1ContractAddresses.rollupAddress.toString()).toMatch(/0x[a-fA-F0-9]+/);
-    });
-
-    // Note: Not testing `isGlobalStateSynchronized`, `isAccountStateSynchronized` and `getSyncStatus` as these methods
-    //       only call synchronizer.
-  });
-};

package/src/simulator/index.ts

@@ -1,24 +0,0 @@
-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';
-import { SimulatorOracle } from '../simulator_oracle/index.js';
-
-/**
- * Helper method to create an instance of the acir simulator.
- */
-export function getAcirSimulator(
-  db: Database,
-  stateInfoProvider: StateInfoProvider,
-  keyStore: KeyStore,
-  contractDataOracle?: ContractDataOracle,
-) {
-  const simulatorOracle = new SimulatorOracle(
-    contractDataOracle ?? new ContractDataOracle(db, stateInfoProvider),
-    db,
-    keyStore,
-    stateInfoProvider,
-  );
-  return new AcirSimulator(simulatorOracle);
-}

package/src/simulator_oracle/index.ts

@@ -1,186 +0,0 @@
-import { DBOracle, FunctionArtifactWithDebugMetadata, MessageLoadOracleInputs } from '@aztec/acir-simulator';
-import {
-  AztecAddress,
-  BlockHeader,
-  CompleteAddress,
-  EthAddress,
-  Fr,
-  FunctionSelector,
-  GrumpkinPrivateKey,
-  PublicKey,
-} from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { KeyStore, L2Block, MerkleTreeId, NullifierMembershipWitness, 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 class SimulatorOracle implements DBOracle {
-  constructor(
-    private contractDataOracle: ContractDataOracle,
-    private db: Database,
-    private keyStore: KeyStore,
-    private stateInfoProvider: StateInfoProvider,
-    private log = createDebugLogger('aztec:pxe:simulator_oracle'),
-  ) {}
-
-  getSecretKey(_contractAddress: AztecAddress, pubKey: PublicKey): Promise<GrumpkinPrivateKey> {
-    return this.keyStore.getAccountPrivateKey(pubKey);
-  }
-
-  async getCompleteAddress(address: AztecAddress): Promise<CompleteAddress> {
-    const completeAddress = await this.db.getCompleteAddress(address);
-    if (!completeAddress) {
-      throw new Error(
-        `No public key registered for address ${address.toString()}. Register it by calling pxe.registerRecipient(...) or pxe.registerAccount(...).\nSee docs for context: https://docs.aztec.network/dev_docs/contracts/common_errors#no-public-key-registered-error`,
-      );
-    }
-    return completeAddress;
-  }
-
-  async getAuthWitness(messageHash: Fr): Promise<Fr[]> {
-    const witness = await this.db.getAuthWitness(messageHash);
-    if (!witness) {
-      throw new Error(`Unknown auth witness for message hash ${messageHash.toString()}`);
-    }
-    return witness;
-  }
-
-  async popCapsule(): Promise<Fr[]> {
-    const capsule = await this.db.popCapsule();
-    if (!capsule) {
-      throw new Error(`No capsules available`);
-    }
-    return capsule;
-  }
-
-  async getNotes(contractAddress: AztecAddress, storageSlot: Fr) {
-    const noteDaos = await this.db.getNotes({ contractAddress, storageSlot });
-    return noteDaos.map(({ contractAddress, storageSlot, nonce, note, innerNoteHash, siloedNullifier, index }) => ({
-      contractAddress,
-      storageSlot,
-      nonce,
-      note,
-      innerNoteHash,
-      siloedNullifier,
-      // PXE can use this index to get full MembershipWitness
-      index,
-    }));
-  }
-
-  async getFunctionArtifact(
-    contractAddress: AztecAddress,
-    selector: FunctionSelector,
-  ): Promise<FunctionArtifactWithDebugMetadata> {
-    const artifact = await this.contractDataOracle.getFunctionArtifact(contractAddress, selector);
-    const debug = await this.contractDataOracle.getFunctionDebugMetadata(contractAddress, selector);
-    return {
-      ...artifact,
-      debug,
-    };
-  }
-
-  async getFunctionArtifactByName(
-    contractAddress: AztecAddress,
-    functionName: string,
-  ): Promise<FunctionArtifactWithDebugMetadata | undefined> {
-    const artifact = await this.contractDataOracle.getFunctionArtifactByName(contractAddress, functionName);
-    if (!artifact) {
-      return;
-    }
-
-    const debug = await this.contractDataOracle.getFunctionDebugMetadata(contractAddress, artifact.selector);
-    return {
-      ...artifact,
-      debug,
-    };
-  }
-
-  async getPortalContractAddress(contractAddress: AztecAddress): Promise<EthAddress> {
-    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: Fr): Promise<MessageLoadOracleInputs> {
-    const messageAndIndex = await this.stateInfoProvider.getL1ToL2MessageAndIndex(msgKey);
-    const message = messageAndIndex.message.toFieldArray();
-    const index = messageAndIndex.index;
-    const siblingPath = await this.stateInfoProvider.getL1ToL2MessageSiblingPath('latest', index);
-    return {
-      message,
-      siblingPath: siblingPath.toFieldArray(),
-      index,
-    };
-  }
-
-  /**
-   * Gets the index of a commitment in the note hash tree.
-   * @param commitment - The commitment.
-   * @returns - The index of the commitment. Undefined if it does not exist in the tree.
-   */
-  async getCommitmentIndex(commitment: Fr) {
-    return await this.stateInfoProvider.findLeafIndex('latest', MerkleTreeId.NOTE_HASH_TREE, commitment);
-  }
-
-  async getNullifierIndex(nullifier: Fr) {
-    return await this.stateInfoProvider.findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
-  }
-
-  public async findLeafIndex(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<bigint | undefined> {
-    return await this.stateInfoProvider.findLeafIndex(blockNumber, treeId, leafValue);
-  }
-
-  public async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: bigint): Promise<Fr[]> {
-    // @todo Doing a nasty workaround here because of https://github.com/AztecProtocol/aztec-packages/issues/3414
-    switch (treeId) {
-      case MerkleTreeId.NULLIFIER_TREE:
-        return (await this.stateInfoProvider.getNullifierTreeSiblingPath(blockNumber, leafIndex)).toFieldArray();
-      case MerkleTreeId.NOTE_HASH_TREE:
-        return (await this.stateInfoProvider.getNoteHashSiblingPath(blockNumber, leafIndex)).toFieldArray();
-      case MerkleTreeId.BLOCKS_TREE:
-        return (await this.stateInfoProvider.getBlocksTreeSiblingPath(blockNumber, leafIndex)).toFieldArray();
-      case MerkleTreeId.PUBLIC_DATA_TREE:
-        return (await this.stateInfoProvider.getPublicDataTreeSiblingPath(blockNumber, leafIndex)).toFieldArray();
-      default:
-        throw new Error('Not implemented');
-    }
-  }
-
-  public getNullifierMembershipWitness(
-    blockNumber: number,
-    nullifier: Fr,
-  ): Promise<NullifierMembershipWitness | undefined> {
-    return this.stateInfoProvider.getNullifierMembershipWitness(blockNumber, nullifier);
-  }
-
-  public getLowNullifierMembershipWitness(
-    blockNumber: number,
-    nullifier: Fr,
-  ): Promise<NullifierMembershipWitness | undefined> {
-    return this.stateInfoProvider.getLowNullifierMembershipWitness(blockNumber, nullifier);
-  }
-
-  public async getBlock(blockNumber: number): Promise<L2Block | undefined> {
-    return await this.stateInfoProvider.getBlock(blockNumber);
-  }
-
-  /**
-   * Retrieve the databases view of the Block Header object.
-   * This structure is fed into the circuits simulator and is used to prove against certain historical roots.
-   *
-   * @returns A Promise that resolves to a BlockHeader object.
-   */
-  getBlockHeader(): Promise<BlockHeader> {
-    return Promise.resolve(this.db.getBlockHeader());
-  }
-}

package/src/synchronizer/index.ts

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

package/src/synchronizer/synchronizer.ts

@@ -1,296 +0,0 @@
-import { AztecAddress, BlockHeader, Fr, PublicKey } from '@aztec/circuits.js';
-import { computeGlobalsHash } from '@aztec/circuits.js/abis';
-import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { InterruptibleSleep } from '@aztec/foundation/sleep';
-import { AztecNode, INITIAL_L2_BLOCK_NUM, KeyStore, L2BlockContext, L2BlockL2Logs, LogType } from '@aztec/types';
-import { NoteProcessorCaughtUpStats } from '@aztec/types/stats';
-
-import { Database } from '../database/index.js';
-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 {
-  private runningPromise?: Promise<void>;
-  private noteProcessors: NoteProcessor[] = [];
-  private interruptibleSleep = new InterruptibleSleep();
-  private running = false;
-  private initialSyncBlockNumber = 0;
-  private synchedToBlock = 0;
-  private log: DebugLogger;
-  private noteProcessorsToCatchUp: NoteProcessor[] = [];
-
-  constructor(private node: AztecNode, private db: Database, logSuffix = '') {
-    this.log = createDebugLogger(logSuffix ? `aztec:pxe_synchronizer_${logSuffix}` : 'aztec:pxe_synchronizer');
-  }
-
-  /**
-   * Starts the synchronization 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.
-   */
-  public 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');
-  }
-
-  protected async initialSync() {
-    const [blockNumber, blockHeader] = await Promise.all([this.node.getBlockNumber(), this.node.getBlockHeader()]);
-    this.initialSyncBlockNumber = blockNumber;
-    this.synchedToBlock = this.initialSyncBlockNumber;
-    await this.db.setBlockHeader(blockHeader);
-  }
-
-  protected async work(limit = 1, retryInterval = 1000): Promise<void> {
-    const from = this.synchedToBlock + 1;
-    try {
-      let encryptedLogs = await this.node.getLogs(from, limit, LogType.ENCRYPTED);
-      if (!encryptedLogs.length) {
-        await this.interruptibleSleep.sleep(retryInterval);
-        return;
-      }
-
-      let unencryptedLogs = await this.node.getLogs(from, limit, LogType.UNENCRYPTED);
-      if (!unencryptedLogs.length) {
-        await this.interruptibleSleep.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.interruptibleSleep.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);
-
-      const logCount = L2BlockL2Logs.getTotalLogCount(encryptedLogs);
-      this.log(`Forwarding ${logCount} 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.interruptibleSleep.sleep(retryInterval);
-    }
-  }
-
-  protected async workNoteProcessorCatchUp(limit = 1, retryInterval = 1000): Promise<void> {
-    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));
-
-      const logCount = L2BlockL2Logs.getTotalLogCount(encryptedLogs);
-      this.log(`Forwarding ${logCount} 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.log(`Note processor for ${noteProcessor.publicKey.toString()} has caught up`, {
-          eventName: 'note-processor-caught-up',
-          publicKey: noteProcessor.publicKey.toString(),
-          duration: noteProcessor.timer.ms(),
-          dbSize: this.db.estimateSize(),
-          ...noteProcessor.stats,
-        } satisfies NoteProcessorCaughtUpStats);
-        this.noteProcessorsToCatchUp.shift();
-        this.noteProcessors.push(noteProcessor);
-      }
-    } catch (err) {
-      this.log.error(`Error in synchronizer workNoteProcessorCatchUp`, err);
-      await this.interruptibleSleep.sleep(retryInterval);
-    }
-  }
-
-  private async setBlockDataFromBlock(latestBlock: L2BlockContext) {
-    const { block } = latestBlock;
-    if (block.number < this.initialSyncBlockNumber) {
-      return;
-    }
-
-    const globalsHash = computeGlobalsHash(latestBlock.block.globalVariables);
-    const blockHeader = new BlockHeader(
-      block.endNoteHashTreeSnapshot.root,
-      block.endNullifierTreeSnapshot.root,
-      block.endContractTreeSnapshot.root,
-      block.endL1ToL2MessagesTreeSnapshot.root,
-      block.endBlocksTreeSnapshot.root,
-      Fr.ZERO, // todo: private kernel vk tree root
-      block.endPublicDataTreeRoot,
-      globalsHash,
-    );
-
-    await this.db.setBlockHeader(blockHeader);
-  }
-
-  /**
-   * 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.
-   */
-  public async stop() {
-    this.running = false;
-    this.interruptibleSleep.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.
-   * @param startingBlock - The block where to start scanning for notes for this accounts.
-   * @returns A promise that resolves once the account is added to the Synchronizer.
-   */
-  public addAccount(publicKey: PublicKey, keyStore: KeyStore, startingBlock: number) {
-    const predicate = (x: NoteProcessor) => x.publicKey.equals(publicKey);
-    const processor = this.noteProcessors.find(predicate) ?? this.noteProcessorsToCatchUp.find(predicate);
-    if (processor) {
-      return;
-    }
-
-    this.noteProcessorsToCatchUp.push(new NoteProcessor(publicKey, keyStore, this.db, this.node, startingBlock));
-  }
-
-  /**
-   * 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.
-   */
-  public async isAccountStateSynchronized(account: AztecAddress) {
-    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 findByPublicKey = (x: NoteProcessor) => x.publicKey.equals(completeAddress.publicKey);
-    const processor = this.noteProcessors.find(findByPublicKey) ?? this.noteProcessorsToCatchUp.find(findByPublicKey);
-    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.
-   */
-  public 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.
-   */
-  public getSyncStatus() {
-    return {
-      blocks: this.synchedToBlock,
-      notes: Object.fromEntries(this.noteProcessors.map(n => [n.publicKey.toString(), n.status.syncedToBlock])),
-    };
-  }
-}