@waku/core 0.0.5 → 0.0.6

package/bundle/{index-a67d7136.js → index-925587a4.js}

@@ -1,33 +1,10 @@
-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';
+import { d as debug, j as createCodec$1, C as CODEC_TYPES, m as message, k as encodeMessage, l as decodeMessage } from './message-70dbb19b.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";
@@ -63,7 +40,7 @@ var itAll = all;
  * To guarantee Uint8Array semantics, convert nodejs Buffers
  * into vanilla Uint8Arrays
  */
-function asUint8Array$1(buf) {
+function asUint8Array(buf) {
     if (globalThis.Buffer != null) {
         return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
     }
@@ -76,7 +53,7 @@ function asUint8Array$1(buf) {
  */
 function alloc(size = 0) {
     if (globalThis.Buffer?.alloc != null) {
-        return asUint8Array$1(globalThis.Buffer.alloc(size));
+        return asUint8Array(globalThis.Buffer.alloc(size));
     }
     return new Uint8Array(size);
 }
@@ -85,9 +62,9 @@ function alloc(size = 0) {
  * uninitialized memory. Only use if you are certain you will immediately
  * overwrite every value in the returned `Uint8Array`.
  */
-function allocUnsafe$2(size = 0) {
+function allocUnsafe$1(size = 0) {
     if (globalThis.Buffer?.allocUnsafe != null) {
-        return asUint8Array$1(globalThis.Buffer.allocUnsafe(size));
+        return asUint8Array(globalThis.Buffer.allocUnsafe(size));
     }
     return new Uint8Array(size);
 }
@@ -95,23 +72,23 @@ function allocUnsafe$2(size = 0) {
 /**
  * Returns a new Uint8Array created by concatenating the passed ArrayLikes
  */
-function concat(arrays, length) {
+function concat$1(arrays, length) {
     if (length == null) {
         length = arrays.reduce((acc, curr) => acc + curr.length, 0);
     }
-    const output = allocUnsafe$2(length);
+    const output = allocUnsafe$1(length);
     let offset = 0;
     for (const arr of arrays) {
         output.set(arr, offset);
         offset += arr.length;
     }
-    return asUint8Array$1(output);
+    return asUint8Array(output);
 }
 
 /**
  * Returns true if the two passed Uint8Arrays have the same content
  */
-function equals(a, b) {
+function equals$2(a, b) {
     if (a === b) {
         return true;
     }
@@ -281,7 +258,7 @@ class Uint8ArrayList {
      */
     slice(beginInclusive, endExclusive) {
         const { bufs, length } = this._subList(beginInclusive, endExclusive);
-        return concat(bufs, length);
+        return concat$1(bufs, length);
     }
     /**
      * Returns a alloc from the given start and end element index.
@@ -294,7 +271,7 @@ class Uint8ArrayList {
         if (bufs.length === 1) {
             return bufs[0];
         }
-        return concat(bufs, length);
+        return concat$1(bufs, length);
     }
     /**
      * Returns a allocList from the given start and end element index.
@@ -385,7 +362,7 @@ class Uint8ArrayList {
         return view.getInt8(0);
     }
     setInt8(byteOffset, value) {
-        const buf = allocUnsafe$2(1);
+        const buf = allocUnsafe$1(1);
         const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
         view.setInt8(0, value);
         this.write(buf, byteOffset);
@@ -429,7 +406,7 @@ class Uint8ArrayList {
         return view.getUint8(0);
     }
     setUint8(byteOffset, value) {
-        const buf = allocUnsafe$2(1);
+        const buf = allocUnsafe$1(1);
         const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
         view.setUint8(0, value);
         this.write(buf, byteOffset);
@@ -500,7 +477,7 @@ class Uint8ArrayList {
             return false;
         }
         for (let i = 0; i < this.bufs.length; i++) {
-            if (!equals(this.bufs[i], other.bufs[i])) {
+            if (!equals$2(this.bufs[i], other.bufs[i])) {
                 return false;
             }
         }
@@ -720,65 +697,42 @@ class LongBits {
     }
 }
 
-/**
- * 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 N1$1 = Math.pow(2, 7);
+const N2$1 = Math.pow(2, 14);
+const N3$1 = Math.pow(2, 21);
+const N4$1 = Math.pow(2, 28);
+const N5$1 = Math.pow(2, 35);
+const N6$1 = Math.pow(2, 42);
+const N7$1 = Math.pow(2, 49);
+const N8$1 = Math.pow(2, 56);
+const N9$1 = Math.pow(2, 63);
 const unsigned = {
     encodingLength(value) {
-        if (value < N1) {
+        if (value < N1$1) {
             return 1;
         }
-        if (value < N2) {
+        if (value < N2$1) {
             return 2;
         }
-        if (value < N3) {
+        if (value < N3$1) {
             return 3;
         }
-        if (value < N4) {
+        if (value < N4$1) {
             return 4;
         }
-        if (value < N5) {
+        if (value < N5$1) {
             return 5;
         }
-        if (value < N6) {
+        if (value < N6$1) {
             return 6;
         }
-        if (value < N7) {
+        if (value < N7$1) {
             return 7;
         }
-        if (value < N8) {
+        if (value < N8$1) {
             return 8;
         }
-        if (value < N9) {
+        if (value < N9$1) {
             return 9;
         }
         return 10;
@@ -813,7 +767,7 @@ const defaultEncoder = (length) => {
     return lengthBuf;
 };
 defaultEncoder.bytes = 0;
-function encode(options) {
+function encode$4(options) {
     options = options ?? {};
     const encodeLength = options.lengthEncoder ?? defaultEncoder;
     const encoder = async function* (source) {
@@ -838,12 +792,80 @@ function encode(options) {
     };
     return encoder;
 }
-encode.single = (chunk, options) => {
+encode$4.single = (chunk, options) => {
     options = options ?? {};
     const encodeLength = options.lengthEncoder ?? defaultEncoder;
     return new Uint8ArrayList(encodeLength(chunk.byteLength), chunk);
 };
 
+/**
+ * @typedef {{ [key: string]: any }} Extensions
+ * @typedef {Error} Err
+ * @property {string} message
+ */
+
+/**
+ *
+ * @param {Error} obj
+ * @param {Extensions} props
+ * @returns {Error & Extensions}
+ */
+function assign(obj, props) {
+    for (const key in props) {
+        Object.defineProperty(obj, key, {
+            value: props[key],
+            enumerable: true,
+            configurable: true,
+        });
+    }
+
+    return obj;
+}
+
+/**
+ *
+ * @param {any} err - An Error
+ * @param {string|Extensions} code - A string code or props to set on the error
+ * @param {Extensions} [props] - Props to set on the error
+ * @returns {Error & Extensions}
+ */
+function createError(err, code, props) {
+    if (!err || typeof err === 'string') {
+        throw new TypeError('Please pass an Error to err-code');
+    }
+
+    if (!props) {
+        props = {};
+    }
+
+    if (typeof code === 'object') {
+        props = code;
+        code = '';
+    }
+
+    if (code) {
+        props.code = code;
+    }
+
+    try {
+        return assign(err, props);
+    } catch (_) {
+        props.message = err.message;
+        props.stack = err.stack;
+
+        const ErrClass = function () {};
+
+        ErrClass.prototype = Object.create(Object.getPrototypeOf(err));
+
+        // @ts-ignore
+        const output = assign(new ErrClass(), props);
+
+        return output;
+    }
+}
+
+var errCode = createError;
+
 /* 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
@@ -860,7 +882,7 @@ const defaultDecoder = (buf) => {
     return length;
 };
 defaultDecoder.bytes = 0;
-function decode(options) {
+function decode$5(options) {
     const decoder = async function* (source) {
         const buffer = new Uint8ArrayList();
         let mode = ReadMode.LENGTH;
@@ -924,7 +946,7 @@ function decode(options) {
  * @param {import('./types').DecoderOptions} [options]
  * @returns
  */
-decode.fromReader = (reader, options) => {
+decode$5.fromReader = (reader, options) => {
     let byteLength = 1; // Read single byte chunks until the length is known
     const varByteSource = (async function* () {
         while (true) {
@@ -953,7 +975,7 @@ decode.fromReader = (reader, options) => {
      * Once the length has been parsed, read chunk for that length
      */
     const onLength = (l) => { byteLength = l; };
-    return decode({
+    return decode$5({
         ...(options ?? {}),
         onLength
     })(varByteSource);
@@ -1572,6 +1594,7 @@ const EmptyMessage = {
     version: undefined,
     timestamp: undefined,
     rateLimitProof: undefined,
+    ephemeral: undefined,
 };
 function toProtoMessage(wire) {
     return { ...EmptyMessage, ...wire };
@@ -2058,6 +2081,27 @@ function sha1(bytes) {
 
 v35('v5', 0x50, sha1);
 
+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$1('enum', CODEC_TYPES.VARINT, encode, decode);
+}
+
 /* eslint-disable import/export */
 var FilterRequest;
 (function (FilterRequest) {
@@ -2435,6 +2479,10 @@ var WakuMessage$2;
                     writer.uint32(170);
                     RateLimitProof$2.codec().encode(obj.rateLimitProof, writer);
                 }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
                 if (opts.lengthDelimited !== false) {
                     writer.ldelim();
                 }
@@ -2462,6 +2510,9 @@ var WakuMessage$2;
                         case 21:
                             obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32());
                             break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
                         default:
                             reader.skipType(tag & 7);
                             break;
@@ -2532,12 +2583,12 @@ const log$2 = debug("waku:filter");
  * - https://github.com/status-im/nwaku/issues/948
  */
 class WakuFilter {
-    constructor(libp2p, options) {
-        this.libp2p = libp2p;
+    constructor(components, options) {
+        this.components = components;
         this.subscriptions = new Map();
         this.decoders = new Map();
         this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
-        this.libp2p
+        this.components.registrar
             .handle(FilterCodec, this.onRequest.bind(this))
             .catch((e) => log$2("Failed to register filter protocol", e));
     }
@@ -2561,7 +2612,7 @@ class WakuFilter {
         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));
+            const res = await pipe([request.encode()], encode$4(), stream, decode$5(), async (source) => await itAll(source));
             log$2("response", res);
         }
         catch (e) {
@@ -2576,10 +2627,13 @@ class WakuFilter {
             this.deleteCallback(requestId);
         };
     }
+    get peerStore() {
+        return this.components.peerStore;
+    }
     onRequest(streamData) {
         log$2("Receiving message push");
         try {
-            pipe(streamData.stream, decode(), async (source) => {
+            pipe(streamData.stream, decode$5(), async (source) => {
                 for await (const bytes of source) {
                     const res = FilterRPC.decode(bytes.slice());
                     if (res.requestId && res.push?.messages?.length) {
@@ -2663,7 +2717,7 @@ class WakuFilter {
         const unsubscribeRequest = FilterRPC.createRequest(topic, contentFilters, requestId, false);
         const stream = await this.newStream(peer);
         try {
-            await pipe([unsubscribeRequest.encode()], encode(), stream.sink);
+            await pipe([unsubscribeRequest.encode()], encode$4(), stream.sink);
         }
         catch (e) {
             log$2("Error unsubscribing", e);
@@ -2671,7 +2725,7 @@ class WakuFilter {
         }
     }
     async newStream(peer) {
-        const connections = this.libp2p.connectionManager.getConnections(peer.id);
+        const connections = this.components.connectionManager.getConnections(peer.id);
         const connection = selectConnection(connections);
         if (!connection) {
             throw new Error("Failed to get a connection to the peer");
@@ -2679,24 +2733,27 @@ class WakuFilter {
         return connection.newStream(FilterCodec);
     }
     async getPeer(peerId) {
-        const res = await selectPeerForProtocol(this.libp2p.peerStore, [FilterCodec], peerId);
+        const res = await selectPeerForProtocol(this.components.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]);
+        return getPeersForProtocol(this.components.peerStore, [FilterCodec]);
     }
     async randomPeer() {
         return selectRandomPeer(await this.peers());
     }
 }
+function wakuFilter(init = {}) {
+    return (components) => new WakuFilter(components, init);
+}
 
 var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     FilterCodec: FilterCodec,
-    WakuFilter: WakuFilter
+    wakuFilter: wakuFilter
 });
 
 /* eslint-disable import/export */
@@ -3021,6 +3078,10 @@ var WakuMessage$1;
                     writer.uint32(170);
                     RateLimitProof$1.codec().encode(obj.rateLimitProof, writer);
                 }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
                 if (opts.lengthDelimited !== false) {
                     writer.ldelim();
                 }
@@ -3048,6 +3109,9 @@ var WakuMessage$1;
                         case 21:
                             obj.rateLimitProof = RateLimitProof$1.codec().decode(reader, reader.uint32());
                             break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
                         default:
                             reader.skipType(tag & 7);
                             break;
@@ -3101,18 +3165,18 @@ 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;
+    constructor(components, options) {
+        this.components = components;
         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);
+        const res = await selectPeerForProtocol(this.components.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 connections = this.components.connectionManager.getConnections(peer.id);
         const connection = selectConnection(connections);
         if (!connection)
             throw "Failed to get a connection to the peer";
@@ -3125,7 +3189,7 @@ class WakuLightPush {
                 return { recipients };
             }
             const query = PushRPC.createRequest(protoMessage, pubSubTopic);
-            const res = await pipe([query.encode()], encode(), stream, decode(), async (source) => await itAll(source));
+            const res = await pipe([query.encode()], encode$4(), stream, decode$5(), async (source) => await itAll(source));
             try {
                 const bytes = new Uint8ArrayList();
                 res.forEach((chunk) => {
@@ -3155,7 +3219,7 @@ class WakuLightPush {
      * peers.
      */
     async peers() {
-        return getPeersForProtocol(this.libp2p.peerStore, [LightPushCodec]);
+        return getPeersForProtocol(this.components.peerStore, [LightPushCodec]);
     }
     /**
      * Returns a random peer that supports light push protocol from the address
@@ -3165,15 +3229,1504 @@ class WakuLightPush {
     async randomPeer() {
         return selectRandomPeer(await this.peers());
     }
+    get peerStore() {
+        return this.components.peerStore;
+    }
+}
+function wakuLightPush(init = {}) {
+    return (components) => new WakuLightPush(components, init);
 }
 
 var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     LightPushCodec: LightPushCodec,
     get PushResponse () { return PushResponse; },
-    WakuLightPush: WakuLightPush
+    wakuLightPush: wakuLightPush
+});
+
+function number(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error(`Wrong positive integer: ${n}`);
+}
+function bool(b) {
+    if (typeof b !== 'boolean')
+        throw new Error(`Expected boolean, not ${b}`);
+}
+function bytes(b, ...lengths) {
+    if (!(b instanceof Uint8Array))
+        throw new TypeError('Expected Uint8Array');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+}
+function hash(hash) {
+    if (typeof hash !== 'function' || typeof hash.create !== 'function')
+        throw new Error('Hash should be wrapped by utils.wrapConstructor');
+    number(hash.outputLen);
+    number(hash.blockLen);
+}
+function exists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+function output(out, instance) {
+    bytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+    }
+}
+const assert = {
+    number,
+    bool,
+    bytes,
+    hash,
+    exists,
+    output,
+};
+
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// Cast array to view
+const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+// The rotate right (circular right shift) operation for uint32
+const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
+const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.
+// So, just to be sure not to corrupt anything.
+if (!isLE)
+    throw new Error('Non little-endian hardware is not supported');
+Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
+function utf8ToBytes$1(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
+    }
+    return new TextEncoder().encode(str);
+}
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes$1(data);
+    if (!(data instanceof Uint8Array))
+        throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
+    return data;
+}
+// For runtime check if class implements interface
+class Hash {
+    // Safe version that clones internal state
+    clone() {
+        return this._cloneInto();
+    }
+}
+function wrapConstructor(hashConstructor) {
+    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
+    const tmp = hashConstructor();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashConstructor();
+    return hashC;
+}
+
+// Polyfill for Safari 14
+function setBigUint64(view, byteOffset, value, isLE) {
+    if (typeof view.setBigUint64 === 'function')
+        return view.setBigUint64(byteOffset, value, isLE);
+    const _32n = BigInt(32);
+    const _u32_max = BigInt(0xffffffff);
+    const wh = Number((value >> _32n) & _u32_max);
+    const wl = Number(value & _u32_max);
+    const h = isLE ? 4 : 0;
+    const l = isLE ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE);
+    view.setUint32(byteOffset + l, wl, isLE);
+}
+// Base SHA2 class (RFC 6234)
+class SHA2 extends Hash {
+    constructor(blockLen, outputLen, padOffset, isLE) {
+        super();
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
+        this.finished = false;
+        this.length = 0;
+        this.pos = 0;
+        this.destroyed = false;
+        this.buffer = new Uint8Array(blockLen);
+        this.view = createView(this.buffer);
+    }
+    update(data) {
+        assert.exists(this);
+        const { view, buffer, blockLen } = this;
+        data = toBytes(data);
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                const dataView = createView(data);
+                for (; blockLen <= len - pos; pos += blockLen)
+                    this.process(dataView, pos);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            pos += take;
+            if (this.pos === blockLen) {
+                this.process(view, 0);
+                this.pos = 0;
+            }
+        }
+        this.length += data.length;
+        this.roundClean();
+        return this;
+    }
+    digestInto(out) {
+        assert.exists(this);
+        assert.output(out, this);
+        this.finished = true;
+        // Padding
+        // We can avoid allocation of buffer for padding completely if it
+        // was previously not allocated here. But it won't change performance.
+        const { buffer, view, blockLen, isLE } = this;
+        let { pos } = this;
+        // append the bit '1' to the message
+        buffer[pos++] = 0b10000000;
+        this.buffer.subarray(pos).fill(0);
+        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again
+        if (this.padOffset > blockLen - pos) {
+            this.process(view, 0);
+            pos = 0;
+        }
+        // Pad until full block byte with zeros
+        for (let i = pos; i < blockLen; i++)
+            buffer[i] = 0;
+        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+        // So we just write lowest 64 bits of that value.
+        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+        this.process(view, 0);
+        const oview = createView(out);
+        this.get().forEach((v, i) => oview.setUint32(4 * i, v, isLE));
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        to || (to = new this.constructor());
+        to.set(...this.get());
+        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.length = length;
+        to.pos = pos;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        if (length % blockLen)
+            to.buffer.set(buffer);
+        return to;
+    }
+}
+
+// Choice: a ? b : c
+const Chi = (a, b, c) => (a & b) ^ (~a & c);
+// Majority function, true if any two inpust is true
+const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
+// Round constants:
+// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
+// prettier-ignore
+const SHA256_K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+// prettier-ignore
+const IV = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+]);
+// Temporary buffer, not used to store anything between runs
+// Named this way because it matches specification.
+const SHA256_W = new Uint32Array(64);
+class SHA256 extends SHA2 {
+    constructor() {
+        super(64, 32, 8, false);
+        // We cannot use array here since array allows indexing by variable
+        // which means optimizer/compiler cannot use registers.
+        this.A = IV[0] | 0;
+        this.B = IV[1] | 0;
+        this.C = IV[2] | 0;
+        this.D = IV[3] | 0;
+        this.E = IV[4] | 0;
+        this.F = IV[5] | 0;
+        this.G = IV[6] | 0;
+        this.H = IV[7] | 0;
+    }
+    get() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+        this.E = E | 0;
+        this.F = F | 0;
+        this.G = G | 0;
+        this.H = H | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4)
+            SHA256_W[i] = view.getUint32(offset, false);
+        for (let i = 16; i < 64; i++) {
+            const W15 = SHA256_W[i - 15];
+            const W2 = SHA256_W[i - 2];
+            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+        }
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D, E, F, G, H } = this;
+        for (let i = 0; i < 64; i++) {
+            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+            const T2 = (sigma0 + Maj(A, B, C)) | 0;
+            H = G;
+            G = F;
+            F = E;
+            E = (D + T1) | 0;
+            D = C;
+            C = B;
+            B = A;
+            A = (T1 + T2) | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        E = (E + this.E) | 0;
+        F = (F + this.F) | 0;
+        G = (G + this.G) | 0;
+        H = (H + this.H) | 0;
+        this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+        SHA256_W.fill(0);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        this.buffer.fill(0);
+    }
+}
+/**
+ * SHA2-256 hash function
+ * @param message - data that would be hashed
+ */
+const sha256$1 = wrapConstructor(() => new SHA256());
+
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+function base (ALPHABET, name) {
+  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+  var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+  function encode (source) {
+    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
+    if (source.length === 0) { return '' }
+        // Skip & count leading zeroes.
+    var zeroes = 0;
+    var length = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+        // Allocate enough space in big-endian base58 representation.
+    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+    var b58 = new Uint8Array(size);
+        // Process the bytes.
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+      var i = 0;
+      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+        carry += (256 * b58[it1]) >>> 0;
+        b58[it1] = (carry % BASE) >>> 0;
+        carry = (carry / BASE) >>> 0;
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i;
+      pbegin++;
+    }
+        // Skip leading zeroes in base58 result.
+    var it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+        // Translate the result into a string.
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
+    return str
+  }
+  function decodeUnsafe (source) {
+    if (typeof source !== 'string') { throw new TypeError('Expected String') }
+    if (source.length === 0) { return new Uint8Array() }
+    var psz = 0;
+        // Skip leading spaces.
+    if (source[psz] === ' ') { return }
+        // Skip and count leading '1's.
+    var zeroes = 0;
+    var length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+        // Allocate enough space in big-endian base256 representation.
+    var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+    var b256 = new Uint8Array(size);
+        // Process the characters.
+    while (source[psz]) {
+            // Decode character
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+      if (carry === 255) { return }
+      var i = 0;
+      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+        carry += (BASE * b256[it3]) >>> 0;
+        b256[it3] = (carry % 256) >>> 0;
+        carry = (carry / 256) >>> 0;
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i;
+      psz++;
+    }
+        // Skip trailing spaces.
+    if (source[psz] === ' ') { return }
+        // Skip leading zeroes in b256.
+    var it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j = zeroes;
+    while (it4 !== size) {
+      vch[j++] = b256[it4++];
+    }
+    return vch
+  }
+  function decode (string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) { return buffer }
+    throw new Error(`Non-${name} character`)
+  }
+  return {
+    encode: encode,
+    decodeUnsafe: decodeUnsafe,
+    decode: decode
+  }
+}
+var src = base;
+
+var _brrp__multiformats_scope_baseX = src;
+
+/**
+ * @param {Uint8Array} aa
+ * @param {Uint8Array} bb
+ */
+const equals$1 = (aa, bb) => {
+  if (aa === bb) return true
+  if (aa.byteLength !== bb.byteLength) {
+    return false
+  }
+
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false
+    }
+  }
+
+  return true
+};
+
+/**
+ * @param {ArrayBufferView|ArrayBuffer|Uint8Array} o
+ * @returns {Uint8Array}
+ */
+const coerce = o => {
+  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') return o
+  if (o instanceof ArrayBuffer) return new Uint8Array(o)
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength)
+  }
+  throw new Error('Unknown type, must be binary type')
+};
+
+/**
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+const fromString$1 = str => (new TextEncoder()).encode(str);
+
+/**
+ * @param {Uint8Array} b
+ * @returns {string}
+ */
+const toString = b => (new TextDecoder()).decode(b);
+
+/**
+ * Class represents both BaseEncoder and MultibaseEncoder meaning it
+ * can be used to encode to multibase or base encode without multibase
+ * prefix.
+ *
+ * @class
+ * @template {string} Base
+ * @template {string} Prefix
+ * @implements {API.MultibaseEncoder<Prefix>}
+ * @implements {API.BaseEncoder}
+ */
+class Encoder {
+  /**
+   * @param {Base} name
+   * @param {Prefix} prefix
+   * @param {(bytes:Uint8Array) => string} baseEncode
+   */
+  constructor (name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {API.Multibase<Prefix>}
+   */
+  encode (bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`
+    } else {
+      throw Error('Unknown type, must be binary type')
+    }
+  }
+}
+
+/**
+ * @template {string} Prefix
+ */
+/**
+ * Class represents both BaseDecoder and MultibaseDecoder so it could be used
+ * to decode multibases (with matching prefix) or just base decode strings
+ * with corresponding base encoding.
+ *
+ * @class
+ * @template {string} Base
+ * @template {string} Prefix
+ * @implements {API.MultibaseDecoder<Prefix>}
+ * @implements {API.UnibaseDecoder<Prefix>}
+ * @implements {API.BaseDecoder}
+ */
+class Decoder {
+  /**
+   * @param {Base} name
+   * @param {Prefix} prefix
+   * @param {(text:string) => Uint8Array} baseDecode
+   */
+  constructor (name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    /* c8 ignore next 3 */
+    if (prefix.codePointAt(0) === undefined) {
+      throw new Error('Invalid prefix character')
+    }
+    /** @private */
+    this.prefixCodePoint = /** @type {number} */ (prefix.codePointAt(0));
+    this.baseDecode = baseDecode;
+  }
+
+  /**
+   * @param {string} text
+   */
+  decode (text) {
+    if (typeof text === 'string') {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`)
+      }
+      return this.baseDecode(text.slice(this.prefix.length))
+    } else {
+      throw Error('Can only multibase decode strings')
+    }
+  }
+
+  /**
+   * @template {string} OtherPrefix
+   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
+   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
+   */
+  or (decoder) {
+    return or(this, decoder)
+  }
+}
+
+/**
+ * @template {string} Prefix
+ * @typedef {Record<Prefix, API.UnibaseDecoder<Prefix>>} Decoders
+ */
+
+/**
+ * @template {string} Prefix
+ * @implements {API.MultibaseDecoder<Prefix>}
+ * @implements {API.CombobaseDecoder<Prefix>}
+ */
+class ComposedDecoder {
+  /**
+   * @param {Decoders<Prefix>} decoders
+   */
+  constructor (decoders) {
+    this.decoders = decoders;
+  }
+
+  /**
+   * @template {string} OtherPrefix
+   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
+   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
+   */
+  or (decoder) {
+    return or(this, decoder)
+  }
+
+  /**
+   * @param {string} input
+   * @returns {Uint8Array}
+   */
+  decode (input) {
+    const prefix = /** @type {Prefix} */ (input[0]);
+    const decoder = this.decoders[prefix];
+    if (decoder) {
+      return decoder.decode(input)
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`)
+    }
+  }
+}
+
+/**
+ * @template {string} L
+ * @template {string} R
+ * @param {API.UnibaseDecoder<L>|API.CombobaseDecoder<L>} left
+ * @param {API.UnibaseDecoder<R>|API.CombobaseDecoder<R>} right
+ * @returns {ComposedDecoder<L|R>}
+ */
+const or = (left, right) => new ComposedDecoder(/** @type {Decoders<L|R>} */({
+  ...(left.decoders || { [/** @type API.UnibaseDecoder<L> */(left).prefix]: left }),
+  ...(right.decoders || { [/** @type API.UnibaseDecoder<R> */(right).prefix]: right })
+}));
+
+/**
+ * @class
+ * @template {string} Base
+ * @template {string} Prefix
+ * @implements {API.MultibaseCodec<Prefix>}
+ * @implements {API.MultibaseEncoder<Prefix>}
+ * @implements {API.MultibaseDecoder<Prefix>}
+ * @implements {API.BaseCodec}
+ * @implements {API.BaseEncoder}
+ * @implements {API.BaseDecoder}
+ */
+class Codec {
+  /**
+   * @param {Base} name
+   * @param {Prefix} prefix
+   * @param {(bytes:Uint8Array) => string} baseEncode
+   * @param {(text:string) => Uint8Array} baseDecode
+   */
+  constructor (name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
+  }
+
+  /**
+   * @param {Uint8Array} input
+   */
+  encode (input) {
+    return this.encoder.encode(input)
+  }
+
+  /**
+   * @param {string} input
+   */
+  decode (input) {
+    return this.decoder.decode(input)
+  }
+}
+
+/**
+ * @template {string} Base
+ * @template {string} Prefix
+ * @param {object} options
+ * @param {Base} options.name
+ * @param {Prefix} options.prefix
+ * @param {(bytes:Uint8Array) => string} options.encode
+ * @param {(input:string) => Uint8Array} options.decode
+ * @returns {Codec<Base, Prefix>}
+ */
+const from$1 = ({ name, prefix, encode, decode }) =>
+  new Codec(name, prefix, encode, decode);
+
+/**
+ * @template {string} Base
+ * @template {string} Prefix
+ * @param {object} options
+ * @param {Base} options.name
+ * @param {Prefix} options.prefix
+ * @param {string} options.alphabet
+ * @returns {Codec<Base, Prefix>}
+ */
+const baseX = ({ prefix, name, alphabet }) => {
+  const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
+  return from$1({
+    prefix,
+    name,
+    encode,
+    /**
+     * @param {string} text
+     */
+    decode: text => coerce(decode(text))
+  })
+};
+
+/**
+ * @param {string} string
+ * @param {string} alphabet
+ * @param {number} bitsPerChar
+ * @param {string} name
+ * @returns {Uint8Array}
+ */
+const decode$4 = (string, alphabet, bitsPerChar, name) => {
+  // Build the character lookup table:
+  /** @type {Record<string, number>} */
+  const codes = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    codes[alphabet[i]] = i;
+  }
+
+  // Count the padding bytes:
+  let end = string.length;
+  while (string[end - 1] === '=') {
+    --end;
+  }
+
+  // Allocate the output:
+  const out = new Uint8Array((end * bitsPerChar / 8) | 0);
+
+  // Parse the data:
+  let bits = 0; // Number of bits currently in the buffer
+  let buffer = 0; // Bits waiting to be written out, MSB first
+  let written = 0; // Next byte to write
+  for (let i = 0; i < end; ++i) {
+    // Read one character from the string:
+    const value = codes[string[i]];
+    if (value === undefined) {
+      throw new SyntaxError(`Non-${name} character`)
+    }
+
+    // Append the bits to the buffer:
+    buffer = (buffer << bitsPerChar) | value;
+    bits += bitsPerChar;
+
+    // Write out some bits if the buffer has a byte's worth:
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 0xff & (buffer >> bits);
+    }
+  }
+
+  // Verify that we have received just enough bits:
+  if (bits >= bitsPerChar || 0xff & (buffer << (8 - bits))) {
+    throw new SyntaxError('Unexpected end of data')
+  }
+
+  return out
+};
+
+/**
+ * @param {Uint8Array} data
+ * @param {string} alphabet
+ * @param {number} bitsPerChar
+ * @returns {string}
+ */
+const encode$3 = (data, alphabet, bitsPerChar) => {
+  const pad = alphabet[alphabet.length - 1] === '=';
+  const mask = (1 << bitsPerChar) - 1;
+  let out = '';
+
+  let bits = 0; // Number of bits currently in the buffer
+  let buffer = 0; // Bits waiting to be written out, MSB first
+  for (let i = 0; i < data.length; ++i) {
+    // Slurp data into the buffer:
+    buffer = (buffer << 8) | data[i];
+    bits += 8;
+
+    // Write out as much as we can:
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet[mask & (buffer >> bits)];
+    }
+  }
+
+  // Partial character:
+  if (bits) {
+    out += alphabet[mask & (buffer << (bitsPerChar - bits))];
+  }
+
+  // Add padding characters until we hit a byte boundary:
+  if (pad) {
+    while ((out.length * bitsPerChar) & 7) {
+      out += '=';
+    }
+  }
+
+  return out
+};
+
+/**
+ * RFC4648 Factory
+ *
+ * @template {string} Base
+ * @template {string} Prefix
+ * @param {object} options
+ * @param {Base} options.name
+ * @param {Prefix} options.prefix
+ * @param {string} options.alphabet
+ * @param {number} options.bitsPerChar
+ */
+const rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
+  return from$1({
+    prefix,
+    name,
+    encode (input) {
+      return encode$3(input, alphabet, bitsPerChar)
+    },
+    decode (input) {
+      return decode$4(input, alphabet, bitsPerChar, name)
+    }
+  })
+};
+
+// @ts-check
+
+const identity$2 = from$1({
+  prefix: '\x00',
+  name: 'identity',
+  encode: (buf) => toString(buf),
+  decode: (str) => fromString$1(str)
+});
+
+var identityBase = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    identity: identity$2
+});
+
+// @ts-check
+
+const base2 = rfc4648({
+  prefix: '0',
+  name: 'base2',
+  alphabet: '01',
+  bitsPerChar: 1
+});
+
+var base2$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base2: base2
+});
+
+// @ts-check
+
+const base8 = rfc4648({
+  prefix: '7',
+  name: 'base8',
+  alphabet: '01234567',
+  bitsPerChar: 3
+});
+
+var base8$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base8: base8
+});
+
+const base10 = baseX({
+  prefix: '9',
+  name: 'base10',
+  alphabet: '0123456789'
+});
+
+var base10$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base10: base10
+});
+
+// @ts-check
+
+const base16 = rfc4648({
+  prefix: 'f',
+  name: 'base16',
+  alphabet: '0123456789abcdef',
+  bitsPerChar: 4
+});
+
+const base16upper = rfc4648({
+  prefix: 'F',
+  name: 'base16upper',
+  alphabet: '0123456789ABCDEF',
+  bitsPerChar: 4
+});
+
+var base16$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base16: base16,
+    base16upper: base16upper
+});
+
+const base32 = rfc4648({
+  prefix: 'b',
+  name: 'base32',
+  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
+  bitsPerChar: 5
+});
+
+const base32upper = rfc4648({
+  prefix: 'B',
+  name: 'base32upper',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+  bitsPerChar: 5
+});
+
+const base32pad = rfc4648({
+  prefix: 'c',
+  name: 'base32pad',
+  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
+  bitsPerChar: 5
+});
+
+const base32padupper = rfc4648({
+  prefix: 'C',
+  name: 'base32padupper',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
+  bitsPerChar: 5
+});
+
+const base32hex = rfc4648({
+  prefix: 'v',
+  name: 'base32hex',
+  alphabet: '0123456789abcdefghijklmnopqrstuv',
+  bitsPerChar: 5
+});
+
+const base32hexupper = rfc4648({
+  prefix: 'V',
+  name: 'base32hexupper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+  bitsPerChar: 5
+});
+
+const base32hexpad = rfc4648({
+  prefix: 't',
+  name: 'base32hexpad',
+  alphabet: '0123456789abcdefghijklmnopqrstuv=',
+  bitsPerChar: 5
+});
+
+const base32hexpadupper = rfc4648({
+  prefix: 'T',
+  name: 'base32hexpadupper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
+  bitsPerChar: 5
+});
+
+const base32z = rfc4648({
+  prefix: 'h',
+  name: 'base32z',
+  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+  bitsPerChar: 5
+});
+
+var base32$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base32: base32,
+    base32upper: base32upper,
+    base32pad: base32pad,
+    base32padupper: base32padupper,
+    base32hex: base32hex,
+    base32hexupper: base32hexupper,
+    base32hexpad: base32hexpad,
+    base32hexpadupper: base32hexpadupper,
+    base32z: base32z
 });
 
+const base36 = baseX({
+  prefix: 'k',
+  name: 'base36',
+  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+});
+
+const base36upper = baseX({
+  prefix: 'K',
+  name: 'base36upper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+});
+
+var base36$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base36: base36,
+    base36upper: base36upper
+});
+
+const base58btc = baseX({
+  name: 'base58btc',
+  prefix: 'z',
+  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+});
+
+const base58flickr = baseX({
+  name: 'base58flickr',
+  prefix: 'Z',
+  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+});
+
+var base58 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base58btc: base58btc,
+    base58flickr: base58flickr
+});
+
+// @ts-check
+
+const base64 = rfc4648({
+  prefix: 'm',
+  name: 'base64',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+  bitsPerChar: 6
+});
+
+const base64pad = rfc4648({
+  prefix: 'M',
+  name: 'base64pad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+  bitsPerChar: 6
+});
+
+const base64url = rfc4648({
+  prefix: 'u',
+  name: 'base64url',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+  bitsPerChar: 6
+});
+
+const base64urlpad = rfc4648({
+  prefix: 'U',
+  name: 'base64urlpad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
+  bitsPerChar: 6
+});
+
+var base64$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base64: base64,
+    base64pad: base64pad,
+    base64url: base64url,
+    base64urlpad: base64urlpad
+});
+
+const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
+const alphabetBytesToChars = /** @type {string[]} */ (alphabet.reduce((p, c, i) => { p[i] = c; return p }, /** @type {string[]} */([])));
+const alphabetCharsToBytes = /** @type {number[]} */ (alphabet.reduce((p, c, i) => { p[/** @type {number} */ (c.codePointAt(0))] = i; return p }, /** @type {number[]} */([])));
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function encode$2 (data) {
+  return data.reduce((p, c) => {
+    p += alphabetBytesToChars[c];
+    return p
+  }, '')
+}
+
+/**
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+function decode$3 (str) {
+  const byts = [];
+  for (const char of str) {
+    const byt = alphabetCharsToBytes[/** @type {number} */ (char.codePointAt(0))];
+    if (byt === undefined) {
+      throw new Error(`Non-base256emoji character: ${char}`)
+    }
+    byts.push(byt);
+  }
+  return new Uint8Array(byts)
+}
+
+const base256emoji = from$1({
+  prefix: '🚀',
+  name: 'base256emoji',
+  encode: encode$2,
+  decode: decode$3
+});
+
+var base256emoji$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base256emoji: base256emoji
+});
+
+var encode_1 = encode$1;
+
+var MSB = 0x80
+  , REST = 0x7F
+  , MSBALL = ~REST
+  , INT = Math.pow(2, 31);
+
+function encode$1(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+
+  while(num >= INT) {
+    out[offset++] = (num & 0xFF) | MSB;
+    num /= 128;
+  }
+  while(num & MSBALL) {
+    out[offset++] = (num & 0xFF) | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  
+  encode$1.bytes = offset - oldOffset + 1;
+  
+  return out
+}
+
+var decode$2 = read;
+
+var MSB$1 = 0x80
+  , REST$1 = 0x7F;
+
+function read(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length;
+
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++];
+    res += shift < 28
+      ? (b & REST$1) << shift
+      : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1)
+
+  read.bytes = counter - offset;
+
+  return res
+}
+
+var N1 = Math.pow(2,  7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+
+var length = function (value) {
+  return (
+    value < N1 ? 1
+  : value < N2 ? 2
+  : value < N3 ? 3
+  : value < N4 ? 4
+  : value < N5 ? 5
+  : value < N6 ? 6
+  : value < N7 ? 7
+  : value < N8 ? 8
+  : value < N9 ? 9
+  :              10
+  )
+};
+
+var varint = {
+    encode: encode_1
+  , decode: decode$2
+  , encodingLength: length
+};
+
+var _brrp_varint = varint;
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} [offset=0]
+ * @returns {[number, number]}
+ */
+const decode$1 = (data, offset = 0) => {
+  const code = _brrp_varint.decode(data, offset);
+  return [code, _brrp_varint.decode.bytes]
+};
+
+/**
+ * @param {number} int
+ * @param {Uint8Array} target
+ * @param {number} [offset=0]
+ */
+const encodeTo = (int, target, offset = 0) => {
+  _brrp_varint.encode(int, target, offset);
+  return target
+};
+
+/**
+ * @param {number} int
+ * @returns {number}
+ */
+const encodingLength = (int) => {
+  return _brrp_varint.encodingLength(int)
+};
+
+/**
+ * Creates a multihash digest.
+ *
+ * @template {number} Code
+ * @param {Code} code
+ * @param {Uint8Array} digest
+ */
+const create = (code, digest) => {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+
+  return new Digest(code, size, digest, bytes)
+};
+
+/**
+ * Turns bytes representation of multihash digest into an instance.
+ *
+ * @param {Uint8Array} multihash
+ * @returns {MultihashDigest}
+ */
+const decode = (multihash) => {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decode$1(bytes);
+  const [size, digestOffset] = decode$1(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+
+  if (digest.byteLength !== size) {
+    throw new Error('Incorrect length')
+  }
+
+  return new Digest(code, size, digest, bytes)
+};
+
+/**
+ * @param {MultihashDigest} a
+ * @param {unknown} b
+ * @returns {b is MultihashDigest}
+ */
+const equals = (a, b) => {
+  if (a === b) {
+    return true
+  } else {
+    const data = /** @type {{code?:unknown, size?:unknown, bytes?:unknown}} */(b);
+
+    return (
+      a.code === data.code &&
+      a.size === data.size &&
+      data.bytes instanceof Uint8Array &&
+      equals$1(a.bytes, data.bytes)
+    )
+  }
+};
+
+/**
+ * @typedef {import('./interface.js').MultihashDigest} MultihashDigest
+ */
+
+/**
+ * Represents a multihash digest which carries information about the
+ * hashing alogrithm and an actual hash digest.
+ *
+ * @template {number} Code
+ * @template {number} Size
+ * @class
+ * @implements {MultihashDigest}
+ */
+class Digest {
+  /**
+   * Creates a multihash digest.
+   *
+   * @param {Code} code
+   * @param {Size} size
+   * @param {Uint8Array} digest
+   * @param {Uint8Array} bytes
+   */
+  constructor (code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+}
+
+/**
+ * @template {string} Name
+ * @template {number} Code
+ * @param {object} options
+ * @param {Name} options.name
+ * @param {Code} options.code
+ * @param {(input: Uint8Array) => Await<Uint8Array>} options.encode
+ */
+const from = ({ name, code, encode }) => new Hasher(name, code, encode);
+
+/**
+ * Hasher represents a hashing algorithm implementation that produces as
+ * `MultihashDigest`.
+ *
+ * @template {string} Name
+ * @template {number} Code
+ * @class
+ * @implements {MultihashHasher<Code>}
+ */
+class Hasher {
+  /**
+   *
+   * @param {Name} name
+   * @param {Code} code
+   * @param {(input: Uint8Array) => Await<Uint8Array>} encode
+   */
+  constructor (name, code, encode) {
+    this.name = name;
+    this.code = code;
+    this.encode = encode;
+  }
+
+  /**
+   * @param {Uint8Array} input
+   * @returns {Await<Digest.Digest<Code, number>>}
+   */
+  digest (input) {
+    if (input instanceof Uint8Array) {
+      const result = this.encode(input);
+      return result instanceof Uint8Array
+        ? create(this.code, result)
+        /* c8 ignore next 1 */
+        : result.then(digest => create(this.code, digest))
+    } else {
+      throw Error('Unknown type, must be binary type')
+      /* c8 ignore next 1 */
+    }
+  }
+}
+
+/**
+ * @template {number} Alg
+ * @typedef {import('./interface.js').MultihashHasher} MultihashHasher
+ */
+
+/**
+ * @template T
+ * @typedef {Promise<T>|T} Await
+ */
+
+/* global crypto */
+
+/**
+ * @param {AlgorithmIdentifier} name
+ */
+const sha = name =>
+  /**
+   * @param {Uint8Array} data
+   */
+  async data => new Uint8Array(await crypto.subtle.digest(name, data));
+
+const sha256 = from({
+  name: 'sha2-256',
+  code: 0x12,
+  encode: sha('SHA-256')
+});
+
+const sha512 = from({
+  name: 'sha2-512',
+  code: 0x13,
+  encode: sha('SHA-512')
+});
+
+var sha2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    sha256: sha256,
+    sha512: sha512
+});
+
+const code = 0x0;
+const name = 'identity';
+
+/** @type {(input:Uint8Array) => Uint8Array} */
+const encode = coerce;
+
+/**
+ * @param {Uint8Array} input
+ * @returns {Digest.Digest<typeof code, number>}
+ */
+const digest = (input) => create(code, encode(input));
+
+const identity = { code, name, encode, digest };
+
+var identity$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    identity: identity
+});
+
+// @ts-check
+
+/**
+ * @template T
+ * @typedef {import('./interface.js').ByteView<T>} ByteView
+ */
+
+new TextEncoder();
+new TextDecoder();
+
+// @ts-check
+
+const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$1, ...base256emoji$1 };
+({ ...sha2, ...identity$1 });
+
+function createCodec(name, prefix, encode, decode) {
+    return {
+        name,
+        prefix,
+        encoder: {
+            name,
+            prefix,
+            encode
+        },
+        decoder: {
+            decode
+        }
+    };
+}
+const string = createCodec('utf8', 'u', (buf) => {
+    const decoder = new TextDecoder('utf8');
+    return 'u' + decoder.decode(buf);
+}, (str) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(str.substring(1));
+});
+const ascii = createCodec('ascii', 'a', (buf) => {
+    let string = 'a';
+    for (let i = 0; i < buf.length; i++) {
+        string += String.fromCharCode(buf[i]);
+    }
+    return string;
+}, (str) => {
+    str = str.substring(1);
+    const buf = allocUnsafe$1(str.length);
+    for (let i = 0; i < str.length; i++) {
+        buf[i] = str.charCodeAt(i);
+    }
+    return buf;
+});
+const BASES = {
+    utf8: string,
+    'utf-8': string,
+    hex: bases.base16,
+    latin1: ascii,
+    ascii: ascii,
+    binary: ascii,
+    ...bases
+};
+
+/**
+ * Create a `Uint8Array` from the passed string
+ *
+ * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
+ *
+ * Also `ascii` which is similar to node's 'binary' encoding.
+ */
+function fromString(string, encoding = 'utf8') {
+    const base = BASES[encoding];
+    if (base == null) {
+        throw new Error(`Unsupported encoding "${encoding}"`);
+    }
+    if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
+        return asUint8Array(globalThis.Buffer.from(string, 'utf-8'));
+    }
+    // add multibase prefix
+    return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
+}
+
+/**
+ * Encode utf-8 string to byte array.
+ */
+const utf8ToBytes = (s) => fromString(s, "utf8");
+/**
+ * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
+ */
+function concat(byteArrays, totalLength) {
+    const len = totalLength ?? byteArrays.reduce((acc, curr) => acc + curr.length, 0);
+    const res = new Uint8Array(len);
+    let offset = 0;
+    for (const bytes of byteArrays) {
+        res.set(bytes, offset);
+        offset += bytes.length;
+    }
+    return res;
+}
+
 /* eslint-disable import/export */
 var Index;
 (function (Index) {
@@ -3727,6 +5280,10 @@ var WakuMessage;
                     writer.uint32(170);
                     RateLimitProof.codec().encode(obj.rateLimitProof, writer);
                 }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
                 if (opts.lengthDelimited !== false) {
                     writer.ldelim();
                 }
@@ -3754,6 +5311,9 @@ var WakuMessage;
                         case 21:
                             obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32());
                             break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
                         default:
                             reader.skipType(tag & 7);
                             break;
@@ -3851,8 +5411,8 @@ const DefaultPageSize = 10;
  * The Waku Store protocol can be used to retrieved historical messages.
  */
 class WakuStore {
-    constructor(libp2p, options) {
-        this.libp2p = libp2p;
+    constructor(components, options) {
+        this.components = components;
         this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
     }
     /**
@@ -3960,19 +5520,19 @@ class WakuStore {
             pageSize: DefaultPageSize,
         }, options, { contentTopics, startTime, endTime });
         log("Querying history with the following options", {
-            peerId: options?.peerId?.toString(),
             ...options,
+            peerId: options?.peerId?.toString(),
         });
-        const res = await selectPeerForProtocol(this.libp2p.peerStore, [StoreCodec], options?.peerId);
+        const res = await selectPeerForProtocol(this.components.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 connections = this.components.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)) {
+        for await (const messages of paginate(connection, protocol, queryOpts, decodersAsMap, options?.cursor)) {
             yield messages;
         }
     }
@@ -3981,21 +5541,23 @@ class WakuStore {
      * store protocol. Waku may or  may not be currently connected to these peers.
      */
     async peers() {
-        return getPeersForProtocol(this.libp2p.peerStore, [StoreCodec]);
+        return getPeersForProtocol(this.components.peerStore, [StoreCodec]);
+    }
+    get peerStore() {
+        return this.components.peerStore;
     }
 }
-async function* paginate(connection, protocol, queryOpts, decoders) {
+async function* paginate(connection, protocol, queryOpts, decoders, cursor) {
     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 res = await pipe([historyRpcQuery.encode()], encode$4(), stream, decode$5(), async (source) => await itAll(source));
         const bytes = new Uint8ArrayList();
         res.forEach((chunk) => {
             bytes.append(chunk);
@@ -4046,14 +5608,35 @@ async function* paginate(connection, protocol, queryOpts, decoders) {
 function isDefined(msg) {
     return !!msg;
 }
+async function createCursor(message, pubsubTopic = DefaultPubSubTopic) {
+    if (!message ||
+        !message.timestamp ||
+        !message.payload ||
+        !message.contentTopic) {
+        throw new Error("Message is missing required fields");
+    }
+    const contentTopicBytes = utf8ToBytes(message.contentTopic);
+    const digest = sha256$1(concat([contentTopicBytes, message.payload]));
+    const messageTime = BigInt(message.timestamp.getTime()) * BigInt(1000000);
+    return {
+        digest,
+        pubsubTopic,
+        senderTime: messageTime,
+        receivedTime: messageTime,
+    };
+}
+function wakuStore(init = {}) {
+    return (components) => new WakuStore(components, init);
+}
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     StoreCodec: StoreCodec,
     DefaultPageSize: DefaultPageSize,
     get PageDirection () { return PageDirection; },
-    WakuStore: WakuStore,
-    isDefined: isDefined
+    isDefined: isDefined,
+    createCursor: createCursor,
+    wakuStore: wakuStore
 });
 
-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 };
+export { wakuLightPush as A, BASES as B, PushResponse as C, Digest as D, index as E, FilterCodec as F, PageDirection as G, wakuStore as H, createCursor as I, LightPushCodec as L, Protocols as P, StoreCodec as S, Uint8ArrayList as U, coerce as a, base32 as b, create as c, decode as d, equals as e, base58btc as f, encodeTo as g, decode$1 as h, encodingLength as i, concat$1 as j, fromString as k, errCode as l, base64 as m, equals$2 as n, identity as o, bases as p, pushable$1 as q, pipe as r, sha256 as s, encode$4 as t, unsigned as u, decode$5 as v, DefaultPubSubTopic as w, index$2 as x, wakuFilter as y, index$1 as z };