@waku/core 0.0.6 → 0.0.8

package/bundle/{message-70dbb19b.js → peer_exchange-df95c3a7.js}

@@ -746,16 +746,6 @@ var common$1 = setup;
 
 var debug = browser.exports;
 
-var protobufjs = {exports: {}};
-
-var src = {exports: {}};
-
-var indexLight = {exports: {}};
-
-var indexMinimal = {};
-
-var minimal = {};
-
 var aspromise = asPromise$1;
 
 /**
@@ -1535,6 +1525,16 @@ function pool(alloc, slice, size) {
     };
 }
 
+var protobufjs = {exports: {}};
+
+var src = {exports: {}};
+
+var indexLight = {exports: {}};
+
+var indexMinimal = {};
+
+var minimal = {};
+
 var longbits;
 var hasRequiredLongbits;
 
@@ -5430,7 +5430,7 @@ function requireService () {
 	return service;
 }
 
-var message$1 = Message;
+var message$2 = Message;
 
 var util$1 = requireMinimal();
 
@@ -6212,7 +6212,7 @@ var wrappers = {};
 	 */
 	var wrappers = exports;
 
-	var Message = message$1;
+	var Message = message$2;
 
 	/**
 	 * From object converter part of an {@link IWrapper}.
@@ -6324,7 +6324,7 @@ function requireType () {
 	    Field     = requireField(),
 	    MapField  = requireMapfield(),
 	    Service   = requireService(),
-	    Message   = message$1,
+	    Message   = message$2,
 	    Reader    = reader,
 	    Writer    = writer,
 	    util      = requireUtil(),
@@ -8153,7 +8153,7 @@ function requireEncoder () {
 	protobuf.Method           = requireMethod();
 
 	// Runtime
-	protobuf.Message          = message$1;
+	protobuf.Message          = message$2;
 	protobuf.wrappers         = wrappers;
 
 	// Utility
@@ -9911,8 +9911,1891 @@ function createCodec(name, type, encode, decode) {
     };
 }
 
-function message(encode, decode) {
+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);
+}
+
+function message$1(encode, decode) {
     return createCodec('message', CODEC_TYPES.LENGTH_DELIMITED, encode, decode);
 }
 
-export { CODEC_TYPES as C, aspromise as a, base64$1 as b, commonjsGlobal as c, debug as d, eventemitter as e, float as f, getAugmentedNamespace as g, getDefaultExportFromCjs as h, inquire_1 as i, createCodec as j, encodeMessage as k, decodeMessage as l, message as m, pool_1 as p, utf8$2 as u };
+/* eslint-disable import/export */
+var RateLimitProof$3;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof$3 || (RateLimitProof$3 = {}));
+var WakuMessage$3;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof$3.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage$3 || (WakuMessage$3 = {}));
+
+var message = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	get RateLimitProof () { return RateLimitProof$3; },
+	get WakuMessage () { return WakuMessage$3; }
+});
+
+/* eslint-disable import/export */
+var FilterRequest;
+(function (FilterRequest) {
+    (function (ContentFilter) {
+        let _codec;
+        ContentFilter.codec = () => {
+            if (_codec == null) {
+                _codec = message$1((obj, writer, opts = {}) => {
+                    if (opts.lengthDelimited !== false) {
+                        writer.fork();
+                    }
+                    if (obj.contentTopic != null) {
+                        writer.uint32(10);
+                        writer.string(obj.contentTopic);
+                    }
+                    if (opts.lengthDelimited !== false) {
+                        writer.ldelim();
+                    }
+                }, (reader, length) => {
+                    const obj = {};
+                    const end = length == null ? reader.len : reader.pos + length;
+                    while (reader.pos < end) {
+                        const tag = reader.uint32();
+                        switch (tag >>> 3) {
+                            case 1:
+                                obj.contentTopic = reader.string();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                        }
+                    }
+                    return obj;
+                });
+            }
+            return _codec;
+        };
+        ContentFilter.encode = (obj) => {
+            return encodeMessage(obj, ContentFilter.codec());
+        };
+        ContentFilter.decode = (buf) => {
+            return decodeMessage(buf, ContentFilter.codec());
+        };
+    })(FilterRequest.ContentFilter || (FilterRequest.ContentFilter = {}));
+    let _codec;
+    FilterRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.subscribe != null) {
+                    writer.uint32(8);
+                    writer.bool(obj.subscribe);
+                }
+                if (obj.topic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.topic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        writer.uint32(26);
+                        FilterRequest.ContentFilter.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "contentFilters" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    contentFilters: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.subscribe = reader.bool();
+                            break;
+                        case 2:
+                            obj.topic = reader.string();
+                            break;
+                        case 3:
+                            obj.contentFilters.push(FilterRequest.ContentFilter.codec().decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterRequest.encode = (obj) => {
+        return encodeMessage(obj, FilterRequest.codec());
+    };
+    FilterRequest.decode = (buf) => {
+        return decodeMessage(buf, FilterRequest.codec());
+    };
+})(FilterRequest || (FilterRequest = {}));
+var MessagePush;
+(function (MessagePush) {
+    let _codec;
+    MessagePush.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        writer.uint32(10);
+                        WakuMessage$2.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "messages" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    messages: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.messages.push(WakuMessage$2.codec().decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    MessagePush.encode = (obj) => {
+        return encodeMessage(obj, MessagePush.codec());
+    };
+    MessagePush.decode = (buf) => {
+        return decodeMessage(buf, MessagePush.codec());
+    };
+})(MessagePush || (MessagePush = {}));
+var FilterRPC;
+(function (FilterRPC) {
+    let _codec;
+    FilterRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    writer.uint32(18);
+                    FilterRequest.codec().encode(obj.request, writer);
+                }
+                if (obj.push != null) {
+                    writer.uint32(26);
+                    MessagePush.codec().encode(obj.push, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.request = FilterRequest.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.push = MessagePush.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterRPC.encode = (obj) => {
+        return encodeMessage(obj, FilterRPC.codec());
+    };
+    FilterRPC.decode = (buf) => {
+        return decodeMessage(buf, FilterRPC.codec());
+    };
+})(FilterRPC || (FilterRPC = {}));
+var RateLimitProof$2;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof$2 || (RateLimitProof$2 = {}));
+var WakuMessage$2;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof$2.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage$2 || (WakuMessage$2 = {}));
+
+/* eslint-disable import/export */
+var TopicOnlyMessage;
+(function (TopicOnlyMessage) {
+    let _codec;
+    TopicOnlyMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    TopicOnlyMessage.encode = (obj) => {
+        return encodeMessage(obj, TopicOnlyMessage.codec());
+    };
+    TopicOnlyMessage.decode = (buf) => {
+        return decodeMessage(buf, TopicOnlyMessage.codec());
+    };
+})(TopicOnlyMessage || (TopicOnlyMessage = {}));
+
+/* eslint-disable import/export */
+var PushRequest;
+(function (PushRequest) {
+    let _codec;
+    PushRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pubSubTopic != null) {
+                    writer.uint32(10);
+                    writer.string(obj.pubSubTopic);
+                }
+                if (obj.message != null) {
+                    writer.uint32(18);
+                    WakuMessage$1.codec().encode(obj.message, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.pubSubTopic = reader.string();
+                            break;
+                        case 2:
+                            obj.message = WakuMessage$1.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushRequest.encode = (obj) => {
+        return encodeMessage(obj, PushRequest.codec());
+    };
+    PushRequest.decode = (buf) => {
+        return decodeMessage(buf, PushRequest.codec());
+    };
+})(PushRequest || (PushRequest = {}));
+var PushResponse;
+(function (PushResponse) {
+    let _codec;
+    PushResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.isSuccess != null) {
+                    writer.uint32(8);
+                    writer.bool(obj.isSuccess);
+                }
+                if (obj.info != null) {
+                    writer.uint32(18);
+                    writer.string(obj.info);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.isSuccess = reader.bool();
+                            break;
+                        case 2:
+                            obj.info = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushResponse.encode = (obj) => {
+        return encodeMessage(obj, PushResponse.codec());
+    };
+    PushResponse.decode = (buf) => {
+        return decodeMessage(buf, PushResponse.codec());
+    };
+})(PushResponse || (PushResponse = {}));
+var PushRPC;
+(function (PushRPC) {
+    let _codec;
+    PushRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    writer.uint32(18);
+                    PushRequest.codec().encode(obj.request, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(26);
+                    PushResponse.codec().encode(obj.response, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.request = PushRequest.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.response = PushResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushRPC.encode = (obj) => {
+        return encodeMessage(obj, PushRPC.codec());
+    };
+    PushRPC.decode = (buf) => {
+        return decodeMessage(buf, PushRPC.codec());
+    };
+})(PushRPC || (PushRPC = {}));
+var RateLimitProof$1;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof$1 || (RateLimitProof$1 = {}));
+var WakuMessage$1;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof$1.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof$1.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage$1 || (WakuMessage$1 = {}));
+
+/* eslint-disable import/export */
+var Index;
+(function (Index) {
+    let _codec;
+    Index.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.digest != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.digest);
+                }
+                if (obj.receivedTime != null) {
+                    writer.uint32(16);
+                    writer.sint64(obj.receivedTime);
+                }
+                if (obj.senderTime != null) {
+                    writer.uint32(24);
+                    writer.sint64(obj.senderTime);
+                }
+                if (obj.pubsubTopic != null) {
+                    writer.uint32(34);
+                    writer.string(obj.pubsubTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.digest = reader.bytes();
+                            break;
+                        case 2:
+                            obj.receivedTime = reader.sint64();
+                            break;
+                        case 3:
+                            obj.senderTime = reader.sint64();
+                            break;
+                        case 4:
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    Index.encode = (obj) => {
+        return encodeMessage(obj, Index.codec());
+    };
+    Index.decode = (buf) => {
+        return decodeMessage(buf, Index.codec());
+    };
+})(Index || (Index = {}));
+var PagingInfo;
+(function (PagingInfo) {
+    (function (Direction) {
+        Direction["DIRECTION_BACKWARD_UNSPECIFIED"] = "DIRECTION_BACKWARD_UNSPECIFIED";
+        Direction["DIRECTION_FORWARD"] = "DIRECTION_FORWARD";
+    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let __DirectionValues;
+    (function (__DirectionValues) {
+        __DirectionValues[__DirectionValues["DIRECTION_BACKWARD_UNSPECIFIED"] = 0] = "DIRECTION_BACKWARD_UNSPECIFIED";
+        __DirectionValues[__DirectionValues["DIRECTION_FORWARD"] = 1] = "DIRECTION_FORWARD";
+    })(__DirectionValues || (__DirectionValues = {}));
+    (function (Direction) {
+        Direction.codec = () => {
+            return enumeration(__DirectionValues);
+        };
+    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let _codec;
+    PagingInfo.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pageSize != null) {
+                    writer.uint32(8);
+                    writer.uint64(obj.pageSize);
+                }
+                if (obj.cursor != null) {
+                    writer.uint32(18);
+                    Index.codec().encode(obj.cursor, writer);
+                }
+                if (obj.direction != null) {
+                    writer.uint32(24);
+                    PagingInfo.Direction.codec().encode(obj.direction, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.pageSize = reader.uint64();
+                            break;
+                        case 2:
+                            obj.cursor = Index.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.direction = PagingInfo.Direction.codec().decode(reader);
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PagingInfo.encode = (obj) => {
+        return encodeMessage(obj, PagingInfo.codec());
+    };
+    PagingInfo.decode = (buf) => {
+        return decodeMessage(buf, PagingInfo.codec());
+    };
+})(PagingInfo || (PagingInfo = {}));
+var ContentFilter;
+(function (ContentFilter) {
+    let _codec;
+    ContentFilter.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(10);
+                    writer.string(obj.contentTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.contentTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    ContentFilter.encode = (obj) => {
+        return encodeMessage(obj, ContentFilter.codec());
+    };
+    ContentFilter.decode = (buf) => {
+        return decodeMessage(buf, ContentFilter.codec());
+    };
+})(ContentFilter || (ContentFilter = {}));
+var HistoryQuery;
+(function (HistoryQuery) {
+    let _codec;
+    HistoryQuery.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pubSubTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.pubSubTopic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        writer.uint32(26);
+                        ContentFilter.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "contentFilters" was not found in object');
+                }
+                if (obj.pagingInfo != null) {
+                    writer.uint32(34);
+                    PagingInfo.codec().encode(obj.pagingInfo, writer);
+                }
+                if (obj.startTime != null) {
+                    writer.uint32(40);
+                    writer.sint64(obj.startTime);
+                }
+                if (obj.endTime != null) {
+                    writer.uint32(48);
+                    writer.sint64(obj.endTime);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    contentFilters: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.pubSubTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32()));
+                            break;
+                        case 4:
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                            break;
+                        case 5:
+                            obj.startTime = reader.sint64();
+                            break;
+                        case 6:
+                            obj.endTime = reader.sint64();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryQuery.encode = (obj) => {
+        return encodeMessage(obj, HistoryQuery.codec());
+    };
+    HistoryQuery.decode = (buf) => {
+        return decodeMessage(buf, HistoryQuery.codec());
+    };
+})(HistoryQuery || (HistoryQuery = {}));
+var HistoryResponse;
+(function (HistoryResponse) {
+    (function (HistoryError) {
+        HistoryError["ERROR_NONE_UNSPECIFIED"] = "ERROR_NONE_UNSPECIFIED";
+        HistoryError["ERROR_INVALID_CURSOR"] = "ERROR_INVALID_CURSOR";
+    })(HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let __HistoryErrorValues;
+    (function (__HistoryErrorValues) {
+        __HistoryErrorValues[__HistoryErrorValues["ERROR_NONE_UNSPECIFIED"] = 0] = "ERROR_NONE_UNSPECIFIED";
+        __HistoryErrorValues[__HistoryErrorValues["ERROR_INVALID_CURSOR"] = 1] = "ERROR_INVALID_CURSOR";
+    })(__HistoryErrorValues || (__HistoryErrorValues = {}));
+    (function (HistoryError) {
+        HistoryError.codec = () => {
+            return enumeration(__HistoryErrorValues);
+        };
+    })(HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let _codec;
+    HistoryResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        writer.uint32(18);
+                        WakuMessage.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "messages" was not found in object');
+                }
+                if (obj.pagingInfo != null) {
+                    writer.uint32(26);
+                    PagingInfo.codec().encode(obj.pagingInfo, writer);
+                }
+                if (obj.error != null) {
+                    writer.uint32(32);
+                    HistoryResponse.HistoryError.codec().encode(obj.error, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    messages: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32()));
+                            break;
+                        case 3:
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                            break;
+                        case 4:
+                            obj.error = HistoryResponse.HistoryError.codec().decode(reader);
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryResponse.encode = (obj) => {
+        return encodeMessage(obj, HistoryResponse.codec());
+    };
+    HistoryResponse.decode = (buf) => {
+        return decodeMessage(buf, HistoryResponse.codec());
+    };
+})(HistoryResponse || (HistoryResponse = {}));
+var HistoryRPC;
+(function (HistoryRPC) {
+    let _codec;
+    HistoryRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.query != null) {
+                    writer.uint32(18);
+                    HistoryQuery.codec().encode(obj.query, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(26);
+                    HistoryResponse.codec().encode(obj.response, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.query = HistoryQuery.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.response = HistoryResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryRPC.encode = (obj) => {
+        return encodeMessage(obj, HistoryRPC.codec());
+    };
+    HistoryRPC.decode = (buf) => {
+        return decodeMessage(buf, HistoryRPC.codec());
+    };
+})(HistoryRPC || (HistoryRPC = {}));
+var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof || (RateLimitProof = {}));
+var WakuMessage;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (obj.ephemeral != null) {
+                    writer.uint32(248);
+                    writer.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage || (WakuMessage = {}));
+
+/* eslint-disable import/export */
+var PeerInfo;
+(function (PeerInfo) {
+    let _codec;
+    PeerInfo.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.enr != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.enr);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.enr = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerInfo.encode = (obj) => {
+        return encodeMessage(obj, PeerInfo.codec());
+    };
+    PeerInfo.decode = (buf) => {
+        return decodeMessage(buf, PeerInfo.codec());
+    };
+})(PeerInfo || (PeerInfo = {}));
+var PeerExchangeQuery;
+(function (PeerExchangeQuery) {
+    let _codec;
+    PeerExchangeQuery.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.numPeers != null) {
+                    writer.uint32(8);
+                    writer.uint64(obj.numPeers);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.numPeers = reader.uint64();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeQuery.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeQuery.codec());
+    };
+    PeerExchangeQuery.decode = (buf) => {
+        return decodeMessage(buf, PeerExchangeQuery.codec());
+    };
+})(PeerExchangeQuery || (PeerExchangeQuery = {}));
+var PeerExchangeResponse;
+(function (PeerExchangeResponse) {
+    let _codec;
+    PeerExchangeResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.peerInfos != null) {
+                    for (const value of obj.peerInfos) {
+                        writer.uint32(10);
+                        PeerInfo.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "peerInfos" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    peerInfos: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.peerInfos.push(PeerInfo.codec().decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeResponse.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeResponse.codec());
+    };
+    PeerExchangeResponse.decode = (buf) => {
+        return decodeMessage(buf, PeerExchangeResponse.codec());
+    };
+})(PeerExchangeResponse || (PeerExchangeResponse = {}));
+var PeerExchangeRPC;
+(function (PeerExchangeRPC) {
+    let _codec;
+    PeerExchangeRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.query != null) {
+                    writer.uint32(10);
+                    PeerExchangeQuery.codec().encode(obj.query, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(18);
+                    PeerExchangeResponse.codec().encode(obj.response, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.query = PeerExchangeQuery.codec().decode(reader, reader.uint32());
+                            break;
+                        case 2:
+                            obj.response = PeerExchangeResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeRPC.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeRPC.codec());
+    };
+    PeerExchangeRPC.decode = (buf) => {
+        return decodeMessage(buf, PeerExchangeRPC.codec());
+    };
+})(PeerExchangeRPC || (PeerExchangeRPC = {}));
+
+export { FilterRPC as F, HistoryRPC as H, PushRPC as P, TopicOnlyMessage as T, WakuMessage$3 as W, aspromise as a, base64$1 as b, commonjsGlobal as c, debug as d, eventemitter as e, float as f, getAugmentedNamespace as g, PushResponse as h, inquire_1 as i, PagingInfo as j, HistoryResponse as k, getDefaultExportFromCjs as l, message as m, pool_1 as p, utf8$2 as u };