@waku/core 0.0.36-f911bf8.0 → 0.0.36

package/src/lib/store/rpc.ts

@@ -14,6 +14,7 @@ export class StoreQueryRequest {
   public static create(params: QueryRequestParams): StoreQueryRequest {
     const request = new StoreQueryRequest({
       ...params,
+      contentTopics: params.contentTopics || [],
       requestId: uuid(),
       timeStart: params.timeStart
         ? BigInt(params.timeStart.getTime() * ONE_MILLION)
@@ -27,26 +28,29 @@ export class StoreQueryRequest {
         : undefined
     });
 
-    // Validate request parameters based on RFC
-    if (
-      (params.pubsubTopic && !params.contentTopics) ||
-      (!params.pubsubTopic && params.contentTopics)
-    ) {
-      throw new Error(
-        "Both pubsubTopic and contentTopics must be set or unset"
-      );
-    }
+    const isHashQuery = params.messageHashes && params.messageHashes.length > 0;
+    const hasContentTopics =
+      params.contentTopics && params.contentTopics.length > 0;
+    const hasTimeFilter = params.timeStart || params.timeEnd;
 
-    if (
-      params.messageHashes &&
-      (params.pubsubTopic ||
-        params.contentTopics ||
-        params.timeStart ||
-        params.timeEnd)
-    ) {
-      throw new Error(
-        "Message hash lookup queries cannot include content filter criteria"
-      );
+    if (isHashQuery) {
+      if (hasContentTopics || hasTimeFilter) {
+        throw new Error(
+          "Message hash lookup queries cannot include content filter criteria (contentTopics, timeStart, or timeEnd)"
+        );
+      }
+    } else {
+      if (
+        (params.pubsubTopic &&
+          (!params.contentTopics || params.contentTopics.length === 0)) ||
+        (!params.pubsubTopic &&
+          params.contentTopics &&
+          params.contentTopics.length > 0)
+      ) {
+        throw new Error(
+          "Both pubsubTopic and contentTopics must be set together for content-filtered queries"
+        );
+      }
     }
 
     return request;

package/src/lib/store/store.ts

@@ -2,7 +2,6 @@ import type { PeerId } from "@libp2p/interface";
 import {
   IDecodedMessage,
   IDecoder,
-  IStoreCore,
   Libp2p,
   PubsubTopic,
   QueryRequestParams
@@ -13,7 +12,7 @@ import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
 import { Uint8ArrayList } from "uint8arraylist";
 
-import { BaseProtocol } from "../base_protocol.js";
+import { StreamManager } from "../stream_manager/index.js";
 import { toProtoMessage } from "../to_proto_message.js";
 
 import {
@@ -27,12 +26,16 @@ const log = new Logger("store");
 
 export const StoreCodec = "/vac/waku/store-query/3.0.0";
 
-export class StoreCore extends BaseProtocol implements IStoreCore {
+export class StoreCore {
+  private readonly streamManager: StreamManager;
+
+  public readonly multicodec = StoreCodec;
+
   public constructor(
     public readonly pubsubTopics: PubsubTopic[],
     libp2p: Libp2p
   ) {
-    super(StoreCodec, libp2p.components, pubsubTopics);
+    this.streamManager = new StreamManager(StoreCodec, libp2p.components);
   }
 
   public async *queryPerPage<T extends IDecodedMessage>(
@@ -40,9 +43,14 @@ export class StoreCore extends BaseProtocol implements IStoreCore {
     decoders: Map<string, IDecoder<T>>,
     peerId: PeerId
   ): AsyncGenerator<Promise<T | undefined>[]> {
+    // Only validate decoder content topics for content-filtered queries
+    const isHashQuery =
+      queryOpts.messageHashes && queryOpts.messageHashes.length > 0;
     if (
+      !isHashQuery &&
+      queryOpts.contentTopics &&
       queryOpts.contentTopics.toString() !==
-      Array.from(decoders.keys()).toString()
+        Array.from(decoders.keys()).toString()
     ) {
       throw new Error(
         "Internal error, the decoders should match the query's content topics"
@@ -56,9 +64,16 @@ export class StoreCore extends BaseProtocol implements IStoreCore {
         paginationCursor: currentCursor
       });
 
+      log.info("Sending store query request:", {
+        hasMessageHashes: !!queryOpts.messageHashes?.length,
+        messageHashCount: queryOpts.messageHashes?.length,
+        pubsubTopic: queryOpts.pubsubTopic,
+        contentTopics: queryOpts.contentTopics
+      });
+
       let stream;
       try {
-        stream = await this.getStream(peerId);
+        stream = await this.streamManager.getStream(peerId);
       } catch (e) {
         log.error("Failed to get stream", e);
         break;

package/src/lib/stream_manager/stream_manager.ts

@@ -1,5 +1,5 @@
 import type { Peer, PeerId, PeerUpdate, Stream } from "@libp2p/interface";
-import type { Libp2p } from "@waku/interfaces";
+import type { Libp2pComponents } from "@waku/interfaces";
 import { Logger } from "@waku/utils";
 
 import { selectOpenConnection } from "./utils.js";
@@ -14,11 +14,13 @@ export class StreamManager {
 
   public constructor(
     private multicodec: string,
-    private getConnections: Libp2p["getConnections"],
-    private addEventListener: Libp2p["addEventListener"]
+    private readonly libp2p: Libp2pComponents
   ) {
     this.log = new Logger(`stream-manager:${multicodec}`);
-    this.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
+    this.libp2p.events.addEventListener(
+      "peer:update",
+      this.handlePeerUpdateStreamPool
+    );
   }
 
   public async getStream(peerId: PeerId): Promise<Stream> {
@@ -47,7 +49,7 @@ export class StreamManager {
   }
 
   private async createStream(peerId: PeerId, retries = 0): Promise<Stream> {
-    const connections = this.getConnections(peerId);
+    const connections = this.libp2p.connectionManager.getConnections(peerId);
     const connection = selectOpenConnection(connections);
 
     if (!connection) {
@@ -135,7 +137,7 @@ export class StreamManager {
   }
 
   private getOpenStreamForCodec(peerId: PeerId): Stream | undefined {
-    const connections = this.getConnections(peerId);
+    const connections = this.libp2p.connectionManager.getConnections(peerId);
     const connection = selectOpenConnection(connections);
 
     if (!connection) {

package/bundle/base_protocol-DvQrudwy.js

@@ -1,152 +0,0 @@
-import { L as Logger } from './index-CTo1my9M.js';
-
-function selectOpenConnection(connections) {
-    return connections
-        .filter((c) => c.status === "open")
-        .sort((left, right) => right.timeline.open - left.timeline.open)
-        .at(0);
-}
-
-const STREAM_LOCK_KEY = "consumed";
-class StreamManager {
-    multicodec;
-    getConnections;
-    addEventListener;
-    log;
-    ongoingCreation = new Set();
-    streamPool = new Map();
-    constructor(multicodec, getConnections, addEventListener) {
-        this.multicodec = multicodec;
-        this.getConnections = getConnections;
-        this.addEventListener = addEventListener;
-        this.log = new Logger(`stream-manager:${multicodec}`);
-        this.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
-    }
-    async getStream(peerId) {
-        const peerIdStr = peerId.toString();
-        const scheduledStream = this.streamPool.get(peerIdStr);
-        if (scheduledStream) {
-            this.streamPool.delete(peerIdStr);
-            await scheduledStream;
-        }
-        let stream = this.getOpenStreamForCodec(peerId);
-        if (stream) {
-            this.log.info(`Found existing stream peerId=${peerIdStr} multicodec=${this.multicodec}`);
-            this.lockStream(peerIdStr, stream);
-            return stream;
-        }
-        stream = await this.createStream(peerId);
-        this.lockStream(peerIdStr, stream);
-        return stream;
-    }
-    async createStream(peerId, retries = 0) {
-        const connections = this.getConnections(peerId);
-        const connection = selectOpenConnection(connections);
-        if (!connection) {
-            throw new Error(`Failed to get a connection to the peer peerId=${peerId.toString()} multicodec=${this.multicodec}`);
-        }
-        let lastError;
-        let stream;
-        for (let i = 0; i < retries + 1; i++) {
-            try {
-                this.log.info(`Attempting to create a stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
-                stream = await connection.newStream(this.multicodec);
-                this.log.info(`Created stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
-                break;
-            }
-            catch (error) {
-                lastError = error;
-            }
-        }
-        if (!stream) {
-            throw new Error(`Failed to create a new stream for ${peerId.toString()} -- ` + lastError);
-        }
-        return stream;
-    }
-    async createStreamWithLock(peer) {
-        const peerId = peer.id.toString();
-        if (this.ongoingCreation.has(peerId)) {
-            this.log.info(`Skipping creation of a stream due to lock for peerId=${peerId} multicodec=${this.multicodec}`);
-            return;
-        }
-        try {
-            this.ongoingCreation.add(peerId);
-            await this.createStream(peer.id);
-        }
-        catch (error) {
-            this.log.error(`Failed to createStreamWithLock:`, error);
-        }
-        finally {
-            this.ongoingCreation.delete(peerId);
-        }
-        return;
-    }
-    handlePeerUpdateStreamPool = (evt) => {
-        const { peer } = evt.detail;
-        if (!peer.protocols.includes(this.multicodec)) {
-            return;
-        }
-        const stream = this.getOpenStreamForCodec(peer.id);
-        if (stream) {
-            return;
-        }
-        this.scheduleNewStream(peer);
-    };
-    scheduleNewStream(peer) {
-        this.log.info(`Scheduling creation of a stream for peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
-        // abandon previous attempt
-        if (this.streamPool.has(peer.id.toString())) {
-            this.streamPool.delete(peer.id.toString());
-        }
-        this.streamPool.set(peer.id.toString(), this.createStreamWithLock(peer));
-    }
-    getOpenStreamForCodec(peerId) {
-        const connections = this.getConnections(peerId);
-        const connection = selectOpenConnection(connections);
-        if (!connection) {
-            return;
-        }
-        const stream = connection.streams.find((s) => s.protocol === this.multicodec);
-        if (!stream) {
-            return;
-        }
-        const isStreamUnusable = ["done", "closed", "closing"].includes(stream.writeStatus || "");
-        if (isStreamUnusable || this.isStreamLocked(stream)) {
-            return;
-        }
-        return stream;
-    }
-    lockStream(peerId, stream) {
-        this.log.info(`Locking stream for peerId:${peerId}\tstreamId:${stream.id}`);
-        stream.metadata[STREAM_LOCK_KEY] = true;
-    }
-    isStreamLocked(stream) {
-        return !!stream.metadata[STREAM_LOCK_KEY];
-    }
-}
-
-/**
- * A class with predefined helpers, to be used as a base to implement Waku
- * Protocols.
- */
-class BaseProtocol {
-    multicodec;
-    components;
-    pubsubTopics;
-    addLibp2pEventListener;
-    removeLibp2pEventListener;
-    streamManager;
-    constructor(multicodec, components, pubsubTopics) {
-        this.multicodec = multicodec;
-        this.components = components;
-        this.pubsubTopics = pubsubTopics;
-        this.addLibp2pEventListener = components.events.addEventListener.bind(components.events);
-        this.removeLibp2pEventListener = components.events.removeEventListener.bind(components.events);
-        this.streamManager = new StreamManager(multicodec, components.connectionManager.getConnections.bind(components.connectionManager), this.addLibp2pEventListener);
-    }
-    async getStream(peerId) {
-        return this.streamManager.getStream(peerId);
-    }
-}
-
-export { BaseProtocol as B, StreamManager as S };