@waku/core 0.0.1

package/bundle/index-691c0be6.js

@@ -0,0 +1,4059 @@
+import { d as debug } from './browser-1e1a2f27.js';
+import { c as createCodec, C as CODEC_TYPES, m as message, e as encodeMessage, d as decodeMessage } from './message-e2db79d7.js';
+import { e as errCode } from './index-64ce43f0.js';
+
+/**
+ * DefaultPubSubTopic is the default gossipsub topic to use for Waku.
+ */
+const DefaultPubSubTopic = "/waku/2/default-waku/proto";
+
+function enumeration(v) {
+    function findValue(val) {
+        // Use the reverse mapping to look up the enum key for the stored value
+        // https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
+        if (v[val.toString()] == null) {
+            throw new Error('Invalid enum value');
+        }
+        return v[val];
+    }
+    const encode = function enumEncode(val, writer) {
+        const enumValue = findValue(val);
+        writer.int32(enumValue);
+    };
+    const decode = function enumDecode(reader) {
+        const val = reader.uint32();
+        return findValue(val);
+    };
+    // @ts-expect-error yeah yeah
+    return createCodec('enum', CODEC_TYPES.VARINT, encode, decode);
+}
+
+var Protocols;
+(function (Protocols) {
+    Protocols["Relay"] = "relay";
+    Protocols["Store"] = "store";
+    Protocols["LightPush"] = "lightpush";
+    Protocols["Filter"] = "filter";
+})(Protocols || (Protocols = {}));
+var PageDirection$1;
+(function (PageDirection) {
+    PageDirection["BACKWARD"] = "backward";
+    PageDirection["FORWARD"] = "forward";
+})(PageDirection$1 || (PageDirection$1 = {}));
+
+/**
+ * Collects all values from an (async) iterable into an array and returns it.
+ *
+ * @template T
+ * @param {AsyncIterable<T>|Iterable<T>} source
+ */
+const all = async (source) => {
+  const arr = [];
+
+  for await (const entry of source) {
+    arr.push(entry);
+  }
+
+  return arr
+};
+
+var itAll = all;
+
+/**
+ * To guarantee Uint8Array semantics, convert nodejs Buffers
+ * into vanilla Uint8Arrays
+ */
+function asUint8Array$1(buf) {
+    if (globalThis.Buffer != null) {
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    return buf;
+}
+
+/**
+ * Returns a `Uint8Array` of the requested size. Referenced memory will
+ * be initialized to 0.
+ */
+function alloc(size = 0) {
+    if (globalThis.Buffer?.alloc != null) {
+        return asUint8Array$1(globalThis.Buffer.alloc(size));
+    }
+    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$2(size = 0) {
+    if (globalThis.Buffer?.allocUnsafe != null) {
+        return asUint8Array$1(globalThis.Buffer.allocUnsafe(size));
+    }
+    return new Uint8Array(size);
+}
+
+/**
+ * Returns a new Uint8Array created by concatenating the passed ArrayLikes
+ */
+function concat(arrays, length) {
+    if (length == null) {
+        length = arrays.reduce((acc, curr) => acc + curr.length, 0);
+    }
+    const output = allocUnsafe$2(length);
+    let offset = 0;
+    for (const arr of arrays) {
+        output.set(arr, offset);
+        offset += arr.length;
+    }
+    return asUint8Array$1(output);
+}
+
+/**
+ * Returns true if the two passed Uint8Arrays have the same content
+ */
+function equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    for (let i = 0; i < a.byteLength; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const symbol = Symbol.for('@achingbrain/uint8arraylist');
+function findBufAndOffset(bufs, index) {
+    if (index == null || index < 0) {
+        throw new RangeError('index is out of bounds');
+    }
+    let offset = 0;
+    for (const buf of bufs) {
+        const bufEnd = offset + buf.byteLength;
+        if (index < bufEnd) {
+            return {
+                buf,
+                index: index - offset
+            };
+        }
+        offset = bufEnd;
+    }
+    throw new RangeError('index is out of bounds');
+}
+/**
+ * Check if object is a CID instance
+ */
+function isUint8ArrayList(value) {
+    return Boolean(value?.[symbol]);
+}
+class Uint8ArrayList {
+    constructor(...data) {
+        // Define symbol
+        Object.defineProperty(this, symbol, { value: true });
+        this.bufs = [];
+        this.length = 0;
+        if (data.length > 0) {
+            this.appendAll(data);
+        }
+    }
+    *[Symbol.iterator]() {
+        yield* this.bufs;
+    }
+    get byteLength() {
+        return this.length;
+    }
+    /**
+     * Add one or more `bufs` to the end of this Uint8ArrayList
+     */
+    append(...bufs) {
+        this.appendAll(bufs);
+    }
+    /**
+     * Add all `bufs` to the end of this Uint8ArrayList
+     */
+    appendAll(bufs) {
+        let length = 0;
+        for (const buf of bufs) {
+            if (buf instanceof Uint8Array) {
+                length += buf.byteLength;
+                this.bufs.push(buf);
+            }
+            else if (isUint8ArrayList(buf)) {
+                length += buf.byteLength;
+                this.bufs.push(...buf.bufs);
+            }
+            else {
+                throw new Error('Could not append value, must be an Uint8Array or a Uint8ArrayList');
+            }
+        }
+        this.length += length;
+    }
+    /**
+     * Add one or more `bufs` to the start of this Uint8ArrayList
+     */
+    prepend(...bufs) {
+        this.prependAll(bufs);
+    }
+    /**
+     * Add all `bufs` to the start of this Uint8ArrayList
+     */
+    prependAll(bufs) {
+        let length = 0;
+        for (const buf of bufs.reverse()) {
+            if (buf instanceof Uint8Array) {
+                length += buf.byteLength;
+                this.bufs.unshift(buf);
+            }
+            else if (isUint8ArrayList(buf)) {
+                length += buf.byteLength;
+                this.bufs.unshift(...buf.bufs);
+            }
+            else {
+                throw new Error('Could not prepend value, must be an Uint8Array or a Uint8ArrayList');
+            }
+        }
+        this.length += length;
+    }
+    /**
+     * Read the value at `index`
+     */
+    get(index) {
+        const res = findBufAndOffset(this.bufs, index);
+        return res.buf[res.index];
+    }
+    /**
+     * Set the value at `index` to `value`
+     */
+    set(index, value) {
+        const res = findBufAndOffset(this.bufs, index);
+        res.buf[res.index] = value;
+    }
+    /**
+     * Copy bytes from `buf` to the index specified by `offset`
+     */
+    write(buf, offset = 0) {
+        if (buf instanceof Uint8Array) {
+            for (let i = 0; i < buf.length; i++) {
+                this.set(offset + i, buf[i]);
+            }
+        }
+        else if (isUint8ArrayList(buf)) {
+            for (let i = 0; i < buf.length; i++) {
+                this.set(offset + i, buf.get(i));
+            }
+        }
+        else {
+            throw new Error('Could not write value, must be an Uint8Array or a Uint8ArrayList');
+        }
+    }
+    /**
+     * Remove bytes from the front of the pool
+     */
+    consume(bytes) {
+        // first, normalize the argument, in accordance with how Buffer does it
+        bytes = Math.trunc(bytes);
+        // do nothing if not a positive number
+        if (Number.isNaN(bytes) || bytes <= 0) {
+            return;
+        }
+        while (this.bufs.length > 0) {
+            if (bytes >= this.bufs[0].byteLength) {
+                bytes -= this.bufs[0].byteLength;
+                this.length -= this.bufs[0].byteLength;
+                this.bufs.shift();
+            }
+            else {
+                this.bufs[0] = this.bufs[0].subarray(bytes);
+                this.length -= bytes;
+                break;
+            }
+        }
+    }
+    /**
+     * Extracts a section of an array and returns a new array.
+     *
+     * This is a copy operation as it is with Uint8Arrays and Arrays
+     * - note this is different to the behaviour of Node Buffers.
+     */
+    slice(beginInclusive, endExclusive) {
+        const { bufs, length } = this._subList(beginInclusive, endExclusive);
+        return concat(bufs, length);
+    }
+    /**
+     * Returns a alloc from the given start and end element index.
+     *
+     * In the best case where the data extracted comes from a single Uint8Array
+     * internally this is a no-copy operation otherwise it is a copy operation.
+     */
+    subarray(beginInclusive, endExclusive) {
+        const { bufs, length } = this._subList(beginInclusive, endExclusive);
+        if (bufs.length === 1) {
+            return bufs[0];
+        }
+        return concat(bufs, length);
+    }
+    /**
+     * Returns a allocList from the given start and end element index.
+     *
+     * This is a no-copy operation.
+     */
+    sublist(beginInclusive, endExclusive) {
+        const { bufs, length } = this._subList(beginInclusive, endExclusive);
+        const list = new Uint8ArrayList();
+        list.length = length;
+        // don't loop, just set the bufs
+        list.bufs = bufs;
+        return list;
+    }
+    _subList(beginInclusive, endExclusive) {
+        beginInclusive = beginInclusive ?? 0;
+        endExclusive = endExclusive ?? this.length;
+        if (beginInclusive < 0) {
+            beginInclusive = this.length + beginInclusive;
+        }
+        if (endExclusive < 0) {
+            endExclusive = this.length + endExclusive;
+        }
+        if (beginInclusive < 0 || endExclusive > this.length) {
+            throw new RangeError('index is out of bounds');
+        }
+        if (beginInclusive === endExclusive) {
+            return { bufs: [], length: 0 };
+        }
+        if (beginInclusive === 0 && endExclusive === this.length) {
+            return { bufs: [...this.bufs], length: this.length };
+        }
+        const bufs = [];
+        let offset = 0;
+        for (let i = 0; i < this.bufs.length; i++) {
+            const buf = this.bufs[i];
+            const bufStart = offset;
+            const bufEnd = bufStart + buf.byteLength;
+            // for next loop
+            offset = bufEnd;
+            if (beginInclusive >= bufEnd) {
+                // start after this buf
+                continue;
+            }
+            const sliceStartInBuf = beginInclusive >= bufStart && beginInclusive < bufEnd;
+            const sliceEndsInBuf = endExclusive > bufStart && endExclusive <= bufEnd;
+            if (sliceStartInBuf && sliceEndsInBuf) {
+                // slice is wholly contained within this buffer
+                if (beginInclusive === bufStart && endExclusive === bufEnd) {
+                    // requested whole buffer
+                    bufs.push(buf);
+                    break;
+                }
+                // requested part of buffer
+                const start = beginInclusive - bufStart;
+                bufs.push(buf.subarray(start, start + (endExclusive - beginInclusive)));
+                break;
+            }
+            if (sliceStartInBuf) {
+                // slice starts in this buffer
+                if (beginInclusive === 0) {
+                    // requested whole buffer
+                    bufs.push(buf);
+                    continue;
+                }
+                // requested part of buffer
+                bufs.push(buf.subarray(beginInclusive - bufStart));
+                continue;
+            }
+            if (sliceEndsInBuf) {
+                if (endExclusive === bufEnd) {
+                    // requested whole buffer
+                    bufs.push(buf);
+                    break;
+                }
+                // requested part of buffer
+                bufs.push(buf.subarray(0, endExclusive - bufStart));
+                break;
+            }
+            // slice started before this buffer and ends after it
+            bufs.push(buf);
+        }
+        return { bufs, length: endExclusive - beginInclusive };
+    }
+    getInt8(byteOffset) {
+        const buf = this.subarray(byteOffset, byteOffset + 1);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getInt8(0);
+    }
+    setInt8(byteOffset, value) {
+        const buf = allocUnsafe$2(1);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setInt8(0, value);
+        this.write(buf, byteOffset);
+    }
+    getInt16(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 2);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getInt16(0, littleEndian);
+    }
+    setInt16(byteOffset, value, littleEndian) {
+        const buf = alloc(2);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setInt16(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getInt32(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getInt32(0, littleEndian);
+    }
+    setInt32(byteOffset, value, littleEndian) {
+        const buf = alloc(4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setInt32(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getBigInt64(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getBigInt64(0, littleEndian);
+    }
+    setBigInt64(byteOffset, value, littleEndian) {
+        const buf = alloc(8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setBigInt64(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getUint8(byteOffset) {
+        const buf = this.subarray(byteOffset, byteOffset + 1);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getUint8(0);
+    }
+    setUint8(byteOffset, value) {
+        const buf = allocUnsafe$2(1);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setUint8(0, value);
+        this.write(buf, byteOffset);
+    }
+    getUint16(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 2);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getUint16(0, littleEndian);
+    }
+    setUint16(byteOffset, value, littleEndian) {
+        const buf = alloc(2);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setUint16(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getUint32(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getUint32(0, littleEndian);
+    }
+    setUint32(byteOffset, value, littleEndian) {
+        const buf = alloc(4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setUint32(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getBigUint64(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getBigUint64(0, littleEndian);
+    }
+    setBigUint64(byteOffset, value, littleEndian) {
+        const buf = alloc(8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setBigUint64(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getFloat32(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getFloat32(0, littleEndian);
+    }
+    setFloat32(byteOffset, value, littleEndian) {
+        const buf = alloc(4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setFloat32(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getFloat64(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getFloat64(0, littleEndian);
+    }
+    setFloat64(byteOffset, value, littleEndian) {
+        const buf = alloc(8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setFloat64(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    equals(other) {
+        if (other == null) {
+            return false;
+        }
+        if (!(other instanceof Uint8ArrayList)) {
+            return false;
+        }
+        if (other.bufs.length !== this.bufs.length) {
+            return false;
+        }
+        for (let i = 0; i < this.bufs.length; i++) {
+            if (!equals(this.bufs[i], other.bufs[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Create a Uint8ArrayList from a pre-existing list of Uint8Arrays.  Use this
+     * method if you know the total size of all the Uint8Arrays ahead of time.
+     */
+    static fromUint8Arrays(bufs, length) {
+        const list = new Uint8ArrayList();
+        list.bufs = bufs;
+        if (length == null) {
+            length = bufs.reduce((acc, curr) => acc + curr.byteLength, 0);
+        }
+        list.length = length;
+        return list;
+    }
+}
+
+function accessor(buf) {
+    if (buf instanceof Uint8Array) {
+        return {
+            get(index) {
+                return buf[index];
+            },
+            set(index, value) {
+                buf[index] = value;
+            }
+        };
+    }
+    return {
+        get(index) {
+            return buf.get(index);
+        },
+        set(index, value) {
+            buf.set(index, value);
+        }
+    };
+}
+
+const TWO_32 = 4294967296;
+class LongBits {
+    constructor(hi = 0, lo = 0) {
+        this.hi = hi;
+        this.lo = lo;
+    }
+    /**
+     * Returns these hi/lo bits as a BigInt
+     */
+    toBigInt(unsigned) {
+        if (unsigned === true) {
+            return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+        }
+        if ((this.hi >>> 31) !== 0) {
+            const lo = ~this.lo + 1 >>> 0;
+            let hi = ~this.hi >>> 0;
+            if (lo === 0) {
+                hi = hi + 1 >>> 0;
+            }
+            return -(BigInt(lo) + (BigInt(hi) << 32n));
+        }
+        return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+    }
+    /**
+     * Returns these hi/lo bits as a Number - this may overflow, toBigInt
+     * should be preferred
+     */
+    toNumber(unsigned) {
+        return Number(this.toBigInt(unsigned));
+    }
+    /**
+     * ZigZag decode a LongBits object
+     */
+    zzDecode() {
+        const mask = -(this.lo & 1);
+        const lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+        const hi = (this.hi >>> 1 ^ mask) >>> 0;
+        return new LongBits(hi, lo);
+    }
+    /**
+     * ZigZag encode a LongBits object
+     */
+    zzEncode() {
+        const mask = this.hi >> 31;
+        const hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+        const lo = (this.lo << 1 ^ mask) >>> 0;
+        return new LongBits(hi, lo);
+    }
+    /**
+     * Encode a LongBits object as a varint byte array
+     */
+    toBytes(buf, offset = 0) {
+        const access = accessor(buf);
+        while (this.hi > 0) {
+            access.set(offset++, this.lo & 127 | 128);
+            this.lo = (this.lo >>> 7 | this.hi << 25) >>> 0;
+            this.hi >>>= 7;
+        }
+        while (this.lo > 127) {
+            access.set(offset++, this.lo & 127 | 128);
+            this.lo = this.lo >>> 7;
+        }
+        access.set(offset++, this.lo);
+    }
+    /**
+     * Parse a LongBits object from a BigInt
+     */
+    static fromBigInt(value) {
+        if (value === 0n) {
+            return new LongBits();
+        }
+        const negative = value < 0;
+        if (negative) {
+            value = -value;
+        }
+        let hi = Number(value >> 32n) | 0;
+        let lo = Number(value - (BigInt(hi) << 32n)) | 0;
+        if (negative) {
+            hi = ~hi >>> 0;
+            lo = ~lo >>> 0;
+            if (++lo > TWO_32) {
+                lo = 0;
+                if (++hi > TWO_32) {
+                    hi = 0;
+                }
+            }
+        }
+        return new LongBits(hi, lo);
+    }
+    /**
+     * Parse a LongBits object from a Number
+     */
+    static fromNumber(value) {
+        if (value === 0) {
+            return new LongBits();
+        }
+        const sign = value < 0;
+        if (sign) {
+            value = -value;
+        }
+        let lo = value >>> 0;
+        let hi = (value - lo) / 4294967296 >>> 0;
+        if (sign) {
+            hi = ~hi >>> 0;
+            lo = ~lo >>> 0;
+            if (++lo > 4294967295) {
+                lo = 0;
+                if (++hi > 4294967295) {
+                    hi = 0;
+                }
+            }
+        }
+        return new LongBits(hi, lo);
+    }
+    /**
+     * Parse a LongBits object from a varint byte array
+     */
+    static fromBytes(buf, offset = 0) {
+        const access = accessor(buf);
+        // tends to deopt with local vars for octet etc.
+        const bits = new LongBits();
+        let i = 0;
+        if (buf.length - offset > 4) { // fast route (lo)
+            for (; i < 4; ++i) {
+                // 1st..4th
+                bits.lo = (bits.lo | (access.get(offset) & 127) << i * 7) >>> 0;
+                if (access.get(offset++) < 128) {
+                    return bits;
+                }
+            }
+            // 5th
+            bits.lo = (bits.lo | (access.get(offset) & 127) << 28) >>> 0;
+            bits.hi = (bits.hi | (access.get(offset) & 127) >> 4) >>> 0;
+            if (access.get(offset++) < 128) {
+                return bits;
+            }
+            i = 0;
+        }
+        else {
+            for (; i < 4; ++i) {
+                /* istanbul ignore if */
+                if (offset >= buf.length) {
+                    throw RangeError(`index out of range: ${offset} > ${buf.length}`);
+                }
+                // 1st..4th
+                bits.lo = (bits.lo | (access.get(offset) & 127) << i * 7) >>> 0;
+                if (access.get(offset++) < 128) {
+                    return bits;
+                }
+            }
+        }
+        if (buf.length - offset > 4) { // fast route (hi)
+            for (; i < 5; ++i) {
+                // 6th..10th
+                bits.hi = (bits.hi | (access.get(offset) & 127) << i * 7 + 3) >>> 0;
+                if (access.get(offset++) < 128) {
+                    return bits;
+                }
+            }
+        }
+        else if (offset < buf.byteLength) {
+            for (; i < 5; ++i) {
+                /* istanbul ignore if */
+                if (offset >= buf.length) {
+                    throw RangeError(`index out of range: ${offset} > ${buf.length}`);
+                }
+                // 6th..10th
+                bits.hi = (bits.hi | (access.get(offset) & 127) << i * 7 + 3) >>> 0;
+                if (access.get(offset++) < 128) {
+                    return bits;
+                }
+            }
+        }
+        /* istanbul ignore next */
+        throw RangeError('invalid varint encoding');
+    }
+}
+
+/**
+ * To guarantee Uint8Array semantics, convert nodejs Buffers
+ * into vanilla Uint8Arrays
+ */
+function asUint8Array(buf) {
+    if (globalThis.Buffer != null) {
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    return buf;
+}
+
+/**
+ * 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$1(size = 0) {
+    if (globalThis.Buffer?.allocUnsafe != null) {
+        return asUint8Array(globalThis.Buffer.allocUnsafe(size));
+    }
+    return new Uint8Array(size);
+}
+
+const N1 = Math.pow(2, 7);
+const N2 = Math.pow(2, 14);
+const N3 = Math.pow(2, 21);
+const N4 = Math.pow(2, 28);
+const N5 = Math.pow(2, 35);
+const N6 = Math.pow(2, 42);
+const N7 = Math.pow(2, 49);
+const N8 = Math.pow(2, 56);
+const N9 = Math.pow(2, 63);
+const unsigned = {
+    encodingLength(value) {
+        if (value < N1) {
+            return 1;
+        }
+        if (value < N2) {
+            return 2;
+        }
+        if (value < N3) {
+            return 3;
+        }
+        if (value < N4) {
+            return 4;
+        }
+        if (value < N5) {
+            return 5;
+        }
+        if (value < N6) {
+            return 6;
+        }
+        if (value < N7) {
+            return 7;
+        }
+        if (value < N8) {
+            return 8;
+        }
+        if (value < N9) {
+            return 9;
+        }
+        return 10;
+    },
+    encode(value, buf, offset = 0) {
+        if (Number.MAX_SAFE_INTEGER != null && value > Number.MAX_SAFE_INTEGER) {
+            throw new RangeError('Could not encode varint');
+        }
+        if (buf == null) {
+            buf = allocUnsafe$1(unsigned.encodingLength(value));
+        }
+        LongBits.fromNumber(value).toBytes(buf, offset);
+        return buf;
+    },
+    decode(buf, offset = 0) {
+        return LongBits.fromBytes(buf, offset).toNumber(true);
+    }
+};
+
+function allocUnsafe(len) {
+    if (globalThis?.Buffer?.allocUnsafe != null) {
+        return globalThis.Buffer.allocUnsafe(len);
+    }
+    return new Uint8Array(len);
+}
+
+const defaultEncoder = (length) => {
+    const lengthLength = unsigned.encodingLength(length);
+    const lengthBuf = allocUnsafe(lengthLength);
+    unsigned.encode(length, lengthBuf);
+    defaultEncoder.bytes = lengthLength;
+    return lengthBuf;
+};
+defaultEncoder.bytes = 0;
+function encode(options) {
+    options = options ?? {};
+    const encodeLength = options.lengthEncoder ?? defaultEncoder;
+    const encoder = async function* (source) {
+        for await (const chunk of source) {
+            // length + data
+            const length = encodeLength(chunk.byteLength);
+            // yield only Uint8Arrays
+            if (length instanceof Uint8Array) {
+                yield length;
+            }
+            else {
+                yield* length;
+            }
+            // yield only Uint8Arrays
+            if (chunk instanceof Uint8Array) {
+                yield chunk;
+            }
+            else {
+                yield* chunk;
+            }
+        }
+    };
+    return encoder;
+}
+encode.single = (chunk, options) => {
+    options = options ?? {};
+    const encodeLength = options.lengthEncoder ?? defaultEncoder;
+    return new Uint8ArrayList(encodeLength(chunk.byteLength), chunk);
+};
+
+/* eslint max-depth: ["error", 6] */
+// Maximum length of the length section of the message
+const MAX_LENGTH_LENGTH = 8; // Varint.encode(Number.MAX_SAFE_INTEGER).length
+// Maximum length of the data section of the message
+const MAX_DATA_LENGTH = 1024 * 1024 * 4;
+var ReadMode;
+(function (ReadMode) {
+    ReadMode[ReadMode["LENGTH"] = 0] = "LENGTH";
+    ReadMode[ReadMode["DATA"] = 1] = "DATA";
+})(ReadMode || (ReadMode = {}));
+const defaultDecoder = (buf) => {
+    const length = unsigned.decode(buf);
+    defaultDecoder.bytes = unsigned.encodingLength(length);
+    return length;
+};
+defaultDecoder.bytes = 0;
+function decode(options) {
+    const decoder = async function* (source) {
+        const buffer = new Uint8ArrayList();
+        let mode = ReadMode.LENGTH;
+        let dataLength = -1;
+        const lengthDecoder = options?.lengthDecoder ?? defaultDecoder;
+        const maxLengthLength = options?.maxLengthLength ?? MAX_LENGTH_LENGTH;
+        const maxDataLength = options?.maxDataLength ?? MAX_DATA_LENGTH;
+        for await (const buf of source) {
+            buffer.append(buf);
+            while (buffer.byteLength > 0) {
+                if (mode === ReadMode.LENGTH) {
+                    // read length, ignore errors for short reads
+                    try {
+                        dataLength = lengthDecoder(buffer);
+                        if (dataLength < 0) {
+                            throw errCode(new Error('invalid message length'), 'ERR_INVALID_MSG_LENGTH');
+                        }
+                        if (dataLength > maxDataLength) {
+                            throw errCode(new Error('message length too long'), 'ERR_MSG_DATA_TOO_LONG');
+                        }
+                        const dataLengthLength = lengthDecoder.bytes;
+                        buffer.consume(dataLengthLength);
+                        if (options?.onLength != null) {
+                            options.onLength(dataLength);
+                        }
+                        mode = ReadMode.DATA;
+                    }
+                    catch (err) {
+                        if (err instanceof RangeError) {
+                            if (buffer.byteLength > maxLengthLength) {
+                                throw errCode(new Error('message length length too long'), 'ERR_MSG_LENGTH_TOO_LONG');
+                            }
+                            break;
+                        }
+                        throw err;
+                    }
+                }
+                if (mode === ReadMode.DATA) {
+                    if (buffer.byteLength < dataLength) {
+                        // not enough data, wait for more
+                        break;
+                    }
+                    const data = buffer.sublist(0, dataLength);
+                    buffer.consume(dataLength);
+                    if (options?.onData != null) {
+                        options.onData(data);
+                    }
+                    yield data;
+                    mode = ReadMode.LENGTH;
+                }
+            }
+        }
+        if (buffer.byteLength > 0) {
+            throw errCode(new Error('unexpected end of input'), 'ERR_UNEXPECTED_EOF');
+        }
+    };
+    return decoder;
+}
+/**
+ * @param {*} reader
+ * @param {import('./types').DecoderOptions} [options]
+ * @returns
+ */
+decode.fromReader = (reader, options) => {
+    let byteLength = 1; // Read single byte chunks until the length is known
+    const varByteSource = (async function* () {
+        while (true) {
+            try {
+                const { done, value } = await reader.next(byteLength);
+                if (done === true) {
+                    return;
+                }
+                if (value != null) {
+                    yield value;
+                }
+            }
+            catch (err) {
+                if (err.code === 'ERR_UNDER_READ') {
+                    return { done: true, value: null };
+                }
+                throw err;
+            }
+            finally {
+                // Reset the byteLength so we continue to check for varints
+                byteLength = 1;
+            }
+        }
+    }());
+    /**
+     * Once the length has been parsed, read chunk for that length
+     */
+    const onLength = (l) => { byteLength = l; };
+    return decode({
+        ...(options ?? {}),
+        onLength
+    })(varByteSource);
+};
+
+// ported from https://www.npmjs.com/package/fast-fifo
+class FixedFIFO$1 {
+    constructor(hwm) {
+        if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) {
+            throw new Error('Max size for a FixedFIFO should be a power of two');
+        }
+        this.buffer = new Array(hwm);
+        this.mask = hwm - 1;
+        this.top = 0;
+        this.btm = 0;
+        this.next = null;
+    }
+    push(data) {
+        if (this.buffer[this.top] !== undefined) {
+            return false;
+        }
+        this.buffer[this.top] = data;
+        this.top = (this.top + 1) & this.mask;
+        return true;
+    }
+    shift() {
+        const last = this.buffer[this.btm];
+        if (last === undefined) {
+            return undefined;
+        }
+        this.buffer[this.btm] = undefined;
+        this.btm = (this.btm + 1) & this.mask;
+        return last;
+    }
+    isEmpty() {
+        return this.buffer[this.btm] === undefined;
+    }
+}
+class FIFO$1 {
+    constructor(options = {}) {
+        this.hwm = options.splitLimit ?? 16;
+        this.head = new FixedFIFO$1(this.hwm);
+        this.tail = this.head;
+        this.size = 0;
+    }
+    calculateSize(obj) {
+        if (obj?.byteLength != null) {
+            return obj.byteLength;
+        }
+        return 1;
+    }
+    push(val) {
+        if (val?.value != null) {
+            this.size += this.calculateSize(val.value);
+        }
+        if (!this.head.push(val)) {
+            const prev = this.head;
+            this.head = prev.next = new FixedFIFO$1(2 * this.head.buffer.length);
+            this.head.push(val);
+        }
+    }
+    shift() {
+        let val = this.tail.shift();
+        if (val === undefined && (this.tail.next != null)) {
+            const next = this.tail.next;
+            this.tail.next = null;
+            this.tail = next;
+            val = this.tail.shift();
+        }
+        if (val?.value != null) {
+            this.size -= this.calculateSize(val.value);
+        }
+        return val;
+    }
+    isEmpty() {
+        return this.head.isEmpty();
+    }
+}
+
+function pushable$1(options = {}) {
+    const getNext = (buffer) => {
+        const next = buffer.shift();
+        if (next == null) {
+            return { done: true };
+        }
+        if (next.error != null) {
+            throw next.error;
+        }
+        return {
+            done: next.done === true,
+            // @ts-expect-error
+            value: next.value
+        };
+    };
+    return _pushable(getNext, options);
+}
+function _pushable(getNext, options) {
+    options = options ?? {};
+    let onEnd = options.onEnd;
+    let buffer = new FIFO$1();
+    let pushable;
+    let onNext;
+    let ended;
+    const waitNext = async () => {
+        if (!buffer.isEmpty()) {
+            return getNext(buffer);
+        }
+        if (ended) {
+            return { done: true };
+        }
+        return await new Promise((resolve, reject) => {
+            onNext = (next) => {
+                onNext = null;
+                buffer.push(next);
+                try {
+                    resolve(getNext(buffer));
+                }
+                catch (err) {
+                    reject(err);
+                }
+                return pushable;
+            };
+        });
+    };
+    const bufferNext = (next) => {
+        if (onNext != null) {
+            return onNext(next);
+        }
+        buffer.push(next);
+        return pushable;
+    };
+    const bufferError = (err) => {
+        buffer = new FIFO$1();
+        if (onNext != null) {
+            return onNext({ error: err });
+        }
+        buffer.push({ error: err });
+        return pushable;
+    };
+    const push = (value) => {
+        if (ended) {
+            return pushable;
+        }
+        // @ts-expect-error `byteLength` is not declared on PushType
+        if (options?.objectMode !== true && value?.byteLength == null) {
+            throw new Error('objectMode was not true but tried to push non-Uint8Array value');
+        }
+        return bufferNext({ done: false, value });
+    };
+    const end = (err) => {
+        if (ended)
+            return pushable;
+        ended = true;
+        return (err != null) ? bufferError(err) : bufferNext({ done: true });
+    };
+    const _return = () => {
+        buffer = new FIFO$1();
+        end();
+        return { done: true };
+    };
+    const _throw = (err) => {
+        end(err);
+        return { done: true };
+    };
+    pushable = {
+        [Symbol.asyncIterator]() { return this; },
+        next: waitNext,
+        return: _return,
+        throw: _throw,
+        push,
+        end,
+        get readableLength() {
+            return buffer.size;
+        }
+    };
+    if (onEnd == null) {
+        return pushable;
+    }
+    const _pushable = pushable;
+    pushable = {
+        [Symbol.asyncIterator]() { return this; },
+        next() {
+            return _pushable.next();
+        },
+        throw(err) {
+            _pushable.throw(err);
+            if (onEnd != null) {
+                onEnd(err);
+                onEnd = undefined;
+            }
+            return { done: true };
+        },
+        return() {
+            _pushable.return();
+            if (onEnd != null) {
+                onEnd();
+                onEnd = undefined;
+            }
+            return { done: true };
+        },
+        push,
+        end(err) {
+            _pushable.end(err);
+            if (onEnd != null) {
+                onEnd(err);
+                onEnd = undefined;
+            }
+            return pushable;
+        },
+        get readableLength() {
+            return _pushable.readableLength;
+        }
+    };
+    return pushable;
+}
+
+var fixedSize = class FixedFIFO {
+  constructor (hwm) {
+    if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two')
+    this.buffer = new Array(hwm);
+    this.mask = hwm - 1;
+    this.top = 0;
+    this.btm = 0;
+    this.next = null;
+  }
+
+  push (data) {
+    if (this.buffer[this.top] !== undefined) return false
+    this.buffer[this.top] = data;
+    this.top = (this.top + 1) & this.mask;
+    return true
+  }
+
+  shift () {
+    const last = this.buffer[this.btm];
+    if (last === undefined) return undefined
+    this.buffer[this.btm] = undefined;
+    this.btm = (this.btm + 1) & this.mask;
+    return last
+  }
+
+  peek () {
+    return this.buffer[this.btm]
+  }
+
+  isEmpty () {
+    return this.buffer[this.btm] === undefined
+  }
+};
+
+const FixedFIFO = fixedSize;
+
+var fastFifo = class FastFIFO {
+  constructor (hwm) {
+    this.hwm = hwm || 16;
+    this.head = new FixedFIFO(this.hwm);
+    this.tail = this.head;
+  }
+
+  push (val) {
+    if (!this.head.push(val)) {
+      const prev = this.head;
+      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+      this.head.push(val);
+    }
+  }
+
+  shift () {
+    const val = this.tail.shift();
+    if (val === undefined && this.tail.next) {
+      const next = this.tail.next;
+      this.tail.next = null;
+      this.tail = next;
+      return this.tail.shift()
+    }
+    return val
+  }
+
+  peek () {
+    return this.tail.peek()
+  }
+
+  isEmpty () {
+    return this.head.isEmpty()
+  }
+};
+
+const FIFO = fastFifo;
+
+var itPushable = (options) => {
+  options = options || {};
+  let onEnd;
+
+  if (typeof options === 'function') {
+    onEnd = options;
+    options = {};
+  } else {
+    onEnd = options.onEnd;
+  }
+
+  let buffer = new FIFO();
+  let pushable, onNext, ended;
+
+  const waitNext = () => {
+    if (!buffer.isEmpty()) {
+      if (options.writev) {
+        let next;
+        const values = [];
+        while (!buffer.isEmpty()) {
+          next = buffer.shift();
+          if (next.error) throw next.error
+          values.push(next.value);
+        }
+        return { done: next.done, value: values }
+      }
+
+      const next = buffer.shift();
+      if (next.error) throw next.error
+      return next
+    }
+
+    if (ended) return { done: true }
+
+    return new Promise((resolve, reject) => {
+      onNext = next => {
+        onNext = null;
+        if (next.error) {
+          reject(next.error);
+        } else {
+          if (options.writev && !next.done) {
+            resolve({ done: next.done, value: [next.value] });
+          } else {
+            resolve(next);
+          }
+        }
+        return pushable
+      };
+    })
+  };
+
+  const bufferNext = next => {
+    if (onNext) return onNext(next)
+    buffer.push(next);
+    return pushable
+  };
+
+  const bufferError = err => {
+    buffer = new FIFO();
+    if (onNext) return onNext({ error: err })
+    buffer.push({ error: err });
+    return pushable
+  };
+
+  const push = value => {
+    if (ended) return pushable
+    return bufferNext({ done: false, value })
+  };
+  const end = err => {
+    if (ended) return pushable
+    ended = true;
+    return err ? bufferError(err) : bufferNext({ done: true })
+  };
+  const _return = () => {
+    buffer = new FIFO();
+    end();
+    return { done: true }
+  };
+  const _throw = err => {
+    end(err);
+    return { done: true }
+  };
+
+  pushable = {
+    [Symbol.asyncIterator] () { return this },
+    next: waitNext,
+    return: _return,
+    throw: _throw,
+    push,
+    end
+  };
+
+  if (!onEnd) return pushable
+
+  const _pushable = pushable;
+
+  pushable = {
+    [Symbol.asyncIterator] () { return this },
+    next () {
+      return _pushable.next()
+    },
+    throw (err) {
+      _pushable.throw(err);
+      if (onEnd) {
+        onEnd(err);
+        onEnd = null;
+      }
+      return { done: true }
+    },
+    return () {
+      _pushable.return();
+      if (onEnd) {
+        onEnd();
+        onEnd = null;
+      }
+      return { done: true }
+    },
+    push,
+    end (err) {
+      _pushable.end(err);
+      if (onEnd) {
+        onEnd(err);
+        onEnd = null;
+      }
+      return pushable
+    }
+  };
+
+  return pushable
+};
+
+const pushable = itPushable;
+
+/**
+ * Treat one or more iterables as a single iterable.
+ *
+ * Nb. sources are iterated over in parallel so the
+ * order of emitted items is not guaranteed.
+ *
+ * @template T
+ * @param {...AsyncIterable<T>|Iterable<T>} sources
+ * @returns {AsyncIterable<T>}
+ */
+const merge = async function * (...sources) {
+  const output = pushable();
+
+  setTimeout(async () => {
+    try {
+      await Promise.all(
+        sources.map(async (source) => {
+          for await (const item of source) {
+            output.push(item);
+          }
+        })
+      );
+
+      output.end();
+    } catch (/** @type {any} */ err) {
+      output.end(err);
+    }
+  }, 0);
+
+  yield * output;
+};
+
+var itMerge = merge;
+
+const rawPipe = (...fns) => {
+    let res;
+    while (fns.length > 0) {
+        res = fns.shift()(res);
+    }
+    return res;
+};
+const isIterable = (obj) => {
+    return obj != null && (typeof obj[Symbol.asyncIterator] === 'function' ||
+        typeof obj[Symbol.iterator] === 'function' ||
+        typeof obj.next === 'function' // Probably, right?
+    );
+};
+const isDuplex = (obj) => {
+    return obj != null && typeof obj.sink === 'function' && isIterable(obj.source);
+};
+const duplexPipelineFn = (duplex) => {
+    return (source) => {
+        const p = duplex.sink(source);
+        if (p.then != null) {
+            const stream = pushable$1({
+                objectMode: true
+            });
+            p.then(() => {
+                stream.end();
+            }, (err) => {
+                stream.end(err);
+            });
+            const sourceWrap = async function* () {
+                yield* duplex.source;
+                stream.end();
+            };
+            return itMerge(stream, sourceWrap());
+        }
+        return duplex.source;
+    };
+};
+function pipe(first, ...rest) {
+    // Duplex at start: wrap in function and return duplex source
+    if (isDuplex(first)) {
+        const duplex = first;
+        first = () => duplex.source;
+        // Iterable at start: wrap in function
+    }
+    else if (isIterable(first)) {
+        const source = first;
+        first = () => source;
+    }
+    const fns = [first, ...rest];
+    if (fns.length > 1) {
+        // Duplex at end: use duplex sink
+        if (isDuplex(fns[fns.length - 1])) {
+            fns[fns.length - 1] = fns[fns.length - 1].sink;
+        }
+    }
+    if (fns.length > 2) {
+        // Duplex in the middle, consume source with duplex sink and return duplex source
+        for (let i = 1; i < fns.length - 1; i++) {
+            if (isDuplex(fns[i])) {
+                fns[i] = duplexPipelineFn(fns[i]);
+            }
+        }
+    }
+    return rawPipe(...fns);
+}
+
+function groupByContentTopic(values) {
+    const groupedDecoders = new Map();
+    values.forEach((value) => {
+        let decs = groupedDecoders.get(value.contentTopic);
+        if (!decs) {
+            groupedDecoders.set(value.contentTopic, []);
+            decs = groupedDecoders.get(value.contentTopic);
+        }
+        decs.push(value);
+    });
+    return groupedDecoders;
+}
+
+function selectConnection(connections) {
+    if (!connections.length)
+        return;
+    if (connections.length === 1)
+        return connections[0];
+    let latestConnection;
+    connections.forEach((connection) => {
+        if (connection.stat.status === "OPEN") {
+            if (!latestConnection) {
+                latestConnection = connection;
+            }
+            else if (connection.stat.timeline.open > latestConnection.stat.timeline.open) {
+                latestConnection = connection;
+            }
+        }
+    });
+    return latestConnection;
+}
+
+const log$3 = debug("waku:select-peer");
+/**
+ * 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 list of peers that supports the given protocol.
+ */
+async function getPeersForProtocol(peerStore, protocols) {
+    const peers = [];
+    await peerStore.forEach((peer) => {
+        for (let i = 0; i < protocols.length; i++) {
+            if (peer.protocols.includes(protocols[i])) {
+                peers.push(peer);
+                break;
+            }
+        }
+    });
+    return peers;
+}
+async function selectPeerForProtocol(peerStore, protocols, peerId) {
+    let peer;
+    if (peerId) {
+        peer = await peerStore.get(peerId);
+        if (!peer) {
+            log$3(`Failed to retrieve connection details for provided peer in peer store: ${peerId.toString()}`);
+            return;
+        }
+    }
+    else {
+        const peers = await getPeersForProtocol(peerStore, protocols);
+        peer = selectRandomPeer(peers);
+        if (!peer) {
+            log$3("Failed to find known peer that registers protocols", protocols);
+            return;
+        }
+    }
+    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
+        }
+    }
+    log$3(`Using codec ${protocol}`);
+    if (!protocol) {
+        log$3(`Peer does not register required protocols: ${peer.id.toString()}`, protocols);
+        return;
+    }
+    return { peer, protocol };
+}
+
+const EmptyMessage = {
+    payload: undefined,
+    contentTopic: undefined,
+    version: undefined,
+    timestamp: undefined,
+    rateLimitProof: undefined,
+};
+function toProtoMessage(wire) {
+    return { ...EmptyMessage, ...wire };
+}
+
+// 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()).
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+    // find the complete implementation of crypto (msCrypto) on IE11.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
+
+var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+function validate(uuid) {
+  return typeof uuid === 'string' && REGEX.test(uuid);
+}
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+var byteToHex = [];
+
+for (var i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).substr(1));
+}
+
+function stringify(arr) {
+  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
+  // of the following:
+  // - One or more input array values don't map to a hex octet (leading to
+  // "undefined" in the uuid)
+  // - Invalid input values for the RFC `version` or `variant` fields
+
+  if (!validate(uuid)) {
+    throw TypeError('Stringified UUID is invalid');
+  }
+
+  return uuid;
+}
+
+function parse(uuid) {
+  if (!validate(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  var v;
+  var arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 0xff;
+  arr[2] = v >>> 8 & 0xff;
+  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+  arr[11] = v / 0x100000000 & 0xff;
+  arr[12] = v >>> 24 & 0xff;
+  arr[13] = v >>> 16 & 0xff;
+  arr[14] = v >>> 8 & 0xff;
+  arr[15] = v & 0xff;
+  return arr;
+}
+
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str)); // UTF8 escape
+
+  var bytes = [];
+
+  for (var i = 0; i < str.length; ++i) {
+    bytes.push(str.charCodeAt(i));
+  }
+
+  return bytes;
+}
+
+var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+function v35 (name, version, hashfunc) {
+  function generateUUID(value, namespace, buf, offset) {
+    if (typeof value === 'string') {
+      value = stringToBytes(value);
+    }
+
+    if (typeof namespace === 'string') {
+      namespace = parse(namespace);
+    }
+
+    if (namespace.length !== 16) {
+      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+    } // Compute hash of namespace and value, Per 4.3
+    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+    // hashfunc([...namespace, ... value])`
+
+
+    var bytes = new Uint8Array(16 + value.length);
+    bytes.set(namespace);
+    bytes.set(value, namespace.length);
+    bytes = hashfunc(bytes);
+    bytes[6] = bytes[6] & 0x0f | version;
+    bytes[8] = bytes[8] & 0x3f | 0x80;
+
+    if (buf) {
+      offset = offset || 0;
+
+      for (var i = 0; i < 16; ++i) {
+        buf[offset + i] = bytes[i];
+      }
+
+      return buf;
+    }
+
+    return stringify(bytes);
+  } // Function#name is not settable on some platforms (#270)
+
+
+  try {
+    generateUUID.name = name; // eslint-disable-next-line no-empty
+  } catch (err) {} // For CommonJS default export support
+
+
+  generateUUID.DNS = DNS;
+  generateUUID.URL = URL;
+  return generateUUID;
+}
+
+/*
+ * Browser-compatible JavaScript MD5
+ *
+ * Modification of JavaScript MD5
+ * https://github.com/blueimp/JavaScript-MD5
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ *
+ * Based on
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+function md5(bytes) {
+  if (typeof bytes === 'string') {
+    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+    bytes = new Uint8Array(msg.length);
+
+    for (var i = 0; i < msg.length; ++i) {
+      bytes[i] = msg.charCodeAt(i);
+    }
+  }
+
+  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
+}
+/*
+ * Convert an array of little-endian words to an array of bytes
+ */
+
+
+function md5ToHexEncodedArray(input) {
+  var output = [];
+  var length32 = input.length * 32;
+  var hexTab = '0123456789abcdef';
+
+  for (var i = 0; i < length32; i += 8) {
+    var x = input[i >> 5] >>> i % 32 & 0xff;
+    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
+    output.push(hex);
+  }
+
+  return output;
+}
+/**
+ * Calculate output length with padding and bit length
+ */
+
+
+function getOutputLength(inputLength8) {
+  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
+}
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length.
+ */
+
+
+function wordsToMd5(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << len % 32;
+  x[getOutputLength(len) - 1] = len;
+  var a = 1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d = 271733878;
+
+  for (var i = 0; i < x.length; i += 16) {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+    a = md5ff(a, b, c, d, x[i], 7, -680876936);
+    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5gg(b, c, d, a, x[i], 20, -373897302);
+    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5hh(d, a, b, c, x[i], 11, -358537222);
+    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = md5ii(a, b, c, d, x[i], 6, -198630844);
+    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = safeAdd(a, olda);
+    b = safeAdd(b, oldb);
+    c = safeAdd(c, oldc);
+    d = safeAdd(d, oldd);
+  }
+
+  return [a, b, c, d];
+}
+/*
+ * Convert an array bytes to an array of little-endian words
+ * Characters >255 have their high-byte silently ignored.
+ */
+
+
+function bytesToWords(input) {
+  if (input.length === 0) {
+    return [];
+  }
+
+  var length8 = input.length * 8;
+  var output = new Uint32Array(getOutputLength(length8));
+
+  for (var i = 0; i < length8; i += 8) {
+    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
+  }
+
+  return output;
+}
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+
+
+function safeAdd(x, y) {
+  var lsw = (x & 0xffff) + (y & 0xffff);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xffff;
+}
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+
+
+function bitRotateLeft(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+
+
+function md5cmn(q, a, b, x, s, t) {
+  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+}
+
+function md5ff(a, b, c, d, x, s, t) {
+  return md5cmn(b & c | ~b & d, a, b, x, s, t);
+}
+
+function md5gg(a, b, c, d, x, s, t) {
+  return md5cmn(b & d | c & ~d, a, b, x, s, t);
+}
+
+function md5hh(a, b, c, d, x, s, t) {
+  return md5cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function md5ii(a, b, c, d, x, s, t) {
+  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+v35('v3', 0x30, md5);
+
+function v4(options, buf, offset) {
+  options = options || {};
+  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (var i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+
+    return buf;
+  }
+
+  return stringify(rnds);
+}
+
+// Adapted from Chris Veness' SHA1 code at
+// http://www.movable-type.co.uk/scripts/sha1.html
+function f(s, x, y, z) {
+  switch (s) {
+    case 0:
+      return x & y ^ ~x & z;
+
+    case 1:
+      return x ^ y ^ z;
+
+    case 2:
+      return x & y ^ x & z ^ y & z;
+
+    case 3:
+      return x ^ y ^ z;
+  }
+}
+
+function ROTL(x, n) {
+  return x << n | x >>> 32 - n;
+}
+
+function sha1(bytes) {
+  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+
+  if (typeof bytes === 'string') {
+    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+    bytes = [];
+
+    for (var i = 0; i < msg.length; ++i) {
+      bytes.push(msg.charCodeAt(i));
+    }
+  } else if (!Array.isArray(bytes)) {
+    // Convert Array-like to Array
+    bytes = Array.prototype.slice.call(bytes);
+  }
+
+  bytes.push(0x80);
+  var l = bytes.length / 4 + 2;
+  var N = Math.ceil(l / 16);
+  var M = new Array(N);
+
+  for (var _i = 0; _i < N; ++_i) {
+    var arr = new Uint32Array(16);
+
+    for (var j = 0; j < 16; ++j) {
+      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];
+    }
+
+    M[_i] = arr;
+  }
+
+  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
+  M[N - 1][14] = Math.floor(M[N - 1][14]);
+  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
+
+  for (var _i2 = 0; _i2 < N; ++_i2) {
+    var W = new Uint32Array(80);
+
+    for (var t = 0; t < 16; ++t) {
+      W[t] = M[_i2][t];
+    }
+
+    for (var _t = 16; _t < 80; ++_t) {
+      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);
+    }
+
+    var a = H[0];
+    var b = H[1];
+    var c = H[2];
+    var d = H[3];
+    var e = H[4];
+
+    for (var _t2 = 0; _t2 < 80; ++_t2) {
+      var s = Math.floor(_t2 / 20);
+      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;
+      e = d;
+      d = c;
+      c = ROTL(b, 30) >>> 0;
+      b = a;
+      a = T;
+    }
+
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+  }
+
+  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
+}
+
+v35('v5', 0x50, sha1);
+
+/* eslint-disable import/export */
+var FilterRequest;
+(function (FilterRequest) {
+    (function (ContentFilter) {
+        let _codec;
+        ContentFilter.codec = () => {
+            if (_codec == null) {
+                _codec = message((obj, writer, opts = {}) => {
+                    if (opts.lengthDelimited !== false) {
+                        writer.fork();
+                    }
+                    if (obj.contentTopic != null) {
+                        writer.uint32(10);
+                        writer.string(obj.contentTopic);
+                    }
+                    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.contentTopic = reader.string();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                        }
+                    }
+                    return obj;
+                });
+            }
+            return _codec;
+        };
+        ContentFilter.encode = (obj) => {
+            return encodeMessage(obj, ContentFilter.codec());
+        };
+        ContentFilter.decode = (buf) => {
+            return decodeMessage(buf, ContentFilter.codec());
+        };
+    })(FilterRequest.ContentFilter || (FilterRequest.ContentFilter = {}));
+    let _codec;
+    FilterRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.subscribe != null) {
+                    writer.uint32(8);
+                    writer.bool(obj.subscribe);
+                }
+                if (obj.topic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.topic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        writer.uint32(26);
+                        FilterRequest.ContentFilter.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "contentFilters" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    contentFilters: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.subscribe = reader.bool();
+                            break;
+                        case 2:
+                            obj.topic = reader.string();
+                            break;
+                        case 3:
+                            obj.contentFilters.push(FilterRequest.ContentFilter.codec().decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterRequest.encode = (obj) => {
+        return encodeMessage(obj, FilterRequest.codec());
+    };
+    FilterRequest.decode = (buf) => {
+        return decodeMessage(buf, FilterRequest.codec());
+    };
+})(FilterRequest || (FilterRequest = {}));
+var MessagePush;
+(function (MessagePush) {
+    let _codec;
+    MessagePush.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        writer.uint32(10);
+                        WakuMessage$2.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "messages" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    messages: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.messages.push(WakuMessage$2.codec().decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    MessagePush.encode = (obj) => {
+        return encodeMessage(obj, MessagePush.codec());
+    };
+    MessagePush.decode = (buf) => {
+        return decodeMessage(buf, MessagePush.codec());
+    };
+})(MessagePush || (MessagePush = {}));
+var FilterRPC$1;
+(function (FilterRPC) {
+    let _codec;
+    FilterRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    writer.uint32(18);
+                    FilterRequest.codec().encode(obj.request, writer);
+                }
+                if (obj.push != null) {
+                    writer.uint32(26);
+                    MessagePush.codec().encode(obj.push, writer);
+                }
+                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.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.request = FilterRequest.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.push = MessagePush.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterRPC.encode = (obj) => {
+        return encodeMessage(obj, FilterRPC.codec());
+    };
+    FilterRPC.decode = (buf) => {
+        return decodeMessage(buf, FilterRPC.codec());
+    };
+})(FilterRPC$1 || (FilterRPC$1 = {}));
+var RateLimitProof$2;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message((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$2 || (RateLimitProof$2 = {}));
+var WakuMessage$2;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((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$2.codec().encode(obj.rateLimitProof, writer);
+                }
+                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$2.codec().decode(reader, reader.uint32());
+                            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$2 || (WakuMessage$2 = {}));
+
+/**
+ * FilterRPC represents a message conforming to the Waku Filter protocol
+ */
+class FilterRPC {
+    constructor(proto) {
+        this.proto = proto;
+    }
+    static createRequest(topic, contentFilters, requestId, subscribe = true) {
+        return new FilterRPC({
+            requestId: requestId || v4(),
+            request: {
+                subscribe,
+                topic,
+                contentFilters,
+            },
+            push: undefined,
+        });
+    }
+    /**
+     *
+     * @param bytes Uint8Array of bytes from a FilterRPC message
+     * @returns FilterRPC
+     */
+    static decode(bytes) {
+        const res = FilterRPC$1.decode(bytes);
+        return new FilterRPC(res);
+    }
+    /**
+     * Encode the current FilterRPC request to bytes
+     * @returns Uint8Array
+     */
+    encode() {
+        return FilterRPC$1.encode(this.proto);
+    }
+    get push() {
+        return this.proto.push;
+    }
+    get requestId() {
+        return this.proto.requestId;
+    }
+}
+
+const FilterCodec = "/vac/waku/filter/2.0.0-beta1";
+const log$2 = debug("waku:filter");
+/**
+ * Implements client side of the [Waku v2 Filter protocol](https://rfc.vac.dev/spec/12/).
+ *
+ * Note this currently only works in NodeJS when the Waku node is listening on a port, see:
+ * - https://github.com/status-im/go-waku/issues/245
+ * - https://github.com/status-im/nwaku/issues/948
+ */
+class WakuFilter {
+    constructor(libp2p, options) {
+        this.libp2p = libp2p;
+        this.subscriptions = new Map();
+        this.decoders = new Map();
+        this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
+        this.libp2p
+            .handle(FilterCodec, this.onRequest.bind(this))
+            .catch((e) => log$2("Failed to register filter protocol", e));
+    }
+    /**
+     * @param decoders Array of Decoders to use to decode messages, it also specifies the content topics.
+     * @param callback A function that will be called on each message returned by the filter.
+     * @param opts The FilterSubscriptionOpts used to narrow which messages are returned, and which peer to connect to.
+     * @returns Unsubscribe function that can be used to end the subscription.
+     */
+    async subscribe(decoders, callback, opts) {
+        const topic = opts?.pubSubTopic ?? this.pubSubTopic;
+        const groupedDecoders = groupByContentTopic(decoders);
+        const contentTopics = Array.from(groupedDecoders.keys());
+        const contentFilters = contentTopics.map((contentTopic) => ({
+            contentTopic,
+        }));
+        const request = FilterRPC.createRequest(topic, contentFilters, undefined, true);
+        const requestId = request.requestId;
+        if (!requestId)
+            throw new Error("Internal error: createRequest expected to set `requestId`");
+        const peer = await this.getPeer(opts?.peerId);
+        const stream = await this.newStream(peer);
+        try {
+            const res = await pipe([request.encode()], encode(), stream, decode(), async (source) => await itAll(source));
+            log$2("response", res);
+        }
+        catch (e) {
+            log$2("Error subscribing to peer ", peer.id.toString(), "for content topics", contentTopics, ": ", e);
+            throw e;
+        }
+        this.addDecoders(groupedDecoders);
+        this.addCallback(requestId, callback);
+        return async () => {
+            await this.unsubscribe(topic, contentFilters, requestId, peer);
+            this.deleteDecoders(groupedDecoders);
+            this.deleteCallback(requestId);
+        };
+    }
+    onRequest(streamData) {
+        log$2("Receiving message push");
+        try {
+            pipe(streamData.stream, decode(), async (source) => {
+                for await (const bytes of source) {
+                    const res = FilterRPC.decode(bytes.slice());
+                    if (res.requestId && res.push?.messages?.length) {
+                        await this.pushMessages(res.requestId, res.push.messages);
+                    }
+                }
+            }).then(() => {
+                log$2("Receiving pipe closed.");
+            }, (e) => {
+                log$2("Error with receiving pipe", e);
+            });
+        }
+        catch (e) {
+            log$2("Error decoding message", e);
+        }
+    }
+    async pushMessages(requestId, messages) {
+        const callback = this.subscriptions.get(requestId);
+        if (!callback) {
+            log$2(`No callback registered for request ID ${requestId}`);
+            return;
+        }
+        for (const protoMessage of messages) {
+            const contentTopic = protoMessage.contentTopic;
+            if (!contentTopic) {
+                log$2("Message has no content topic, skipping");
+                return;
+            }
+            const decoders = this.decoders.get(contentTopic);
+            if (!decoders) {
+                log$2("No decoder for", contentTopic);
+                return;
+            }
+            let msg;
+            // We don't want to wait for decoding failure, just attempt to decode
+            // all messages and do the call back on the one that works
+            // noinspection ES6MissingAwait
+            decoders.forEach(async (dec) => {
+                if (msg)
+                    return;
+                const decoded = await dec.fromProtoObj(toProtoMessage(protoMessage));
+                if (!decoded) {
+                    log$2("Not able to decode message");
+                    return;
+                }
+                // This is just to prevent more decoding attempt
+                // TODO: Could be better if we were to abort promises
+                msg = decoded;
+                await callback(decoded);
+            });
+        }
+    }
+    addCallback(requestId, callback) {
+        this.subscriptions.set(requestId, callback);
+    }
+    deleteCallback(requestId) {
+        this.subscriptions.delete(requestId);
+    }
+    addDecoders(decoders) {
+        decoders.forEach((decoders, contentTopic) => {
+            const currDecs = this.decoders.get(contentTopic);
+            if (!currDecs) {
+                this.decoders.set(contentTopic, new Set(decoders));
+            }
+            else {
+                this.decoders.set(contentTopic, new Set([...currDecs, ...decoders]));
+            }
+        });
+    }
+    deleteDecoders(decoders) {
+        decoders.forEach((decoders, contentTopic) => {
+            const currDecs = this.decoders.get(contentTopic);
+            if (currDecs) {
+                decoders.forEach((dec) => {
+                    currDecs.delete(dec);
+                });
+            }
+        });
+    }
+    async unsubscribe(topic, contentFilters, requestId, peer) {
+        const unsubscribeRequest = FilterRPC.createRequest(topic, contentFilters, requestId, false);
+        const stream = await this.newStream(peer);
+        try {
+            await pipe([unsubscribeRequest.encode()], encode(), stream.sink);
+        }
+        catch (e) {
+            log$2("Error unsubscribing", e);
+            throw e;
+        }
+    }
+    async newStream(peer) {
+        const connections = this.libp2p.connectionManager.getConnections(peer.id);
+        const connection = selectConnection(connections);
+        if (!connection) {
+            throw new Error("Failed to get a connection to the peer");
+        }
+        return connection.newStream(FilterCodec);
+    }
+    async getPeer(peerId) {
+        const res = await selectPeerForProtocol(this.libp2p.peerStore, [FilterCodec], peerId);
+        if (!res) {
+            throw new Error(`Failed to select peer for ${FilterCodec}`);
+        }
+        return res.peer;
+    }
+    async peers() {
+        return getPeersForProtocol(this.libp2p.peerStore, [FilterCodec]);
+    }
+    async randomPeer() {
+        return selectRandomPeer(await this.peers());
+    }
+}
+
+var index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FilterCodec: FilterCodec,
+    WakuFilter: WakuFilter
+});
+
+/* eslint-disable import/export */
+var PushRequest;
+(function (PushRequest) {
+    let _codec;
+    PushRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pubSubTopic != null) {
+                    writer.uint32(10);
+                    writer.string(obj.pubSubTopic);
+                }
+                if (obj.message != null) {
+                    writer.uint32(18);
+                    WakuMessage$1.codec().encode(obj.message, writer);
+                }
+                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.pubSubTopic = reader.string();
+                            break;
+                        case 2:
+                            obj.message = WakuMessage$1.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushRequest.encode = (obj) => {
+        return encodeMessage(obj, PushRequest.codec());
+    };
+    PushRequest.decode = (buf) => {
+        return decodeMessage(buf, PushRequest.codec());
+    };
+})(PushRequest || (PushRequest = {}));
+var PushResponse;
+(function (PushResponse) {
+    let _codec;
+    PushResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.isSuccess != null) {
+                    writer.uint32(8);
+                    writer.bool(obj.isSuccess);
+                }
+                if (obj.info != null) {
+                    writer.uint32(18);
+                    writer.string(obj.info);
+                }
+                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.isSuccess = reader.bool();
+                            break;
+                        case 2:
+                            obj.info = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushResponse.encode = (obj) => {
+        return encodeMessage(obj, PushResponse.codec());
+    };
+    PushResponse.decode = (buf) => {
+        return decodeMessage(buf, PushResponse.codec());
+    };
+})(PushResponse || (PushResponse = {}));
+var PushRPC$1;
+(function (PushRPC) {
+    let _codec;
+    PushRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    writer.uint32(18);
+                    PushRequest.codec().encode(obj.request, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(26);
+                    PushResponse.codec().encode(obj.response, writer);
+                }
+                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.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.request = PushRequest.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.response = PushResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushRPC.encode = (obj) => {
+        return encodeMessage(obj, PushRPC.codec());
+    };
+    PushRPC.decode = (buf) => {
+        return decodeMessage(buf, PushRPC.codec());
+    };
+})(PushRPC$1 || (PushRPC$1 = {}));
+var RateLimitProof$1;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message((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$1 || (RateLimitProof$1 = {}));
+var WakuMessage$1;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((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$1.codec().encode(obj.rateLimitProof, writer);
+                }
+                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$1.codec().decode(reader, reader.uint32());
+                            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$1 || (WakuMessage$1 = {}));
+
+class PushRPC {
+    constructor(proto) {
+        this.proto = proto;
+    }
+    static createRequest(message, pubSubTopic) {
+        return new PushRPC({
+            requestId: v4(),
+            request: {
+                message: message,
+                pubSubTopic: pubSubTopic,
+            },
+            response: undefined,
+        });
+    }
+    static decode(bytes) {
+        const res = PushRPC$1.decode(bytes);
+        return new PushRPC(res);
+    }
+    encode() {
+        return PushRPC$1.encode(this.proto);
+    }
+    get query() {
+        return this.proto.request;
+    }
+    get response() {
+        return this.proto.response;
+    }
+}
+
+const log$1 = debug("waku:light-push");
+const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
+/**
+ * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
+ */
+class WakuLightPush {
+    constructor(libp2p, options) {
+        this.libp2p = libp2p;
+        this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
+    }
+    async push(encoder, message, opts) {
+        const pubSubTopic = opts?.pubSubTopic ? opts.pubSubTopic : this.pubSubTopic;
+        const res = await selectPeerForProtocol(this.libp2p.peerStore, [LightPushCodec], opts?.peerId);
+        if (!res) {
+            throw new Error("Failed to get a peer");
+        }
+        const { peer } = res;
+        const connections = this.libp2p.connectionManager.getConnections(peer.id);
+        const connection = selectConnection(connections);
+        if (!connection)
+            throw "Failed to get a connection to the peer";
+        const stream = await connection.newStream(LightPushCodec);
+        const recipients = [];
+        try {
+            const protoMessage = await encoder.toProtoObj(message);
+            if (!protoMessage) {
+                log$1("Failed to encode to protoMessage, aborting push");
+                return { recipients };
+            }
+            const query = PushRPC.createRequest(protoMessage, pubSubTopic);
+            const res = await pipe([query.encode()], encode(), stream, decode(), async (source) => await itAll(source));
+            try {
+                const bytes = new Uint8ArrayList();
+                res.forEach((chunk) => {
+                    bytes.append(chunk);
+                });
+                const response = PushRPC.decode(bytes).response;
+                if (!response) {
+                    log$1("No response in PushRPC");
+                    return { recipients };
+                }
+                if (response.isSuccess) {
+                    recipients.push(peer.id);
+                }
+            }
+            catch (err) {
+                log$1("Failed to decode push reply", err);
+            }
+        }
+        catch (err) {
+            log$1("Failed to send waku light push request", err);
+        }
+        return { recipients };
+    }
+    /**
+     * Returns known peers from the address book (`libp2p.peerStore`) that support
+     * light push protocol. Waku may or may not be currently connected to these
+     * peers.
+     */
+    async peers() {
+        return getPeersForProtocol(this.libp2p.peerStore, [LightPushCodec]);
+    }
+    /**
+     * Returns a random peer that supports light push protocol from the address
+     * book (`libp2p.peerStore`). Waku may or  may not be currently connected to
+     * this peer.
+     */
+    async randomPeer() {
+        return selectRandomPeer(await this.peers());
+    }
+}
+
+var index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LightPushCodec: LightPushCodec,
+    get PushResponse () { return PushResponse; },
+    WakuLightPush: WakuLightPush
+});
+
+/* eslint-disable import/export */
+var Index;
+(function (Index) {
+    let _codec;
+    Index.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.digest != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.digest);
+                }
+                if (obj.receivedTime != null) {
+                    writer.uint32(16);
+                    writer.sint64(obj.receivedTime);
+                }
+                if (obj.senderTime != null) {
+                    writer.uint32(24);
+                    writer.sint64(obj.senderTime);
+                }
+                if (obj.pubsubTopic != null) {
+                    writer.uint32(34);
+                    writer.string(obj.pubsubTopic);
+                }
+                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.digest = reader.bytes();
+                            break;
+                        case 2:
+                            obj.receivedTime = reader.sint64();
+                            break;
+                        case 3:
+                            obj.senderTime = reader.sint64();
+                            break;
+                        case 4:
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    Index.encode = (obj) => {
+        return encodeMessage(obj, Index.codec());
+    };
+    Index.decode = (buf) => {
+        return decodeMessage(buf, Index.codec());
+    };
+})(Index || (Index = {}));
+var PagingInfo;
+(function (PagingInfo) {
+    (function (Direction) {
+        Direction["DIRECTION_BACKWARD_UNSPECIFIED"] = "DIRECTION_BACKWARD_UNSPECIFIED";
+        Direction["DIRECTION_FORWARD"] = "DIRECTION_FORWARD";
+    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let __DirectionValues;
+    (function (__DirectionValues) {
+        __DirectionValues[__DirectionValues["DIRECTION_BACKWARD_UNSPECIFIED"] = 0] = "DIRECTION_BACKWARD_UNSPECIFIED";
+        __DirectionValues[__DirectionValues["DIRECTION_FORWARD"] = 1] = "DIRECTION_FORWARD";
+    })(__DirectionValues || (__DirectionValues = {}));
+    (function (Direction) {
+        Direction.codec = () => {
+            return enumeration(__DirectionValues);
+        };
+    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let _codec;
+    PagingInfo.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pageSize != null) {
+                    writer.uint32(8);
+                    writer.uint64(obj.pageSize);
+                }
+                if (obj.cursor != null) {
+                    writer.uint32(18);
+                    Index.codec().encode(obj.cursor, writer);
+                }
+                if (obj.direction != null) {
+                    writer.uint32(24);
+                    PagingInfo.Direction.codec().encode(obj.direction, writer);
+                }
+                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.pageSize = reader.uint64();
+                            break;
+                        case 2:
+                            obj.cursor = Index.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.direction = PagingInfo.Direction.codec().decode(reader);
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PagingInfo.encode = (obj) => {
+        return encodeMessage(obj, PagingInfo.codec());
+    };
+    PagingInfo.decode = (buf) => {
+        return decodeMessage(buf, PagingInfo.codec());
+    };
+})(PagingInfo || (PagingInfo = {}));
+var ContentFilter;
+(function (ContentFilter) {
+    let _codec;
+    ContentFilter.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(10);
+                    writer.string(obj.contentTopic);
+                }
+                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.contentTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    ContentFilter.encode = (obj) => {
+        return encodeMessage(obj, ContentFilter.codec());
+    };
+    ContentFilter.decode = (buf) => {
+        return decodeMessage(buf, ContentFilter.codec());
+    };
+})(ContentFilter || (ContentFilter = {}));
+var HistoryQuery;
+(function (HistoryQuery) {
+    let _codec;
+    HistoryQuery.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pubSubTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.pubSubTopic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        writer.uint32(26);
+                        ContentFilter.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "contentFilters" was not found in object');
+                }
+                if (obj.pagingInfo != null) {
+                    writer.uint32(34);
+                    PagingInfo.codec().encode(obj.pagingInfo, writer);
+                }
+                if (obj.startTime != null) {
+                    writer.uint32(40);
+                    writer.sint64(obj.startTime);
+                }
+                if (obj.endTime != null) {
+                    writer.uint32(48);
+                    writer.sint64(obj.endTime);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    contentFilters: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.pubSubTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32()));
+                            break;
+                        case 4:
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                            break;
+                        case 5:
+                            obj.startTime = reader.sint64();
+                            break;
+                        case 6:
+                            obj.endTime = reader.sint64();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryQuery.encode = (obj) => {
+        return encodeMessage(obj, HistoryQuery.codec());
+    };
+    HistoryQuery.decode = (buf) => {
+        return decodeMessage(buf, HistoryQuery.codec());
+    };
+})(HistoryQuery || (HistoryQuery = {}));
+var HistoryResponse;
+(function (HistoryResponse) {
+    (function (HistoryError) {
+        HistoryError["ERROR_NONE_UNSPECIFIED"] = "ERROR_NONE_UNSPECIFIED";
+        HistoryError["ERROR_INVALID_CURSOR"] = "ERROR_INVALID_CURSOR";
+    })(HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let __HistoryErrorValues;
+    (function (__HistoryErrorValues) {
+        __HistoryErrorValues[__HistoryErrorValues["ERROR_NONE_UNSPECIFIED"] = 0] = "ERROR_NONE_UNSPECIFIED";
+        __HistoryErrorValues[__HistoryErrorValues["ERROR_INVALID_CURSOR"] = 1] = "ERROR_INVALID_CURSOR";
+    })(__HistoryErrorValues || (__HistoryErrorValues = {}));
+    (function (HistoryError) {
+        HistoryError.codec = () => {
+            return enumeration(__HistoryErrorValues);
+        };
+    })(HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let _codec;
+    HistoryResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        writer.uint32(18);
+                        WakuMessage.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "messages" was not found in object');
+                }
+                if (obj.pagingInfo != null) {
+                    writer.uint32(26);
+                    PagingInfo.codec().encode(obj.pagingInfo, writer);
+                }
+                if (obj.error != null) {
+                    writer.uint32(32);
+                    HistoryResponse.HistoryError.codec().encode(obj.error, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    messages: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32()));
+                            break;
+                        case 3:
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                            break;
+                        case 4:
+                            obj.error = HistoryResponse.HistoryError.codec().decode(reader);
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryResponse.encode = (obj) => {
+        return encodeMessage(obj, HistoryResponse.codec());
+    };
+    HistoryResponse.decode = (buf) => {
+        return decodeMessage(buf, HistoryResponse.codec());
+    };
+})(HistoryResponse || (HistoryResponse = {}));
+var HistoryRPC$1;
+(function (HistoryRPC) {
+    let _codec;
+    HistoryRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.query != null) {
+                    writer.uint32(18);
+                    HistoryQuery.codec().encode(obj.query, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(26);
+                    HistoryResponse.codec().encode(obj.response, writer);
+                }
+                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.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.query = HistoryQuery.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.response = HistoryResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryRPC.encode = (obj) => {
+        return encodeMessage(obj, HistoryRPC.codec());
+    };
+    HistoryRPC.decode = (buf) => {
+        return decodeMessage(buf, HistoryRPC.codec());
+    };
+})(HistoryRPC$1 || (HistoryRPC$1 = {}));
+var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message((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((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 (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;
+                        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 = {}));
+
+const OneMillion = BigInt(1000000);
+var PageDirection;
+(function (PageDirection) {
+    PageDirection["BACKWARD"] = "backward";
+    PageDirection["FORWARD"] = "forward";
+})(PageDirection || (PageDirection = {}));
+class HistoryRPC {
+    constructor(proto) {
+        this.proto = proto;
+    }
+    get query() {
+        return this.proto.query;
+    }
+    get response() {
+        return this.proto.response;
+    }
+    /**
+     * Create History Query.
+     */
+    static createQuery(params) {
+        const contentFilters = params.contentTopics.map((contentTopic) => {
+            return { contentTopic };
+        });
+        const direction = directionToProto(params.pageDirection);
+        const pagingInfo = {
+            pageSize: BigInt(params.pageSize),
+            cursor: params.cursor,
+            direction,
+        };
+        let startTime, endTime;
+        if (params.startTime) {
+            // milliseconds 10^-3 to nanoseconds 10^-9
+            startTime = BigInt(params.startTime.valueOf()) * OneMillion;
+        }
+        if (params.endTime) {
+            // milliseconds 10^-3 to nanoseconds 10^-9
+            endTime = BigInt(params.endTime.valueOf()) * OneMillion;
+        }
+        return new HistoryRPC({
+            requestId: v4(),
+            query: {
+                pubSubTopic: params.pubSubTopic,
+                contentFilters,
+                pagingInfo,
+                startTime,
+                endTime,
+            },
+            response: undefined,
+        });
+    }
+    decode(bytes) {
+        const res = HistoryRPC$1.decode(bytes);
+        return new HistoryRPC(res);
+    }
+    encode() {
+        return HistoryRPC$1.encode(this.proto);
+    }
+}
+function directionToProto(pageDirection) {
+    switch (pageDirection) {
+        case PageDirection.BACKWARD:
+            return PagingInfo.Direction.DIRECTION_BACKWARD_UNSPECIFIED;
+        case PageDirection.FORWARD:
+            return PagingInfo.Direction.DIRECTION_FORWARD;
+        default:
+            return PagingInfo.Direction.DIRECTION_BACKWARD_UNSPECIFIED;
+    }
+}
+
+var HistoryError = HistoryResponse.HistoryError;
+const log = debug("waku:store");
+const StoreCodec = "/vac/waku/store/2.0.0-beta4";
+const DefaultPageSize = 10;
+/**
+ * Implements the [Waku v2 Store protocol](https://rfc.vac.dev/spec/13/).
+ *
+ * The Waku Store protocol can be used to retrieved historical messages.
+ */
+class WakuStore {
+    constructor(libp2p, options) {
+        this.libp2p = libp2p;
+        this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
+    }
+    /**
+     * Do a query to a Waku Store to retrieve historical/missed messages.
+     *
+     * The callback function takes a `WakuMessage` in input,
+     * messages are processed in order:
+     * - oldest to latest if `options.pageDirection` == { @link PageDirection.FORWARD }
+     * - latest to oldest if `options.pageDirection` == { @link PageDirection.BACKWARD }
+     *
+     * The ordering may affect performance.
+     * The ordering depends on the behavior of the remote store node.
+     * If strong ordering is needed, you may need to handle this at application level
+     * and set your own timestamps too (the WakuMessage timestamps are not certified).
+     *
+     * @throws If not able to reach a Waku Store peer to query,
+     * or if an error is encountered when processing the reply,
+     * or if two decoders with the same content topic are passed.
+     */
+    async queryOrderedCallback(decoders, callback, options) {
+        let abort = false;
+        for await (const promises of this.queryGenerator(decoders, options)) {
+            if (abort)
+                break;
+            const messagesOrUndef = await Promise.all(promises);
+            let messages = messagesOrUndef.filter(isDefined);
+            // Messages in pages are ordered from oldest (first) to most recent (last).
+            // https://github.com/vacp2p/rfc/issues/533
+            if (typeof options?.pageDirection === "undefined" ||
+                options?.pageDirection === PageDirection.BACKWARD) {
+                messages = messages.reverse();
+            }
+            await Promise.all(messages.map(async (msg) => {
+                if (msg && !abort) {
+                    abort = Boolean(await callback(msg));
+                }
+            }));
+        }
+    }
+    /**
+     * Do a query to a Waku Store to retrieve historical/missed messages.
+     *
+     * The callback function takes a `Promise<WakuMessage>` in input,
+     * useful if messages needs to be decrypted and performance matters.
+     *
+     * The order of the messages passed to the callback is as follows:
+     * - within a page, messages are expected to be ordered from oldest to most recent
+     * - pages direction depends on { @link QueryOptions.pageDirection }
+     *
+     * Do note that the resolution of the `Promise<WakuMessage | undefined` may
+     * break the order as it may rely on the browser decryption API, which in turn,
+     * may have a different speed depending on the type of decryption.
+     *
+     * @throws If not able to reach a Waku Store peer to query,
+     * or if an error is encountered when processing the reply,
+     * or if two decoders with the same content topic are passed.
+     */
+    async queryCallbackOnPromise(decoders, callback, options) {
+        let abort = false;
+        let promises = [];
+        for await (const page of this.queryGenerator(decoders, options)) {
+            const _promises = page.map(async (msg) => {
+                if (!abort) {
+                    abort = Boolean(await callback(msg));
+                }
+            });
+            promises = promises.concat(_promises);
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Do a query to a Waku Store to retrieve historical/missed messages.
+     *
+     * This is a generator, useful if you want most control on how messages
+     * are processed.
+     *
+     * The order of the messages returned by the remote Waku node SHOULD BE
+     * as follows:
+     * - within a page, messages SHOULD be ordered from oldest to most recent
+     * - pages direction depends on { @link QueryOptions.pageDirection }
+     *
+     * However, there is no way to guarantee the behavior of the remote node.
+     *
+     * @throws If not able to reach a Waku Store peer to query,
+     * or if an error is encountered when processing the reply,
+     * or if two decoders with the same content topic are passed.
+     */
+    async *queryGenerator(decoders, options) {
+        let startTime, endTime;
+        if (options?.timeFilter) {
+            startTime = options.timeFilter.startTime;
+            endTime = options.timeFilter.endTime;
+        }
+        const decodersAsMap = new Map();
+        decoders.forEach((dec) => {
+            if (decodersAsMap.has(dec.contentTopic)) {
+                throw new Error("API does not support different decoder per content topic");
+            }
+            decodersAsMap.set(dec.contentTopic, dec);
+        });
+        const contentTopics = decoders.map((dec) => dec.contentTopic);
+        const queryOpts = Object.assign({
+            pubSubTopic: this.pubSubTopic,
+            pageDirection: PageDirection.BACKWARD,
+            pageSize: DefaultPageSize,
+        }, options, { contentTopics, startTime, endTime });
+        log("Querying history with the following options", {
+            peerId: options?.peerId?.toString(),
+            ...options,
+        });
+        const res = await selectPeerForProtocol(this.libp2p.peerStore, [StoreCodec], options?.peerId);
+        if (!res) {
+            throw new Error("Failed to get a peer");
+        }
+        const { peer, protocol } = res;
+        const connections = this.libp2p.connectionManager.getConnections(peer.id);
+        const connection = selectConnection(connections);
+        if (!connection)
+            throw "Failed to get a connection to the peer";
+        for await (const messages of paginate(connection, protocol, queryOpts, decodersAsMap)) {
+            yield messages;
+        }
+    }
+    /**
+     * Returns known peers from the address book (`libp2p.peerStore`) that support
+     * store protocol. Waku may or  may not be currently connected to these peers.
+     */
+    async peers() {
+        return getPeersForProtocol(this.libp2p.peerStore, [StoreCodec]);
+    }
+}
+async function* paginate(connection, protocol, queryOpts, decoders) {
+    if (queryOpts.contentTopics.toString() !==
+        Array.from(decoders.keys()).toString()) {
+        throw new Error("Internal error, the decoders should match the query's content topics");
+    }
+    let cursor = undefined;
+    while (true) {
+        queryOpts = Object.assign(queryOpts, { cursor });
+        const stream = await connection.newStream(protocol);
+        const historyRpcQuery = HistoryRPC.createQuery(queryOpts);
+        log("Querying store peer", connection.remoteAddr.toString(), `for (${queryOpts.pubSubTopic})`, queryOpts.contentTopics);
+        const res = await pipe([historyRpcQuery.encode()], encode(), stream, decode(), async (source) => await itAll(source));
+        const bytes = new Uint8ArrayList();
+        res.forEach((chunk) => {
+            bytes.append(chunk);
+        });
+        const reply = historyRpcQuery.decode(bytes);
+        if (!reply.response) {
+            log("Stopping pagination due to store `response` field missing");
+            break;
+        }
+        const response = reply.response;
+        if (response.error &&
+            response.error !== HistoryError.ERROR_NONE_UNSPECIFIED) {
+            throw "History response contains an Error: " + response.error;
+        }
+        if (!response.messages || !response.messages.length) {
+            log("Stopping pagination due to store `response.messages` field missing or empty");
+            break;
+        }
+        log(`${response.messages.length} messages retrieved from store`);
+        yield response.messages.map((protoMsg) => {
+            const contentTopic = protoMsg.contentTopic;
+            if (typeof contentTopic !== "undefined") {
+                const decoder = decoders.get(contentTopic);
+                if (decoder) {
+                    return decoder.fromProtoObj(toProtoMessage(protoMsg));
+                }
+            }
+            return Promise.resolve(undefined);
+        });
+        cursor = response.pagingInfo?.cursor;
+        if (typeof cursor === "undefined") {
+            // If the server does not return cursor then there is an issue,
+            // Need to abort, or we end up in an infinite loop
+            log("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
+            break;
+        }
+        const responsePageSize = response.pagingInfo?.pageSize;
+        const queryPageSize = historyRpcQuery.query?.pagingInfo?.pageSize;
+        if (
+        // Response page size smaller than query, meaning this is the last page
+        responsePageSize &&
+            queryPageSize &&
+            responsePageSize < queryPageSize) {
+            break;
+        }
+    }
+}
+function isDefined(msg) {
+    return !!msg;
+}
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    StoreCodec: StoreCodec,
+    DefaultPageSize: DefaultPageSize,
+    get PageDirection () { return PageDirection; },
+    WakuStore: WakuStore,
+    isDefined: isDefined
+});
+
+export { DefaultPubSubTopic as D, FilterCodec as F, LightPushCodec as L, Protocols as P, StoreCodec as S, Uint8ArrayList as U, WakuFilter as W, pipe as a, index$1 as b, WakuLightPush as c, decode as d, encode as e, PushResponse as f, index as g, PageDirection as h, index$2 as i, WakuStore as j, pushable$1 as p, unsigned as u };