@waku/message-encryption 0.0.34-6d86b6f.0 → 0.0.34-76fb1ea.0

package/bundle/{encryption-D9GhWgcp.js → encryption-BoPH9rg4.js}

@@ -1349,7 +1349,7 @@ 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 */
-var RateLimitProof$4;
+var RateLimitProof$6;
 (function (RateLimitProof) {
     let _codec;
     RateLimitProof.codec = () => {
@@ -1448,8 +1448,8 @@ var RateLimitProof$4;
     RateLimitProof.decode = (buf, opts) => {
         return decodeMessage(buf, RateLimitProof.codec(), opts);
     };
-})(RateLimitProof$4 || (RateLimitProof$4 = {}));
-var WakuMessage$4;
+})(RateLimitProof$6 || (RateLimitProof$6 = {}));
+var WakuMessage$6;
 (function (WakuMessage) {
     let _codec;
     WakuMessage.codec = () => {
@@ -1480,7 +1480,7 @@ var WakuMessage$4;
                 }
                 if (obj.rateLimitProof != null) {
                     w.uint32(170);
-                    RateLimitProof$4.codec().encode(obj.rateLimitProof, w);
+                    RateLimitProof$6.codec().encode(obj.rateLimitProof, w);
                 }
                 if (obj.ephemeral != null) {
                     w.uint32(248);
@@ -1519,7 +1519,7 @@ var WakuMessage$4;
                             break;
                         }
                         case 21: {
-                            obj.rateLimitProof = RateLimitProof$4.codec().decode(reader, reader.uint32(), {
+                            obj.rateLimitProof = RateLimitProof$6.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.rateLimitProof
                             });
                             break;
@@ -1545,7 +1545,7 @@ var WakuMessage$4;
     WakuMessage.decode = (buf, opts) => {
         return decodeMessage(buf, WakuMessage.codec(), opts);
     };
-})(WakuMessage$4 || (WakuMessage$4 = {}));
+})(WakuMessage$6 || (WakuMessage$6 = {}));
 
 /* eslint-disable import/export */
 /* eslint-disable complexity */
@@ -1680,7 +1680,7 @@ var MessagePush$1;
                 if (obj.messages != null) {
                     for (const value of obj.messages) {
                         w.uint32(10);
-                        WakuMessage$3.codec().encode(value, w);
+                        WakuMessage$5.codec().encode(value, w);
                     }
                 }
                 if (opts.lengthDelimited !== false) {
@@ -1698,7 +1698,7 @@ var MessagePush$1;
                             if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
                                 throw new MaxLengthError('Decode error - map field "messages" had too many elements');
                             }
-                            obj.messages.push(WakuMessage$3.codec().decode(reader, reader.uint32(), {
+                            obj.messages.push(WakuMessage$5.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.messages$
                             }));
                             break;
@@ -1787,7 +1787,7 @@ var FilterRpc;
         return decodeMessage(buf, FilterRpc.codec(), opts);
     };
 })(FilterRpc || (FilterRpc = {}));
-var RateLimitProof$3;
+var RateLimitProof$5;
 (function (RateLimitProof) {
     let _codec;
     RateLimitProof.codec = () => {
@@ -1886,8 +1886,8 @@ var RateLimitProof$3;
     RateLimitProof.decode = (buf, opts) => {
         return decodeMessage(buf, RateLimitProof.codec(), opts);
     };
-})(RateLimitProof$3 || (RateLimitProof$3 = {}));
-var WakuMessage$3;
+})(RateLimitProof$5 || (RateLimitProof$5 = {}));
+var WakuMessage$5;
 (function (WakuMessage) {
     let _codec;
     WakuMessage.codec = () => {
@@ -1918,7 +1918,7 @@ var WakuMessage$3;
                 }
                 if (obj.rateLimitProof != null) {
                     w.uint32(170);
-                    RateLimitProof$3.codec().encode(obj.rateLimitProof, w);
+                    RateLimitProof$5.codec().encode(obj.rateLimitProof, w);
                 }
                 if (obj.ephemeral != null) {
                     w.uint32(248);
@@ -1957,7 +1957,7 @@ var WakuMessage$3;
                             break;
                         }
                         case 21: {
-                            obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32(), {
+                            obj.rateLimitProof = RateLimitProof$5.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.rateLimitProof
                             });
                             break;
@@ -1983,7 +1983,7 @@ var WakuMessage$3;
     WakuMessage.decode = (buf, opts) => {
         return decodeMessage(buf, WakuMessage.codec(), opts);
     };
-})(WakuMessage$3 || (WakuMessage$3 = {}));
+})(WakuMessage$5 || (WakuMessage$5 = {}));
 
 /* eslint-disable import/export */
 /* eslint-disable complexity */
@@ -2070,54 +2070,815 @@ var FilterSubscribeRequest;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if ((obj.requestId != null && obj.requestId !== '')) {
+                if ((obj.requestId != null && obj.requestId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.filterSubscribeType != null && __FilterSubscribeTypeValues[obj.filterSubscribeType] !== 0) {
+                    w.uint32(16);
+                    FilterSubscribeRequest.FilterSubscribeType.codec().encode(obj.filterSubscribeType, w);
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(82);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.contentTopics != null) {
+                    for (const value of obj.contentTopics) {
+                        w.uint32(90);
+                        w.string(value);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    requestId: '',
+                    filterSubscribeType: FilterSubscribeType.SUBSCRIBER_PING,
+                    contentTopics: []
+                };
+                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.filterSubscribeType = FilterSubscribeRequest.FilterSubscribeType.codec().decode(reader);
+                            break;
+                        }
+                        case 10: {
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        }
+                        case 11: {
+                            if (opts.limits?.contentTopics != null && obj.contentTopics.length === opts.limits.contentTopics) {
+                                throw new MaxLengthError('Decode error - map field "contentTopics" had too many elements');
+                            }
+                            obj.contentTopics.push(reader.string());
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterSubscribeRequest.encode = (obj) => {
+        return encodeMessage(obj, FilterSubscribeRequest.codec());
+    };
+    FilterSubscribeRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, FilterSubscribeRequest.codec(), opts);
+    };
+})(FilterSubscribeRequest || (FilterSubscribeRequest = {}));
+var FilterSubscribeResponse;
+(function (FilterSubscribeResponse) {
+    let _codec;
+    FilterSubscribeResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.requestId != null && obj.requestId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if ((obj.statusCode != null && obj.statusCode !== 0)) {
+                    w.uint32(80);
+                    w.uint32(obj.statusCode);
+                }
+                if (obj.statusDesc != null) {
+                    w.uint32(90);
+                    w.string(obj.statusDesc);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    requestId: '',
+                    statusCode: 0
+                };
+                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 10: {
+                            obj.statusCode = reader.uint32();
+                            break;
+                        }
+                        case 11: {
+                            obj.statusDesc = reader.string();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterSubscribeResponse.encode = (obj) => {
+        return encodeMessage(obj, FilterSubscribeResponse.codec());
+    };
+    FilterSubscribeResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, FilterSubscribeResponse.codec(), opts);
+    };
+})(FilterSubscribeResponse || (FilterSubscribeResponse = {}));
+var MessagePush;
+(function (MessagePush) {
+    let _codec;
+    MessagePush.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.wakuMessage != null) {
+                    w.uint32(10);
+                    WakuMessage$4.codec().encode(obj.wakuMessage, w);
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(18);
+                    w.string(obj.pubsubTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                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.wakuMessage = WakuMessage$4.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.wakuMessage
+                            });
+                            break;
+                        }
+                        case 2: {
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    MessagePush.encode = (obj) => {
+        return encodeMessage(obj, MessagePush.codec());
+    };
+    MessagePush.decode = (buf, opts) => {
+        return decodeMessage(buf, MessagePush.codec(), opts);
+    };
+})(MessagePush || (MessagePush = {}));
+var RateLimitProof$4;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    proof: alloc$1(0),
+                    merkleRoot: alloc$1(0),
+                    epoch: alloc$1(0),
+                    shareX: alloc$1(0),
+                    shareY: alloc$1(0),
+                    nullifier: alloc$1(0),
+                    rlnIdentifier: alloc$1(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;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
+    };
+})(RateLimitProof$4 || (RateLimitProof$4 = {}));
+var WakuMessage$4;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof$4.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    payload: alloc$1(0),
+                    contentTopic: ''
+                };
+                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 10: {
+                            obj.timestamp = reader.sint64();
+                            break;
+                        }
+                        case 11: {
+                            obj.meta = reader.bytes();
+                            break;
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof$4.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
+                            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, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
+    };
+})(WakuMessage$4 || (WakuMessage$4 = {}));
+
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+var PushRequest$1;
+(function (PushRequest) {
+    let _codec;
+    PushRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(162);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.message != null) {
+                    w.uint32(170);
+                    WakuMessage$3.codec().encode(obj.message, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 20: {
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        }
+                        case 21: {
+                            obj.message = WakuMessage$3.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.message
+                            });
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushRequest.encode = (obj) => {
+        return encodeMessage(obj, PushRequest.codec());
+    };
+    PushRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, PushRequest.codec(), opts);
+    };
+})(PushRequest$1 || (PushRequest$1 = {}));
+var PushResponse$1;
+(function (PushResponse) {
+    let _codec;
+    PushResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.statusCode != null && obj.statusCode !== 0)) {
+                    w.uint32(160);
+                    w.uint32(obj.statusCode);
+                }
+                if (obj.statusDesc != null) {
+                    w.uint32(242);
+                    w.string(obj.statusDesc);
+                }
+                if (obj.relayPeerCount != null) {
+                    w.uint32(320);
+                    w.uint32(obj.relayPeerCount);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    statusCode: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 20: {
+                            obj.statusCode = reader.uint32();
+                            break;
+                        }
+                        case 30: {
+                            obj.statusDesc = reader.string();
+                            break;
+                        }
+                        case 40: {
+                            obj.relayPeerCount = reader.uint32();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushResponse.encode = (obj) => {
+        return encodeMessage(obj, PushResponse.codec());
+    };
+    PushResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, PushResponse.codec(), opts);
+    };
+})(PushResponse$1 || (PushResponse$1 = {}));
+var PushRpc$1;
+(function (PushRpc) {
+    let _codec;
+    PushRpc.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.requestId != null && obj.requestId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.request != null) {
+                    w.uint32(18);
+                    PushRequest$1.codec().encode(obj.request, w);
+                }
+                if (obj.response != null) {
+                    w.uint32(26);
+                    PushResponse$1.codec().encode(obj.response, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    requestId: ''
+                };
+                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$1.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.request
+                            });
+                            break;
+                        }
+                        case 3: {
+                            obj.response = PushResponse$1.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.response
+                            });
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PushRpc.encode = (obj) => {
+        return encodeMessage(obj, PushRpc.codec());
+    };
+    PushRpc.decode = (buf, opts) => {
+        return decodeMessage(buf, PushRpc.codec(), opts);
+    };
+})(PushRpc$1 || (PushRpc$1 = {}));
+var RateLimitProof$3;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    proof: alloc$1(0),
+                    merkleRoot: alloc$1(0),
+                    epoch: alloc$1(0),
+                    shareX: alloc$1(0),
+                    shareY: alloc$1(0),
+                    nullifier: alloc$1(0),
+                    rlnIdentifier: alloc$1(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;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
+    };
+})(RateLimitProof$3 || (RateLimitProof$3 = {}));
+var WakuMessage$3;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof$3.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    payload: alloc$1(0),
+                    contentTopic: ''
+                };
+                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 10: {
+                            obj.timestamp = reader.sint64();
+                            break;
+                        }
+                        case 11: {
+                            obj.meta = reader.bytes();
+                            break;
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
+                            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, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
+    };
+})(WakuMessage$3 || (WakuMessage$3 = {}));
+
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+var PushRequest;
+(function (PushRequest) {
+    let _codec;
+    PushRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.pubsubTopic != null && obj.pubsubTopic !== '')) {
                     w.uint32(10);
-                    w.string(obj.requestId);
-                }
-                if (obj.filterSubscribeType != null && __FilterSubscribeTypeValues[obj.filterSubscribeType] !== 0) {
-                    w.uint32(16);
-                    FilterSubscribeRequest.FilterSubscribeType.codec().encode(obj.filterSubscribeType, w);
-                }
-                if (obj.pubsubTopic != null) {
-                    w.uint32(82);
                     w.string(obj.pubsubTopic);
                 }
-                if (obj.contentTopics != null) {
-                    for (const value of obj.contentTopics) {
-                        w.uint32(90);
-                        w.string(value);
-                    }
+                if (obj.message != null) {
+                    w.uint32(18);
+                    WakuMessage$2.codec().encode(obj.message, w);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
-                    requestId: '',
-                    filterSubscribeType: FilterSubscribeType.SUBSCRIBER_PING,
-                    contentTopics: []
+                    pubsubTopic: ''
                 };
                 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.filterSubscribeType = FilterSubscribeRequest.FilterSubscribeType.codec().decode(reader);
-                            break;
-                        }
-                        case 10: {
                             obj.pubsubTopic = reader.string();
                             break;
                         }
-                        case 11: {
-                            if (opts.limits?.contentTopics != null && obj.contentTopics.length === opts.limits.contentTopics) {
-                                throw new MaxLengthError('Decode error - map field "contentTopics" had too many elements');
-                            }
-                            obj.contentTopics.push(reader.string());
+                        case 2: {
+                            obj.message = WakuMessage$2.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.message
+                            });
                             break;
                         }
                         default: {
@@ -2131,56 +2892,47 @@ var FilterSubscribeRequest;
         }
         return _codec;
     };
-    FilterSubscribeRequest.encode = (obj) => {
-        return encodeMessage(obj, FilterSubscribeRequest.codec());
+    PushRequest.encode = (obj) => {
+        return encodeMessage(obj, PushRequest.codec());
     };
-    FilterSubscribeRequest.decode = (buf, opts) => {
-        return decodeMessage(buf, FilterSubscribeRequest.codec(), opts);
+    PushRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, PushRequest.codec(), opts);
     };
-})(FilterSubscribeRequest || (FilterSubscribeRequest = {}));
-var FilterSubscribeResponse;
-(function (FilterSubscribeResponse) {
+})(PushRequest || (PushRequest = {}));
+var PushResponse;
+(function (PushResponse) {
     let _codec;
-    FilterSubscribeResponse.codec = () => {
+    PushResponse.codec = () => {
         if (_codec == null) {
             _codec = message((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if ((obj.requestId != null && obj.requestId !== '')) {
-                    w.uint32(10);
-                    w.string(obj.requestId);
-                }
-                if ((obj.statusCode != null && obj.statusCode !== 0)) {
-                    w.uint32(80);
-                    w.uint32(obj.statusCode);
+                if ((obj.isSuccess != null && obj.isSuccess !== false)) {
+                    w.uint32(8);
+                    w.bool(obj.isSuccess);
                 }
-                if (obj.statusDesc != null) {
-                    w.uint32(90);
-                    w.string(obj.statusDesc);
+                if (obj.info != null) {
+                    w.uint32(18);
+                    w.string(obj.info);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
-                    requestId: '',
-                    statusCode: 0
+                    isSuccess: false
                 };
                 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 10: {
-                            obj.statusCode = reader.uint32();
+                            obj.isSuccess = reader.bool();
                             break;
                         }
-                        case 11: {
-                            obj.statusDesc = reader.string();
+                        case 2: {
+                            obj.info = reader.string();
                             break;
                         }
                         default: {
@@ -2194,47 +2946,59 @@ var FilterSubscribeResponse;
         }
         return _codec;
     };
-    FilterSubscribeResponse.encode = (obj) => {
-        return encodeMessage(obj, FilterSubscribeResponse.codec());
+    PushResponse.encode = (obj) => {
+        return encodeMessage(obj, PushResponse.codec());
     };
-    FilterSubscribeResponse.decode = (buf, opts) => {
-        return decodeMessage(buf, FilterSubscribeResponse.codec(), opts);
+    PushResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, PushResponse.codec(), opts);
     };
-})(FilterSubscribeResponse || (FilterSubscribeResponse = {}));
-var MessagePush;
-(function (MessagePush) {
+})(PushResponse || (PushResponse = {}));
+var PushRpc;
+(function (PushRpc) {
     let _codec;
-    MessagePush.codec = () => {
+    PushRpc.codec = () => {
         if (_codec == null) {
             _codec = message((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.wakuMessage != null) {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
-                    WakuMessage$2.codec().encode(obj.wakuMessage, w);
+                    w.string(obj.requestId);
                 }
-                if (obj.pubsubTopic != null) {
+                if (obj.request != null) {
                     w.uint32(18);
-                    w.string(obj.pubsubTopic);
+                    PushRequest.codec().encode(obj.request, w);
+                }
+                if (obj.response != null) {
+                    w.uint32(26);
+                    PushResponse.codec().encode(obj.response, w);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
-                const obj = {};
+                const obj = {
+                    requestId: ''
+                };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
                         case 1: {
-                            obj.wakuMessage = WakuMessage$2.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.wakuMessage
-                            });
+                            obj.requestId = reader.string();
                             break;
                         }
                         case 2: {
-                            obj.pubsubTopic = reader.string();
+                            obj.request = PushRequest.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.request
+                            });
+                            break;
+                        }
+                        case 3: {
+                            obj.response = PushResponse.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.response
+                            });
                             break;
                         }
                         default: {
@@ -2248,13 +3012,13 @@ var MessagePush;
         }
         return _codec;
     };
-    MessagePush.encode = (obj) => {
-        return encodeMessage(obj, MessagePush.codec());
+    PushRpc.encode = (obj) => {
+        return encodeMessage(obj, PushRpc.codec());
     };
-    MessagePush.decode = (buf, opts) => {
-        return decodeMessage(buf, MessagePush.codec(), opts);
+    PushRpc.decode = (buf, opts) => {
+        return decodeMessage(buf, PushRpc.codec(), opts);
     };
-})(MessagePush || (MessagePush = {}));
+})(PushRpc || (PushRpc = {}));
 var RateLimitProof$2;
 (function (RateLimitProof) {
     let _codec;
@@ -2458,21 +3222,25 @@ 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 */
-var PushRequest;
-(function (PushRequest) {
+var LightpushRequest;
+(function (LightpushRequest) {
     let _codec;
-    PushRequest.codec = () => {
+    LightpushRequest.codec = () => {
         if (_codec == null) {
             _codec = message((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if ((obj.pubsubTopic != null && obj.pubsubTopic !== '')) {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(162);
                     w.string(obj.pubsubTopic);
                 }
                 if (obj.message != null) {
-                    w.uint32(18);
+                    w.uint32(170);
                     WakuMessage$1.codec().encode(obj.message, w);
                 }
                 if (opts.lengthDelimited !== false) {
@@ -2480,17 +3248,21 @@ var PushRequest;
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
-                    pubsubTopic: ''
+                    requestId: ''
                 };
                 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 20: {
                             obj.pubsubTopic = reader.string();
                             break;
                         }
-                        case 2: {
+                        case 21: {
                             obj.message = WakuMessage$1.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.message
                             });
@@ -2507,71 +3279,17 @@ var PushRequest;
         }
         return _codec;
     };
-    PushRequest.encode = (obj) => {
-        return encodeMessage(obj, PushRequest.codec());
-    };
-    PushRequest.decode = (buf, opts) => {
-        return decodeMessage(buf, PushRequest.codec(), opts);
-    };
-})(PushRequest || (PushRequest = {}));
-var PushResponse;
-(function (PushResponse) {
-    let _codec;
-    PushResponse.codec = () => {
-        if (_codec == null) {
-            _codec = message((obj, w, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    w.fork();
-                }
-                if ((obj.isSuccess != null && obj.isSuccess !== false)) {
-                    w.uint32(8);
-                    w.bool(obj.isSuccess);
-                }
-                if (obj.info != null) {
-                    w.uint32(18);
-                    w.string(obj.info);
-                }
-                if (opts.lengthDelimited !== false) {
-                    w.ldelim();
-                }
-            }, (reader, length, opts = {}) => {
-                const obj = {
-                    isSuccess: false
-                };
-                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());
+    LightpushRequest.encode = (obj) => {
+        return encodeMessage(obj, LightpushRequest.codec());
     };
-    PushResponse.decode = (buf, opts) => {
-        return decodeMessage(buf, PushResponse.codec(), opts);
+    LightpushRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, LightpushRequest.codec(), opts);
     };
-})(PushResponse || (PushResponse = {}));
-var PushRpc;
-(function (PushRpc) {
+})(LightpushRequest || (LightpushRequest = {}));
+var LightpushResponse;
+(function (LightpushResponse) {
     let _codec;
-    PushRpc.codec = () => {
+    LightpushResponse.codec = () => {
         if (_codec == null) {
             _codec = message((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
@@ -2581,20 +3299,25 @@ var PushRpc;
                     w.uint32(10);
                     w.string(obj.requestId);
                 }
-                if (obj.request != null) {
-                    w.uint32(18);
-                    PushRequest.codec().encode(obj.request, w);
+                if ((obj.statusCode != null && obj.statusCode !== 0)) {
+                    w.uint32(80);
+                    w.uint32(obj.statusCode);
                 }
-                if (obj.response != null) {
-                    w.uint32(26);
-                    PushResponse.codec().encode(obj.response, w);
+                if (obj.statusDesc != null) {
+                    w.uint32(90);
+                    w.string(obj.statusDesc);
+                }
+                if (obj.relayPeerCount != null) {
+                    w.uint32(96);
+                    w.uint32(obj.relayPeerCount);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
-                    requestId: ''
+                    requestId: '',
+                    statusCode: 0
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -2604,16 +3327,16 @@ var PushRpc;
                             obj.requestId = reader.string();
                             break;
                         }
-                        case 2: {
-                            obj.request = PushRequest.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.request
-                            });
+                        case 10: {
+                            obj.statusCode = reader.uint32();
                             break;
                         }
-                        case 3: {
-                            obj.response = PushResponse.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.response
-                            });
+                        case 11: {
+                            obj.statusDesc = reader.string();
+                            break;
+                        }
+                        case 12: {
+                            obj.relayPeerCount = reader.uint32();
                             break;
                         }
                         default: {
@@ -2627,13 +3350,13 @@ var PushRpc;
         }
         return _codec;
     };
-    PushRpc.encode = (obj) => {
-        return encodeMessage(obj, PushRpc.codec());
+    LightpushResponse.encode = (obj) => {
+        return encodeMessage(obj, LightpushResponse.codec());
     };
-    PushRpc.decode = (buf, opts) => {
-        return decodeMessage(buf, PushRpc.codec(), opts);
+    LightpushResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, LightpushResponse.codec(), opts);
     };
-})(PushRpc || (PushRpc = {}));
+})(LightpushResponse || (LightpushResponse = {}));
 var RateLimitProof$1;
 (function (RateLimitProof) {
     let _codec;
@@ -4142,6 +4865,21 @@ const sha256$1 = /* @__PURE__ */ createHasher(() => new SHA256());
 /** @deprecated Use import from `noble/hashes/sha2` module */
 const sha256 = sha256$1;
 
+// Light Push V3 Protocol Types and Constants
+var LightPushStatusCodeV3;
+(function (LightPushStatusCodeV3) {
+    LightPushStatusCodeV3[LightPushStatusCodeV3["SUCCESS"] = 200] = "SUCCESS";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["INVALID_MESSAGE_ERROR"] = 420] = "INVALID_MESSAGE_ERROR";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["UNSUPPORTED_PUBSUB_TOPIC"] = 421] = "UNSUPPORTED_PUBSUB_TOPIC";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["SERVICE_NOT_AVAILABLE"] = 503] = "SERVICE_NOT_AVAILABLE";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["OUT_OF_RLN_PROOF"] = 504] = "OUT_OF_RLN_PROOF";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["NO_PEERS_TO_RELAY"] = 505] = "NO_PEERS_TO_RELAY";
+})(LightPushStatusCodeV3 || (LightPushStatusCodeV3 = {}));
+
 var Protocols;
 (function (Protocols) {
     Protocols["Relay"] = "relay";
@@ -5140,9 +5878,6 @@ let DecodedMessage$1 = class DecodedMessage {
     get contentTopic() {
         return this.proto.contentTopic;
     }
-    get _rawTimestamp() {
-        return this.proto.timestamp;
-    }
     get timestamp() {
         // In the case we receive a value that is bigger than JS's max number,
         // we catch the error and return undefined.
@@ -5164,7 +5899,7 @@ let DecodedMessage$1 = class DecodedMessage {
     get version() {
         // https://rfc.vac.dev/spec/14/
         // > If omitted, the value SHOULD be interpreted as version 0.
-        return this.proto.version ?? 0;
+        return this.proto.version ?? Version;
     }
     get rateLimitProof() {
         return this.proto.rateLimitProof;
@@ -5181,7 +5916,7 @@ let Decoder$1 = class Decoder {
         }
     }
     fromWireToProtoObj(bytes) {
-        const protoMessage = WakuMessage$4.decode(bytes);
+        const protoMessage = WakuMessage$6.decode(bytes);
         return Promise.resolve({
             payload: protoMessage.payload,
             contentTopic: protoMessage.contentTopic,
@@ -5419,4 +6154,4 @@ function postCipher(message) {
     return { payload, sig };
 }
 
-export { Decoder$1 as D, Logger as L, WakuMessage$3 as W, decryptAsymmetric as a, postCipher as b, DecodedMessage as c, determinePubsubTopic as d, encryptAsymmetric as e, encryptSymmetric as f, decryptSymmetric as g, preCipher as p };
+export { Decoder$1 as D, Logger as L, WakuMessage$5 as W, decryptAsymmetric as a, postCipher as b, DecodedMessage as c, determinePubsubTopic as d, encryptAsymmetric as e, encryptSymmetric as f, decryptSymmetric as g, preCipher as p };