@aztec/pxe 0.82.3 → 0.83.0

package/dest/pxe_service/pxe_service.js

@@ -6,12 +6,10 @@ import { KeyStore } from '@aztec/key-store';
 import { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { ProtocolContractAddress, protocolContractNames } from '@aztec/protocol-contracts';
 import { AcirSimulator, readCurrentClassId } from '@aztec/simulator/client';
-import { EventSelector, FunctionSelector, FunctionType, decodeFunctionSignature, encodeArguments } from '@aztec/stdlib/abi';
+import { EventSelector, FunctionSelector, FunctionType, decodeFromAbi, decodeFunctionSignature, encodeArguments } from '@aztec/stdlib/abi';
 import { computeContractAddressFromInstance, getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
-import { EventMetadata, L1EventPayload } from '@aztec/stdlib/event';
 import { siloNullifier } from '@aztec/stdlib/hash';
-import { computeAddressSecret } from '@aztec/stdlib/keys';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { UniqueNote } from '@aztec/stdlib/note';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
@@ -25,6 +23,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';
@@ -41,6 +40,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     syncDataProvider;
     taggingDataProvider;
     addressDataProvider;
+    privateEventDataProvider;
     simulator;
     packageVersion;
     proverEnabled;
@@ -48,7 +48,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     protocolContractsProvider;
     log;
     jobQueue;
-    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue){
+    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue){
         this.node = node;
         this.synchronizer = synchronizer;
         this.keyStore = keyStore;
@@ -58,6 +58,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         this.syncDataProvider = syncDataProvider;
         this.taggingDataProvider = taggingDataProvider;
         this.addressDataProvider = addressDataProvider;
+        this.privateEventDataProvider = privateEventDataProvider;
         this.simulator = simulator;
         this.packageVersion = packageVersion;
         this.proverEnabled = proverEnabled;
@@ -77,6 +78,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         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);
@@ -85,14 +87,14 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         const keyStore = new KeyStore(store);
         const tipsStore = new L2TipsKVStore(store, 'pxe');
         const synchronizer = new Synchronizer(node, syncDataProvider, noteDataProvider, taggingDataProvider, tipsStore, config, loggerOrSuffix);
-        const pxeOracleInterface = new PXEOracleInterface(node, keyStore, simulationProvider, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, log);
+        const pxeOracleInterface = new PXEOracleInterface(node, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, log);
         const simulator = new AcirSimulator(pxeOracleInterface, simulationProvider);
         const jobQueue = new SerialQueue();
-        const pxeService = new PXEService(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue);
+        const pxeService = new PXEService(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue);
         pxeService.jobQueue.start();
         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;
     }
     // Aztec node proxy methods
@@ -572,7 +574,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         });
     }
     async getNodeInfo() {
-        const [nodeVersion, protocolVersion, chainId, enr, contractAddresses, protocolContractAddresses] = await Promise.all([
+        const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses] = await Promise.all([
             this.node.getNodeVersion(),
             this.node.getVersion(),
             this.node.getChainId(),
@@ -583,7 +585,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         const nodeInfo = {
             nodeVersion,
             l1ChainId: chainId,
-            protocolVersion,
+            rollupVersion,
             enr,
             l1ContractAddresses: contractAddresses,
             protocolContractAddresses: protocolContractAddresses
@@ -601,71 +603,39 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             }
         });
     }
-    async getPrivateEvents(eventMetadataDef, from, limit, // TODO (#9272): Make this better, we should be able to only pass an address now
-    vpks) {
-        const eventMetadata = new EventMetadata(eventMetadataDef);
-        if (vpks.length === 0) {
-            throw new Error('Tried to get encrypted events without supplying any viewing public keys');
+    async getPrivateEvents(contractAddress, eventMetadataDef, from, numBlocks, recipients) {
+        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);
-        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');
-                }
-                const preaddress = await registeredAccount.getPreaddress();
-                secretKey = await computeAddressSecret(preaddress, secretKey);
-            }
-            return secretKey;
-        }));
-        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);
+        this.log.verbose(`Getting private events for ${contractAddress.toString()} from ${from} to ${from + numBlocks}`);
+        // 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 events = await this.privateEventDataProvider.getPrivateEvents(contractAddress, from, numBlocks, recipients, eventMetadataDef.eventSelector);
+        const decodedEvents = events.map((event)=>decodeFromAbi([
+                eventMetadataDef.abiType
+            ], event));
         return decodedEvents;
     }
     async getPublicEvents(eventMetadataDef, from, limit) {
-        const eventMetadata = new EventMetadata(eventMetadataDef);
         const { logs } = await this.node.getPublicLogs({
             fromBlock: from,
             toBlock: from + limit
         });
         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:
             if (log.log.log.slice(expectedLength + 1).find((f)=>!f.isZero())) {
                 throw new Error('Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length');
             }
-            return eventMetadata.decode(log.log);
+            return decodeFromAbi([
+                eventMetadataDef.abiType
+            ], log.log.log);
         }).filter((log)=>log !== undefined);
         return decodedEvents;
     }

package/dest/storage/capsule_data_provider/capsule_data_provider.d.ts

@@ -11,6 +11,15 @@ export declare class CapsuleDataProvider implements DataProvider {
     loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
     deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void>;
     copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
+    /**
+     * 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>;
     getSize(): Promise<number>;
 }
 //# sourceMappingURL=capsule_data_provider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"capsule_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/capsule_data_provider/capsule_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,KAAK,EAAyB,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,mBAAoB,YAAW,YAAY;;IAMtD,KAAK,EAAE,KAAK,CAAC;gBAED,KAAK,EAAE,iBAAiB;IAQ9B,YAAY,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAInF,WAAW,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC;IAa1E,aAAa,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrE,WAAW,CAAC,eAAe,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBhG,OAAO;CAMrB"}
+{"version":3,"file":"capsule_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/capsule_data_provider/capsule_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,KAAK,EAAyB,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,mBAAoB,YAAW,YAAY;;IAMtD,KAAK,EAAE,KAAK,CAAC;gBAED,KAAK,EAAE,iBAAiB;IAQ9B,YAAY,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAInF,WAAW,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC;IAa1E,aAAa,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrE,WAAW,CAAC,eAAe,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB7G;;;;;;;OAOG;IACH,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBrF,OAAO;CAMrB"}

package/dest/storage/capsule_data_provider/capsule_data_provider.js

@@ -48,6 +48,30 @@ export class CapsuleDataProvider {
             await this.#capsules.set(currentDstSlot, toCopy);
         }
     }
+    /**
+   * 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, baseSlot, capsules) {
+        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)
+            ]);
+        });
+    }
     async getSize() {
         return (await toArray(this.#capsules.valuesAsync())).reduce((sum, value)=>sum + value.length * Fr.SIZE_IN_BYTES, 0);
     }

package/dest/storage/index.d.ts

@@ -6,4 +6,5 @@ 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';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,8DAA8D,CAAC"}

package/dest/storage/index.js

@@ -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/dest/storage/private_event_data_provider/private_event_data_provider.d.ts

@@ -0,0 +1,37 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAsyncKVStore } 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';
+/**
+ * Stores decrypted private event logs.
+ */
+export declare class PrivateEventDataProvider implements DataProvider {
+    #private;
+    logger: import("@aztec/foundation/log").Logger;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * 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>;
+    /**
+     * 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.
+     */
+    getPrivateEvents(contractAddress: AztecAddress, from: number, numBlocks: number, recipients: AztecAddress[], eventSelector: EventSelector): Promise<Fr[][]>;
+    getSize(): Promise<number>;
+}
+//# sourceMappingURL=private_event_data_provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"private_event_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/private_event_data_provider/private_event_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,KAAK,EAAmB,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAQxD;;GAEG;AACH,qBAAa,wBAAyB,YAAW,YAAY;;IAY3D,MAAM,yCAA+C;gBAEzC,KAAK,EAAE,iBAAiB;IAOpC;;;;;;;;;OASG;IACH,oBAAoB,CAClB,eAAe,EAAE,YAAY,EAC7B,SAAS,EAAE,YAAY,EACvB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,EAAE,EAAE,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC;IA2BhB;;;;;;;;OAQG;IACU,gBAAgB,CAC3B,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,YAAY,EAAE,EAC1B,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IAiClB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;CAG3B"}

package/dest/storage/private_event_data_provider/private_event_data_provider.js

@@ -0,0 +1,106 @@
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+/**
+ * Stores decrypted private event logs.
+ */ export class PrivateEventDataProvider {
+    #store;
+    /** Array storing the actual private event log entries containing the log content and block number */ #eventLogs;
+    /** Map from contract_address_recipient_eventSelector to array of indices into #eventLogs for efficient lookup */ #eventLogIndex;
+    /**
+   * Map from txHash_logIndexInTx to boolean indicating if log has been seen.
+   * @dev A single transaction can have multiple logs.
+   */ #seenLogs;
+    logger = createLogger('private_event_data_provider');
+    constructor(store){
+        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, recipient, eventSelector, logContent, txHash, logIndexInTx, blockNumber) {
+        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.
+   */ async getPrivateEvents(contractAddress, from, numBlocks, recipients, eventSelector) {
+        const events = [];
+        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() {
+        return this.#eventLogs.lengthAsync();
+    }
+}

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

@@ -5,7 +5,7 @@ export declare class SyncDataProvider implements DataProvider {
     #private;
     constructor(store: AztecAsyncKVStore);
     setHeader(header: BlockHeader): Promise<void>;
-    getBlockNumber(): Promise<number | undefined>;
+    getBlockNumber(): Promise<number>;
     getBlockHeader(): Promise<BlockHeader>;
     getSize(): Promise<number>;
 }

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

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

package/dest/storage/sync_data_provider/sync_data_provider.js

@@ -12,7 +12,7 @@ export class SyncDataProvider {
     async getBlockNumber() {
         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/dest/storage/tagging_data_provider/tagging_data_provider.d.ts

@@ -5,10 +5,10 @@ import type { IndexedTaggingSecret } from '@aztec/stdlib/logs';
 export declare class TaggingDataProvider {
     #private;
     constructor(store: AztecAsyncKVStore);
-    setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[]): Promise<void>;
-    setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[]): Promise<void>;
-    getTaggingSecretsIndexesAsRecipient(appTaggingSecrets: Fr[]): Promise<number[]>;
-    getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[]): Promise<number[]>;
+    setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[], sender: AztecAddress): Promise<void[]>;
+    setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[], recipient: AztecAddress): Promise<void[]>;
+    getTaggingSecretsIndexesAsRecipient(appTaggingSecrets: Fr[], recipient: AztecAddress): Promise<number[]>;
+    getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[], sender: AztecAddress): Promise<number[]>;
     resetNoteSyncData(): Promise<void>;
     addSenderAddress(address: AztecAddress): Promise<boolean>;
     getSenderAddresses(): Promise<AztecAddress[]>;

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

@@ -1 +1 @@
-{"version":3,"file":"tagging_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_data_provider/tagging_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,qBAAa,mBAAmB;;gBAUlB,KAAK,EAAE,iBAAiB;IAS9B,gCAAgC,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvF,mCAAmC,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAY1F,mCAAmC,CAAC,iBAAiB,EAAE,EAAE,EAAE;IAI3D,gCAAgC,CAAC,iBAAiB,EAAE,EAAE,EAAE;IAQ9D,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAUzD,kBAAkB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAI7C,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAU5D,OAAO;CAKd"}
+{"version":3,"file":"tagging_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_data_provider/tagging_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,qBAAa,mBAAmB;;gBAUlB,KAAK,EAAE,iBAAiB;IASpC,gCAAgC,CAAC,cAAc,EAAE,oBAAoB,EAAE,EAAE,MAAM,EAAE,YAAY;IAI7F,mCAAmC,CAAC,cAAc,EAAE,oBAAoB,EAAE,EAAE,SAAS,EAAE,YAAY;IAyBnG,mCAAmC,CAAC,iBAAiB,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,YAAY;IAIpF,gCAAgC,CAAC,iBAAiB,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,YAAY;IA0B9E,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAUzD,kBAAkB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAI7C,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAU5D,OAAO;CAKd"}

package/dest/storage/tagging_data_provider/tagging_data_provider.js

@@ -14,23 +14,40 @@ export class TaggingDataProvider {
         this.#taggingSecretIndexesForSenders = this.#store.openMap('tagging_secret_indexes_for_senders');
         this.#taggingSecretIndexesForRecipients = this.#store.openMap('tagging_secret_indexes_for_recipients');
     }
-    async setTaggingSecretsIndexesAsSender(indexedSecrets) {
-        await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders);
+    setTaggingSecretsIndexesAsSender(indexedSecrets, sender) {
+        return this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders, sender);
     }
-    async setTaggingSecretsIndexesAsRecipient(indexedSecrets) {
-        await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients);
+    setTaggingSecretsIndexesAsRecipient(indexedSecrets, recipient) {
+        return this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients, recipient);
     }
-    async #setTaggingSecretsIndexes(indexedSecrets, storageMap) {
-        await Promise.all(indexedSecrets.map((indexedSecret)=>storageMap.set(indexedSecret.appTaggingSecret.toString(), indexedSecret.index)));
+    /**
+   * 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, storageMap, inDirectionOf) {
+        return Promise.all(indexedSecrets.map((indexedSecret)=>storageMap.set(`${indexedSecret.appTaggingSecret.toString()}_${inDirectionOf.toString()}`, indexedSecret.index)));
     }
-    async getTaggingSecretsIndexesAsRecipient(appTaggingSecrets) {
-        return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForRecipients);
+    getTaggingSecretsIndexesAsRecipient(appTaggingSecrets, recipient) {
+        return this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForRecipients, recipient);
     }
-    async getTaggingSecretsIndexesAsSender(appTaggingSecrets) {
-        return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders);
+    getTaggingSecretsIndexesAsSender(appTaggingSecrets, sender) {
+        return this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders, sender);
     }
-    #getTaggingSecretsIndexes(appTaggingSecrets, storageMap) {
-        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, storageMap, inDirectionOf) {
+        return Promise.all(appTaggingSecrets.map(async (secret)=>await storageMap.getAsync(`${secret.toString()}_${inDirectionOf.toString()}`) ?? 0));
     }
     resetNoteSyncData() {
         return this.#store.transactionAsync(async ()=>{

package/dest/synchronizer/synchronizer.d.ts

@@ -7,10 +7,9 @@ import type { NoteDataProvider } from '../storage/note_data_provider/note_data_p
 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.
+ * 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 declare class Synchronizer implements L2BlockStreamEventHandler {
     private node;
@@ -18,7 +17,6 @@ export declare class Synchronizer implements L2BlockStreamEventHandler {
     private noteDataProvider;
     private taggingDataProvider;
     private l2TipsStore;
-    private initialSyncBlockNumber;
     private log;
     private isSyncing;
     protected readonly blockStream: L2BlockStream;
@@ -27,7 +25,7 @@ export declare class Synchronizer implements L2BlockStreamEventHandler {
     /** Handle events emitted by the block stream. */
     handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
     /**
-     * Syncs PXE and the node by dowloading the metadata of the latest blocks, allowing simulations to use
+     * 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.
      */
     sync(): Promise<void>;

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

@@ -1 +1 @@
-{"version":3,"file":"synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/synchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC7G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2DAA2D,CAAC;AAErG;;;;;GAKG;AACH,qBAAa,YAAa,YAAW,yBAAyB;IAO1D,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,WAAW;IAVrB,OAAO,CAAC,sBAAsB,CAA4B;IAC1D,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAA4B;IAC7C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;gBAGpC,IAAI,EAAE,SAAS,EACf,gBAAgB,EAAE,gBAAgB,EAClC,gBAAgB,EAAE,gBAAgB,EAClC,mBAAmB,EAAE,mBAAmB,EACxC,WAAW,EAAE,aAAa,EAClC,MAAM,GAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAM,EACxD,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM;IASlC,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;IAM/E,iDAAiD;IACpC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmC7E;;;OAGG;IACU,IAAI;YAiBH,MAAM;IAeP,qBAAqB;CAGnC"}
+{"version":3,"file":"synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/synchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC7G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2DAA2D,CAAC;AAErG;;;;GAIG;AACH,qBAAa,YAAa,YAAW,yBAAyB;IAM1D,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,WAAW;IATrB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAA4B;IAC7C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;gBAGpC,IAAI,EAAE,SAAS,EACf,gBAAgB,EAAE,gBAAgB,EAClC,gBAAgB,EAAE,gBAAgB,EAClC,mBAAmB,EAAE,mBAAmB,EACxC,WAAW,EAAE,aAAa,EAClC,MAAM,GAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAM,EACxD,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM;IASlC,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;IAM/E,iDAAiD;IACpC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmC7E;;;OAGG;IACU,IAAI;YAiBH,MAAM;IAeb,qBAAqB;CAG7B"}

package/dest/synchronizer/synchronizer.js

@@ -1,18 +1,15 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { L2BlockStream } from '@aztec/stdlib/block';
 /**
- * The Synchronizer class manages the synchronization with the aztec node, allowing PXE to retrieve the
- * latest block header and handle reorgs.
- * It provides methods to trigger a sync and get the block number we are syncec to
- * details, and fetch transactions by hash.
+ * 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 {
     node;
     syncDataProvider;
     noteDataProvider;
     taggingDataProvider;
     l2TipsStore;
-    initialSyncBlockNumber;
     log;
     isSyncing;
     blockStream;
@@ -22,7 +19,6 @@ import { L2BlockStream } from '@aztec/stdlib/block';
         this.noteDataProvider = noteDataProvider;
         this.taggingDataProvider = taggingDataProvider;
         this.l2TipsStore = l2TipsStore;
-        this.initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
         this.log = !loggerOrSuffix || typeof loggerOrSuffix === 'string' ? createLogger(loggerOrSuffix ? `pxe:synchronizer:${loggerOrSuffix}` : `pxe:synchronizer`) : loggerOrSuffix;
         this.blockStream = this.createBlockStream(config);
     }
@@ -47,18 +43,18 @@ import { L2BlockStream } from '@aztec/stdlib/block';
                 }
             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);
                     }
@@ -67,7 +63,7 @@ import { L2BlockStream } from '@aztec/stdlib/block';
         }
     }
     /**
-   * 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.
    */ async sync() {
         if (this.isSyncing !== undefined) {
@@ -97,7 +93,7 @@ import { L2BlockStream } from '@aztec/stdlib/block';
         }
         await this.blockStream.sync();
     }
-    async getSynchedBlockNumber() {
-        return await this.syncDataProvider.getBlockNumber() ?? this.initialSyncBlockNumber;
+    getSynchedBlockNumber() {
+        return this.syncDataProvider.getBlockNumber();
     }
 }