@waku/core 0.0.34-b6339f7.0 → 0.0.34-c43cec2.0

package/bundle/base_protocol-DxFKDXX2.js

@@ -0,0 +1,153 @@
+import { L as Logger } from './index-yLOEQnIE.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(peer) {
+        const peerId = peer.id.toString();
+        const scheduledStream = this.streamPool.get(peerId);
+        if (scheduledStream) {
+            this.streamPool.delete(peerId);
+            await scheduledStream;
+        }
+        let stream = this.getOpenStreamForCodec(peer.id);
+        if (stream) {
+            this.log.info(`Found existing stream peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
+            this.lockStream(peer.id.toString(), stream);
+            return stream;
+        }
+        stream = await this.createStream(peer);
+        this.lockStream(peer.id.toString(), stream);
+        return stream;
+    }
+    async createStream(peer, retries = 0) {
+        const connections = this.getConnections(peer.id);
+        const connection = selectOpenConnection(connections);
+        if (!connection) {
+            throw new Error(`Failed to get a connection to the peer peerId=${peer.id.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=${peer.id.toString()} multicodec=${this.multicodec}`);
+                stream = await connection.newStream(this.multicodec);
+                this.log.info(`Created stream for peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
+                break;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        if (!stream) {
+            throw new Error(`Failed to create a new stream for ${peer.id.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);
+        }
+        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(peer) {
+        return this.streamManager.getStream(peer);
+    }
+}
+
+export { BaseProtocol as B, StreamManager as S };

package/bundle/{index-BIW3qNYx.js → index-yLOEQnIE.js}

@@ -1,19 +1,3 @@
-/**
- * Returns a `Uint8Array` of the requested size. Referenced memory will
- * be initialized to 0.
- */
-function alloc(size = 0) {
-    return new Uint8Array(size);
-}
-/**
- * Where possible returns a Uint8Array of the requested size that references
- * uninitialized memory. Only use if you are certain you will immediately
- * overwrite every value in the returned `Uint8Array`.
- */
-function allocUnsafe(size = 0) {
-    return new Uint8Array(size);
-}
-
 function coerce(o) {
     if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
         return o;
@@ -24,10 +8,10 @@ function coerce(o) {
     }
     throw new Error('Unknown type, must be binary type');
 }
-function fromString$1(str) {
+function fromString(str) {
     return new TextEncoder().encode(str);
 }
-function toString$1(b) {
+function toString(b) {
     return new TextDecoder().decode(b);
 }
 
@@ -636,8 +620,8 @@ var base8$1 = /*#__PURE__*/Object.freeze({
 const identity = from({
     prefix: '\x00',
     name: 'identity',
-    encode: (buf) => toString$1(buf),
-    decode: (str) => fromString$1(str)
+    encode: (buf) => toString(buf),
+    decode: (str) => fromString(str)
 });
 
 var identityBase = /*#__PURE__*/Object.freeze({
@@ -648,69 +632,6 @@ var identityBase = /*#__PURE__*/Object.freeze({
 new TextEncoder();
 new TextDecoder();
 
-const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$1, ...base256emoji$1 };
-
-function createCodec(name, prefix, encode, decode) {
-    return {
-        name,
-        prefix,
-        encoder: {
-            name,
-            prefix,
-            encode
-        },
-        decoder: {
-            decode
-        }
-    };
-}
-const string = createCodec('utf8', 'u', (buf) => {
-    const decoder = new TextDecoder('utf8');
-    return 'u' + decoder.decode(buf);
-}, (str) => {
-    const encoder = new TextEncoder();
-    return encoder.encode(str.substring(1));
-});
-const ascii = createCodec('ascii', 'a', (buf) => {
-    let string = 'a';
-    for (let i = 0; i < buf.length; i++) {
-        string += String.fromCharCode(buf[i]);
-    }
-    return string;
-}, (str) => {
-    str = str.substring(1);
-    const buf = allocUnsafe(str.length);
-    for (let i = 0; i < str.length; i++) {
-        buf[i] = str.charCodeAt(i);
-    }
-    return buf;
-});
-const BASES = {
-    utf8: string,
-    'utf-8': string,
-    hex: bases.base16,
-    latin1: ascii,
-    ascii,
-    binary: ascii,
-    ...bases
-};
-
-/**
- * Create a `Uint8Array` from the passed string
- *
- * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
- *
- * Also `ascii` which is similar to node's 'binary' encoding.
- */
-function fromString(string, encoding = 'utf8') {
-    const base = BASES[encoding];
-    if (base == null) {
-        throw new Error(`Unsupported encoding "${encoding}"`);
-    }
-    // add multibase prefix
-    return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
-}
-
 var Protocols;
 (function (Protocols) {
     Protocols["Relay"] = "relay";
@@ -832,44 +753,6 @@ var HealthStatus;
     HealthStatus["SufficientlyHealthy"] = "SufficientlyHealthy";
 })(HealthStatus || (HealthStatus = {}));
 
-/**
- * Turns a `Uint8Array` into a string.
- *
- * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.
- *
- * Also `ascii` which is similar to node's 'binary' encoding.
- */
-function toString(array, encoding = 'utf8') {
-    const base = BASES[encoding];
-    if (base == null) {
-        throw new Error(`Unsupported encoding "${encoding}"`);
-    }
-    // strip multibase prefix
-    return base.encoder.encode(array).substring(1);
-}
-
-/**
- * Decode byte array to utf-8 string.
- */
-const bytesToUtf8 = (b) => toString(b, "utf8");
-/**
- * Encode utf-8 string to byte array.
- */
-const utf8ToBytes = (s) => fromString(s, "utf8");
-/**
- * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
- */
-function concat(byteArrays, totalLength) {
-    const len = byteArrays.reduce((acc, curr) => acc + curr.length, 0);
-    const res = new Uint8Array(len);
-    let offset = 0;
-    for (const bytes of byteArrays) {
-        res.set(bytes, offset);
-        offset += bytes.length;
-    }
-    return res;
-}
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -1626,4 +1509,4 @@ class Logger {
     }
 }
 
-export { EPeersByDiscoveryEvents as E, HealthStatus as H, Logger as L, ProtocolError as P, Tags as T, allocUnsafe as a, alloc as b, EConnectionStateEvents as c, Protocols as d, concat as e, fromString as f, bytesToUtf8 as g, utf8ToBytes as u };
+export { EPeersByDiscoveryEvents as E, HealthStatus as H, Logger as L, ProtocolError as P, Tags as T, EConnectionStateEvents as a, Protocols as b, base2$1 as c, base8$1 as d, base10$1 as e, base16$1 as f, base32$1 as g, base36$1 as h, identityBase as i, base58 as j, base64$1 as k, base256emoji$1 as l };

package/bundle/index.js

@@ -1,8 +1,8 @@
-import { v as version_0, e as encodingLength, a as encode$1, d as decode$1, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, P as PushRpc$1, c as PushResponse, S as StoreQueryRequest$1, f as StoreQueryResponse$1, g as createEncoder, p as pubsubTopicToSingleShardInfo, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, h as pubsubTopicsToShardInfo, i as WakuMetadataResponse } from './version_0-CdmZMfkQ.js';
-export { j as createDecoder } from './version_0-CdmZMfkQ.js';
-import { a as allocUnsafe, b as alloc, L as Logger, P as ProtocolError, u as utf8ToBytes, T as Tags, E as EPeersByDiscoveryEvents, c as EConnectionStateEvents, H as HealthStatus, d as Protocols } from './index-BIW3qNYx.js';
-import { B as BaseProtocol } from './base_protocol-sjpC9_Fu.js';
-export { S as StreamManager } from './base_protocol-sjpC9_Fu.js';
+import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength, c as encode$1, d as decode$1, M as MessagePush, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, P as PushRpc$1, g as PushResponse, S as StoreQueryRequest$1, h as StoreQueryResponse$1, u as utf8ToBytes, i as createEncoder, p as pubsubTopicToSingleShardInfo, j as bytesToUtf8, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, k as pubsubTopicsToShardInfo, l as WakuMetadataResponse } from './version_0-Che4t3mN.js';
+export { m as createDecoder } from './version_0-Che4t3mN.js';
+import { L as Logger, P as ProtocolError, T as Tags, E as EPeersByDiscoveryEvents, a as EConnectionStateEvents, H as HealthStatus, b as Protocols } from './index-yLOEQnIE.js';
+import { B as BaseProtocol } from './base_protocol-DxFKDXX2.js';
+export { S as StreamManager } from './base_protocol-DxFKDXX2.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -1620,7 +1620,7 @@ class FilterCore extends BaseProtocol {
     handleIncomingMessage;
     pubsubTopics;
     constructor(handleIncomingMessage, pubsubTopics, libp2p) {
-        super(FilterCodecs.SUBSCRIBE, libp2p.components, log$5, pubsubTopics);
+        super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
         this.handleIncomingMessage = handleIncomingMessage;
         this.pubsubTopics = pubsubTopics;
         libp2p
@@ -1882,7 +1882,7 @@ const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 class LightPushCore extends BaseProtocol {
     pubsubTopics;
     constructor(pubsubTopics, libp2p) {
-        super(LightPushCodec, libp2p.components, log$4, pubsubTopics);
+        super(LightPushCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
     }
     async preparePushMessage(encoder, message) {
@@ -1914,6 +1914,7 @@ class LightPushCore extends BaseProtocol {
             };
         }
     }
+    // TODO(weboko): use peer.id as parameter instead
     async send(encoder, message, peer) {
         const { query, error: preparationError } = await this.preparePushMessage(encoder, message);
         if (preparationError || !query) {
@@ -2103,7 +2104,7 @@ const StoreCodec = "/vac/waku/store-query/3.0.0";
 class StoreCore extends BaseProtocol {
     pubsubTopics;
     constructor(pubsubTopics, libp2p) {
-        super(StoreCodec, libp2p.components, log$3, pubsubTopics);
+        super(StoreCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
     }
     async *queryPerPage(queryOpts, decoders, peer) {
@@ -2179,10 +2180,14 @@ var index = /*#__PURE__*/Object.freeze({
     StoreCore: StoreCore
 });
 
-/** Noop for browser compatibility */
+/**
+ * Noop for browser compatibility
+ */
 function setMaxListeners$1() { }
 
-// create a setMaxListeners that doesn't break browser usage
+/**
+ * Create a setMaxListeners that doesn't break browser usage
+ */
 const setMaxListeners = (n, ...eventTargets) => {
     try {
         setMaxListeners$1(n, ...eventTargets);
@@ -2356,13 +2361,36 @@ class KeepAliveManager {
     }
 }
 
+/**
+ * Reads peer's metadata and retrieves ping value.
+ * @param peer Peer or null
+ * @returns -1 if no ping attached, otherwise returns ping value
+ */
+const getPeerPing = (peer) => {
+    if (!peer) {
+        return -1;
+    }
+    try {
+        const bytes = peer.metadata.get("ping");
+        if (!bytes) {
+            return -1;
+        }
+        return Number(bytesToUtf8(bytes));
+    }
+    catch (e) {
+        return -1;
+    }
+};
+
 const log$1 = new Logger("connection-manager");
 const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 1;
 const DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER = 3;
 const DEFAULT_MAX_PARALLEL_DIALS = 3;
+const DEFAULT_PING_KEEP_ALIVE_SEC = 5 * 60;
+const DEFAULT_RELAY_KEEP_ALIVE_SEC = 5 * 60;
 class ConnectionManager extends TypedEventEmitter {
-    configuredPubsubTopics;
-    static instances = new Map();
+    // TODO(weboko): make it private
+    pubsubTopics;
     keepAliveManager;
     options;
     libp2p;
@@ -2377,14 +2405,6 @@ class ConnectionManager extends TypedEventEmitter {
         }
         return this.isP2PNetworkConnected;
     }
-    static create(peerId, libp2p, keepAliveOptions, pubsubTopics, relay, options) {
-        let instance = ConnectionManager.instances.get(peerId);
-        if (!instance) {
-            instance = new ConnectionManager(libp2p, keepAliveOptions, pubsubTopics, relay, options);
-            ConnectionManager.instances.set(peerId, instance);
-        }
-        return instance;
-    }
     stop() {
         this.keepAliveManager.stopAll();
         this.libp2p.removeEventListener("peer:connect", this.onEventHandlers["peer:connect"]);
@@ -2451,21 +2471,25 @@ class ConnectionManager extends TypedEventEmitter {
             }
         };
     }
-    constructor(libp2p, keepAliveOptions, configuredPubsubTopics, relay, options) {
+    constructor(options) {
         super();
-        this.configuredPubsubTopics = configuredPubsubTopics;
-        this.libp2p = libp2p;
-        this.configuredPubsubTopics = configuredPubsubTopics;
+        this.libp2p = options.libp2p;
+        this.pubsubTopics = options.pubsubTopics;
         this.options = {
             maxDialAttemptsForPeer: DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER,
             maxBootstrapPeersAllowed: DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED,
             maxParallelDials: DEFAULT_MAX_PARALLEL_DIALS,
-            ...options
+            pingKeepAlive: DEFAULT_PING_KEEP_ALIVE_SEC,
+            relayKeepAlive: DEFAULT_RELAY_KEEP_ALIVE_SEC,
+            ...options.config
         };
         this.keepAliveManager = new KeepAliveManager({
-            relay,
-            libp2p,
-            options: keepAliveOptions
+            relay: options.relay,
+            libp2p: options.libp2p,
+            options: {
+                pingKeepAlive: this.options.pingKeepAlive,
+                relayKeepAlive: this.options.relayKeepAlive
+            }
         });
         this.startEventListeners()
             .then(() => log$1.info(`Connection Manager is now running`))
@@ -2475,6 +2499,24 @@ class ConnectionManager extends TypedEventEmitter {
         // we will dial the peers in peerStore ONCE before we start to listen to the `peer:discovery` events within the ConnectionManager
         this.dialPeerStorePeers().catch((error) => log$1.error(`Unexpected error while dialing peer store peers`, error));
     }
+    async getConnectedPeers(codec) {
+        const peerIDs = this.libp2p.getPeers();
+        if (peerIDs.length === 0) {
+            return [];
+        }
+        const peers = await Promise.all(peerIDs.map(async (id) => {
+            try {
+                return await this.libp2p.peerStore.get(id);
+            }
+            catch (e) {
+                return null;
+            }
+        }));
+        return peers
+            .filter((p) => !!p)
+            .filter((p) => (codec ? p.protocols.includes(codec) : true))
+            .sort((left, right) => getPeerPing(left) - getPeerPing(right));
+    }
     async dialPeerStorePeers() {
         const peerInfos = await this.libp2p.peerStore.all();
         const dialPromises = [];
@@ -2690,7 +2732,7 @@ class ConnectionManager extends TypedEventEmitter {
         const isSameShard = await this.isPeerTopicConfigured(peerId);
         if (!isSameShard) {
             const shardInfo = await this.getPeerShardInfo(peerId, this.libp2p.peerStore);
-            log$1.warn(`Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${this.configuredPubsubTopics}).
+            log$1.warn(`Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${this.pubsubTopics}).
             Not dialing.`);
             return false;
         }
@@ -2751,7 +2793,7 @@ class ConnectionManager extends TypedEventEmitter {
         if (!shardInfo)
             return true;
         const pubsubTopics = shardInfoToPubsubTopics(shardInfo);
-        const isTopicConfigured = pubsubTopics.some((topic) => this.configuredPubsubTopics.includes(topic));
+        const isTopicConfigured = pubsubTopics.some((topic) => this.pubsubTopics.includes(topic));
         return isTopicConfigured;
     }
     async getPeerShardInfo(peerId, peerStore) {
@@ -2875,7 +2917,7 @@ class Metadata extends BaseProtocol {
     libp2pComponents;
     handshakesConfirmed = new Map();
     constructor(pubsubTopics, libp2p) {
-        super(MetadataCodec, libp2p.components, log, pubsubTopics);
+        super(MetadataCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
         this.libp2pComponents = libp2p;
         void libp2p.registrar.handle(MetadataCodec, (streamData) => {
@@ -2979,4 +3021,4 @@ function wakuMetadata(pubsubTopics) {
     return (components) => new Metadata(pubsubTopics, components);
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, KeepAliveManager, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, getHealthManager, index$3 as message, 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, createEncoder, getHealthManager, index$3 as message, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };

package/bundle/lib/base_protocol.js

@@ -1,2 +1,2 @@
-export { B as BaseProtocol } from '../base_protocol-sjpC9_Fu.js';
-import '../index-BIW3qNYx.js';
+export { B as BaseProtocol } from '../base_protocol-DxFKDXX2.js';
+import '../index-yLOEQnIE.js';

package/bundle/lib/message/version_0.js

@@ -1,2 +1,2 @@
-export { D as DecodedMessage, k as Decoder, E as Encoder, V as Version, j as createDecoder, g as createEncoder, m as proto } from '../../version_0-CdmZMfkQ.js';
-import '../../index-BIW3qNYx.js';
+export { D as DecodedMessage, o as Decoder, E as Encoder, V as Version, m as createDecoder, i as createEncoder, n as proto } from '../../version_0-Che4t3mN.js';
+import '../../index-yLOEQnIE.js';