@waku/core 0.0.6 → 0.0.8

package/bundle/lib/wait_for_remote_peer.js

@@ -1,324 +0,0 @@
-import { P as Protocols, S as StoreCodec, L as LightPushCodec, F as FilterCodec } from '../index-925587a4.js';
-import { d as debug } from '../message-70dbb19b.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.peerStore.removeEventListener("change:protocols", cb);
-                    resolve();
-                    break;
-                }
-            }
-        };
-        waku.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

@@ -1,2 +0,0 @@
-import '../../message-70dbb19b.js';
-export { T as TopicOnlyDecoder, a as TopicOnlyMessage } from '../../topic_only_message-a80fe8b2.js';

package/bundle/lib/waku_message/version_0.js

@@ -1,330 +0,0 @@
-import { m as message$1, k as encodeMessage, l as decodeMessage, d as debug } from '../../message-70dbb19b.js';
-
-/* eslint-disable import/export */
-var RateLimitProof;
-(function (RateLimitProof) {
-    let _codec;
-    RateLimitProof.codec = () => {
-        if (_codec == null) {
-            _codec = message$1((obj, writer, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    writer.fork();
-                }
-                if (obj.proof != null) {
-                    writer.uint32(10);
-                    writer.bytes(obj.proof);
-                }
-                else {
-                    throw new Error('Protocol error: required field "proof" was not found in object');
-                }
-                if (obj.merkleRoot != null) {
-                    writer.uint32(18);
-                    writer.bytes(obj.merkleRoot);
-                }
-                else {
-                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
-                }
-                if (obj.epoch != null) {
-                    writer.uint32(26);
-                    writer.bytes(obj.epoch);
-                }
-                else {
-                    throw new Error('Protocol error: required field "epoch" was not found in object');
-                }
-                if (obj.shareX != null) {
-                    writer.uint32(34);
-                    writer.bytes(obj.shareX);
-                }
-                else {
-                    throw new Error('Protocol error: required field "shareX" was not found in object');
-                }
-                if (obj.shareY != null) {
-                    writer.uint32(42);
-                    writer.bytes(obj.shareY);
-                }
-                else {
-                    throw new Error('Protocol error: required field "shareY" was not found in object');
-                }
-                if (obj.nullifier != null) {
-                    writer.uint32(50);
-                    writer.bytes(obj.nullifier);
-                }
-                else {
-                    throw new Error('Protocol error: required field "nullifier" was not found in object');
-                }
-                if (obj.rlnIdentifier != null) {
-                    writer.uint32(58);
-                    writer.bytes(obj.rlnIdentifier);
-                }
-                else {
-                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
-                }
-                if (opts.lengthDelimited !== false) {
-                    writer.ldelim();
-                }
-            }, (reader, length) => {
-                const obj = {
-                    proof: new Uint8Array(0),
-                    merkleRoot: new Uint8Array(0),
-                    epoch: new Uint8Array(0),
-                    shareX: new Uint8Array(0),
-                    shareY: new Uint8Array(0),
-                    nullifier: new Uint8Array(0),
-                    rlnIdentifier: new Uint8Array(0),
-                };
-                const end = length == null ? reader.len : reader.pos + length;
-                while (reader.pos < end) {
-                    const tag = reader.uint32();
-                    switch (tag >>> 3) {
-                        case 1:
-                            obj.proof = reader.bytes();
-                            break;
-                        case 2:
-                            obj.merkleRoot = reader.bytes();
-                            break;
-                        case 3:
-                            obj.epoch = reader.bytes();
-                            break;
-                        case 4:
-                            obj.shareX = reader.bytes();
-                            break;
-                        case 5:
-                            obj.shareY = reader.bytes();
-                            break;
-                        case 6:
-                            obj.nullifier = reader.bytes();
-                            break;
-                        case 7:
-                            obj.rlnIdentifier = reader.bytes();
-                            break;
-                        default:
-                            reader.skipType(tag & 7);
-                            break;
-                    }
-                }
-                if (obj.proof == null) {
-                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
-                }
-                if (obj.merkleRoot == null) {
-                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
-                }
-                if (obj.epoch == null) {
-                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
-                }
-                if (obj.shareX == null) {
-                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
-                }
-                if (obj.shareY == null) {
-                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
-                }
-                if (obj.nullifier == null) {
-                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
-                }
-                if (obj.rlnIdentifier == null) {
-                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
-                }
-                return obj;
-            });
-        }
-        return _codec;
-    };
-    RateLimitProof.encode = (obj) => {
-        return encodeMessage(obj, RateLimitProof.codec());
-    };
-    RateLimitProof.decode = (buf) => {
-        return decodeMessage(buf, RateLimitProof.codec());
-    };
-})(RateLimitProof || (RateLimitProof = {}));
-var WakuMessage;
-(function (WakuMessage) {
-    let _codec;
-    WakuMessage.codec = () => {
-        if (_codec == null) {
-            _codec = message$1((obj, writer, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    writer.fork();
-                }
-                if (obj.payload != null) {
-                    writer.uint32(10);
-                    writer.bytes(obj.payload);
-                }
-                if (obj.contentTopic != null) {
-                    writer.uint32(18);
-                    writer.string(obj.contentTopic);
-                }
-                if (obj.version != null) {
-                    writer.uint32(24);
-                    writer.uint32(obj.version);
-                }
-                if (obj.timestampDeprecated != null) {
-                    writer.uint32(33);
-                    writer.double(obj.timestampDeprecated);
-                }
-                if (obj.timestamp != null) {
-                    writer.uint32(80);
-                    writer.sint64(obj.timestamp);
-                }
-                if (obj.rateLimitProof != null) {
-                    writer.uint32(170);
-                    RateLimitProof.codec().encode(obj.rateLimitProof, writer);
-                }
-                if (obj.ephemeral != null) {
-                    writer.uint32(248);
-                    writer.bool(obj.ephemeral);
-                }
-                if (opts.lengthDelimited !== false) {
-                    writer.ldelim();
-                }
-            }, (reader, length) => {
-                const obj = {};
-                const end = length == null ? reader.len : reader.pos + length;
-                while (reader.pos < end) {
-                    const tag = reader.uint32();
-                    switch (tag >>> 3) {
-                        case 1:
-                            obj.payload = reader.bytes();
-                            break;
-                        case 2:
-                            obj.contentTopic = reader.string();
-                            break;
-                        case 3:
-                            obj.version = reader.uint32();
-                            break;
-                        case 4:
-                            obj.timestampDeprecated = reader.double();
-                            break;
-                        case 10:
-                            obj.timestamp = reader.sint64();
-                            break;
-                        case 21:
-                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32());
-                            break;
-                        case 31:
-                            obj.ephemeral = reader.bool();
-                            break;
-                        default:
-                            reader.skipType(tag & 7);
-                            break;
-                    }
-                }
-                return obj;
-            });
-        }
-        return _codec;
-    };
-    WakuMessage.encode = (obj) => {
-        return encodeMessage(obj, WakuMessage.codec());
-    };
-    WakuMessage.decode = (buf) => {
-        return decodeMessage(buf, WakuMessage.codec());
-    };
-})(WakuMessage || (WakuMessage = {}));
-
-var message = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get RateLimitProof () { return RateLimitProof; },
-    get WakuMessage () { return WakuMessage; }
-});
-
-const log = debug("waku:message:version-0");
-const OneMillion = BigInt(1000000);
-const Version = 0;
-class MessageV0 {
-    constructor(proto) {
-        this.proto = proto;
-    }
-    get _rawPayload() {
-        if (this.proto.payload) {
-            return new Uint8Array(this.proto.payload);
-        }
-        return;
-    }
-    get ephemeral() {
-        return Boolean(this.proto.ephemeral);
-    }
-    get payload() {
-        return this._rawPayload;
-    }
-    get contentTopic() {
-        return this.proto.contentTopic;
-    }
-    get _rawTimestamp() {
-        return this.proto.timestamp;
-    }
-    get timestamp() {
-        // In the case we receive a value that is bigger than JS's max number,
-        // we catch the error and return undefined.
-        try {
-            if (this.proto.timestamp) {
-                // nanoseconds 10^-9 to milliseconds 10^-3
-                const timestamp = this.proto.timestamp / OneMillion;
-                return new Date(Number(timestamp));
-            }
-            if (this.proto.timestampDeprecated) {
-                return new Date(this.proto.timestampDeprecated * 1000);
-            }
-        }
-        catch (e) {
-            return;
-        }
-        return;
-    }
-    get version() {
-        // https://github.com/status-im/js-waku/issues/921
-        return this.proto.version ?? 0;
-    }
-    get rateLimitProof() {
-        return this.proto.rateLimitProof;
-    }
-}
-class EncoderV0 {
-    constructor(contentTopic, ephemeral = false) {
-        this.contentTopic = contentTopic;
-        this.ephemeral = ephemeral;
-    }
-    async toWire(message$1) {
-        return WakuMessage.encode(await this.toProtoObj(message$1));
-    }
-    async toProtoObj(message) {
-        const timestamp = message.timestamp ?? new Date();
-        return {
-            payload: message.payload,
-            version: Version,
-            contentTopic: this.contentTopic,
-            timestamp: BigInt(timestamp.valueOf()) * OneMillion,
-            rateLimitProof: message.rateLimitProof,
-            ephemeral: this.ephemeral,
-        };
-    }
-}
-class DecoderV0 {
-    constructor(contentTopic, ephemeral = false) {
-        this.contentTopic = contentTopic;
-        this.ephemeral = ephemeral;
-    }
-    fromWireToProtoObj(bytes) {
-        const protoMessage = WakuMessage.decode(bytes);
-        log("Message decoded", protoMessage);
-        return Promise.resolve({
-            payload: protoMessage.payload ?? undefined,
-            contentTopic: protoMessage.contentTopic ?? undefined,
-            version: protoMessage.version ?? undefined,
-            timestamp: protoMessage.timestamp ?? undefined,
-            rateLimitProof: protoMessage.rateLimitProof ?? undefined,
-            ephemeral: protoMessage.ephemeral ?? false,
-        });
-    }
-    async fromProtoObj(proto) {
-        // https://github.com/status-im/js-waku/issues/921
-        if (proto.version === undefined) {
-            proto.version = 0;
-        }
-        if (proto.version !== Version) {
-            log("Failed to decode due to incorrect version, expected:", Version, ", actual:", proto.version);
-            return Promise.resolve(undefined);
-        }
-        return new MessageV0(proto);
-    }
-}
-
-export { DecoderV0, EncoderV0, MessageV0, Version, message as proto };