@waku/core 0.0.5 → 0.0.7

package/bundle/index-a67d7136.js

@@ -1,4059 +0,0 @@
-import { d as debug } from './browser-1e1a2f27.js';
-import { i as createCodec, C as CODEC_TYPES, m as message, j as encodeMessage, k as decodeMessage } from './message-049c8b67.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 };