@waku/core 0.0.36-383e0b2.0 → 0.0.36-4c18ca2.0

package/src/lib/filter/filter.ts

@@ -3,7 +3,6 @@ import type { IncomingStreamData } from "@libp2p/interface-internal";
 import {
   type ContentTopic,
   type CoreProtocolResult,
-  type IBaseProtocolCore,
   type Libp2p,
   ProtocolError,
   type PubsubTopic
@@ -15,7 +14,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 {
   FilterPushRpc,
@@ -30,17 +29,50 @@ export const FilterCodecs = {
   PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
 
-export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
+type IncomingMessageHandler = (
+  pubsubTopic: PubsubTopic,
+  wakuMessage: WakuMessage,
+  peerIdStr: string
+) => Promise<void>;
+
+export class FilterCore {
+  private streamManager: StreamManager;
+  private static handleIncomingMessage?: IncomingMessageHandler;
+
+  public readonly multicodec = FilterCodecs.SUBSCRIBE;
+
   public constructor(
-    private handleIncomingMessage: (
-      pubsubTopic: PubsubTopic,
-      wakuMessage: WakuMessage,
-      peerIdStr: string
-    ) => Promise<void>,
+    handleIncomingMessage: IncomingMessageHandler,
     public readonly pubsubTopics: PubsubTopic[],
     libp2p: Libp2p
   ) {
-    super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
+    this.streamManager = new StreamManager(
+      FilterCodecs.SUBSCRIBE,
+      libp2p.components
+    );
+
+    // TODO(weboko): remove when @waku/sdk 0.0.33 is released
+    const prevHandler = FilterCore.handleIncomingMessage;
+    FilterCore.handleIncomingMessage = !prevHandler
+      ? handleIncomingMessage
+      : async (pubsubTopic, message, peerIdStr): Promise<void> => {
+          try {
+            await prevHandler(pubsubTopic, message, peerIdStr);
+          } catch (e) {
+            log.error(
+              "Previous FilterCore incoming message handler failed ",
+              e
+            );
+          }
+
+          try {
+            await handleIncomingMessage(pubsubTopic, message, peerIdStr);
+          } catch (e) {
+            log.error("Present FilterCore incoming message handler failed ", e);
+          }
+
+          return;
+        };
 
     libp2p
       .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
@@ -56,7 +88,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     peerId: PeerId,
     contentTopics: ContentTopic[]
   ): Promise<CoreProtocolResult> {
-    const stream = await this.getStream(peerId);
+    const stream = await this.streamManager.getStream(peerId);
 
     const request = FilterSubscribeRpc.createSubscribeRequest(
       pubsubTopic,
@@ -112,7 +144,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
   ): Promise<CoreProtocolResult> {
     let stream: Stream | undefined;
     try {
-      stream = await this.getStream(peerId);
+      stream = await this.streamManager.getStream(peerId);
     } catch (error) {
       log.error(
         `Failed to get a stream for remote peer${peerId.toString()}`,
@@ -155,7 +187,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     pubsubTopic: PubsubTopic,
     peerId: PeerId
   ): Promise<CoreProtocolResult> {
-    const stream = await this.getStream(peerId);
+    const stream = await this.streamManager.getStream(peerId);
 
     const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
 
@@ -202,7 +234,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
   public async ping(peerId: PeerId): Promise<CoreProtocolResult> {
     let stream: Stream | undefined;
     try {
-      stream = await this.getStream(peerId);
+      stream = await this.streamManager.getStream(peerId);
     } catch (error) {
       log.error(
         `Failed to get a stream for remote peer${peerId.toString()}`,
@@ -291,7 +323,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
             return;
           }
 
-          await this.handleIncomingMessage(
+          await FilterCore.handleIncomingMessage?.(
             pubsubTopic,
             wakuMessage,
             connection.remotePeer.toString()

package/src/lib/light_push/light_push.ts

@@ -1,7 +1,6 @@
 import type { PeerId, Stream } from "@libp2p/interface";
 import {
   type CoreProtocolResult,
-  type IBaseProtocolCore,
   type IEncoder,
   type IMessage,
   type Libp2p,
@@ -17,7 +16,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 { PushRpc } from "./push_rpc.js";
 import { isRLNResponseError } from "./utils.js";
@@ -32,12 +31,16 @@ type PreparePushMessageResult = ThisOrThat<"query", PushRpc>;
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
-export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
+export class LightPushCore {
+  private readonly streamManager: StreamManager;
+
+  public readonly multicodec = LightPushCodec;
+
   public constructor(
     public readonly pubsubTopics: PubsubTopic[],
     libp2p: Libp2p
   ) {
-    super(LightPushCodec, libp2p.components, pubsubTopics);
+    this.streamManager = new StreamManager(LightPushCodec, libp2p.components);
   }
 
   private async preparePushMessage(
@@ -98,7 +101,7 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
 
     let stream: Stream;
     try {
-      stream = await this.getStream(peerId);
+      stream = await this.streamManager.getStream(peerId);
     } catch (error) {
       log.error("Failed to get stream", error);
       return {

package/src/lib/message/version_0.ts

@@ -22,7 +22,7 @@ export { proto };
 export class DecodedMessage implements IDecodedMessage {
   public constructor(
     public pubsubTopic: string,
-    protected proto: proto.WakuMessage
+    private proto: proto.WakuMessage
   ) {}
 
   public get ephemeral(): boolean {
@@ -37,10 +37,6 @@ export class DecodedMessage implements IDecodedMessage {
     return this.proto.contentTopic;
   }
 
-  public get _rawTimestamp(): bigint | undefined {
-    return this.proto.timestamp;
-  }
-
   public get timestamp(): Date | undefined {
     // In the case we receive a value that is bigger than JS's max number,
     // we catch the error and return undefined.
@@ -63,7 +59,7 @@ export class DecodedMessage implements IDecodedMessage {
   public get version(): number {
     // https://rfc.vac.dev/spec/14/
     // > If omitted, the value SHOULD be interpreted as version 0.
-    return this.proto.version ?? 0;
+    return this.proto.version ?? Version;
   }
 
   public get rateLimitProof(): IRateLimitProof | undefined {
@@ -160,7 +156,7 @@ export class Decoder implements IDecoder<IDecodedMessage> {
   public async fromProtoObj(
     pubsubTopic: string,
     proto: IProtoMessage
-  ): Promise<DecodedMessage | undefined> {
+  ): Promise<IDecodedMessage | undefined> {
     // https://rfc.vac.dev/spec/14/
     // > If omitted, the value SHOULD be interpreted as version 0.
     if (proto.version ?? 0 !== Version) {

package/src/lib/message_hash/index.ts

@@ -0,0 +1 @@
+export { messageHash, messageHashStr } from "./message_hash.js";

package/src/lib/message_hash/message_hash.ts

@@ -0,0 +1,106 @@
+import { sha256 } from "@noble/hashes/sha256";
+import type { IDecodedMessage, IProtoMessage } from "@waku/interfaces";
+import { isDefined } from "@waku/utils";
+import {
+  bytesToHex,
+  concat,
+  numberToBytes,
+  utf8ToBytes
+} from "@waku/utils/bytes";
+
+/**
+ * Deterministic Message Hashing as defined in
+ * [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/#deterministic-message-hashing)
+ *
+ * Computes a SHA-256 hash of the concatenation of pubsub topic, payload, content topic, meta, and timestamp.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A Uint8Array containing the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHash } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hash = messageHash(pubsubTopic, message);
+ * ```
+ */
+export function messageHash(
+  pubsubTopic: string,
+  message: IProtoMessage | IDecodedMessage
+): Uint8Array {
+  const pubsubTopicBytes = utf8ToBytes(pubsubTopic);
+  const contentTopicBytes = utf8ToBytes(message.contentTopic);
+  const timestampBytes = tryConvertTimestampToBytes(message.timestamp);
+
+  const bytes = concat(
+    [
+      pubsubTopicBytes,
+      message.payload,
+      contentTopicBytes,
+      message.meta,
+      timestampBytes
+    ].filter(isDefined)
+  );
+
+  return sha256(bytes);
+}
+
+function tryConvertTimestampToBytes(
+  timestamp: Date | number | bigint | undefined
+): undefined | Uint8Array {
+  if (!timestamp) {
+    return;
+  }
+
+  let bigIntTimestamp: bigint;
+
+  if (typeof timestamp === "bigint") {
+    bigIntTimestamp = timestamp;
+  } else {
+    bigIntTimestamp = BigInt(timestamp.valueOf()) * 1000000n;
+  }
+
+  return numberToBytes(bigIntTimestamp);
+}
+
+/**
+ * Computes a deterministic message hash and returns it as a hexadecimal string.
+ * This is a convenience wrapper around messageHash that converts the result to a hex string.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A string containing the hex representation of the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHashStr } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hashString = messageHashStr(pubsubTopic, message);
+ * console.log(hashString); // e.g. "a1b2c3d4..."
+ * ```
+ */
+export function messageHashStr(
+  pubsubTopic: string,
+  message: IProtoMessage | IDecodedMessage
+): string {
+  const hash = messageHash(pubsubTopic, message);
+  const hashStr = bytesToHex(hash);
+  return hashStr;
+}

package/src/lib/metadata/metadata.ts

@@ -16,21 +16,24 @@ 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";
 
 const log = new Logger("metadata");
 
 export const MetadataCodec = "/vac/waku/metadata/1.0.0";
 
-class Metadata extends BaseProtocol implements IMetadata {
-  private libp2pComponents: Libp2pComponents;
+class Metadata implements IMetadata {
+  private readonly streamManager: StreamManager;
+  private readonly libp2pComponents: Libp2pComponents;
   protected handshakesConfirmed: Map<PeerIdStr, ShardInfo> = new Map();
 
+  public readonly multicodec = MetadataCodec;
+
   public constructor(
     public pubsubTopics: PubsubTopic[],
     libp2p: Libp2pComponents
   ) {
-    super(MetadataCodec, libp2p.components, pubsubTopics);
+    this.streamManager = new StreamManager(MetadataCodec, libp2p);
     this.libp2pComponents = libp2p;
     void libp2p.registrar.handle(MetadataCodec, (streamData) => {
       void this.onRequest(streamData);
@@ -55,7 +58,7 @@ class Metadata extends BaseProtocol implements IMetadata {
 
     let stream;
     try {
-      stream = await this.getStream(peerId);
+      stream = await this.streamManager.getStream(peerId);
     } catch (error) {
       log.error("Failed to get stream", error);
       return {

package/src/lib/store/rpc.ts

@@ -28,22 +28,18 @@ export class StoreQueryRequest {
         : undefined
     });
 
-    // Validate request parameters based on RFC
     const isHashQuery = params.messageHashes && params.messageHashes.length > 0;
     const hasContentTopics =
       params.contentTopics && params.contentTopics.length > 0;
     const hasTimeFilter = params.timeStart || params.timeEnd;
 
     if (isHashQuery) {
-      // Message hash lookup queries cannot include content topics or time filters
-      // but pubsubTopic is allowed/required
       if (hasContentTopics || hasTimeFilter) {
         throw new Error(
           "Message hash lookup queries cannot include content filter criteria (contentTopics, timeStart, or timeEnd)"
         );
       }
     } else {
-      // Content-filtered queries require both pubsubTopic and contentTopics to be set together
       if (
         (params.pubsubTopic &&
           (!params.contentTopics || params.contentTopics.length === 0)) ||

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>(
@@ -70,7 +73,7 @@ export class StoreCore extends BaseProtocol implements IStoreCore {
 
       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 };