@waku/core 0.0.26 → 0.0.28-434be7b.0

package/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The file is maintained by [Release Please](https://github.com/googleapis/release-please) based on [Conventional Commits](https://www.conventionalcommits.org) specification,
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.27](https://github.com/waku-org/js-waku/compare/core-v0.0.26...core-v0.0.27) (2024-03-04)
+
+
+### ⚠ BREAKING CHANGES
+
+* protocols filter peers as per configured shard ([#1756](https://github.com/waku-org/js-waku/issues/1756))
+
+### Features
+
+* Create node and subscription by content topic ([ee2d417](https://github.com/waku-org/js-waku/commit/ee2d4176f8cca45a51b7dac0009f0eb01952f540))
+* Decouple sharding params out of core ([e138b4f](https://github.com/waku-org/js-waku/commit/e138b4f5c49a35a37830e31e8be87d824f53249f))
+* Lightpush & filter send requests to multiple peers ([#1779](https://github.com/waku-org/js-waku/issues/1779)) ([7affbe2](https://github.com/waku-org/js-waku/commit/7affbe222dd30ccb6619839f4bc5eb86433a80f7))
+* Local discovery ([#1811](https://github.com/waku-org/js-waku/issues/1811)) ([199f6ab](https://github.com/waku-org/js-waku/commit/199f6ab2ff83694b93e94e935e2925537e01e281))
+* Make ShardingParams optional in sdk, required internally ([68d3229](https://github.com/waku-org/js-waku/commit/68d3229644f395bd84b2e2a7067c7b51e9da3dd0))
+* Protocols filter peers as per configured shard ([#1756](https://github.com/waku-org/js-waku/issues/1756)) ([477c2a5](https://github.com/waku-org/js-waku/commit/477c2a5918f2f75cd2c14bc6ed75e1687c5a09b4))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @waku/enr bumped from ^0.0.20 to ^0.0.21
+    * @waku/interfaces bumped from 0.0.21 to 0.0.22
+    * @waku/message-hash bumped from ^0.1.10 to ^0.1.11
+    * @waku/utils bumped from 0.0.14 to 0.0.15
+
 ## [0.0.26](https://github.com/waku-org/js-waku/compare/core-v0.0.25...core-v0.0.26) (2024-01-10)
 
 

package/bundle/{base_protocol-pDODy0G6.js → base_protocol-BCwLeb-A.js}

@@ -1,39 +1,86 @@
-import { T as Tags } from './browser-mTOOnVZp.js';
-import { k as bytesToUtf8, L as Logger, s as shardInfoToPubsubTopics, D as DefaultPubsubTopic } from './index-cmONXM-V.js';
+import { b as bytesToUtf8, L as Logger, k as ensureShardingConfigured } from './index-vlQahmUj.js';
+import { T as Tags } from './browser-DoQRY-an.js';
+
+const decodeRelayShard = (bytes) => {
+    // explicitly converting to Uint8Array to avoid Buffer
+    // https://github.com/libp2p/js-libp2p/issues/2146
+    bytes = new Uint8Array(bytes);
+    if (bytes.length < 3)
+        throw new Error("Insufficient data");
+    const view = new DataView(bytes.buffer);
+    const clusterId = view.getUint16(0);
+    const shards = [];
+    if (bytes.length === 130) {
+        // rsv format (Bit Vector)
+        for (let i = 0; i < 1024; i++) {
+            const byteIndex = Math.floor(i / 8) + 2; // Adjusted for the 2-byte cluster field
+            const bitIndex = 7 - (i % 8);
+            if (view.getUint8(byteIndex) & (1 << bitIndex)) {
+                shards.push(i);
+            }
+        }
+    }
+    else {
+        // rs format (Index List)
+        const numIndices = view.getUint8(2);
+        for (let i = 0, offset = 3; i < numIndices; i++, offset += 2) {
+            if (offset + 1 >= bytes.length)
+                throw new Error("Unexpected end of data");
+            shards.push(view.getUint16(offset));
+        }
+    }
+    return { clusterId, shards };
+};
+const encodeRelayShard = (shardInfo) => {
+    const { clusterId, shards } = shardInfo;
+    const totalLength = shards.length >= 64 ? 130 : 3 + 2 * shards.length;
+    const buffer = new ArrayBuffer(totalLength);
+    const view = new DataView(buffer);
+    view.setUint16(0, clusterId);
+    if (shards.length >= 64) {
+        // rsv format (Bit Vector)
+        for (const index of shards) {
+            const byteIndex = Math.floor(index / 8) + 2; // Adjusted for the 2-byte cluster field
+            const bitIndex = 7 - (index % 8);
+            view.setUint8(byteIndex, view.getUint8(byteIndex) | (1 << bitIndex));
+        }
+    }
+    else {
+        // rs format (Index List)
+        view.setUint8(2, shards.length);
+        for (let i = 0, offset = 3; i < shards.length; i++, offset += 2) {
+            view.setUint16(offset, shards[i]);
+        }
+    }
+    return new Uint8Array(buffer);
+};
 
 /**
- * Returns a pseudo-random peer that supports the given protocol.
- * Useful for protocols such as store and light push
- */
-function selectRandomPeer(peers) {
-    if (peers.length === 0)
-        return;
-    const index = Math.round(Math.random() * (peers.length - 1));
-    return peers[index];
-}
-/**
- * Returns the peer with the lowest latency.
+ * Function to sort peers by latency from lowest to highest
  * @param peerStore - The Libp2p PeerStore
  * @param peers - The list of peers to choose from
- * @returns The peer with the lowest latency, or undefined if no peer could be reached
+ * @returns Sorted array of peers by latency
  */
-async function selectLowestLatencyPeer(peerStore, peers) {
+async function sortPeersByLatency(peerStore, peers) {
     if (peers.length === 0)
-        return;
+        return [];
     const results = await Promise.all(peers.map(async (peer) => {
-        const pingBytes = (await peerStore.get(peer.id)).metadata.get("ping");
-        if (!pingBytes)
+        try {
+            const pingBytes = (await peerStore.get(peer.id)).metadata.get("ping");
+            if (!pingBytes)
+                return { peer, ping: Infinity };
+            const ping = Number(bytesToUtf8(pingBytes));
+            return { peer, ping };
+        }
+        catch (error) {
             return { peer, ping: Infinity };
-        const ping = Number(bytesToUtf8(pingBytes)) ?? Infinity;
-        return { peer, ping };
+        }
     }));
-    const lowestLatencyResult = results.sort((a, b) => a.ping - b.ping)[0];
-    if (!lowestLatencyResult) {
-        return undefined;
-    }
-    return lowestLatencyResult.ping !== Infinity
-        ? lowestLatencyResult.peer
-        : undefined;
+    // filter out null values
+    const validResults = results.filter((result) => result !== null);
+    return validResults
+        .sort((a, b) => a.ping - b.ping)
+        .map((result) => result.peer);
 }
 /**
  * Returns the list of peers that supports the given protocol.
@@ -50,51 +97,28 @@ async function getPeersForProtocol(peerStore, protocols) {
     });
     return peers;
 }
-async function getConnectedPeersForProtocol(connections, peerStore, protocols) {
+async function getConnectedPeersForProtocolAndShard(connections, peerStore, protocols, shardInfo) {
     const openConnections = connections.filter((connection) => connection.status === "open");
     const peerPromises = openConnections.map(async (connection) => {
         const peer = await peerStore.get(connection.remotePeer);
-        const supportsProtocol = peer.protocols.some((protocol) => protocols.includes(protocol));
-        return supportsProtocol ? peer : null;
+        const supportsProtocol = protocols.some((protocol) => peer.protocols.includes(protocol));
+        if (supportsProtocol) {
+            if (shardInfo) {
+                const encodedPeerShardInfo = peer.metadata.get("shardInfo");
+                const peerShardInfo = encodedPeerShardInfo && decodeRelayShard(encodedPeerShardInfo);
+                if (peerShardInfo && shardInfo.clusterId === peerShardInfo.clusterId) {
+                    return peer;
+                }
+            }
+            else {
+                return peer;
+            }
+        }
+        return null;
     });
     const peersWithNulls = await Promise.all(peerPromises);
     return peersWithNulls.filter((peer) => peer !== null);
 }
-/**
- * Returns a peer that supports the given protocol.
- * If peerId is provided, the peer with that id is returned.
- * Otherwise, the peer with the lowest latency is returned.
- * If no peer is found from the above criteria, a random peer is returned.
- */
-async function selectPeerForProtocol(peerStore, protocols, peerId) {
-    let peer;
-    if (peerId) {
-        peer = await peerStore.get(peerId);
-        if (!peer) {
-            throw new Error(`Failed to retrieve connection details for provided peer in peer store: ${peerId.toString()}`);
-        }
-    }
-    else {
-        const peers = await getPeersForProtocol(peerStore, protocols);
-        peer = await selectLowestLatencyPeer(peerStore, peers);
-        if (!peer) {
-            peer = selectRandomPeer(peers);
-            if (!peer)
-                throw new Error(`Failed to find known peer that registers protocols: ${protocols}`);
-        }
-    }
-    let protocol;
-    for (const codec of protocols) {
-        if (peer.protocols.includes(codec)) {
-            protocol = codec;
-            // Do not break as we want to keep the last value
-        }
-    }
-    if (!protocol) {
-        throw new Error(`Peer does not register required protocols (${peer.id.toString()}): ${protocols}`);
-    }
-    return { peer, protocol };
-}
 function selectConnection(connections) {
     if (!connections.length)
         return;
@@ -115,18 +139,25 @@ function selectConnection(connections) {
 }
 
 /**
- * Retrieves a list of peers based on the specified criteria.
+ * Retrieves a list of peers based on the specified criteria:
+ * 1. If numPeers is 0, return all peers
+ * 2. Bootstrap peers are prioritized
+ * 3. Non-bootstrap peers are randomly selected to fill up to numPeers
  *
  * @param peers - The list of peers to filter from.
- * @param numPeers - The total number of peers to retrieve. If 0, all peers are returned.
+ * @param numPeers - The total number of peers to retrieve. If 0, all peers are returned, irrespective of `maxBootstrapPeers`.
  * @param maxBootstrapPeers - The maximum number of bootstrap peers to retrieve.
- * @returns A Promise that resolves to an array of peers based on the specified criteria.
+ * @returns An array of peers based on the specified criteria.
  */
-async function filterPeers(peers, numPeers, maxBootstrapPeers) {
+function filterPeersByDiscovery(peers, numPeers, maxBootstrapPeers) {
     // Collect the bootstrap peers up to the specified maximum
-    const bootstrapPeers = peers
+    let bootstrapPeers = peers
         .filter((peer) => peer.tags.has(Tags.BOOTSTRAP))
         .slice(0, maxBootstrapPeers);
+    // If numPeers is less than the number of bootstrap peers, adjust the bootstrapPeers array
+    if (numPeers > 0 && numPeers < bootstrapPeers.length) {
+        bootstrapPeers = bootstrapPeers.slice(0, numPeers);
+    }
     // Collect non-bootstrap peers
     const nonBootstrapPeers = peers.filter((peer) => !peer.tags.has(Tags.BOOTSTRAP));
     // If numPeers is 0, return all peers
@@ -205,12 +236,18 @@ class StreamManager {
 class BaseProtocol {
     multicodec;
     components;
+    log;
+    pubsubTopics;
+    options;
     addLibp2pEventListener;
     removeLibp2pEventListener;
     streamManager;
-    constructor(multicodec, components) {
+    constructor(multicodec, components, log, pubsubTopics, options) {
         this.multicodec = multicodec;
         this.components = components;
+        this.log = log;
+        this.pubsubTopics = pubsubTopics;
+        this.options = options;
         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);
@@ -226,35 +263,43 @@ class BaseProtocol {
      * the class protocol. Waku may or may not be currently connected to these
      * peers.
      */
-    async peers() {
+    async allPeers() {
         return getPeersForProtocol(this.peerStore, [this.multicodec]);
     }
-    async getPeer(peerId) {
-        const { peer } = await selectPeerForProtocol(this.peerStore, [this.multicodec], peerId);
-        return peer;
+    async connectedPeers() {
+        const peers = await this.allPeers();
+        return peers.filter((peer) => {
+            return (this.components.connectionManager.getConnections(peer.id).length > 0);
+        });
     }
     /**
-     * Retrieves a list of connected peers based on the specified criteria.
+     * Retrieves a list of connected peers that support the protocol. The list is sorted by latency.
      *
      * @param numPeers - The total number of peers to retrieve. If 0, all peers are returned.
      * @param maxBootstrapPeers - The maximum number of bootstrap peers to retrieve.
-     * @returns A Promise that resolves to an array of peers based on the specified criteria.
-     */
+  
+    * @returns A list of peers that support the protocol sorted by latency.
+    */
     async getPeers({ numPeers, maxBootstrapPeers } = {
         maxBootstrapPeers: 1,
         numPeers: 0
     }) {
-        // Retrieve all connected peers that support the protocol
-        const allPeersForProtocol = await getConnectedPeersForProtocol(this.components.connectionManager.getConnections(), this.peerStore, [this.multicodec]);
-        // Filter the peers based on the specified criteria
-        return filterPeers(allPeersForProtocol, numPeers, maxBootstrapPeers);
-    }
-    initializePubsubTopic(options) {
-        return (options?.pubsubTopics ??
-            (options?.shardInfo
-                ? shardInfoToPubsubTopics(options.shardInfo)
-                : [DefaultPubsubTopic]));
+        // Retrieve all connected peers that support the protocol & shard (if configured)
+        const connectedPeersForProtocolAndShard = await getConnectedPeersForProtocolAndShard(this.components.connectionManager.getConnections(), this.peerStore, [this.multicodec], this.options?.shardInfo
+            ? ensureShardingConfigured(this.options.shardInfo).shardInfo
+            : undefined);
+        // Filter the peers based on discovery & number of peers requested
+        const filteredPeers = filterPeersByDiscovery(connectedPeersForProtocolAndShard, numPeers, maxBootstrapPeers);
+        // Sort the peers by latency
+        const sortedFilteredPeers = await sortPeersByLatency(this.peerStore, filteredPeers);
+        if (sortedFilteredPeers.length === 0) {
+            this.log.warn("No peers found. Ensure you have a connection to the network.");
+        }
+        if (sortedFilteredPeers.length < numPeers) {
+            this.log.warn(`Only ${sortedFilteredPeers.length} peers found. Requested ${numPeers}.`);
+        }
+        return sortedFilteredPeers;
     }
 }
 
-export { BaseProtocol as B, StreamManager as S };
+export { BaseProtocol as B, StreamManager as S, decodeRelayShard as d, encodeRelayShard as e };