@waku/sds 0.0.4-383e0b2.0 → 0.0.4-4c18ca2.0

package/bundle/index.js

@@ -1864,10 +1864,12 @@ function decodeMessage$1(buf, codec, opts) {
 }
 
 function coerce(o) {
-    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
+    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') {
         return o;
-    if (o instanceof ArrayBuffer)
+    }
+    if (o instanceof ArrayBuffer) {
         return new Uint8Array(o);
+    }
     if (ArrayBuffer.isView(o)) {
         return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
     }
@@ -2128,7 +2130,6 @@ class ComposedDecoder {
     }
 }
 function or(left, right) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return new ComposedDecoder({
         ...(left.decoders ?? { [left.prefix]: left }),
         ...(right.decoders ?? { [right.prefix]: right })
@@ -2168,12 +2169,7 @@ function baseX({ name, prefix, alphabet }) {
         decode: (text) => coerce(decode(text))
     });
 }
-function decode$1(string, alphabet, bitsPerChar, name) {
-    // Build the character lookup table:
-    const codes = {};
-    for (let i = 0; i < alphabet.length; ++i) {
-        codes[alphabet[i]] = i;
-    }
+function decode$1(string, alphabetIdx, bitsPerChar, name) {
     // Count the padding bytes:
     let end = string.length;
     while (string[end - 1] === '=') {
@@ -2187,7 +2183,7 @@ function decode$1(string, alphabet, bitsPerChar, name) {
     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]];
+        const value = alphabetIdx[string[i]];
         if (value === undefined) {
             throw new SyntaxError(`Non-${name} character`);
         }
@@ -2234,10 +2230,19 @@ function encode$1(data, alphabet, bitsPerChar) {
     }
     return out;
 }
+function createAlphabetIdx(alphabet) {
+    // Build the character lookup table:
+    const alphabetIdx = {};
+    for (let i = 0; i < alphabet.length; ++i) {
+        alphabetIdx[alphabet[i]] = i;
+    }
+    return alphabetIdx;
+}
 /**
  * RFC4648 Factory
  */
 function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+    const alphabetIdx = createAlphabetIdx(alphabet);
     return from({
         prefix,
         name,
@@ -2245,7 +2250,7 @@ function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
             return encode$1(input, alphabet, bitsPerChar);
         },
         decode(input) {
-            return decode$1(input, alphabet, bitsPerChar, name);
+            return decode$1(input, alphabetIdx, bitsPerChar, name);
         }
     });
 }
@@ -3095,6 +3100,8 @@ class MaxLengthError extends Error {
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var RateLimitProof$4;
 (function (RateLimitProof) {
     let _codec;
@@ -3298,6 +3305,8 @@ var WakuMessage$4;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var FilterRequest;
 (function (FilterRequest) {
     (function (ContentFilter) {
@@ -3736,6 +3745,8 @@ var WakuMessage$3;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var TopicOnlyMessage;
 (function (TopicOnlyMessage) {
     let _codec;
@@ -3788,6 +3799,8 @@ var TopicOnlyMessage;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var FilterSubscribeRequest;
 (function (FilterSubscribeRequest) {
     let FilterSubscribeType;
@@ -4204,6 +4217,8 @@ var WakuMessage$2;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var PushRequest;
 (function (PushRequest) {
     let _codec;
@@ -4583,6 +4598,8 @@ var WakuMessage$1;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var WakuMessageKeyValue;
 (function (WakuMessageKeyValue) {
     let _codec;
@@ -5066,6 +5083,8 @@ var WakuMessage;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var PeerInfo;
 (function (PeerInfo) {
     let _codec;
@@ -5269,6 +5288,8 @@ var PeerExchangeRPC;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var WakuMetadataRequest;
 (function (WakuMetadataRequest) {
     let _codec;
@@ -5393,6 +5414,8 @@ var WakuMetadataResponse;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 var HistoryEntry;
 (function (HistoryEntry) {
     let _codec;
@@ -5561,9 +5584,71 @@ function decodeMessage(data) {
     return SdsMessage.decode(data);
 }
 
+/**
+ * @packageDocumentation
+ *
+ * Adds types to the EventTarget class.
+ *
+ * Hopefully this won't be necessary
+ * forever:
+ *
+ * - https://github.com/microsoft/TypeScript/issues/28357
+ * - https://github.com/microsoft/TypeScript/issues/43477
+ * - https://github.com/microsoft/TypeScript/issues/299
+ * - https://www.npmjs.com/package/typed-events
+ * - https://www.npmjs.com/package/typed-event-emitter
+ * - https://www.npmjs.com/package/typed-event-target
+ * - etc
+ *
+ * In addition to types, a `safeDispatchEvent` method is available which
+ * prevents dispatching events that aren't in the event map, and a
+ * `listenerCount` method which reports the number of listeners that are
+ * currently registered for a given event.
+ *
+ * @example
+ *
+ * ```ts
+ * import { TypedEventEmitter } from 'main-event'
+ * import type { TypedEventTarget } from 'main-event'
+ *
+ * interface EventTypes {
+ *   'test': CustomEvent<string>
+ * }
+ *
+ * const target = new TypedEventEmitter<EventTypes>()
+ *
+ * // it's a regular EventTarget
+ * console.info(target instanceof EventTarget) // true
+ *
+ * // register listeners normally
+ * target.addEventListener('test', (evt) => {
+ *   // evt is CustomEvent<string>
+ * })
+ *
+ * // @ts-expect-error 'derp' is not in the event map
+ * target.addEventListener('derp', () => {})
+ *
+ * // use normal dispatchEvent method
+ * target.dispatchEvent(new CustomEvent('test', {
+ *   detail: 'hello'
+ * }))
+ *
+ * // use type safe dispatch method
+ * target.safeDispatchEvent('test', {
+ *   detail: 'world'
+ * })
+ *
+ * // report listener count
+ * console.info(target.listenerCount('test')) // 0
+ *
+ * // event emitters can be used purely as interfaces too
+ * function acceptTarget (target: TypedEventTarget<EventTypes>) {
+ *   // ...
+ * }
+ * ```
+ */
 /**
  * An implementation of a typed event target
- * etc
  */
 class TypedEventEmitter extends EventTarget {
     #listeners = new Map();
@@ -5614,11 +5699,17 @@ class TypedEventEmitter extends EventTarget {
 }
 
 /**
- * Internal assertion helpers.
+ * Utilities for hex, bytes, CSPRNG.
  * @module
  */
-/** Asserts something is positive integer. */
-/** Is number an Uint8Array? Copied from utils for perf. */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
 function isBytes(a) {
     return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
 }
@@ -5644,19 +5735,13 @@ function aoutput(out, instance) {
         throw new Error('digestInto() expects output buffer of length at least ' + min);
     }
 }
-
-/**
- * Utilities for hex, bytes, CSPRNG.
- * @module
- */
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
-// node.js versions earlier than v19 don't declare it in global scope.
-// For node.js, package.json#exports field mapping rewrites import
-// from `crypto` to `cryptoNode`, which imports native module.
-// Makes the utils un-importable in browsers without a bundler.
-// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
-// Cast array to view
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+    }
+}
+/** Create DataView of an array for easy byte-level manipulation. */
 function createView(arr) {
     return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
@@ -5664,14 +5749,21 @@ function createView(arr) {
 function rotr(word, shift) {
     return (word << (32 - shift)) | (word >>> shift);
 }
+// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+const hasHexBuiltin = /* @__PURE__ */ (() => 
+// @ts-ignore
+typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
 // Array where index 0xf0 (240) is mapped to string 'f0'
 const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
 /**
- * Convert byte array to hex string.
+ * Convert byte array to hex string. Uses built-in function, when available.
  * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
  */
 function bytesToHex(bytes) {
     abytes(bytes);
+    // @ts-ignore
+    if (hasHexBuiltin)
+        return bytes.toHex();
     // pre-caching improves the speed 6x
     let hex = '';
     for (let i = 0; i < bytes.length; i++) {
@@ -5680,12 +5772,12 @@ function bytesToHex(bytes) {
     return hex;
 }
 /**
- * Convert JS string to byte array.
- * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ * Converts string to bytes using UTF8 encoding.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
  */
 function utf8ToBytes(str) {
     if (typeof str !== 'string')
-        throw new Error('utf8ToBytes expected string, got ' + typeof str);
+        throw new Error('string expected');
     return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
 }
 /**
@@ -5701,13 +5793,9 @@ function toBytes(data) {
 }
 /** For runtime check if class implements interface */
 class Hash {
-    // Safe version that clones internal state
-    clone() {
-        return this._cloneInto();
-    }
 }
 /** Wraps hash function, creating an interface on top of it */
-function wrapConstructor(hashCons) {
+function createHasher(hashCons) {
     const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
     const tmp = hashCons();
     hashC.outputLen = tmp.outputLen;
@@ -5748,21 +5836,22 @@ function Maj(a, b, c) {
 class HashMD 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.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
         this.buffer = new Uint8Array(blockLen);
         this.view = createView(this.buffer);
     }
     update(data) {
         aexists(this);
-        const { view, buffer, blockLen } = this;
         data = toBytes(data);
+        abytes(data);
+        const { view, buffer, blockLen } = this;
         const len = data.length;
         for (let pos = 0; pos < len;) {
             const take = Math.min(blockLen - this.pos, len - pos);
@@ -5796,7 +5885,7 @@ class HashMD extends Hash {
         let { pos } = this;
         // append the bit '1' to the message
         buffer[pos++] = 0b10000000;
-        this.buffer.subarray(pos).fill(0);
+        clean(this.buffer.subarray(pos));
         // 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) {
@@ -5834,28 +5923,40 @@ class HashMD extends Hash {
         to || (to = new this.constructor());
         to.set(...this.get());
         const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.destroyed = destroyed;
+        to.finished = finished;
         to.length = length;
         to.pos = pos;
-        to.finished = finished;
-        to.destroyed = destroyed;
         if (length % blockLen)
             to.buffer.set(buffer);
         return to;
     }
+    clone() {
+        return this._cloneInto();
+    }
 }
+/**
+ * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+ * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+ */
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
 
 /**
- * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
- *
- * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
- * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
- *
- * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+ * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+ * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+ * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
  * @module
  */
-/** Round constants: first 32 bits of fractional parts of the cube roots of the first 64 primes 2..311). */
+/**
+ * Round constants:
+ * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+ */
 // prettier-ignore
-const SHA256_K = /* @__PURE__ */ new Uint32Array([
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
@@ -5865,19 +5966,11 @@ const SHA256_K = /* @__PURE__ */ new Uint32Array([
     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 ]);
-/** Initial state: first 32 bits of fractional parts of the square roots of the first 8 primes 2..19. */
-// prettier-ignore
-const SHA256_IV = /* @__PURE__ */ 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.
- */
+/** Reusable temporary buffer. "W" comes straight from spec. */
 const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
 class SHA256 extends HashMD {
-    constructor() {
-        super(64, 32, 8, false);
+    constructor(outputLen = 32) {
+        super(64, outputLen, 8, false);
         // We cannot use array here since array allows indexing by variable
         // which means optimizer/compiler cannot use registers.
         this.A = SHA256_IV[0] | 0;
@@ -5943,15 +6036,929 @@ class SHA256 extends HashMD {
         this.set(A, B, C, D, E, F, G, H);
     }
     roundClean() {
-        SHA256_W.fill(0);
+        clean(SHA256_W);
     }
     destroy() {
         this.set(0, 0, 0, 0, 0, 0, 0, 0);
-        this.buffer.fill(0);
+        clean(this.buffer);
+    }
+}
+/**
+ * SHA2-256 hash function from RFC 4634.
+ *
+ * It is the fastest JS hash, even faster than Blake3.
+ * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+ * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ */
+const sha256$1 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+/**
+ * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+ *
+ * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+ * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ *
+ * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ * @deprecated
+ */
+/** @deprecated Use import from `noble/hashes/sha2` module */
+const sha256 = sha256$1;
+
+var Protocols;
+(function (Protocols) {
+    Protocols["Relay"] = "relay";
+    Protocols["Store"] = "store";
+    Protocols["LightPush"] = "lightpush";
+    Protocols["Filter"] = "filter";
+})(Protocols || (Protocols = {}));
+var ProtocolError;
+(function (ProtocolError) {
+    //
+    // GENERAL ERRORS SECTION
+    //
+    /**
+     * Could not determine the origin of the fault. Best to check connectivity and try again
+     * */
+    ProtocolError["GENERIC_FAIL"] = "Generic error";
+    /**
+     * The remote peer rejected the message. Information provided by the remote peer
+     * is logged. Review message validity, or mitigation for `NO_PEER_AVAILABLE`
+     * or `DECODE_FAILED` can be used.
+     */
+    ProtocolError["REMOTE_PEER_REJECTED"] = "Remote peer rejected";
+    /**
+     * Failure to protobuf decode the message. May be due to a remote peer issue,
+     * ensuring that messages are sent via several peer enable mitigation of this error.
+     */
+    ProtocolError["DECODE_FAILED"] = "Failed to decode";
+    /**
+     * Failure to find a peer with suitable protocols. This may due to a connection issue.
+     * Mitigation can be: retrying after a given time period, display connectivity issue
+     * to user or listening for `peer:connected:bootstrap` or `peer:connected:peer-exchange`
+     * on the connection manager before retrying.
+     */
+    ProtocolError["NO_PEER_AVAILABLE"] = "No peer available";
+    /**
+     * Failure to find a stream to the peer. This may be because the connection with the peer is not still alive.
+     * Mitigation can be: retrying after a given time period, or mitigation for `NO_PEER_AVAILABLE` can be used.
+     */
+    ProtocolError["NO_STREAM_AVAILABLE"] = "No stream available";
+    /**
+     * The remote peer did not behave as expected. Mitigation for `NO_PEER_AVAILABLE`
+     * or `DECODE_FAILED` can be used.
+     */
+    ProtocolError["NO_RESPONSE"] = "No response received";
+    //
+    // SEND ERRORS SECTION
+    //
+    /**
+     * Failure to protobuf encode the message. This is not recoverable and needs
+     * further investigation.
+     */
+    ProtocolError["ENCODE_FAILED"] = "Failed to encode";
+    /**
+     * The message payload is empty, making the message invalid. Ensure that a non-empty
+     * payload is set on the outgoing message.
+     */
+    ProtocolError["EMPTY_PAYLOAD"] = "Payload is empty";
+    /**
+     * The message size is above the maximum message size allowed on the Waku Network.
+     * Compressing the message or using an alternative strategy for large messages is recommended.
+     */
+    ProtocolError["SIZE_TOO_BIG"] = "Size is too big";
+    /**
+     * The PubsubTopic passed to the send function is not configured on the Waku node.
+     * Please ensure that the PubsubTopic is used when initializing the Waku node.
+     */
+    ProtocolError["TOPIC_NOT_CONFIGURED"] = "Topic not configured";
+    /**
+     * Fails when
+     */
+    ProtocolError["STREAM_ABORTED"] = "Stream aborted";
+    /**
+     * General proof generation error message.
+     * nwaku: https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/waku/waku_rln_relay/group_manager/group_manager_base.nim#L201C19-L201C42
+     */
+    ProtocolError["RLN_PROOF_GENERATION"] = "Proof generation failed";
+    //
+    // RECEIVE ERRORS SECTION
+    //
+    /**
+     * The pubsub topic configured on the decoder does not match the pubsub topic setup on the protocol.
+     * Ensure that the pubsub topic used for decoder creation is the same as the one used for protocol.
+     */
+    ProtocolError["TOPIC_DECODER_MISMATCH"] = "Topic decoder mismatch";
+    /**
+     * The topics passed in the decoders do not match each other, or don't exist at all.
+     * Ensure that all the pubsub topics used in the decoders are valid and match each other.
+     */
+    ProtocolError["INVALID_DECODER_TOPICS"] = "Invalid decoder topics";
+})(ProtocolError || (ProtocolError = {}));
+
+var Tags;
+(function (Tags) {
+    Tags["BOOTSTRAP"] = "bootstrap";
+    Tags["PEER_EXCHANGE"] = "peer-exchange";
+    Tags["LOCAL"] = "local-peer-cache";
+})(Tags || (Tags = {}));
+var EPeersByDiscoveryEvents;
+(function (EPeersByDiscoveryEvents) {
+    EPeersByDiscoveryEvents["PEER_DISCOVERY_BOOTSTRAP"] = "peer:discovery:bootstrap";
+    EPeersByDiscoveryEvents["PEER_DISCOVERY_PEER_EXCHANGE"] = "peer:discovery:peer-exchange";
+    EPeersByDiscoveryEvents["PEER_CONNECT_BOOTSTRAP"] = "peer:connected:bootstrap";
+    EPeersByDiscoveryEvents["PEER_CONNECT_PEER_EXCHANGE"] = "peer:connected:peer-exchange";
+})(EPeersByDiscoveryEvents || (EPeersByDiscoveryEvents = {}));
+var EConnectionStateEvents;
+(function (EConnectionStateEvents) {
+    EConnectionStateEvents["CONNECTION_STATUS"] = "waku:connection";
+})(EConnectionStateEvents || (EConnectionStateEvents = {}));
+
+var HealthStatusChangeEvents;
+(function (HealthStatusChangeEvents) {
+    HealthStatusChangeEvents["StatusChange"] = "health:change";
+})(HealthStatusChangeEvents || (HealthStatusChangeEvents = {}));
+var HealthStatus;
+(function (HealthStatus) {
+    HealthStatus["Unhealthy"] = "Unhealthy";
+    HealthStatus["MinimallyHealthy"] = "MinimallyHealthy";
+    HealthStatus["SufficientlyHealthy"] = "SufficientlyHealthy";
+})(HealthStatus || (HealthStatus = {}));
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var browser = {exports: {}};
+
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function (val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
+
+function setup(env) {
+	createDebug.debug = createDebug;
+	createDebug.default = createDebug;
+	createDebug.coerce = coerce;
+	createDebug.disable = disable;
+	createDebug.enable = enable;
+	createDebug.enabled = enabled;
+	createDebug.humanize = requireMs();
+	createDebug.destroy = destroy;
+
+	Object.keys(env).forEach(key => {
+		createDebug[key] = env[key];
+	});
+
+	/**
+	* The currently active debug mode names, and names to skip.
+	*/
+
+	createDebug.names = [];
+	createDebug.skips = [];
+
+	/**
+	* Map of special "%n" handling functions, for the debug "format" argument.
+	*
+	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	*/
+	createDebug.formatters = {};
+
+	/**
+	* Selects a color for a debug namespace
+	* @param {String} namespace The namespace string for the debug instance to be colored
+	* @return {Number|String} An ANSI color code for the given namespace
+	* @api private
+	*/
+	function selectColor(namespace) {
+		let hash = 0;
+
+		for (let i = 0; i < namespace.length; i++) {
+			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+			hash |= 0; // Convert to 32bit integer
+		}
+
+		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+	}
+	createDebug.selectColor = selectColor;
+
+	/**
+	* Create a debugger with the given `namespace`.
+	*
+	* @param {String} namespace
+	* @return {Function}
+	* @api public
+	*/
+	function createDebug(namespace) {
+		let prevTime;
+		let enableOverride = null;
+		let namespacesCache;
+		let enabledCache;
+
+		function debug(...args) {
+			// Disabled?
+			if (!debug.enabled) {
+				return;
+			}
+
+			const self = debug;
+
+			// Set `diff` timestamp
+			const curr = Number(new Date());
+			const ms = curr - (prevTime || curr);
+			self.diff = ms;
+			self.prev = prevTime;
+			self.curr = curr;
+			prevTime = curr;
+
+			args[0] = createDebug.coerce(args[0]);
+
+			if (typeof args[0] !== 'string') {
+				// Anything else let's inspect with %O
+				args.unshift('%O');
+			}
+
+			// Apply any `formatters` transformations
+			let index = 0;
+			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+				// If we encounter an escaped % then don't increase the array index
+				if (match === '%%') {
+					return '%';
+				}
+				index++;
+				const formatter = createDebug.formatters[format];
+				if (typeof formatter === 'function') {
+					const val = args[index];
+					match = formatter.call(self, val);
+
+					// Now we need to remove `args[index]` since it's inlined in the `format`
+					args.splice(index, 1);
+					index--;
+				}
+				return match;
+			});
+
+			// Apply env-specific formatting (colors, etc.)
+			createDebug.formatArgs.call(self, args);
+
+			const logFn = self.log || createDebug.log;
+			logFn.apply(self, args);
+		}
+
+		debug.namespace = namespace;
+		debug.useColors = createDebug.useColors();
+		debug.color = createDebug.selectColor(namespace);
+		debug.extend = extend;
+		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+		Object.defineProperty(debug, 'enabled', {
+			enumerable: true,
+			configurable: false,
+			get: () => {
+				if (enableOverride !== null) {
+					return enableOverride;
+				}
+				if (namespacesCache !== createDebug.namespaces) {
+					namespacesCache = createDebug.namespaces;
+					enabledCache = createDebug.enabled(namespace);
+				}
+
+				return enabledCache;
+			},
+			set: v => {
+				enableOverride = v;
+			}
+		});
+
+		// Env-specific initialization logic for debug instances
+		if (typeof createDebug.init === 'function') {
+			createDebug.init(debug);
+		}
+
+		return debug;
+	}
+
+	function extend(namespace, delimiter) {
+		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+		newDebug.log = this.log;
+		return newDebug;
+	}
+
+	/**
+	* Enables a debug mode by namespaces. This can include modes
+	* separated by a colon and wildcards.
+	*
+	* @param {String} namespaces
+	* @api public
+	*/
+	function enable(namespaces) {
+		createDebug.save(namespaces);
+		createDebug.namespaces = namespaces;
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		const split = (typeof namespaces === 'string' ? namespaces : '')
+			.trim()
+			.replace(/\s+/g, ',')
+			.split(',')
+			.filter(Boolean);
+
+		for (const ns of split) {
+			if (ns[0] === '-') {
+				createDebug.skips.push(ns.slice(1));
+			} else {
+				createDebug.names.push(ns);
+			}
+		}
+	}
+
+	/**
+	 * Checks if the given string matches a namespace template, honoring
+	 * asterisks as wildcards.
+	 *
+	 * @param {String} search
+	 * @param {String} template
+	 * @return {Boolean}
+	 */
+	function matchesTemplate(search, template) {
+		let searchIndex = 0;
+		let templateIndex = 0;
+		let starIndex = -1;
+		let matchIndex = 0;
+
+		while (searchIndex < search.length) {
+			if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
+				// Match character or proceed with wildcard
+				if (template[templateIndex] === '*') {
+					starIndex = templateIndex;
+					matchIndex = searchIndex;
+					templateIndex++; // Skip the '*'
+				} else {
+					searchIndex++;
+					templateIndex++;
+				}
+			} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition
+				// Backtrack to the last '*' and try to match more characters
+				templateIndex = starIndex + 1;
+				matchIndex++;
+				searchIndex = matchIndex;
+			} else {
+				return false; // No match
+			}
+		}
+
+		// Handle trailing '*' in template
+		while (templateIndex < template.length && template[templateIndex] === '*') {
+			templateIndex++;
+		}
+
+		return templateIndex === template.length;
+	}
+
+	/**
+	* Disable debug output.
+	*
+	* @return {String} namespaces
+	* @api public
+	*/
+	function disable() {
+		const namespaces = [
+			...createDebug.names,
+			...createDebug.skips.map(namespace => '-' + namespace)
+		].join(',');
+		createDebug.enable('');
+		return namespaces;
+	}
+
+	/**
+	* Returns true if the given mode name is enabled, false otherwise.
+	*
+	* @param {String} name
+	* @return {Boolean}
+	* @api public
+	*/
+	function enabled(name) {
+		for (const skip of createDebug.skips) {
+			if (matchesTemplate(name, skip)) {
+				return false;
+			}
+		}
+
+		for (const ns of createDebug.names) {
+			if (matchesTemplate(name, ns)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	* Coerce `val`.
+	*
+	* @param {Mixed} val
+	* @return {Mixed}
+	* @api private
+	*/
+	function coerce(val) {
+		if (val instanceof Error) {
+			return val.stack || val.message;
+		}
+		return val;
+	}
+
+	/**
+	* XXX DO NOT USE. This is a temporary stub function.
+	* XXX It WILL be removed in the next major release.
+	*/
+	function destroy() {
+		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+	}
+
+	createDebug.enable(createDebug.load());
+
+	return createDebug;
+}
+
+var common = setup;
+
+/* eslint-env browser */
+
+(function (module, exports) {
+	/**
+	 * This is the web browser implementation of `debug()`.
+	 */
+
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	exports.storage = localstorage();
+	exports.destroy = (() => {
+		let warned = false;
+
+		return () => {
+			if (!warned) {
+				warned = true;
+				console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+			}
+		};
+	})();
+
+	/**
+	 * Colors.
+	 */
+
+	exports.colors = [
+		'#0000CC',
+		'#0000FF',
+		'#0033CC',
+		'#0033FF',
+		'#0066CC',
+		'#0066FF',
+		'#0099CC',
+		'#0099FF',
+		'#00CC00',
+		'#00CC33',
+		'#00CC66',
+		'#00CC99',
+		'#00CCCC',
+		'#00CCFF',
+		'#3300CC',
+		'#3300FF',
+		'#3333CC',
+		'#3333FF',
+		'#3366CC',
+		'#3366FF',
+		'#3399CC',
+		'#3399FF',
+		'#33CC00',
+		'#33CC33',
+		'#33CC66',
+		'#33CC99',
+		'#33CCCC',
+		'#33CCFF',
+		'#6600CC',
+		'#6600FF',
+		'#6633CC',
+		'#6633FF',
+		'#66CC00',
+		'#66CC33',
+		'#9900CC',
+		'#9900FF',
+		'#9933CC',
+		'#9933FF',
+		'#99CC00',
+		'#99CC33',
+		'#CC0000',
+		'#CC0033',
+		'#CC0066',
+		'#CC0099',
+		'#CC00CC',
+		'#CC00FF',
+		'#CC3300',
+		'#CC3333',
+		'#CC3366',
+		'#CC3399',
+		'#CC33CC',
+		'#CC33FF',
+		'#CC6600',
+		'#CC6633',
+		'#CC9900',
+		'#CC9933',
+		'#CCCC00',
+		'#CCCC33',
+		'#FF0000',
+		'#FF0033',
+		'#FF0066',
+		'#FF0099',
+		'#FF00CC',
+		'#FF00FF',
+		'#FF3300',
+		'#FF3333',
+		'#FF3366',
+		'#FF3399',
+		'#FF33CC',
+		'#FF33FF',
+		'#FF6600',
+		'#FF6633',
+		'#FF9900',
+		'#FF9933',
+		'#FFCC00',
+		'#FFCC33'
+	];
+
+	/**
+	 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+	 * and the Firebug extension (any Firefox version) are known
+	 * to support "%c" CSS customizations.
+	 *
+	 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+	 */
+
+	// eslint-disable-next-line complexity
+	function useColors() {
+		// NB: In an Electron preload script, document will be defined but not fully
+		// initialized. Since we know we're in Chrome, we'll just detect this case
+		// explicitly
+		if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+			return true;
+		}
+
+		// Internet Explorer and Edge do not support colors.
+		if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+			return false;
+		}
+
+		let m;
+
+		// Is webkit? http://stackoverflow.com/a/16459606/376773
+		// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+		// eslint-disable-next-line no-return-assign
+		return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+			// Is firebug? http://stackoverflow.com/a/398120/376773
+			(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+			// Is firefox >= v31?
+			// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+			(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
+			// Double check webkit in userAgent just in case we are in a worker
+			(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+	}
+
+	/**
+	 * Colorize log arguments if enabled.
+	 *
+	 * @api public
+	 */
+
+	function formatArgs(args) {
+		args[0] = (this.useColors ? '%c' : '') +
+			this.namespace +
+			(this.useColors ? ' %c' : ' ') +
+			args[0] +
+			(this.useColors ? '%c ' : ' ') +
+			'+' + module.exports.humanize(this.diff);
+
+		if (!this.useColors) {
+			return;
+		}
+
+		const c = 'color: ' + this.color;
+		args.splice(1, 0, c, 'color: inherit');
+
+		// The final "%c" is somewhat tricky, because there could be other
+		// arguments passed either before or after the %c, so we need to
+		// figure out the correct index to insert the CSS into
+		let index = 0;
+		let lastC = 0;
+		args[0].replace(/%[a-zA-Z%]/g, match => {
+			if (match === '%%') {
+				return;
+			}
+			index++;
+			if (match === '%c') {
+				// We only are interested in the *last* %c
+				// (the user may have provided their own)
+				lastC = index;
+			}
+		});
+
+		args.splice(lastC, 0, c);
+	}
+
+	/**
+	 * Invokes `console.debug()` when available.
+	 * No-op when `console.debug` is not a "function".
+	 * If `console.debug` is not available, falls back
+	 * to `console.log`.
+	 *
+	 * @api public
+	 */
+	exports.log = console.debug || console.log || (() => {});
+
+	/**
+	 * Save `namespaces`.
+	 *
+	 * @param {String} namespaces
+	 * @api private
+	 */
+	function save(namespaces) {
+		try {
+			if (namespaces) {
+				exports.storage.setItem('debug', namespaces);
+			} else {
+				exports.storage.removeItem('debug');
+			}
+		} catch (error) {
+			// Swallow
+			// XXX (@Qix-) should we be logging these?
+		}
+	}
+
+	/**
+	 * Load `namespaces`.
+	 *
+	 * @return {String} returns the previously persisted debug modes
+	 * @api private
+	 */
+	function load() {
+		let r;
+		try {
+			r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ;
+		} catch (error) {
+			// Swallow
+			// XXX (@Qix-) should we be logging these?
+		}
+
+		// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+		if (!r && typeof process !== 'undefined' && 'env' in process) {
+			r = process.env.DEBUG;
+		}
+
+		return r;
+	}
+
+	/**
+	 * Localstorage attempts to return the localstorage.
+	 *
+	 * This is necessary because safari throws
+	 * when a user disables cookies/localstorage
+	 * and you attempt to access it.
+	 *
+	 * @return {LocalStorage}
+	 * @api private
+	 */
+
+	function localstorage() {
+		try {
+			// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+			// The Browser also has localStorage in the global context.
+			return localStorage;
+		} catch (error) {
+			// Swallow
+			// XXX (@Qix-) should we be logging these?
+		}
+	}
+
+	module.exports = common(exports);
+
+	const {formatters} = module.exports;
+
+	/**
+	 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+	 */
+
+	formatters.j = function (v) {
+		try {
+			return JSON.stringify(v);
+		} catch (error) {
+			return '[UnexpectedJSONParseError]: ' + error.message;
+		}
+	}; 
+} (browser, browser.exports));
+
+var browserExports = browser.exports;
+var debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
+
+const APP_NAME = "waku";
+class Logger {
+    _info;
+    _warn;
+    _error;
+    static createDebugNamespace(level, prefix) {
+        return prefix ? `${APP_NAME}:${level}:${prefix}` : `${APP_NAME}:${level}`;
+    }
+    constructor(prefix) {
+        this._info = debug(Logger.createDebugNamespace("info", prefix));
+        this._warn = debug(Logger.createDebugNamespace("warn", prefix));
+        this._error = debug(Logger.createDebugNamespace("error", prefix));
+    }
+    get info() {
+        return this._info;
+    }
+    get warn() {
+        return this._warn;
+    }
+    get error() {
+        return this._error;
+    }
+    log(level, ...args) {
+        const logger = this[level];
+        logger(...args);
     }
 }
-/** SHA2-256 hash function */
-const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
 const DEFAULT_BLOOM_FILTER_OPTIONS = {
     capacity: 10000,
@@ -5959,14 +6966,15 @@ const DEFAULT_BLOOM_FILTER_OPTIONS = {
 };
 const DEFAULT_CAUSAL_HISTORY_SIZE = 2;
 const DEFAULT_RECEIVED_MESSAGE_TIMEOUT = 1000 * 60 * 5; // 5 minutes
+const log = new Logger("sds:message-channel");
 class MessageChannel extends TypedEventEmitter {
+    channelId;
     lamportTimestamp;
     filter;
     outgoingBuffer;
     acknowledgements;
     incomingBuffer;
     localHistory;
-    channelId;
     causalHistorySize;
     acknowledgementCount;
     timeReceived;
@@ -6002,40 +7010,61 @@ class MessageChannel extends TypedEventEmitter {
         this.receivedMessageTimeout =
             options.receivedMessageTimeout ?? DEFAULT_RECEIVED_MESSAGE_TIMEOUT;
     }
-    // Periodically called by the library consumer to process async operations
-    // in a sequential manner.
+    static getMessageId(payload) {
+        return bytesToHex(sha256(payload));
+    }
+    /**
+     * Processes all queued tasks sequentially to ensure proper message ordering.
+     *
+     * This method should be called periodically by the library consumer to execute
+     * queued send/receive operations in the correct sequence.
+     *
+     * @example
+     * ```typescript
+     * const channel = new MessageChannel("my-channel");
+     *
+     * // Queue some operations
+     * await channel.sendMessage(payload, callback);
+     * channel.receiveMessage(incomingMessage);
+     *
+     * // Process all queued operations
+     * await channel.processTasks();
+     * ```
+     *
+     * @throws Will emit a 'taskError' event if any task fails, but continues processing remaining tasks
+     */
     async processTasks() {
         while (this.tasks.length > 0) {
             const item = this.tasks.shift();
             if (!item) {
                 continue;
             }
-            // Use a generic helper function to ensure type safety
             await this.executeTask(item);
         }
     }
-    async executeTask(item) {
-        const handler = this.handlers[item.command];
-        await handler(item.params);
-    }
-    static getMessageId(payload) {
-        return bytesToHex(sha256(payload));
-    }
     /**
-     * Send a message to the SDS channel.
+     * Queues a message to be sent on this channel.
      *
-     * Increments the lamport timestamp, constructs a `Message` object
-     * with the given payload, and adds it to the outgoing buffer.
+     * The message will be processed sequentially when processTasks() is called.
+     * This ensures proper lamport timestamp ordering and causal history tracking.
      *
-     * If the callback is successful, the message is also added to
-     * the bloom filter and message history. In the context of
-     * Waku, this likely means the message was published via
-     * light push or relay.
+     * @param payload - The message content as a byte array
+     * @param callback - Optional callback function called after the message is processed
+     * @returns Promise that resolves when the message is queued (not sent)
      *
-     * See https://rfc.vac.dev/vac/raw/sds/#send-message
+     * @example
+     * ```typescript
+     * const channel = new MessageChannel("chat-room");
+     * const message = new TextEncoder().encode("Hello, world!");
      *
-     * @param payload - The payload to send.
-     * @param callback - A callback function that returns a boolean indicating whether the message was sent successfully.
+     * await channel.sendMessage(message, async (processedMessage) => {
+     *   console.log("Message processed:", processedMessage.messageId);
+     *   return { success: true };
+     * });
+     *
+     * // Actually send the message
+     * await channel.processTasks();
+     * ```
      */
     async sendMessage(payload, callback) {
         this.tasks.push({
@@ -6046,38 +7075,6 @@ class MessageChannel extends TypedEventEmitter {
             }
         });
     }
-    async _sendMessage(payload, callback) {
-        this.lamportTimestamp++;
-        const messageId = MessageChannel.getMessageId(payload);
-        const message = {
-            messageId,
-            channelId: this.channelId,
-            lamportTimestamp: this.lamportTimestamp,
-            causalHistory: this.localHistory
-                .slice(-this.causalHistorySize)
-                .map(({ historyEntry }) => historyEntry),
-            bloomFilter: this.filter.toBytes(),
-            content: payload
-        };
-        this.outgoingBuffer.push(message);
-        if (callback) {
-            const { success, retrievalHint } = await callback(message);
-            if (success) {
-                this.filter.insert(messageId);
-                this.localHistory.push({
-                    timestamp: this.lamportTimestamp,
-                    historyEntry: {
-                        messageId,
-                        retrievalHint
-                    }
-                });
-                this.timeReceived.set(messageId, Date.now());
-                this.safeDispatchEvent(MessageChannelEvent.MessageSent, {
-                    detail: message
-                });
-            }
-        }
-    }
     /**
      * Sends a short-lived message without synchronization or reliability requirements.
      *
@@ -6100,32 +7097,24 @@ class MessageChannel extends TypedEventEmitter {
             }
         });
     }
-    async _sendEphemeralMessage(payload, callback) {
-        const message = {
-            messageId: MessageChannel.getMessageId(payload),
-            channelId: this.channelId,
-            content: payload,
-            lamportTimestamp: undefined,
-            causalHistory: [],
-            bloomFilter: undefined
-        };
-        if (callback) {
-            await callback(message);
-        }
-    }
     /**
-     * Process a received SDS message for this channel.
+     * Queues a received message for processing.
+     *
+     * The message will be processed when processTasks() is called, ensuring
+     * proper dependency resolution and causal ordering.
+     *
+     * @param message - The message to receive and process
      *
-     * Review the acknowledgement status of messages in the outgoing buffer
-     * by inspecting the received message's bloom filter and causal history.
-     * Add the received message to the bloom filter.
-     * If the local history contains every message in the received message's
-     * causal history, deliver the message. Otherwise, add the message to the
-     * incoming buffer.
+     * @example
+     * ```typescript
+     * const channel = new MessageChannel("chat-room");
      *
-     * See https://rfc.vac.dev/vac/raw/sds/#receive-message
+     * // Receive a message from the network
+     * channel.receiveMessage(incomingMessage);
      *
-     * @param message - The received SDS message.
+     * // Process the received message
+     * await channel.processTasks();
+     * ```
      */
     receiveMessage(message) {
         this.tasks.push({
@@ -6135,62 +7124,17 @@ class MessageChannel extends TypedEventEmitter {
             }
         });
     }
-    _receiveMessage(message) {
-        if (message.content &&
-            message.content.length > 0 &&
-            this.timeReceived.has(message.messageId)) {
-            // Received a duplicate message
-            return;
-        }
-        if (!message.lamportTimestamp) {
-            // Messages with no timestamp are ephemeral messages and should be delivered immediately
-            this.deliverMessage(message);
-            return;
-        }
-        if (message.content?.length === 0) {
-            this.safeDispatchEvent(MessageChannelEvent.SyncReceived, {
-                detail: message
-            });
-        }
-        else {
-            this.safeDispatchEvent(MessageChannelEvent.MessageReceived, {
-                detail: message
-            });
-        }
-        // review ack status
-        this.reviewAckStatus(message);
-        // add to bloom filter (skip for messages with empty content)
-        if (message.content?.length && message.content.length > 0) {
-            this.filter.insert(message.messageId);
-        }
-        // verify causal history
-        const dependenciesMet = message.causalHistory.every((historyEntry) => this.localHistory.some(({ historyEntry: { messageId } }) => messageId === historyEntry.messageId));
-        if (!dependenciesMet) {
-            this.incomingBuffer.push(message);
-            this.timeReceived.set(message.messageId, Date.now());
-        }
-        else {
-            this.deliverMessage(message);
-            this.safeDispatchEvent(MessageChannelEvent.MessageDelivered, {
-                detail: {
-                    messageId: message.messageId,
-                    sentOrReceived: "received"
-                }
-            });
-        }
-    }
-    // https://rfc.vac.dev/vac/raw/sds/#periodic-incoming-buffer-sweep
-    // Note that even though this function has side effects, it is not async
-    // and does not need to be called through the queue.
+    /**
+     * Processes messages in the incoming buffer, delivering those with satisfied dependencies.
+     *
+     * @returns Array of history entries for messages still missing dependencies
+     */
     sweepIncomingBuffer() {
         const { buffer, missing } = this.incomingBuffer.reduce(({ buffer, missing }, message) => {
-            // Check each message for missing dependencies
             const missingDependencies = message.causalHistory.filter((messageHistoryEntry) => !this.localHistory.some(({ historyEntry: { messageId } }) => messageId === messageHistoryEntry.messageId));
             if (missingDependencies.length === 0) {
-                // Any message with no missing dependencies is delivered
-                // and removed from the buffer (implicitly by not adding it to the new incoming buffer)
                 this.deliverMessage(message);
-                this.safeDispatchEvent(MessageChannelEvent.MessageDelivered, {
+                this.safeSendEvent(MessageChannelEvent.MessageDelivered, {
                     detail: {
                         messageId: message.messageId,
                         sentOrReceived: "received"
@@ -6207,8 +7151,6 @@ class MessageChannel extends TypedEventEmitter {
                     return { buffer, missing };
                 }
             }
-            // Any message with missing dependencies stays in the buffer
-            // and the missing message IDs are returned for processing.
             missingDependencies.forEach((dependency) => {
                 missing.add(dependency);
             });
@@ -6217,16 +7159,14 @@ class MessageChannel extends TypedEventEmitter {
                 missing
             };
         }, { buffer: new Array(), missing: new Set() });
-        // Update the incoming buffer to only include messages with no missing dependencies
         this.incomingBuffer = buffer;
-        this.safeDispatchEvent(MessageChannelEvent.MissedMessages, {
+        this.safeSendEvent(MessageChannelEvent.MissedMessages, {
             detail: Array.from(missing)
         });
         return Array.from(missing);
     }
     // https://rfc.vac.dev/vac/raw/sds/#periodic-outgoing-buffer-sweep
     sweepOutgoingBuffer() {
-        // Partition all messages in the outgoing buffer into unacknowledged and possibly acknowledged messages
         return this.outgoingBuffer.reduce(({ unacknowledged, possiblyAcknowledged }, message) => {
             if (this.acknowledgements.has(message.messageId)) {
                 return {
@@ -6267,13 +7207,136 @@ class MessageChannel extends TypedEventEmitter {
             content: emptyMessage
         };
         if (callback) {
-            await callback(message);
-            this.safeDispatchEvent(MessageChannelEvent.SyncSent, {
+            try {
+                await callback(message);
+                this.safeSendEvent(MessageChannelEvent.SyncSent, {
+                    detail: message
+                });
+                return true;
+            }
+            catch (error) {
+                log.error("Callback execution failed in sendSyncMessage:", error);
+                throw error;
+            }
+        }
+        return false;
+    }
+    _receiveMessage(message) {
+        const isDuplicate = message.content &&
+            message.content.length > 0 &&
+            this.timeReceived.has(message.messageId);
+        if (isDuplicate) {
+            return;
+        }
+        if (!message.lamportTimestamp) {
+            this.deliverMessage(message);
+            return;
+        }
+        if (message.content?.length === 0) {
+            this.safeSendEvent(MessageChannelEvent.SyncReceived, {
                 detail: message
             });
-            return true;
         }
-        return false;
+        else {
+            this.safeSendEvent(MessageChannelEvent.MessageReceived, {
+                detail: message
+            });
+        }
+        this.reviewAckStatus(message);
+        if (message.content?.length && message.content.length > 0) {
+            this.filter.insert(message.messageId);
+        }
+        const dependenciesMet = message.causalHistory.every((historyEntry) => this.localHistory.some(({ historyEntry: { messageId } }) => messageId === historyEntry.messageId));
+        if (!dependenciesMet) {
+            this.incomingBuffer.push(message);
+            this.timeReceived.set(message.messageId, Date.now());
+        }
+        else {
+            this.deliverMessage(message);
+            this.safeSendEvent(MessageChannelEvent.MessageDelivered, {
+                detail: {
+                    messageId: message.messageId,
+                    sentOrReceived: "received"
+                }
+            });
+        }
+    }
+    async executeTask(item) {
+        try {
+            const handler = this.handlers[item.command];
+            await handler(item.params);
+        }
+        catch (error) {
+            log.error(`Task execution failed for command ${item.command}:`, error);
+            this.dispatchEvent(new CustomEvent("taskError", {
+                detail: { command: item.command, error, params: item.params }
+            }));
+        }
+    }
+    safeSendEvent(event, eventInit) {
+        try {
+            this.dispatchEvent(new CustomEvent(event, eventInit));
+        }
+        catch (error) {
+            log.error(`Failed to dispatch event ${event}:`, error);
+        }
+    }
+    async _sendMessage(payload, callback) {
+        this.lamportTimestamp++;
+        const messageId = MessageChannel.getMessageId(payload);
+        const message = {
+            messageId,
+            channelId: this.channelId,
+            lamportTimestamp: this.lamportTimestamp,
+            causalHistory: this.localHistory
+                .slice(-this.causalHistorySize)
+                .map(({ historyEntry }) => historyEntry),
+            bloomFilter: this.filter.toBytes(),
+            content: payload
+        };
+        this.outgoingBuffer.push(message);
+        if (callback) {
+            try {
+                const { success, retrievalHint } = await callback(message);
+                if (success) {
+                    this.filter.insert(messageId);
+                    this.localHistory.push({
+                        timestamp: this.lamportTimestamp,
+                        historyEntry: {
+                            messageId,
+                            retrievalHint
+                        }
+                    });
+                    this.timeReceived.set(messageId, Date.now());
+                    this.safeSendEvent(MessageChannelEvent.MessageSent, {
+                        detail: message
+                    });
+                }
+            }
+            catch (error) {
+                log.error("Callback execution failed in _sendMessage:", error);
+                throw error;
+            }
+        }
+    }
+    async _sendEphemeralMessage(payload, callback) {
+        const message = {
+            messageId: MessageChannel.getMessageId(payload),
+            channelId: this.channelId,
+            content: payload,
+            lamportTimestamp: undefined,
+            causalHistory: [],
+            bloomFilter: undefined
+        };
+        if (callback) {
+            try {
+                await callback(message);
+            }
+            catch (error) {
+                log.error("Callback execution failed in _sendEphemeralMessage:", error);
+                throw error;
+            }
+        }
     }
     // See https://rfc.vac.dev/vac/raw/sds/#deliver-message
     deliverMessage(message, retrievalHint) {
@@ -6311,13 +7374,12 @@ class MessageChannel extends TypedEventEmitter {
     // to determine the acknowledgement status of messages in the outgoing buffer.
     // See https://rfc.vac.dev/vac/raw/sds/#review-ack-status
     reviewAckStatus(receivedMessage) {
-        // the participant MUST mark all messages in the received causal_history as acknowledged.
         receivedMessage.causalHistory.forEach(({ messageId }) => {
             this.outgoingBuffer = this.outgoingBuffer.filter(({ messageId: outgoingMessageId }) => {
                 if (outgoingMessageId !== messageId) {
                     return true;
                 }
-                this.safeDispatchEvent(MessageChannelEvent.MessageAcknowledged, {
+                this.safeSendEvent(MessageChannelEvent.MessageAcknowledged, {
                     detail: messageId
                 });
                 return false;
@@ -6327,7 +7389,6 @@ class MessageChannel extends TypedEventEmitter {
                 this.filter.insert(messageId);
             }
         });
-        // the participant MUST mark all messages included in the bloom_filter as possibly acknowledged
         if (!receivedMessage.bloomFilter) {
             return;
         }
@@ -6342,7 +7403,7 @@ class MessageChannel extends TypedEventEmitter {
             const count = (this.acknowledgements.get(message.messageId) ?? 0) + 1;
             if (count < this.acknowledgementCount) {
                 this.acknowledgements.set(message.messageId, count);
-                this.safeDispatchEvent(MessageChannelEvent.PartialAcknowledgement, {
+                this.safeSendEvent(MessageChannelEvent.PartialAcknowledgement, {
                     detail: {
                         messageId: message.messageId,
                         count
@@ -6360,4 +7421,4 @@ class MessageChannel extends TypedEventEmitter {
     }
 }
 
-export { BloomFilter, Command, DEFAULT_BLOOM_FILTER_OPTIONS, MessageChannel, MessageChannelEvent, decodeMessage, encodeMessage };
+export { BloomFilter, MessageChannel, MessageChannelEvent, decodeMessage, encodeMessage };