@waku/core 0.0.36-27c1236.0 → 0.0.36-34d4730.0

package/bundle/index.js

@@ -1,8 +1,5 @@
-import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength$1, c as encode$2, d as decode$4, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, M as MessagePush, P as PushRpc$1, g as PushResponse, S as StoreQueryRequest$1, h as StoreQueryResponse$1, t as toString$1, i as bases, j as fromString, u as utf8ToBytes, k as createEncoder, p as pubsubTopicToSingleShardInfo, l as bytesToUtf8, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, m as pubsubTopicsToShardInfo, n as WakuMetadataResponse, o as concat$1, q as sha256, r as bytesToHex, w as numberToBytes } from './version_0-CyeTW0Vr.js';
-export { x as createDecoder } from './version_0-CyeTW0Vr.js';
-import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, L as Logger, P as ProtocolError, T as Tags, E as EPeersByDiscoveryEvents, f as EConnectionStateEvents } from './index-CTo1my9M.js';
-import { B as BaseProtocol } from './base_protocol-DvQrudwy.js';
-export { S as StreamManager } from './base_protocol-DvQrudwy.js';
+import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, v as version_0, f as allocUnsafe, g as alloc, h as encodingLength$1, i as encode$2, j as decode$4, L as Logger, F as FilterSubscribeRequest, k as FilterSubscribeResponse$1, M as MessagePush, P as ProtocolError, l as PushRpc$1, m as PushResponse, S as StoreQueryRequest$1, n as StoreQueryResponse$1, t as toString$1, o as bases, p as fromString, u as utf8ToBytes, q as createEncoder, r as pubsubTopicToSingleShardInfo, s as bytesToUtf8, T as Tags, E as EPeersByDiscoveryEvents, w as shardInfoToPubsubTopics, x as EConnectionStateEvents, W as WakuMetadataRequest, y as pubsubTopicsToShardInfo, z as WakuMetadataResponse, A as concat$1, B as sha256, C as bytesToHex, D as numberToBytes } from './version_0-BhBcavwU.js';
+export { G as createDecoder } from './version_0-BhBcavwU.js';
 
 /* eslint-disable */
 var encode_1 = encode$1;
@@ -2136,6 +2133,129 @@ const duplexPipelineFn = (duplex) => {
     };
 };
 
+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;
+    libp2p;
+    log;
+    ongoingCreation = new Set();
+    streamPool = new Map();
+    constructor(multicodec, libp2p) {
+        this.multicodec = multicodec;
+        this.libp2p = libp2p;
+        this.log = new Logger(`stream-manager:${multicodec}`);
+        this.libp2p.events.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.libp2p.connectionManager.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.libp2p.connectionManager.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];
+    }
+}
+
 // Unique ID creation requires a high quality random # generator. In the browser we therefore
 // require the crypto API and do not support built-in fallback to lower quality random number
 // generators (like Math.random()).
@@ -2303,12 +2423,14 @@ const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
-class FilterCore extends BaseProtocol {
+class FilterCore {
     pubsubTopics;
+    streamManager;
     static handleIncomingMessage;
+    multicodec = FilterCodecs.SUBSCRIBE;
     constructor(handleIncomingMessage, pubsubTopics, libp2p) {
-        super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
         this.pubsubTopics = 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
@@ -2337,7 +2459,7 @@ class FilterCore extends BaseProtocol {
         });
     }
     async subscribe(pubsubTopic, peerId, contentTopics) {
-        const stream = await this.getStream(peerId);
+        const stream = await this.streamManager.getStream(peerId);
         const request = FilterSubscribeRpc.createSubscribeRequest(pubsubTopic, contentTopics);
         let res;
         try {
@@ -2372,7 +2494,7 @@ class FilterCore extends BaseProtocol {
     async unsubscribe(pubsubTopic, peerId, contentTopics) {
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
             log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
@@ -2404,7 +2526,7 @@ class FilterCore extends BaseProtocol {
         };
     }
     async unsubscribeAll(pubsubTopic, peerId) {
-        const stream = await this.getStream(peerId);
+        const stream = await this.streamManager.getStream(peerId);
         const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
         const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         if (!res || !res.length) {
@@ -2435,7 +2557,7 @@ class FilterCore extends BaseProtocol {
     async ping(peerId) {
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
             log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
@@ -2577,11 +2699,13 @@ const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
-class LightPushCore extends BaseProtocol {
+class LightPushCore {
     pubsubTopics;
+    streamManager;
+    multicodec = LightPushCodec;
     constructor(pubsubTopics, libp2p) {
-        super(LightPushCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
+        this.streamManager = new StreamManager(LightPushCodec, libp2p.components);
     }
     async preparePushMessage(encoder, message) {
         try {
@@ -2625,7 +2749,7 @@ class LightPushCore extends BaseProtocol {
         }
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
             log$4.error("Failed to get stream", error);
@@ -2804,11 +2928,13 @@ class StoreQueryResponse {
 
 const log$3 = new Logger("store");
 const StoreCodec = "/vac/waku/store-query/3.0.0";
-class StoreCore extends BaseProtocol {
+class StoreCore {
     pubsubTopics;
+    streamManager;
+    multicodec = StoreCodec;
     constructor(pubsubTopics, libp2p) {
-        super(StoreCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
+        this.streamManager = new StreamManager(StoreCodec, libp2p.components);
     }
     async *queryPerPage(queryOpts, decoders, peerId) {
         // Only validate decoder content topics for content-filtered queries
@@ -2833,7 +2959,7 @@ class StoreCore extends BaseProtocol {
             });
             let stream;
             try {
-                stream = await this.getStream(peerId);
+                stream = await this.streamManager.getStream(peerId);
             }
             catch (e) {
                 log$3.error("Failed to get stream", e);
@@ -4783,13 +4909,15 @@ class ConnectionManager extends TypedEventEmitter {
 
 const log = new Logger("metadata");
 const MetadataCodec = "/vac/waku/metadata/1.0.0";
-class Metadata extends BaseProtocol {
+class Metadata {
     pubsubTopics;
+    streamManager;
     libp2pComponents;
     handshakesConfirmed = new Map();
+    multicodec = MetadataCodec;
     constructor(pubsubTopics, libp2p) {
-        super(MetadataCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
+        this.streamManager = new StreamManager(MetadataCodec, libp2p);
         this.libp2pComponents = libp2p;
         void libp2p.registrar.handle(MetadataCodec, (streamData) => {
             void this.onRequest(streamData);
@@ -4809,7 +4937,7 @@ class Metadata extends BaseProtocol {
         }
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
             log.error("Failed to get stream", error);
@@ -4973,4 +5101,4 @@ function messageHashStr(pubsubTopic, message) {
     return hashStr;
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, index$3 as message, messageHash, messageHashStr, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, StreamManager, createEncoder, index$3 as message, messageHash, messageHashStr, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };

package/bundle/lib/message/version_0.js

@@ -1,2 +1 @@
-export { D as DecodedMessage, z as Decoder, E as Encoder, V as Version, x as createDecoder, k as createEncoder, y as proto } from '../../version_0-CyeTW0Vr.js';
-import '../../index-CTo1my9M.js';
+export { I as DecodedMessage, K as Decoder, J as Encoder, V as Version, G as createDecoder, q as createEncoder, H as proto } from '../../version_0-BhBcavwU.js';