@aztec/pxe 0.82.3 → 0.83.0

package/src/pxe_service/pxe_service.ts

@@ -1,5 +1,5 @@
 import { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import { Fr, type Point } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { Timer } from '@aztec/foundation/timer';
@@ -20,6 +20,7 @@ import {
   FunctionCall,
   FunctionSelector,
   FunctionType,
+  decodeFromAbi,
   decodeFunctionSignature,
   encodeArguments,
 } from '@aztec/stdlib/abi';
@@ -36,7 +37,6 @@ import {
   getContractClassFromArtifact,
 } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
-import { EventMetadata, L1EventPayload } from '@aztec/stdlib/event';
 import type { GasFees } from '@aztec/stdlib/gas';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import type {
@@ -49,7 +49,6 @@ import type {
   PrivateKernelProver,
 } from '@aztec/stdlib/interfaces/client';
 import type { PrivateKernelExecutionProofOutput, PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
-import { computeAddressSecret } from '@aztec/stdlib/keys';
 import type { LogFilter } from '@aztec/stdlib/logs';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { type NotesFilter, UniqueNote } from '@aztec/stdlib/note';
@@ -82,6 +81,7 @@ import { AddressDataProvider } from '../storage/address_data_provider/address_da
 import { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
 import { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
 import { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
+import { PrivateEventDataProvider } from '../storage/private_event_data_provider/private_event_data_provider.js';
 import { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
 import { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
 import { Synchronizer } from '../synchronizer/index.js';
@@ -101,6 +101,7 @@ export class PXEService implements PXE {
     private syncDataProvider: SyncDataProvider,
     private taggingDataProvider: TaggingDataProvider,
     private addressDataProvider: AddressDataProvider,
+    private privateEventDataProvider: PrivateEventDataProvider,
     private simulator: AcirSimulator,
     private packageVersion: string,
     private proverEnabled: boolean,
@@ -134,6 +135,7 @@ export class PXEService implements PXE {
     const packageVersion = getPackageInfo().version;
     const proverEnabled = !!config.proverEnabled;
     const addressDataProvider = new AddressDataProvider(store);
+    const privateEventDataProvider = new PrivateEventDataProvider(store);
     const contractDataProvider = new ContractDataProvider(store);
     const noteDataProvider = await NoteDataProvider.create(store);
     const syncDataProvider = new SyncDataProvider(store);
@@ -153,13 +155,13 @@ export class PXEService implements PXE {
     const pxeOracleInterface = new PXEOracleInterface(
       node,
       keyStore,
-      simulationProvider,
       contractDataProvider,
       noteDataProvider,
       capsuleDataProvider,
       syncDataProvider,
       taggingDataProvider,
       addressDataProvider,
+      privateEventDataProvider,
       log,
     );
     const simulator = new AcirSimulator(pxeOracleInterface, simulationProvider);
@@ -175,6 +177,7 @@ export class PXEService implements PXE {
       syncDataProvider,
       taggingDataProvider,
       addressDataProvider,
+      privateEventDataProvider,
       simulator,
       packageVersion,
       proverEnabled,
@@ -188,7 +191,7 @@ export class PXEService implements PXE {
 
     await pxeService.#registerProtocolContracts();
     const info = await pxeService.getNodeInfo();
-    log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
+    log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.rollupVersion}`);
     return pxeService;
   }
 
@@ -846,20 +849,19 @@ export class PXEService implements PXE {
   }
 
   public async getNodeInfo(): Promise<NodeInfo> {
-    const [nodeVersion, protocolVersion, chainId, enr, contractAddresses, protocolContractAddresses] =
-      await Promise.all([
-        this.node.getNodeVersion(),
-        this.node.getVersion(),
-        this.node.getChainId(),
-        this.node.getEncodedEnr(),
-        this.node.getL1ContractAddresses(),
-        this.node.getProtocolContractAddresses(),
-      ]);
+    const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses] = await Promise.all([
+      this.node.getNodeVersion(),
+      this.node.getVersion(),
+      this.node.getChainId(),
+      this.node.getEncodedEnr(),
+      this.node.getL1ContractAddresses(),
+      this.node.getProtocolContractAddresses(),
+    ]);
 
     const nodeInfo: NodeInfo = {
       nodeVersion,
       l1ChainId: chainId,
-      protocolVersion,
+      rollupVersion,
       enr,
       l1ContractAddresses: contractAddresses,
       protocolContractAddresses: protocolContractAddresses,
@@ -881,78 +883,35 @@ export class PXEService implements PXE {
   }
 
   public async getPrivateEvents<T>(
+    contractAddress: AztecAddress,
     eventMetadataDef: EventMetadataDefinition,
     from: number,
-    limit: number,
-    // TODO (#9272): Make this better, we should be able to only pass an address now
-    vpks: Point[],
+    numBlocks: number,
+    recipients: AztecAddress[],
   ): Promise<T[]> {
-    const eventMetadata = new EventMetadata<T>(eventMetadataDef);
-    if (vpks.length === 0) {
-      throw new Error('Tried to get encrypted events without supplying any viewing public keys');
+    if (recipients.length === 0) {
+      throw new Error('Recipients are required to get private events');
     }
 
-    const blocks = await this.node.getBlocks(from, limit);
-
-    const txEffects = blocks.flatMap(block => block.body.txEffects);
-    const privateLogs = txEffects.flatMap(txEffect => txEffect.privateLogs);
+    this.log.verbose(`Getting private events for ${contractAddress.toString()} from ${from} to ${from + numBlocks}`);
 
-    const vsks = await Promise.all(
-      vpks.map(async vpk => {
-        const [keyPrefix, account] = await this.keyStore.getKeyPrefixAndAccount(vpk);
-        let secretKey = await this.keyStore.getMasterSecretKey(vpk);
-        if (keyPrefix === 'iv') {
-          const registeredAccount = (await this.getRegisteredAccounts()).find(completeAddress =>
-            completeAddress.address.equals(account),
-          );
-          if (!registeredAccount) {
-            throw new Error('No registered account');
-          }
+    // TODO(#13113): This is a temporary hack to ensure that the notes are synced before getting the events.
+    await this.simulateUnconstrained('sync_notes', [], contractAddress);
 
-          const preaddress = await registeredAccount.getPreaddress();
-
-          secretKey = await computeAddressSecret(preaddress, secretKey);
-        }
-
-        return secretKey;
-      }),
+    const events = await this.privateEventDataProvider.getPrivateEvents(
+      contractAddress,
+      from,
+      numBlocks,
+      recipients,
+      eventMetadataDef.eventSelector,
     );
 
-    const visibleEvents = (
-      await Promise.all(
-        privateLogs.map(async log => {
-          for (const sk of vsks) {
-            // TODO: Verify that the first field of the log is the tag siloed with contract address.
-            // Or use tags to query logs, like we do with notes.
-            const decryptedEvent = await L1EventPayload.decryptAsIncoming(log, sk);
-            if (decryptedEvent !== undefined) {
-              return [decryptedEvent];
-            }
-          }
-
-          return [];
-        }),
-      )
-    ).flat();
-
-    const decodedEvents = visibleEvents
-      .map(visibleEvent => {
-        if (visibleEvent === undefined) {
-          return undefined;
-        }
-        if (!visibleEvent.eventTypeId.equals(eventMetadata.eventSelector)) {
-          return undefined;
-        }
-
-        return eventMetadata.decode(visibleEvent);
-      })
-      .filter(visibleEvent => visibleEvent !== undefined) as T[];
+    const decodedEvents = events.map((event: Fr[]): T => decodeFromAbi([eventMetadataDef.abiType], event) as T);
 
     return decodedEvents;
   }
 
   async getPublicEvents<T>(eventMetadataDef: EventMetadataDefinition, from: number, limit: number): Promise<T[]> {
-    const eventMetadata = new EventMetadata<T>(eventMetadataDef);
     const { logs } = await this.node.getPublicLogs({
       fromBlock: from,
       toBlock: from + limit,
@@ -961,10 +920,10 @@ export class PXEService implements PXE {
     const decodedEvents = logs
       .map(log => {
         // +1 for the event selector
-        const expectedLength = eventMetadata.fieldNames.length + 1;
+        const expectedLength = eventMetadataDef.fieldNames.length + 1;
         const logFields = log.log.log.slice(0, expectedLength);
         // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
-        if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadata.eventSelector)) {
+        if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
           return undefined;
         }
         // If any of the remaining fields, are non-zero, the payload does match expected:
@@ -974,7 +933,7 @@ export class PXEService implements PXE {
           );
         }
 
-        return eventMetadata.decode(log.log);
+        return decodeFromAbi([eventMetadataDef.abiType], log.log.log) as T;
       })
       .filter(log => log !== undefined) as T[];
 

package/src/storage/capsule_data_provider/capsule_data_provider.ts

@@ -67,6 +67,32 @@ export class CapsuleDataProvider implements DataProvider {
     }
   }
 
+  /**
+   * Appends multiple capsules to a capsule array stored at the base slot.
+   * The array length is stored at the base slot, and elements are stored in consecutive slots after it.
+   * All operations are performed in a single transaction.
+   * @param contractAddress - The contract address that owns the capsule array
+   * @param baseSlot - The slot where the array length is stored
+   * @param capsules - Array of capsule data to append
+   */
+  appendToCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, capsules: Fr[][]): Promise<void> {
+    return this.#store.transactionAsync(async () => {
+      // Load current length, defaulting to 0 if not found
+      const lengthData = await this.loadCapsule(contractAddress, baseSlot);
+      const currentLength = lengthData ? lengthData[0].toBigInt() : 0n;
+
+      // Store each capsule at consecutive slots after baseSlot + 1 + currentLength
+      for (let i = 0; i < capsules.length; i++) {
+        const nextSlot = baseSlot.add(new Fr(1)).add(new Fr(currentLength + BigInt(i)));
+        await this.storeCapsule(contractAddress, nextSlot, capsules[i]);
+      }
+
+      // Update length to include all new capsules
+      const newLength = currentLength + BigInt(capsules.length);
+      await this.storeCapsule(contractAddress, baseSlot, [new Fr(newLength)]);
+    });
+  }
+
   public async getSize() {
     return (await toArray(this.#capsules.valuesAsync())).reduce(
       (sum, value) => sum + value.length * Fr.SIZE_IN_BYTES,

package/src/storage/index.ts

@@ -6,3 +6,4 @@ export * from './sync_data_provider/index.js';
 export * from './tagging_data_provider/index.js';
 export * from './data_provider.js';
 export * from './metadata.js';
+export * from './private_event_data_provider/private_event_data_provider.js';

package/src/storage/private_event_data_provider/private_event_data_provider.ts

@@ -0,0 +1,137 @@
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { AztecAsyncArray, AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { EventSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import type { DataProvider } from '../data_provider.js';
+
+interface PrivateEventEntry {
+  logContent: Buffer;
+  blockNumber: number;
+  logIndexInTx: number;
+}
+
+/**
+ * Stores decrypted private event logs.
+ */
+export class PrivateEventDataProvider implements DataProvider {
+  #store: AztecAsyncKVStore;
+  /** Array storing the actual private event log entries containing the log content and block number */
+  #eventLogs: AztecAsyncArray<PrivateEventEntry>;
+  /** Map from contract_address_recipient_eventSelector to array of indices into #eventLogs for efficient lookup */
+  #eventLogIndex: AztecAsyncMap<string, number[]>;
+  /**
+   * Map from txHash_logIndexInTx to boolean indicating if log has been seen.
+   * @dev A single transaction can have multiple logs.
+   */
+  #seenLogs: AztecAsyncMap<string, boolean>;
+
+  logger = createLogger('private_event_data_provider');
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+    this.#eventLogs = this.#store.openArray('private_event_logs');
+    this.#eventLogIndex = this.#store.openMap('private_event_log_index');
+    this.#seenLogs = this.#store.openMap('seen_logs');
+  }
+
+  /**
+   * Store a private event log.
+   * @param contractAddress - The address of the contract that emitted the event.
+   * @param recipient - The recipient of the event.
+   * @param eventSelector - The event selector of the event.
+   * @param logContent - The content of the event.
+   * @param txHash - The transaction hash of the event log.
+   * @param logIndexInTx - The index of the log within the transaction.
+   * @param blockNumber - The block number in which the event was emitted.
+   */
+  storePrivateEventLog(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+    eventSelector: EventSelector,
+    logContent: Fr[],
+    txHash: TxHash,
+    logIndexInTx: number,
+    blockNumber: number,
+  ): Promise<void> {
+    return this.#store.transactionAsync(async () => {
+      const key = `${contractAddress.toString()}_${recipient.toString()}_${eventSelector.toString()}`;
+
+      // We identify a unique log by its transaction hash and index within that transaction
+      const txKey = `${txHash.toString()}_${logIndexInTx}`;
+
+      // Check if this exact log has already been stored
+      const hasBeenSeen = await this.#seenLogs.getAsync(txKey);
+      if (hasBeenSeen) {
+        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), logIndexInTx });
+        return;
+      }
+
+      this.logger.verbose('storing private event log', { contractAddress, recipient, logContent, blockNumber });
+
+      const index = await this.#eventLogs.lengthAsync();
+      await this.#eventLogs.push({ logContent: serializeToBuffer(logContent), blockNumber, logIndexInTx });
+
+      const existingIndices = (await this.#eventLogIndex.getAsync(key)) || [];
+      await this.#eventLogIndex.set(key, [...existingIndices, index]);
+
+      // Mark this log as seen
+      await this.#seenLogs.set(txKey, true);
+    });
+  }
+
+  /**
+   * Returns the private events given search parameters.
+   * @param contractAddress - The address of the contract to get events from.
+   * @param from - The block number to search from.
+   * @param numBlocks - The amount of blocks to search.
+   * @param recipients - The addresses that decrypted the logs.
+   * @param eventSelector - The event selector to filter by.
+   * @returns - The event log contents.
+   */
+  public async getPrivateEvents(
+    contractAddress: AztecAddress,
+    from: number,
+    numBlocks: number,
+    recipients: AztecAddress[],
+    eventSelector: EventSelector,
+  ): Promise<Fr[][]> {
+    const events: Array<{ logContent: Fr[]; blockNumber: number; logIndexInTx: number }> = [];
+
+    for (const recipient of recipients) {
+      const key = `${contractAddress.toString()}_${recipient.toString()}_${eventSelector.toString()}`;
+      const indices = (await this.#eventLogIndex.getAsync(key)) || [];
+
+      for (const index of indices) {
+        const entry = await this.#eventLogs.atAsync(index);
+        if (!entry || entry.blockNumber < from || entry.blockNumber >= from + numBlocks) {
+          continue;
+        }
+
+        // Convert buffer back to Fr array
+        const reader = BufferReader.asReader(entry.logContent);
+        const numFields = entry.logContent.length / Fr.SIZE_IN_BYTES;
+        const logContent = reader.readArray(numFields, Fr);
+
+        events.push({ logContent, blockNumber: entry.blockNumber, logIndexInTx: entry.logIndexInTx });
+      }
+    }
+
+    // Sort by block number first, then by logIndexInTx (note that we currently don't order by txs within a block)
+    events.sort((a, b) => {
+      if (a.blockNumber !== b.blockNumber) {
+        return a.blockNumber - b.blockNumber;
+      }
+      return a.logIndexInTx - b.logIndexInTx;
+    });
+
+    return events.map(e => e.logContent);
+  }
+
+  getSize(): Promise<number> {
+    return this.#eventLogs.lengthAsync();
+  }
+}

package/src/storage/sync_data_provider/sync_data_provider.ts

@@ -16,10 +16,10 @@ export class SyncDataProvider implements DataProvider {
     await this.#synchronizedHeader.set(header.toBuffer());
   }
 
-  async getBlockNumber(): Promise<number | undefined> {
+  async getBlockNumber(): Promise<number> {
     const headerBuffer = await this.#synchronizedHeader.getAsync();
     if (!headerBuffer) {
-      return undefined;
+      throw new Error(`Trying to get block number with a not-yet-synchronized PXE - this should never happen`);
     }
 
     return Number(BlockHeader.fromBuffer(headerBuffer).globalVariables.blockNumber.toBigInt());

package/src/storage/tagging_data_provider/tagging_data_provider.ts

@@ -23,32 +23,63 @@ export class TaggingDataProvider {
     this.#taggingSecretIndexesForRecipients = this.#store.openMap('tagging_secret_indexes_for_recipients');
   }
 
-  async setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
-    await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders);
+  setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[], sender: AztecAddress) {
+    return this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders, sender);
   }
 
-  async setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
-    await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients);
+  setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[], recipient: AztecAddress) {
+    return this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients, recipient);
   }
 
-  async #setTaggingSecretsIndexes(indexedSecrets: IndexedTaggingSecret[], storageMap: AztecAsyncMap<string, number>) {
-    await Promise.all(
+  /**
+   * Sets the indexes of the tagging secrets for the given app tagging secrets in the direction of the given address.
+   * @dev We need to specify the direction because app tagging secrets are direction-less due to the way they are generated
+   * but we need to guarantee that the index is stored under a uni-directional key because the tags are themselves
+   * uni-directional.
+   * @param indexedSecrets - The app tagging secrets and indexes to set.
+   * @param storageMap - The storage map to set the indexes in.
+   * @param inDirectionOf - The address that the secrets are in the direction of.
+   */
+  #setTaggingSecretsIndexes(
+    indexedSecrets: IndexedTaggingSecret[],
+    storageMap: AztecAsyncMap<string, number>,
+    inDirectionOf: AztecAddress,
+  ) {
+    return Promise.all(
       indexedSecrets.map(indexedSecret =>
-        storageMap.set(indexedSecret.appTaggingSecret.toString(), indexedSecret.index),
+        storageMap.set(`${indexedSecret.appTaggingSecret.toString()}_${inDirectionOf.toString()}`, indexedSecret.index),
       ),
     );
   }
 
-  async getTaggingSecretsIndexesAsRecipient(appTaggingSecrets: Fr[]) {
-    return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForRecipients);
+  getTaggingSecretsIndexesAsRecipient(appTaggingSecrets: Fr[], recipient: AztecAddress) {
+    return this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForRecipients, recipient);
   }
 
-  async getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[]) {
-    return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders);
+  getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[], sender: AztecAddress) {
+    return this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders, sender);
   }
 
-  #getTaggingSecretsIndexes(appTaggingSecrets: Fr[], storageMap: AztecAsyncMap<string, number>): Promise<number[]> {
-    return Promise.all(appTaggingSecrets.map(async secret => (await storageMap.getAsync(`${secret.toString()}`)) ?? 0));
+  /**
+   * Returns the indexes of the tagging secrets for the given app tagging secrets in the direction of the given address.
+   * @dev We need to specify the direction because app tagging secrets are direction-less due to the way they are generated
+   * but we need to guarantee that the index is stored under a uni-directional key because the tags are themselves
+   * uni-directional.
+   * @param appTaggingSecrets - The app tagging secrets to get the indexes for.
+   * @param storageMap - The storage map to get the indexes from.
+   * @param inDirectionOf - The address that the secrets are in the direction of.
+   * @returns The indexes of the tagging secrets.
+   */
+  #getTaggingSecretsIndexes(
+    appTaggingSecrets: Fr[],
+    storageMap: AztecAsyncMap<string, number>,
+    inDirectionOf: AztecAddress,
+  ): Promise<number[]> {
+    return Promise.all(
+      appTaggingSecrets.map(
+        async secret => (await storageMap.getAsync(`${secret.toString()}_${inDirectionOf.toString()}`)) ?? 0,
+      ),
+    );
   }
 
   resetNoteSyncData(): Promise<void> {

package/src/synchronizer/synchronizer.ts

@@ -1,4 +1,3 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
@@ -10,13 +9,11 @@ import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_p
 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.
+ * The Synchronizer class orchestrates synchronization between the PXE and Aztec node, maintaining an up-to-date
+ * view of the L2 chain state. It handles block header retrieval, chain reorganizations, and provides an interface
+ * for querying sync status.
  */
 export class Synchronizer implements L2BlockStreamEventHandler {
-  private initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
   private log: Logger;
   private isSyncing: Promise<void> | undefined;
   protected readonly blockStream: L2BlockStream;
@@ -59,18 +56,18 @@ export class Synchronizer implements L2BlockStreamEventHandler {
         break;
       }
       case 'chain-pruned': {
-        this.log.warn(`Pruning data after block ${event.blockNumber} due to reorg`);
+        this.log.warn(`Pruning data after block ${event.block.number} 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);
+        await this.noteDataProvider.unnullifyNotesAfter(event.block.number, lastSynchedBlockNumber);
+        await this.noteDataProvider.removeNotesAfter(event.block.number);
         // 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);
+        const newHeader = await this.node.getBlockHeader(event.block.number);
         if (!newHeader) {
-          this.log.error(`Block header not found for block number ${event.blockNumber} during chain prune`);
+          this.log.error(`Block header not found for block number ${event.block.number} during chain prune`);
         } else {
           await this.syncDataProvider.setHeader(newHeader);
         }
@@ -80,7 +77,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
   }
 
   /**
-   * Syncs PXE and the node by dowloading the metadata of the latest blocks, allowing simulations to use
+   * Syncs PXE and the node by downloading 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() {
@@ -115,7 +112,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     await this.blockStream.sync();
   }
 
-  public async getSynchedBlockNumber() {
-    return (await this.syncDataProvider.getBlockNumber()) ?? this.initialSyncBlockNumber;
+  public getSynchedBlockNumber() {
+    return this.syncDataProvider.getBlockNumber();
   }
 }

package/src/test/pxe_test_suite.ts

@@ -105,7 +105,7 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
 
     it('successfully gets node info', async () => {
       const nodeInfo = await pxe.getNodeInfo();
-      expect(typeof nodeInfo.protocolVersion).toEqual('number');
+      expect(typeof nodeInfo.rollupVersion).toEqual('number');
       expect(typeof nodeInfo.l1ChainId).toEqual('number');
       expect(nodeInfo.l1ContractAddresses.rollupAddress.toString()).toMatch(/0x[a-fA-F0-9]+/);
     });