@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/src/synchronizer/synchronizer.ts

@@ -1,121 +0,0 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { type Logger, createLogger } 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 class Synchronizer implements L2BlockStreamEventHandler {
-  private initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
-  private log: Logger;
-  private isSyncing: Promise<void> | undefined;
-  protected readonly blockStream: L2BlockStream;
-
-  constructor(
-    private node: AztecNode,
-    private syncDataProvider: SyncDataProvider,
-    private noteDataProvider: NoteDataProvider,
-    private taggingDataProvider: TaggingDataProvider,
-    private l2TipsStore: L2TipsStore,
-    config: Partial<Pick<PXEConfig, 'l2StartingBlock'>> = {},
-    loggerOrSuffix?: string | Logger,
-  ) {
-    this.log =
-      !loggerOrSuffix || typeof loggerOrSuffix === 'string'
-        ? createLogger(loggerOrSuffix ? `pxe:synchronizer:${loggerOrSuffix}` : `pxe:synchronizer`)
-        : loggerOrSuffix;
-    this.blockStream = this.createBlockStream(config);
-  }
-
-  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2StartingBlock'>>) {
-    return new L2BlockStream(this.node, this.l2TipsStore, this, createLogger('pxe:block_stream'), {
-      startingBlock: config.l2StartingBlock,
-    });
-  }
-
-  /** Handle events emitted by the block stream. */
-  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
-    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.
-   */
-  public 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;
-    }
-  }
-
-  private 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();
-  }
-
-  public async getSynchedBlockNumber() {
-    return (await this.syncDataProvider.getBlockNumber()) ?? this.initialSyncBlockNumber;
-  }
-}

package/src/test/pxe_test_suite.ts

@@ -1,111 +0,0 @@
-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 type { PXE } from '@aztec/stdlib/interfaces/client';
-import {
-  randomContractArtifact,
-  randomContractInstanceWithAddress,
-  randomDeployedContract,
-} from '@aztec/stdlib/testing';
-
-import omit from 'lodash.omit';
-
-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 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]+/);
-    });
-  });
-};