@aztec/pxe 0.0.1-commit.2ed92850 → 0.0.1-commit.54489865

package/src/storage/private_event_store/private_event_store.ts

@@ -131,78 +131,76 @@ export class PrivateEventStore implements StagedStore {
    * @returns - The event log contents, augmented with metadata about the transaction and block in which the event was
    * included.
    */
-  public getPrivateEvents(
+  public async getPrivateEvents(
     eventSelector: EventSelector,
     filter: PrivateEventStoreFilter,
   ): Promise<PackedPrivateEvent[]> {
-    return this.#store.transactionAsync(async () => {
-      const events: Array<{
-        l2BlockNumber: number;
-        txIndexInBlock: number;
-        eventIndexInTx: number;
-        event: PackedPrivateEvent;
-      }> = [];
-
-      const key = this.#keyFor(filter.contractAddress, eventSelector);
-      const targetScopes = new Set(filter.scopes.map(s => s.toString()));
-
-      const eventIds: string[] = await toArray(this.#eventsByContractAndEventSelector.getValuesAsync(key));
-
-      for (const eventId of eventIds) {
-        const eventBuffer = await this.#events.getAsync(eventId);
-
-        // Defensive, if it happens, there's a problem with how we're handling #eventsByContractAndEventSelector
-        if (!eventBuffer) {
-          this.logger.verbose(
-            `EventId ${eventId} does not exist in main index but it is referenced from contract event selector index`,
-          );
-          continue;
-        }
+    const events: Array<{
+      l2BlockNumber: number;
+      txIndexInBlock: number;
+      eventIndexInTx: number;
+      event: PackedPrivateEvent;
+    }> = [];
 
-        const storedPrivateEvent = StoredPrivateEvent.fromBuffer(eventBuffer);
+    const key = this.#keyFor(filter.contractAddress, eventSelector);
+    const targetScopes = new Set(filter.scopes.map(s => s.toString()));
 
-        // Filter by block range
-        if (storedPrivateEvent.l2BlockNumber < filter.fromBlock || storedPrivateEvent.l2BlockNumber >= filter.toBlock) {
-          continue;
-        }
+    const eventIds: string[] = await toArray(this.#eventsByContractAndEventSelector.getValuesAsync(key));
 
-        // Filter by scopes
-        if (storedPrivateEvent.scopes.intersection(targetScopes).size === 0) {
-          continue;
-        }
+    for (const eventId of eventIds) {
+      const eventBuffer = await this.#events.getAsync(eventId);
 
-        // Filter by txHash
-        if (filter.txHash && !storedPrivateEvent.txHash.equals(filter.txHash)) {
-          continue;
-        }
+      // Defensive, if it happens, there's a problem with how we're handling #eventsByContractAndEventSelector
+      if (!eventBuffer) {
+        this.logger.verbose(
+          `EventId ${eventId} does not exist in main index but it is referenced from contract event selector index`,
+        );
+        continue;
+      }
 
-        events.push({
-          l2BlockNumber: storedPrivateEvent.l2BlockNumber,
-          txIndexInBlock: storedPrivateEvent.txIndexInBlock,
-          eventIndexInTx: storedPrivateEvent.eventIndexInTx,
-          event: {
-            packedEvent: storedPrivateEvent.msgContent,
-            l2BlockNumber: BlockNumber(storedPrivateEvent.l2BlockNumber),
-            txHash: storedPrivateEvent.txHash,
-            l2BlockHash: storedPrivateEvent.l2BlockHash,
-            eventSelector,
-          },
-        });
+      const storedPrivateEvent = StoredPrivateEvent.fromBuffer(eventBuffer);
+
+      // Filter by block range
+      if (storedPrivateEvent.l2BlockNumber < filter.fromBlock || storedPrivateEvent.l2BlockNumber >= filter.toBlock) {
+        continue;
       }
 
-      // Sort by block number, then by tx index within block, then by event index within tx
-      events.sort((a, b) => {
-        if (a.l2BlockNumber !== b.l2BlockNumber) {
-          return a.l2BlockNumber - b.l2BlockNumber;
-        }
-        if (a.txIndexInBlock !== b.txIndexInBlock) {
-          return a.txIndexInBlock - b.txIndexInBlock;
-        }
-        return a.eventIndexInTx - b.eventIndexInTx;
+      // Filter by scopes
+      if (storedPrivateEvent.scopes.intersection(targetScopes).size === 0) {
+        continue;
+      }
+
+      // Filter by txHash
+      if (filter.txHash && !storedPrivateEvent.txHash.equals(filter.txHash)) {
+        continue;
+      }
+
+      events.push({
+        l2BlockNumber: storedPrivateEvent.l2BlockNumber,
+        txIndexInBlock: storedPrivateEvent.txIndexInBlock,
+        eventIndexInTx: storedPrivateEvent.eventIndexInTx,
+        event: {
+          packedEvent: storedPrivateEvent.msgContent,
+          l2BlockNumber: BlockNumber(storedPrivateEvent.l2BlockNumber),
+          txHash: storedPrivateEvent.txHash,
+          l2BlockHash: storedPrivateEvent.l2BlockHash,
+          eventSelector,
+        },
       });
+    }
 
-      return events.map(ev => ev.event);
+    // Sort by block number, then by tx index within block, then by event index within tx
+    events.sort((a, b) => {
+      if (a.l2BlockNumber !== b.l2BlockNumber) {
+        return a.l2BlockNumber - b.l2BlockNumber;
+      }
+      if (a.txIndexInBlock !== b.txIndexInBlock) {
+        return a.txIndexInBlock - b.txIndexInBlock;
+      }
+      return a.eventIndexInTx - b.eventIndexInTx;
     });
+
+    return events.map(ev => ev.event);
   }
 
   /**

package/src/storage/private_event_store/stored_private_event.ts

@@ -2,7 +2,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { EventSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2BlockHash } from '@aztec/stdlib/block';
+import { BlockHash } from '@aztec/stdlib/block';
 import { TxHash } from '@aztec/stdlib/tx';
 
 /** Serializable private event entry with scope tracking. */
@@ -11,7 +11,7 @@ export class StoredPrivateEvent {
     readonly randomness: Fr,
     readonly msgContent: Fr[],
     readonly l2BlockNumber: number,
-    readonly l2BlockHash: L2BlockHash,
+    readonly l2BlockHash: BlockHash,
     readonly txHash: TxHash,
     readonly txIndexInBlock: number,
     readonly eventIndexInTx: number,
@@ -49,7 +49,7 @@ export class StoredPrivateEvent {
     const msgContentLength = reader.readNumber();
     const msgContent = reader.readArray(msgContentLength, Fr);
     const l2BlockNumber = reader.readNumber();
-    const l2BlockHash = L2BlockHash.fromBuffer(reader);
+    const l2BlockHash = new BlockHash(Fr.fromBuffer(reader));
     const txHash = TxHash.fromBuffer(reader);
     const txIndexInBlock = reader.readNumber();
     const eventIndexInTx = reader.readNumber();

package/src/tagging/get_all_logs_by_tags.ts

@@ -1,5 +1,5 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
+import type { BlockHash } from '@aztec/stdlib/block';
 import { MAX_LOGS_PER_TAG } from '@aztec/stdlib/interfaces/api-limit';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
@@ -42,7 +42,7 @@ async function getAllPages<T>(numTags: number, fetchPage: (page: number) => Prom
 export function getAllPrivateLogsByTags(
   aztecNode: AztecNode,
   tags: SiloedTag[],
-  anchorBlockHash: L2BlockHash,
+  anchorBlockHash: BlockHash,
 ): Promise<TxScopedL2Log[][]> {
   return getAllPages(tags.length, page => aztecNode.getPrivateLogsByTags(tags, page, anchorBlockHash));
 }
@@ -60,7 +60,7 @@ export function getAllPublicLogsByTagsFromContract(
   aztecNode: AztecNode,
   contractAddress: AztecAddress,
   tags: Tag[],
-  anchorBlockHash: L2BlockHash,
+  anchorBlockHash: BlockHash,
 ): Promise<TxScopedL2Log[][]> {
   return getAllPages(tags.length, page =>
     aztecNode.getPublicLogsByTagsFromContract(contractAddress, tags, page, anchorBlockHash),

package/src/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.ts

@@ -1,6 +1,6 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
 
@@ -22,7 +22,7 @@ export async function loadPrivateLogsForSenderRecipientPair(
   aztecNode: AztecNode,
   taggingStore: RecipientTaggingStore,
   anchorBlockNumber: BlockNumber,
-  anchorBlockHash: L2BlockHash,
+  anchorBlockHash: BlockHash,
   jobId: string,
 ): Promise<TxScopedL2Log[]> {
   // # Explanation of how the algorithm works

package/src/tagging/recipient_sync/utils/load_logs_for_range.ts

@@ -1,6 +1,6 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { DirectionalAppTaggingSecret, PreTag, TxScopedL2Log } from '@aztec/stdlib/logs';
 import { SiloedTag, Tag } from '@aztec/stdlib/logs';
@@ -19,7 +19,7 @@ export async function loadLogsForRange(
   start: number,
   end: number,
   anchorBlockNumber: BlockNumber,
-  anchorBlockHash: L2BlockHash,
+  anchorBlockHash: BlockHash,
 ): Promise<Array<{ log: TxScopedL2Log; taggingIndex: number }>> {
   // Derive tags for the window
   const preTags: PreTag[] = Array(end - start)

package/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -1,5 +1,5 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 
@@ -27,7 +27,7 @@ export async function syncSenderTaggingIndexes(
   app: AztecAddress,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
-  anchorBlockHash: L2BlockHash,
+  anchorBlockHash: BlockHash,
   jobId: string,
 ): Promise<void> {
   // # Explanation of how syncing works

package/src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts

@@ -1,5 +1,5 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
 import { SiloedTag, Tag } from '@aztec/stdlib/logs';
@@ -29,7 +29,7 @@ export async function loadAndStoreNewTaggingIndexes(
   end: number,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
-  anchorBlockHash: L2BlockHash,
+  anchorBlockHash: BlockHash,
   jobId: string,
 ) {
   // We compute the tags for the current window of indexes
@@ -55,7 +55,7 @@ export async function loadAndStoreNewTaggingIndexes(
 async function getTxsContainingTags(
   tags: SiloedTag[],
   aztecNode: AztecNode,
-  anchorBlockHash: L2BlockHash,
+  anchorBlockHash: BlockHash,
 ): Promise<TxHash[][]> {
   // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
   // pagination here.