@waku/core 0.0.1

package/bundle/lib/peer_discovery_static_list.js

@@ -0,0 +1,75 @@
+import { m as multiaddrsToPeerInfo, s as symbol } from '../multiaddr_to_peer_info-fd1de516.js';
+import { E as EventEmitter, C as CustomEvent } from '../events-fcbda4dc.js';
+import { m as multiaddr } from '../index-0a4bdddc.js';
+import { d as debug } from '../browser-1e1a2f27.js';
+import { g as getPseudoRandomSubset } from '../random_subset-75d1c511.js';
+import '../index-2ae915be.js';
+import '../index-64ce43f0.js';
+
+const log = debug("waku:peer-discovery-static-list");
+/**
+ * Pass a list of multiaddr that will be used to bootstrap a node.
+ */
+class PeerDiscoveryStaticPeers extends EventEmitter {
+    /**
+     * @param peers Multiaddrs of peers to connect to.
+     * @param opts
+     */
+    constructor(peers, opts) {
+        super();
+        this.interval = opts?.interval ?? PeerDiscoveryStaticPeers.DefaultInterval;
+        const maxPeers = opts?.maxPeers ?? peers?.length;
+        const peerMas = peers.map((peer) => {
+            if (typeof peer === "string") {
+                return multiaddr(peer);
+            }
+            else {
+                return peer;
+            }
+        });
+        this.peers = multiaddrsToPeerInfo(getPseudoRandomSubset(peerMas, maxPeers));
+        log("Use provided list of peers (reduced to maxPeers)", this.peers.map((ma) => ma.toString()));
+    }
+    /**
+     * Start emitting static peers.
+     */
+    start() {
+        this._startTimer();
+    }
+    _startTimer() {
+        if (this.peers) {
+            log("Starting to emit static peers.");
+            if (this.timer != null) {
+                return;
+            }
+            this.timer = setInterval(() => this._returnPeers(), this.interval);
+            this._returnPeers();
+        }
+    }
+    _returnPeers() {
+        if (this.timer == null) {
+            return;
+        }
+        this.peers.forEach((peerData) => {
+            this.dispatchEvent(new CustomEvent("peer", { detail: peerData }));
+        });
+    }
+    /**
+     * Stop emitting peers.
+     */
+    stop() {
+        if (this.timer != null) {
+            clearInterval(this.timer);
+        }
+        this.timer = undefined;
+    }
+    get [symbol]() {
+        return true;
+    }
+    get [Symbol.toStringTag]() {
+        return "@waku/peer-discovery-static-list";
+    }
+}
+PeerDiscoveryStaticPeers.DefaultInterval = 200;
+
+export { PeerDiscoveryStaticPeers };

package/bundle/lib/predefined_bootstrap_nodes.js

@@ -0,0 +1,59 @@
+import { m as multiaddr } from '../index-0a4bdddc.js';
+import { g as getPseudoRandomSubset } from '../random_subset-75d1c511.js';
+import '../index-64ce43f0.js';
+
+const DefaultWantedNumber = 1;
+var Fleet;
+(function (Fleet) {
+    Fleet["Prod"] = "prod";
+    Fleet["Test"] = "test";
+})(Fleet || (Fleet = {}));
+/**
+ * Return list of pre-defined (hardcoded) bootstrap nodes.
+ *
+ * Default behavior is to return nodes of the nwaku Status Prod fleet.
+ *
+ * @param fleet The fleet to be returned. Defaults to production fleet.
+ * @param wantedNumber The number of connections desired. Defaults to {@link DefaultWantedNumber}.
+ *
+ * @returns An array of multiaddresses.
+ */
+function getPredefinedBootstrapNodes(fleet = Fleet.Prod, wantedNumber = DefaultWantedNumber) {
+    if (wantedNumber <= 0) {
+        return [];
+    }
+    let nodes;
+    switch (fleet) {
+        case Fleet.Prod:
+            nodes = fleets.fleets["wakuv2.prod"]["waku-websocket"];
+            break;
+        case Fleet.Test:
+            nodes = fleets.fleets["wakuv2.test"]["waku-websocket"];
+            break;
+        default:
+            nodes = fleets.fleets["wakuv2.prod"]["waku-websocket"];
+    }
+    nodes = Object.values(nodes);
+    nodes = nodes.map((node) => multiaddr(node));
+    return getPseudoRandomSubset(nodes, wantedNumber);
+}
+const fleets = {
+    fleets: {
+        "wakuv2.prod": {
+            "waku-websocket": {
+                "node-01.ac-cn-hongkong-c.wakuv2.prod": "/dns4/node-01.ac-cn-hongkong-c.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAm4v86W3bmT1BiH6oSPzcsSr24iDQpSN5Qa992BCjjwgrD",
+                "node-01.do-ams3.wakuv2.prod": "/dns4/node-01.do-ams3.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAmL5okWopX7NqZWBUKVqW8iUxCEmd5GMHLVPwCgzYzQv3e",
+                "node-01.gc-us-central1-a.wakuv2.prod": "/dns4/node-01.gc-us-central1-a.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAmVkKntsECaYfefR1V2yCR79CegLATuTPE6B9TxgxBiiiA",
+            },
+        },
+        "wakuv2.test": {
+            "waku-websocket": {
+                "node-01.ac-cn-hongkong-c.wakuv2.test": "/dns4/node-01.ac-cn-hongkong-c.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAkvWiyFsgRhuJEb9JfjYxEkoHLgnUQmr1N5mKWnYjxYRVm",
+                "node-01.do-ams3.wakuv2.test": "/dns4/node-01.do-ams3.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAmPLe7Mzm8TsYUubgCAW1aJoeFScxrLj8ppHFivPo97bUZ",
+                "node-01.gc-us-central1-a.wakuv2.test": "/dns4/node-01.gc-us-central1-a.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAmJb2e28qLXxT5kZxVUUoJt72EMzNGXB47Rxx5hw3q4YjS",
+            },
+        },
+    },
+};
+
+export { DefaultWantedNumber, Fleet, fleets, getPredefinedBootstrapNodes };

package/bundle/lib/utils.js

@@ -0,0 +1 @@
+export { d as bytesToHex, g as bytesToUtf8, c as concat, h as hexToBytes, e as utf8ToBytes } from '../utils-9a3221f2.js';

package/bundle/lib/wait_for_remote_peer.js

@@ -0,0 +1,327 @@
+import { P as Protocols, S as StoreCodec, L as LightPushCodec, F as FilterCodec } from '../index-691c0be6.js';
+import { d as debug } from '../browser-1e1a2f27.js';
+import '../message-e2db79d7.js';
+import '../index-ba42b4fc.js';
+import '../index-64ce43f0.js';
+
+class TimeoutError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = 'TimeoutError';
+	}
+}
+
+/**
+An error to be thrown when the request is aborted by AbortController.
+DOMException is thrown instead of this Error when DOMException is available.
+*/
+class AbortError extends Error {
+	constructor(message) {
+		super();
+		this.name = 'AbortError';
+		this.message = message;
+	}
+}
+
+/**
+TODO: Remove AbortError and just throw DOMException when targeting Node 18.
+*/
+const getDOMException = errorMessage => globalThis.DOMException === undefined ?
+	new AbortError(errorMessage) :
+	new DOMException(errorMessage);
+
+/**
+TODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.
+*/
+const getAbortedReason = signal => {
+	const reason = signal.reason === undefined ?
+		getDOMException('This operation was aborted.') :
+		signal.reason;
+
+	return reason instanceof Error ? reason : getDOMException(reason);
+};
+
+function pTimeout(promise, milliseconds, fallback, options) {
+	let timer;
+
+	const cancelablePromise = new Promise((resolve, reject) => {
+		if (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {
+			throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+		}
+
+		if (milliseconds === Number.POSITIVE_INFINITY) {
+			resolve(promise);
+			return;
+		}
+
+		options = {
+			customTimers: {setTimeout, clearTimeout},
+			...options
+		};
+
+		if (options.signal) {
+			const {signal} = options;
+			if (signal.aborted) {
+				reject(getAbortedReason(signal));
+			}
+
+			signal.addEventListener('abort', () => {
+				reject(getAbortedReason(signal));
+			});
+		}
+
+		timer = options.customTimers.setTimeout.call(undefined, () => {
+			if (typeof fallback === 'function') {
+				try {
+					resolve(fallback());
+				} catch (error) {
+					reject(error);
+				}
+
+				return;
+			}
+
+			const message = typeof fallback === 'string' ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
+			const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
+
+			if (typeof promise.cancel === 'function') {
+				promise.cancel();
+			}
+
+			reject(timeoutError);
+		}, milliseconds);
+
+		(async () => {
+			try {
+				resolve(await promise);
+			} catch (error) {
+				reject(error);
+			} finally {
+				options.customTimers.clearTimeout.call(undefined, timer);
+			}
+		})();
+	});
+
+	cancelablePromise.clear = () => {
+		clearTimeout(timer);
+		timer = undefined;
+	};
+
+	return cancelablePromise;
+}
+
+const normalizeEmitter = emitter => {
+	const addListener = emitter.on || emitter.addListener || emitter.addEventListener;
+	const removeListener = emitter.off || emitter.removeListener || emitter.removeEventListener;
+
+	if (!addListener || !removeListener) {
+		throw new TypeError('Emitter is not compatible');
+	}
+
+	return {
+		addListener: addListener.bind(emitter),
+		removeListener: removeListener.bind(emitter),
+	};
+};
+
+function pEventMultiple(emitter, event, options) {
+	let cancel;
+	const returnValue = new Promise((resolve, reject) => {
+		options = {
+			rejectionEvents: ['error'],
+			multiArgs: false,
+			resolveImmediately: false,
+			...options,
+		};
+
+		if (!(options.count >= 0 && (options.count === Number.POSITIVE_INFINITY || Number.isInteger(options.count)))) {
+			throw new TypeError('The `count` option should be at least 0 or more');
+		}
+
+		// Allow multiple events
+		const events = [event].flat();
+
+		const items = [];
+		const {addListener, removeListener} = normalizeEmitter(emitter);
+
+		const onItem = (...arguments_) => {
+			const value = options.multiArgs ? arguments_ : arguments_[0];
+
+			// eslint-disable-next-line unicorn/no-array-callback-reference
+			if (options.filter && !options.filter(value)) {
+				return;
+			}
+
+			items.push(value);
+
+			if (options.count === items.length) {
+				cancel();
+				resolve(items);
+			}
+		};
+
+		const rejectHandler = error => {
+			cancel();
+			reject(error);
+		};
+
+		cancel = () => {
+			for (const event of events) {
+				removeListener(event, onItem);
+			}
+
+			for (const rejectionEvent of options.rejectionEvents) {
+				removeListener(rejectionEvent, rejectHandler);
+			}
+		};
+
+		for (const event of events) {
+			addListener(event, onItem);
+		}
+
+		for (const rejectionEvent of options.rejectionEvents) {
+			addListener(rejectionEvent, rejectHandler);
+		}
+
+		if (options.resolveImmediately) {
+			resolve(items);
+		}
+	});
+
+	returnValue.cancel = cancel;
+
+	if (typeof options.timeout === 'number') {
+		const timeout = pTimeout(returnValue, options.timeout);
+		timeout.cancel = cancel;
+		return timeout;
+	}
+
+	return returnValue;
+}
+
+function pEvent(emitter, event, options) {
+	if (typeof options === 'function') {
+		options = {filter: options};
+	}
+
+	options = {
+		...options,
+		count: 1,
+		resolveImmediately: false,
+	};
+
+	const arrayPromise = pEventMultiple(emitter, event, options);
+	const promise = arrayPromise.then(array => array[0]); // eslint-disable-line promise/prefer-await-to-then
+	promise.cancel = arrayPromise.cancel;
+
+	return promise;
+}
+
+const log = debug("waku:wait-for-remote-peer");
+/**
+ * Wait for a remote peer to be ready given the passed protocols.
+ * Must be used after attempting to connect to nodes, using
+ * {@link index.waku.WakuNode.dial} or a bootstrap method with
+ * {@link lib/create_waku.createLightNode}.
+ *
+ * If the passed protocols is a GossipSub protocol, then it resolves only once
+ * a peer is in a mesh, to help ensure that other peers will send and receive
+ * message to us.
+ *
+ * @param waku The Waku Node
+ * @param protocols The protocols that need to be enabled by remote peers.
+ * @param timeoutMs A timeout value in milliseconds..
+ *
+ * @returns A promise that **resolves** if all desired protocols are fulfilled by
+ * remote nodes, **rejects** if the timeoutMs is reached.
+ * @throws If passing a protocol that is not mounted
+ * @default Wait for remote peers with protocols enabled locally and no time out is applied.
+ */
+async function waitForRemotePeer(waku, protocols, timeoutMs) {
+    protocols = protocols ?? getEnabledProtocols(waku);
+    if (!waku.isStarted())
+        return Promise.reject("Waku node is not started");
+    const promises = [];
+    if (protocols.includes(Protocols.Relay)) {
+        if (!waku.relay)
+            throw new Error("Cannot wait for Relay peer: protocol not mounted");
+        promises.push(waitForGossipSubPeerInMesh(waku.relay));
+    }
+    if (protocols.includes(Protocols.Store)) {
+        if (!waku.store)
+            throw new Error("Cannot wait for Store peer: protocol not mounted");
+        promises.push(waitForConnectedPeer(waku.store, [StoreCodec]));
+    }
+    if (protocols.includes(Protocols.LightPush)) {
+        if (!waku.lightPush)
+            throw new Error("Cannot wait for LightPush peer: protocol not mounted");
+        promises.push(waitForConnectedPeer(waku.lightPush, [LightPushCodec]));
+    }
+    if (protocols.includes(Protocols.Filter)) {
+        if (!waku.filter)
+            throw new Error("Cannot wait for Filter peer: protocol not mounted");
+        promises.push(waitForConnectedPeer(waku.filter, [FilterCodec]));
+    }
+    if (timeoutMs) {
+        await rejectOnTimeout(Promise.all(promises), timeoutMs, "Timed out waiting for a remote peer.");
+    }
+    else {
+        await Promise.all(promises);
+    }
+}
+/**
+ * Wait for a peer with the given protocol to be connected.
+ */
+async function waitForConnectedPeer(waku, codecs) {
+    const peers = await waku.peers();
+    if (peers.length) {
+        log(`${codecs} peer found: `, peers[0].id.toString());
+        return;
+    }
+    await new Promise((resolve) => {
+        const cb = (evt) => {
+            for (const codec of codecs) {
+                if (evt.detail.protocols.includes(codec)) {
+                    log("Resolving for", codec, evt.detail.protocols);
+                    waku.libp2p.peerStore.removeEventListener("change:protocols", cb);
+                    resolve();
+                    break;
+                }
+            }
+        };
+        waku.libp2p.peerStore.addEventListener("change:protocols", cb);
+    });
+}
+/**
+ * Wait for a peer with the given protocol to be connected and in the gossipsub
+ * mesh.
+ */
+async function waitForGossipSubPeerInMesh(waku) {
+    let peers = waku.getMeshPeers();
+    while (peers.length == 0) {
+        await pEvent(waku, "gossipsub:heartbeat");
+        peers = waku.getMeshPeers();
+    }
+}
+const awaitTimeout = (ms, rejectReason) => new Promise((_resolve, reject) => setTimeout(() => reject(rejectReason), ms));
+async function rejectOnTimeout(promise, timeoutMs, rejectReason) {
+    await Promise.race([promise, awaitTimeout(timeoutMs, rejectReason)]);
+}
+function getEnabledProtocols(waku) {
+    const protocols = [];
+    if (waku.relay) {
+        protocols.push(Protocols.Relay);
+    }
+    if (waku.filter) {
+        protocols.push(Protocols.Filter);
+    }
+    if (waku.store) {
+        protocols.push(Protocols.Store);
+    }
+    if (waku.lightPush) {
+        protocols.push(Protocols.LightPush);
+    }
+    return protocols;
+}
+
+export { waitForRemotePeer };

package/bundle/lib/waku_message/topic_only_message.js

@@ -0,0 +1,4 @@
+import '../../browser-1e1a2f27.js';
+export { T as TopicOnlyDecoder, a as TopicOnlyMessage } from '../../topic_only_message-34f36fa6.js';
+import '../../message-e2db79d7.js';
+import '../../index-ba42b4fc.js';

package/bundle/lib/waku_message/version_0.js

@@ -0,0 +1,4 @@
+import '../../browser-1e1a2f27.js';
+export { D as DecoderV0, E as EncoderV0, M as MessageV0, V as Version } from '../../version_0-e6fe440c.js';
+import '../../message-e2db79d7.js';
+import '../../index-ba42b4fc.js';