@waku/message-encryption 0.0.26-b5e8b17.0 → 0.0.26-efe9b8d.0

package/bundle/{symmetric-BtVudDdW.js → encryption-D5jL4iz1.js}

@@ -1,4 +1,4 @@
-import { c as allocUnsafe, f as fromString, d as concat, u as utf8ToBytes$1, e as getDefaultExportFromCjs, h as encrypt, i as hexToBytes, j as decrypt, k as generateIv, l as encrypt$1, S as Symmetric, m as decrypt$1, r as randomBytes, n as keccak256, s as sign, o as Signature, p as recoverPublicKey, V as Version$1, O as OneMillion$1, a as generateSymmetricKey } from './symmetric-TylJB-2X.js';
+import { h as allocUnsafe, i as fromString, j as alloc$1, l as concat, u as utf8ToBytes$1, m as getDefaultExportFromCjs, n as encrypt, o as hexToBytes, p as decrypt, q as generateIv, t as encrypt$1, S as Symmetric, v as decrypt$1, r as randomBytes, k as keccak256, d as sign, w as Signature, x as recoverPublicKey } from './symmetric-qyNI8P98.js';
 
 /* eslint-disable no-fallthrough */
 const N1 = Math.pow(2, 7);
@@ -1320,6 +1320,25 @@ function message(encode, decode) {
     return createCodec('message', CODEC_TYPES.LENGTH_DELIMITED, encode, decode);
 }
 
+/**
+ * @packageDocumentation
+ *
+ * This module contains serialization/deserialization code used when encoding/decoding protobufs.
+ *
+ * It should be declared as a dependency of your project:
+ *
+ * ```console
+ * npm i protons-runtime
+ * ```
+ */
+class CodeError extends Error {
+    code;
+    constructor(message, code, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+
 /* eslint-disable import/export */
 /* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
@@ -1365,44 +1384,52 @@ var RateLimitProof$4;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 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)
+                    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:
+                        case 1: {
                             obj.proof = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.merkleRoot = reader.bytes();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.epoch = reader.bytes();
                             break;
-                        case 4:
+                        }
+                        case 4: {
                             obj.shareX = reader.bytes();
                             break;
-                        case 5:
+                        }
+                        case 5: {
                             obj.shareY = reader.bytes();
                             break;
-                        case 6:
+                        }
+                        case 6: {
                             obj.nullifier = reader.bytes();
                             break;
-                        case 7:
+                        }
+                        case 7: {
                             obj.rlnIdentifier = reader.bytes();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -1413,8 +1440,8 @@ var RateLimitProof$4;
     RateLimitProof.encode = (obj) => {
         return encodeMessage(obj, RateLimitProof.codec());
     };
-    RateLimitProof.decode = (buf) => {
-        return decodeMessage(buf, RateLimitProof.codec());
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
     };
 })(RateLimitProof$4 || (RateLimitProof$4 = {}));
 var WakuMessage$4;
@@ -1457,39 +1484,49 @@ var WakuMessage$4;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
-                    payload: new Uint8Array(0),
+                    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:
+                        case 1: {
                             obj.payload = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.contentTopic = reader.string();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.version = reader.uint32();
                             break;
-                        case 10:
+                        }
+                        case 10: {
                             obj.timestamp = reader.sint64();
                             break;
-                        case 11:
+                        }
+                        case 11: {
                             obj.meta = reader.bytes();
                             break;
-                        case 21:
-                            obj.rateLimitProof = RateLimitProof$4.codec().decode(reader, reader.uint32());
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof$4.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
                             break;
-                        case 31:
+                        }
+                        case 31: {
                             obj.ephemeral = reader.bool();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -1500,8 +1537,8 @@ var WakuMessage$4;
     WakuMessage.encode = (obj) => {
         return encodeMessage(obj, WakuMessage.codec());
     };
-    WakuMessage.decode = (buf) => {
-        return decodeMessage(buf, WakuMessage.codec());
+    WakuMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
     };
 })(WakuMessage$4 || (WakuMessage$4 = {}));
 
@@ -1527,7 +1564,7 @@ var FilterRequest;
                     if (opts.lengthDelimited !== false) {
                         w.ldelim();
                     }
-                }, (reader, length) => {
+                }, (reader, length, opts = {}) => {
                     const obj = {
                         contentTopic: ''
                     };
@@ -1535,12 +1572,14 @@ var FilterRequest;
                     while (reader.pos < end) {
                         const tag = reader.uint32();
                         switch (tag >>> 3) {
-                            case 1:
+                            case 1: {
                                 obj.contentTopic = reader.string();
                                 break;
-                            default:
+                            }
+                            default: {
                                 reader.skipType(tag & 7);
                                 break;
+                            }
                         }
                     }
                     return obj;
@@ -1551,8 +1590,8 @@ var FilterRequest;
         ContentFilter.encode = (obj) => {
             return encodeMessage(obj, ContentFilter.codec());
         };
-        ContentFilter.decode = (buf) => {
-            return decodeMessage(buf, ContentFilter.codec());
+        ContentFilter.decode = (buf, opts) => {
+            return decodeMessage(buf, ContentFilter.codec(), opts);
         };
     })(FilterRequest.ContentFilter || (FilterRequest.ContentFilter = {}));
     let _codec;
@@ -1579,7 +1618,7 @@ var FilterRequest;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     subscribe: false,
                     topic: '',
@@ -1589,18 +1628,27 @@ var FilterRequest;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.subscribe = reader.bool();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.topic = reader.string();
                             break;
-                        case 3:
-                            obj.contentFilters.push(FilterRequest.ContentFilter.codec().decode(reader, reader.uint32()));
+                        }
+                        case 3: {
+                            if (opts.limits?.contentFilters != null && obj.contentFilters.length === opts.limits.contentFilters) {
+                                throw new CodeError('decode error - map field "contentFilters" had too many elements', 'ERR_MAX_LENGTH');
+                            }
+                            obj.contentFilters.push(FilterRequest.ContentFilter.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.contentFilters$
+                            }));
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -1611,8 +1659,8 @@ var FilterRequest;
     FilterRequest.encode = (obj) => {
         return encodeMessage(obj, FilterRequest.codec());
     };
-    FilterRequest.decode = (buf) => {
-        return decodeMessage(buf, FilterRequest.codec());
+    FilterRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, FilterRequest.codec(), opts);
     };
 })(FilterRequest || (FilterRequest = {}));
 var MessagePush$1;
@@ -1633,7 +1681,7 @@ var MessagePush$1;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     messages: []
                 };
@@ -1641,12 +1689,19 @@ var MessagePush$1;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
-                            obj.messages.push(WakuMessage$3.codec().decode(reader, reader.uint32()));
+                        case 1: {
+                            if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
+                                throw new CodeError('decode error - map field "messages" had too many elements', 'ERR_MAX_LENGTH');
+                            }
+                            obj.messages.push(WakuMessage$3.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.messages$
+                            }));
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -1657,8 +1712,8 @@ var MessagePush$1;
     MessagePush.encode = (obj) => {
         return encodeMessage(obj, MessagePush.codec());
     };
-    MessagePush.decode = (buf) => {
-        return decodeMessage(buf, MessagePush.codec());
+    MessagePush.decode = (buf, opts) => {
+        return decodeMessage(buf, MessagePush.codec(), opts);
     };
 })(MessagePush$1 || (MessagePush$1 = {}));
 var FilterRpc;
@@ -1685,7 +1740,7 @@ var FilterRpc;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     requestId: ''
                 };
@@ -1693,18 +1748,26 @@ var FilterRpc;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.requestId = reader.string();
                             break;
-                        case 2:
-                            obj.request = FilterRequest.codec().decode(reader, reader.uint32());
+                        }
+                        case 2: {
+                            obj.request = FilterRequest.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.request
+                            });
                             break;
-                        case 3:
-                            obj.push = MessagePush$1.codec().decode(reader, reader.uint32());
+                        }
+                        case 3: {
+                            obj.push = MessagePush$1.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.push
+                            });
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -1715,8 +1778,8 @@ var FilterRpc;
     FilterRpc.encode = (obj) => {
         return encodeMessage(obj, FilterRpc.codec());
     };
-    FilterRpc.decode = (buf) => {
-        return decodeMessage(buf, FilterRpc.codec());
+    FilterRpc.decode = (buf, opts) => {
+        return decodeMessage(buf, FilterRpc.codec(), opts);
     };
 })(FilterRpc || (FilterRpc = {}));
 var RateLimitProof$3;
@@ -1759,44 +1822,52 @@ var RateLimitProof$3;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 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)
+                    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:
+                        case 1: {
                             obj.proof = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.merkleRoot = reader.bytes();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.epoch = reader.bytes();
                             break;
-                        case 4:
+                        }
+                        case 4: {
                             obj.shareX = reader.bytes();
                             break;
-                        case 5:
+                        }
+                        case 5: {
                             obj.shareY = reader.bytes();
                             break;
-                        case 6:
+                        }
+                        case 6: {
                             obj.nullifier = reader.bytes();
                             break;
-                        case 7:
+                        }
+                        case 7: {
                             obj.rlnIdentifier = reader.bytes();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -1807,8 +1878,8 @@ var RateLimitProof$3;
     RateLimitProof.encode = (obj) => {
         return encodeMessage(obj, RateLimitProof.codec());
     };
-    RateLimitProof.decode = (buf) => {
-        return decodeMessage(buf, RateLimitProof.codec());
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
     };
 })(RateLimitProof$3 || (RateLimitProof$3 = {}));
 var WakuMessage$3;
@@ -1851,39 +1922,49 @@ var WakuMessage$3;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
-                    payload: new Uint8Array(0),
+                    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:
+                        case 1: {
                             obj.payload = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.contentTopic = reader.string();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.version = reader.uint32();
                             break;
-                        case 10:
+                        }
+                        case 10: {
                             obj.timestamp = reader.sint64();
                             break;
-                        case 11:
+                        }
+                        case 11: {
                             obj.meta = reader.bytes();
                             break;
-                        case 21:
-                            obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32());
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
                             break;
-                        case 31:
+                        }
+                        case 31: {
                             obj.ephemeral = reader.bool();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -1894,8 +1975,8 @@ var WakuMessage$3;
     WakuMessage.encode = (obj) => {
         return encodeMessage(obj, WakuMessage.codec());
     };
-    WakuMessage.decode = (buf) => {
-        return decodeMessage(buf, WakuMessage.codec());
+    WakuMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
     };
 })(WakuMessage$3 || (WakuMessage$3 = {}));
 
@@ -1920,7 +2001,7 @@ var TopicOnlyMessage;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     contentTopic: ''
                 };
@@ -1928,12 +2009,14 @@ var TopicOnlyMessage;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 2:
+                        case 2: {
                             obj.contentTopic = reader.string();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -1944,8 +2027,8 @@ var TopicOnlyMessage;
     TopicOnlyMessage.encode = (obj) => {
         return encodeMessage(obj, TopicOnlyMessage.codec());
     };
-    TopicOnlyMessage.decode = (buf) => {
-        return decodeMessage(buf, TopicOnlyMessage.codec());
+    TopicOnlyMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, TopicOnlyMessage.codec(), opts);
     };
 })(TopicOnlyMessage || (TopicOnlyMessage = {}));
 
@@ -2003,7 +2086,7 @@ var FilterSubscribeRequest;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     requestId: '',
                     filterSubscribeType: FilterSubscribeType.SUBSCRIBER_PING,
@@ -2013,21 +2096,29 @@ var FilterSubscribeRequest;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.requestId = reader.string();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.filterSubscribeType = FilterSubscribeRequest.FilterSubscribeType.codec().decode(reader);
                             break;
-                        case 10:
+                        }
+                        case 10: {
                             obj.pubsubTopic = reader.string();
                             break;
-                        case 11:
+                        }
+                        case 11: {
+                            if (opts.limits?.contentTopics != null && obj.contentTopics.length === opts.limits.contentTopics) {
+                                throw new CodeError('decode error - map field "contentTopics" had too many elements', 'ERR_MAX_LENGTH');
+                            }
                             obj.contentTopics.push(reader.string());
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2038,8 +2129,8 @@ var FilterSubscribeRequest;
     FilterSubscribeRequest.encode = (obj) => {
         return encodeMessage(obj, FilterSubscribeRequest.codec());
     };
-    FilterSubscribeRequest.decode = (buf) => {
-        return decodeMessage(buf, FilterSubscribeRequest.codec());
+    FilterSubscribeRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, FilterSubscribeRequest.codec(), opts);
     };
 })(FilterSubscribeRequest || (FilterSubscribeRequest = {}));
 var FilterSubscribeResponse;
@@ -2066,7 +2157,7 @@ var FilterSubscribeResponse;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     requestId: '',
                     statusCode: 0
@@ -2075,18 +2166,22 @@ var FilterSubscribeResponse;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.requestId = reader.string();
                             break;
-                        case 10:
+                        }
+                        case 10: {
                             obj.statusCode = reader.uint32();
                             break;
-                        case 11:
+                        }
+                        case 11: {
                             obj.statusDesc = reader.string();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2097,8 +2192,8 @@ var FilterSubscribeResponse;
     FilterSubscribeResponse.encode = (obj) => {
         return encodeMessage(obj, FilterSubscribeResponse.codec());
     };
-    FilterSubscribeResponse.decode = (buf) => {
-        return decodeMessage(buf, FilterSubscribeResponse.codec());
+    FilterSubscribeResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, FilterSubscribeResponse.codec(), opts);
     };
 })(FilterSubscribeResponse || (FilterSubscribeResponse = {}));
 var MessagePush;
@@ -2121,21 +2216,26 @@ var MessagePush;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (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$2.codec().decode(reader, reader.uint32());
+                        case 1: {
+                            obj.wakuMessage = WakuMessage$2.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.wakuMessage
+                            });
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.pubsubTopic = reader.string();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2146,8 +2246,8 @@ var MessagePush;
     MessagePush.encode = (obj) => {
         return encodeMessage(obj, MessagePush.codec());
     };
-    MessagePush.decode = (buf) => {
-        return decodeMessage(buf, MessagePush.codec());
+    MessagePush.decode = (buf, opts) => {
+        return decodeMessage(buf, MessagePush.codec(), opts);
     };
 })(MessagePush || (MessagePush = {}));
 var RateLimitProof$2;
@@ -2190,44 +2290,52 @@ var RateLimitProof$2;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 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)
+                    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:
+                        case 1: {
                             obj.proof = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.merkleRoot = reader.bytes();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.epoch = reader.bytes();
                             break;
-                        case 4:
+                        }
+                        case 4: {
                             obj.shareX = reader.bytes();
                             break;
-                        case 5:
+                        }
+                        case 5: {
                             obj.shareY = reader.bytes();
                             break;
-                        case 6:
+                        }
+                        case 6: {
                             obj.nullifier = reader.bytes();
                             break;
-                        case 7:
+                        }
+                        case 7: {
                             obj.rlnIdentifier = reader.bytes();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2238,8 +2346,8 @@ var RateLimitProof$2;
     RateLimitProof.encode = (obj) => {
         return encodeMessage(obj, RateLimitProof.codec());
     };
-    RateLimitProof.decode = (buf) => {
-        return decodeMessage(buf, RateLimitProof.codec());
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
     };
 })(RateLimitProof$2 || (RateLimitProof$2 = {}));
 var WakuMessage$2;
@@ -2282,39 +2390,49 @@ var WakuMessage$2;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
-                    payload: new Uint8Array(0),
+                    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:
+                        case 1: {
                             obj.payload = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.contentTopic = reader.string();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.version = reader.uint32();
                             break;
-                        case 10:
+                        }
+                        case 10: {
                             obj.timestamp = reader.sint64();
                             break;
-                        case 11:
+                        }
+                        case 11: {
                             obj.meta = reader.bytes();
                             break;
-                        case 21:
-                            obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32());
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
                             break;
-                        case 31:
+                        }
+                        case 31: {
                             obj.ephemeral = reader.bool();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2325,8 +2443,8 @@ var WakuMessage$2;
     WakuMessage.encode = (obj) => {
         return encodeMessage(obj, WakuMessage.codec());
     };
-    WakuMessage.decode = (buf) => {
-        return decodeMessage(buf, WakuMessage.codec());
+    WakuMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
     };
 })(WakuMessage$2 || (WakuMessage$2 = {}));
 
@@ -2355,7 +2473,7 @@ var PushRequest;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     pubsubTopic: ''
                 };
@@ -2363,15 +2481,20 @@ var PushRequest;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.pubsubTopic = reader.string();
                             break;
-                        case 2:
-                            obj.message = WakuMessage$1.codec().decode(reader, reader.uint32());
+                        }
+                        case 2: {
+                            obj.message = WakuMessage$1.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.message
+                            });
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2382,8 +2505,8 @@ var PushRequest;
     PushRequest.encode = (obj) => {
         return encodeMessage(obj, PushRequest.codec());
     };
-    PushRequest.decode = (buf) => {
-        return decodeMessage(buf, PushRequest.codec());
+    PushRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, PushRequest.codec(), opts);
     };
 })(PushRequest || (PushRequest = {}));
 var PushResponse;
@@ -2406,7 +2529,7 @@ var PushResponse;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     isSuccess: false
                 };
@@ -2414,15 +2537,18 @@ var PushResponse;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.isSuccess = reader.bool();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.info = reader.string();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2433,8 +2559,8 @@ var PushResponse;
     PushResponse.encode = (obj) => {
         return encodeMessage(obj, PushResponse.codec());
     };
-    PushResponse.decode = (buf) => {
-        return decodeMessage(buf, PushResponse.codec());
+    PushResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, PushResponse.codec(), opts);
     };
 })(PushResponse || (PushResponse = {}));
 var PushRpc;
@@ -2461,7 +2587,7 @@ var PushRpc;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     requestId: ''
                 };
@@ -2469,18 +2595,26 @@ var PushRpc;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.requestId = reader.string();
                             break;
-                        case 2:
-                            obj.request = PushRequest.codec().decode(reader, reader.uint32());
+                        }
+                        case 2: {
+                            obj.request = PushRequest.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.request
+                            });
                             break;
-                        case 3:
-                            obj.response = PushResponse.codec().decode(reader, reader.uint32());
+                        }
+                        case 3: {
+                            obj.response = PushResponse.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.response
+                            });
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2491,8 +2625,8 @@ var PushRpc;
     PushRpc.encode = (obj) => {
         return encodeMessage(obj, PushRpc.codec());
     };
-    PushRpc.decode = (buf) => {
-        return decodeMessage(buf, PushRpc.codec());
+    PushRpc.decode = (buf, opts) => {
+        return decodeMessage(buf, PushRpc.codec(), opts);
     };
 })(PushRpc || (PushRpc = {}));
 var RateLimitProof$1;
@@ -2535,44 +2669,52 @@ var RateLimitProof$1;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 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)
+                    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:
+                        case 1: {
                             obj.proof = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.merkleRoot = reader.bytes();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.epoch = reader.bytes();
                             break;
-                        case 4:
+                        }
+                        case 4: {
                             obj.shareX = reader.bytes();
                             break;
-                        case 5:
+                        }
+                        case 5: {
                             obj.shareY = reader.bytes();
                             break;
-                        case 6:
+                        }
+                        case 6: {
                             obj.nullifier = reader.bytes();
                             break;
-                        case 7:
+                        }
+                        case 7: {
                             obj.rlnIdentifier = reader.bytes();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2583,8 +2725,8 @@ var RateLimitProof$1;
     RateLimitProof.encode = (obj) => {
         return encodeMessage(obj, RateLimitProof.codec());
     };
-    RateLimitProof.decode = (buf) => {
-        return decodeMessage(buf, RateLimitProof.codec());
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
     };
 })(RateLimitProof$1 || (RateLimitProof$1 = {}));
 var WakuMessage$1;
@@ -2627,39 +2769,49 @@ var WakuMessage$1;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
-                    payload: new Uint8Array(0),
+                    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:
+                        case 1: {
                             obj.payload = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.contentTopic = reader.string();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.version = reader.uint32();
                             break;
-                        case 10:
+                        }
+                        case 10: {
                             obj.timestamp = reader.sint64();
                             break;
-                        case 11:
+                        }
+                        case 11: {
                             obj.meta = reader.bytes();
                             break;
-                        case 21:
-                            obj.rateLimitProof = RateLimitProof$1.codec().decode(reader, reader.uint32());
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof$1.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
                             break;
-                        case 31:
+                        }
+                        case 31: {
                             obj.ephemeral = reader.bool();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2670,8 +2822,8 @@ var WakuMessage$1;
     WakuMessage.encode = (obj) => {
         return encodeMessage(obj, WakuMessage.codec());
     };
-    WakuMessage.decode = (buf) => {
-        return decodeMessage(buf, WakuMessage.codec());
+    WakuMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
     };
 })(WakuMessage$1 || (WakuMessage$1 = {}));
 
@@ -2708,9 +2860,9 @@ var Index;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
-                    digest: new Uint8Array(0),
+                    digest: alloc$1(0),
                     receiverTime: 0n,
                     senderTime: 0n,
                     pubsubTopic: ''
@@ -2719,21 +2871,26 @@ var Index;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.digest = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.receiverTime = reader.sint64();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.senderTime = reader.sint64();
                             break;
-                        case 4:
+                        }
+                        case 4: {
                             obj.pubsubTopic = reader.string();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2744,8 +2901,8 @@ var Index;
     Index.encode = (obj) => {
         return encodeMessage(obj, Index.codec());
     };
-    Index.decode = (buf) => {
-        return decodeMessage(buf, Index.codec());
+    Index.decode = (buf, opts) => {
+        return decodeMessage(buf, Index.codec(), opts);
     };
 })(Index || (Index = {}));
 var PagingInfo;
@@ -2786,24 +2943,30 @@ var PagingInfo;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (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:
+                        case 1: {
                             obj.pageSize = reader.uint64();
                             break;
-                        case 2:
-                            obj.cursor = Index.codec().decode(reader, reader.uint32());
+                        }
+                        case 2: {
+                            obj.cursor = Index.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.cursor
+                            });
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.direction = PagingInfo.Direction.codec().decode(reader);
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2814,8 +2977,8 @@ var PagingInfo;
     PagingInfo.encode = (obj) => {
         return encodeMessage(obj, PagingInfo.codec());
     };
-    PagingInfo.decode = (buf) => {
-        return decodeMessage(buf, PagingInfo.codec());
+    PagingInfo.decode = (buf, opts) => {
+        return decodeMessage(buf, PagingInfo.codec(), opts);
     };
 })(PagingInfo || (PagingInfo = {}));
 var ContentFilter;
@@ -2834,7 +2997,7 @@ var ContentFilter;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     contentTopic: ''
                 };
@@ -2842,12 +3005,14 @@ var ContentFilter;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.contentTopic = reader.string();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2858,8 +3023,8 @@ var ContentFilter;
     ContentFilter.encode = (obj) => {
         return encodeMessage(obj, ContentFilter.codec());
     };
-    ContentFilter.decode = (buf) => {
-        return decodeMessage(buf, ContentFilter.codec());
+    ContentFilter.decode = (buf, opts) => {
+        return decodeMessage(buf, ContentFilter.codec(), opts);
     };
 })(ContentFilter || (ContentFilter = {}));
 var HistoryQuery;
@@ -2896,7 +3061,7 @@ var HistoryQuery;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     contentFilters: []
                 };
@@ -2904,24 +3069,37 @@ var HistoryQuery;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 2:
+                        case 2: {
                             obj.pubsubTopic = reader.string();
                             break;
-                        case 3:
-                            obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32()));
+                        }
+                        case 3: {
+                            if (opts.limits?.contentFilters != null && obj.contentFilters.length === opts.limits.contentFilters) {
+                                throw new CodeError('decode error - map field "contentFilters" had too many elements', 'ERR_MAX_LENGTH');
+                            }
+                            obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.contentFilters$
+                            }));
                             break;
-                        case 4:
-                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                        }
+                        case 4: {
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.pagingInfo
+                            });
                             break;
-                        case 5:
+                        }
+                        case 5: {
                             obj.startTime = reader.sint64();
                             break;
-                        case 6:
+                        }
+                        case 6: {
                             obj.endTime = reader.sint64();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -2932,8 +3110,8 @@ var HistoryQuery;
     HistoryQuery.encode = (obj) => {
         return encodeMessage(obj, HistoryQuery.codec());
     };
-    HistoryQuery.decode = (buf) => {
-        return decodeMessage(buf, HistoryQuery.codec());
+    HistoryQuery.decode = (buf, opts) => {
+        return decodeMessage(buf, HistoryQuery.codec(), opts);
     };
 })(HistoryQuery || (HistoryQuery = {}));
 var HistoryResponse;
@@ -2977,7 +3155,7 @@ var HistoryResponse;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     messages: [],
                     error: HistoryError.NONE
@@ -2986,18 +3164,29 @@ var HistoryResponse;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 2:
-                            obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32()));
+                        case 2: {
+                            if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
+                                throw new CodeError('decode error - map field "messages" had too many elements', 'ERR_MAX_LENGTH');
+                            }
+                            obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.messages$
+                            }));
                             break;
-                        case 3:
-                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                        }
+                        case 3: {
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.pagingInfo
+                            });
                             break;
-                        case 4:
+                        }
+                        case 4: {
                             obj.error = HistoryResponse.HistoryError.codec().decode(reader);
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3008,8 +3197,8 @@ var HistoryResponse;
     HistoryResponse.encode = (obj) => {
         return encodeMessage(obj, HistoryResponse.codec());
     };
-    HistoryResponse.decode = (buf) => {
-        return decodeMessage(buf, HistoryResponse.codec());
+    HistoryResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, HistoryResponse.codec(), opts);
     };
 })(HistoryResponse || (HistoryResponse = {}));
 var HistoryRpc;
@@ -3036,7 +3225,7 @@ var HistoryRpc;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     requestId: ''
                 };
@@ -3044,18 +3233,26 @@ var HistoryRpc;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.requestId = reader.string();
                             break;
-                        case 2:
-                            obj.query = HistoryQuery.codec().decode(reader, reader.uint32());
+                        }
+                        case 2: {
+                            obj.query = HistoryQuery.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.query
+                            });
                             break;
-                        case 3:
-                            obj.response = HistoryResponse.codec().decode(reader, reader.uint32());
+                        }
+                        case 3: {
+                            obj.response = HistoryResponse.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.response
+                            });
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3066,8 +3263,8 @@ var HistoryRpc;
     HistoryRpc.encode = (obj) => {
         return encodeMessage(obj, HistoryRpc.codec());
     };
-    HistoryRpc.decode = (buf) => {
-        return decodeMessage(buf, HistoryRpc.codec());
+    HistoryRpc.decode = (buf, opts) => {
+        return decodeMessage(buf, HistoryRpc.codec(), opts);
     };
 })(HistoryRpc || (HistoryRpc = {}));
 var RateLimitProof;
@@ -3110,44 +3307,52 @@ var RateLimitProof;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 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)
+                    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:
+                        case 1: {
                             obj.proof = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.merkleRoot = reader.bytes();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.epoch = reader.bytes();
                             break;
-                        case 4:
+                        }
+                        case 4: {
                             obj.shareX = reader.bytes();
                             break;
-                        case 5:
+                        }
+                        case 5: {
                             obj.shareY = reader.bytes();
                             break;
-                        case 6:
+                        }
+                        case 6: {
                             obj.nullifier = reader.bytes();
                             break;
-                        case 7:
+                        }
+                        case 7: {
                             obj.rlnIdentifier = reader.bytes();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3158,8 +3363,8 @@ var RateLimitProof;
     RateLimitProof.encode = (obj) => {
         return encodeMessage(obj, RateLimitProof.codec());
     };
-    RateLimitProof.decode = (buf) => {
-        return decodeMessage(buf, RateLimitProof.codec());
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
     };
 })(RateLimitProof || (RateLimitProof = {}));
 var WakuMessage;
@@ -3202,39 +3407,49 @@ var WakuMessage;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
-                    payload: new Uint8Array(0),
+                    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:
+                        case 1: {
                             obj.payload = reader.bytes();
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.contentTopic = reader.string();
                             break;
-                        case 3:
+                        }
+                        case 3: {
                             obj.version = reader.uint32();
                             break;
-                        case 10:
+                        }
+                        case 10: {
                             obj.timestamp = reader.sint64();
                             break;
-                        case 11:
+                        }
+                        case 11: {
                             obj.meta = reader.bytes();
                             break;
-                        case 21:
-                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32());
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
                             break;
-                        case 31:
+                        }
+                        case 31: {
                             obj.ephemeral = reader.bool();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3245,8 +3460,8 @@ var WakuMessage;
     WakuMessage.encode = (obj) => {
         return encodeMessage(obj, WakuMessage.codec());
     };
-    WakuMessage.decode = (buf) => {
-        return decodeMessage(buf, WakuMessage.codec());
+    WakuMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
     };
 })(WakuMessage || (WakuMessage = {}));
 
@@ -3271,18 +3486,20 @@ var PeerInfo;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (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:
+                        case 1: {
                             obj.enr = reader.bytes();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3293,8 +3510,8 @@ var PeerInfo;
     PeerInfo.encode = (obj) => {
         return encodeMessage(obj, PeerInfo.codec());
     };
-    PeerInfo.decode = (buf) => {
-        return decodeMessage(buf, PeerInfo.codec());
+    PeerInfo.decode = (buf, opts) => {
+        return decodeMessage(buf, PeerInfo.codec(), opts);
     };
 })(PeerInfo || (PeerInfo = {}));
 var PeerExchangeQuery;
@@ -3313,18 +3530,20 @@ var PeerExchangeQuery;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (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:
+                        case 1: {
                             obj.numPeers = reader.uint64();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3335,8 +3554,8 @@ var PeerExchangeQuery;
     PeerExchangeQuery.encode = (obj) => {
         return encodeMessage(obj, PeerExchangeQuery.codec());
     };
-    PeerExchangeQuery.decode = (buf) => {
-        return decodeMessage(buf, PeerExchangeQuery.codec());
+    PeerExchangeQuery.decode = (buf, opts) => {
+        return decodeMessage(buf, PeerExchangeQuery.codec(), opts);
     };
 })(PeerExchangeQuery || (PeerExchangeQuery = {}));
 var PeerExchangeResponse;
@@ -3357,7 +3576,7 @@ var PeerExchangeResponse;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     peerInfos: []
                 };
@@ -3365,12 +3584,19 @@ var PeerExchangeResponse;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
-                            obj.peerInfos.push(PeerInfo.codec().decode(reader, reader.uint32()));
+                        case 1: {
+                            if (opts.limits?.peerInfos != null && obj.peerInfos.length === opts.limits.peerInfos) {
+                                throw new CodeError('decode error - map field "peerInfos" had too many elements', 'ERR_MAX_LENGTH');
+                            }
+                            obj.peerInfos.push(PeerInfo.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.peerInfos$
+                            }));
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3381,8 +3607,8 @@ var PeerExchangeResponse;
     PeerExchangeResponse.encode = (obj) => {
         return encodeMessage(obj, PeerExchangeResponse.codec());
     };
-    PeerExchangeResponse.decode = (buf) => {
-        return decodeMessage(buf, PeerExchangeResponse.codec());
+    PeerExchangeResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, PeerExchangeResponse.codec(), opts);
     };
 })(PeerExchangeResponse || (PeerExchangeResponse = {}));
 var PeerExchangeRPC;
@@ -3405,21 +3631,28 @@ var PeerExchangeRPC;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (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.query = PeerExchangeQuery.codec().decode(reader, reader.uint32());
+                        case 1: {
+                            obj.query = PeerExchangeQuery.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.query
+                            });
                             break;
-                        case 2:
-                            obj.response = PeerExchangeResponse.codec().decode(reader, reader.uint32());
+                        }
+                        case 2: {
+                            obj.response = PeerExchangeResponse.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.response
+                            });
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3430,8 +3663,8 @@ var PeerExchangeRPC;
     PeerExchangeRPC.encode = (obj) => {
         return encodeMessage(obj, PeerExchangeRPC.codec());
     };
-    PeerExchangeRPC.decode = (buf) => {
-        return decodeMessage(buf, PeerExchangeRPC.codec());
+    PeerExchangeRPC.decode = (buf, opts) => {
+        return decodeMessage(buf, PeerExchangeRPC.codec(), opts);
     };
 })(PeerExchangeRPC || (PeerExchangeRPC = {}));
 
@@ -3462,7 +3695,7 @@ var WakuMetadataRequest;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     shards: []
                 };
@@ -3470,15 +3703,21 @@ var WakuMetadataRequest;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.clusterId = reader.uint32();
                             break;
-                        case 2:
+                        }
+                        case 2: {
+                            if (opts.limits?.shards != null && obj.shards.length === opts.limits.shards) {
+                                throw new CodeError('decode error - map field "shards" had too many elements', 'ERR_MAX_LENGTH');
+                            }
                             obj.shards.push(reader.uint32());
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3489,8 +3728,8 @@ var WakuMetadataRequest;
     WakuMetadataRequest.encode = (obj) => {
         return encodeMessage(obj, WakuMetadataRequest.codec());
     };
-    WakuMetadataRequest.decode = (buf) => {
-        return decodeMessage(buf, WakuMetadataRequest.codec());
+    WakuMetadataRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMetadataRequest.codec(), opts);
     };
 })(WakuMetadataRequest || (WakuMetadataRequest = {}));
 var WakuMetadataResponse;
@@ -3515,7 +3754,7 @@ var WakuMetadataResponse;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {
                     shards: []
                 };
@@ -3523,15 +3762,21 @@ var WakuMetadataResponse;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.clusterId = reader.uint32();
                             break;
-                        case 2:
+                        }
+                        case 2: {
+                            if (opts.limits?.shards != null && obj.shards.length === opts.limits.shards) {
+                                throw new CodeError('decode error - map field "shards" had too many elements', 'ERR_MAX_LENGTH');
+                            }
                             obj.shards.push(reader.uint32());
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -3542,21 +3787,21 @@ var WakuMetadataResponse;
     WakuMetadataResponse.encode = (obj) => {
         return encodeMessage(obj, WakuMetadataResponse.codec());
     };
-    WakuMetadataResponse.decode = (buf) => {
-        return decodeMessage(buf, WakuMetadataResponse.codec());
+    WakuMetadataResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMetadataResponse.codec(), opts);
     };
 })(WakuMetadataResponse || (WakuMetadataResponse = {}));
 
 // copied from utils
-function isBytes$1(a) {
+function isBytes(a) {
     return (a instanceof Uint8Array ||
         (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
 }
 function bytes(b, ...lengths) {
-    if (!isBytes$1(b))
-        throw new Error('Expected Uint8Array');
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
     if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+        throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
 }
 function exists(instance, checkFinished = true) {
     if (instance.destroyed)
@@ -3579,21 +3824,11 @@ function output(out, instance) {
 // from `crypto` to `cryptoNode`, which imports native module.
 // Makes the utils un-importable in browsers without a bundler.
 // Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
-function isBytes(a) {
-    return (a instanceof Uint8Array ||
-        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
-}
 // Cast array to view
 const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 // The rotate right (circular right shift) operation for uint32
 const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
-// big-endian hardware is rare. Just in case someone still decides to run hashes:
-// early-throw an error because we don't support BE yet.
-// Other libraries would silently corrupt the data instead of throwing an error,
-// when they don't support it.
-const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
-if (!isLE)
-    throw new Error('Non little-endian hardware is not supported');
+new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
 /**
  * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
  */
@@ -3610,8 +3845,7 @@ function utf8ToBytes(str) {
 function toBytes(data) {
     if (typeof data === 'string')
         data = utf8ToBytes(data);
-    if (!isBytes(data))
-        throw new Error(`expected Uint8Array, got ${typeof data}`);
+    bytes(data);
     return data;
 }
 // For runtime check if class implements interface
@@ -3643,8 +3877,15 @@ function setBigUint64(view, byteOffset, value, isLE) {
     view.setUint32(byteOffset + h, wh, isLE);
     view.setUint32(byteOffset + l, wl, isLE);
 }
-// Base SHA2 class (RFC 6234)
-class SHA2 extends Hash {
+// Choice: a ? b : c
+const Chi = (a, b, c) => (a & b) ^ (~a & c);
+// Majority function, true if any two inpust is true
+const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+class HashMD extends Hash {
     constructor(blockLen, outputLen, padOffset, isLE) {
         super();
         this.blockLen = blockLen;
@@ -3696,7 +3937,8 @@ class SHA2 extends Hash {
         // append the bit '1' to the message
         buffer[pos++] = 0b10000000;
         this.buffer.subarray(pos).fill(0);
-        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again
+        // we have less than padOffset left in buffer, so we cannot put length in
+        // current block, need process it and pad again
         if (this.padOffset > blockLen - pos) {
             this.process(view, 0);
             pos = 0;
@@ -3744,10 +3986,6 @@ class SHA2 extends Hash {
 
 // SHA2-256 need to try 2^128 hashes to execute birthday attack.
 // BTC network is doing 2^67 hashes/sec as per early 2023.
-// Choice: a ? b : c
-const Chi = (a, b, c) => (a & b) ^ (~a & c);
-// Majority function, true if any two inpust is true
-const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
 // Round constants:
 // first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
 // prettier-ignore
@@ -3761,27 +3999,28 @@ const SHA256_K = /* @__PURE__ */ new Uint32Array([
     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 ]);
-// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+// Initial state:
+// first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19
 // prettier-ignore
-const IV = /* @__PURE__ */ new Uint32Array([
+const SHA256_IV = /* @__PURE__ */ new Uint32Array([
     0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 ]);
 // Temporary buffer, not used to store anything between runs
 // Named this way because it matches specification.
 const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-class SHA256 extends SHA2 {
+class SHA256 extends HashMD {
     constructor() {
         super(64, 32, 8, false);
         // We cannot use array here since array allows indexing by variable
         // which means optimizer/compiler cannot use registers.
-        this.A = IV[0] | 0;
-        this.B = IV[1] | 0;
-        this.C = IV[2] | 0;
-        this.D = IV[3] | 0;
-        this.E = IV[4] | 0;
-        this.F = IV[5] | 0;
-        this.G = IV[6] | 0;
-        this.H = IV[7] | 0;
+        this.A = SHA256_IV[0] | 0;
+        this.B = SHA256_IV[1] | 0;
+        this.C = SHA256_IV[2] | 0;
+        this.D = SHA256_IV[3] | 0;
+        this.E = SHA256_IV[4] | 0;
+        this.F = SHA256_IV[5] | 0;
+        this.G = SHA256_IV[6] | 0;
+        this.H = SHA256_IV[7] | 0;
     }
     get() {
         const { A, B, C, D, E, F, G, H } = this;
@@ -4776,8 +5015,8 @@ class Logger {
     }
 }
 
-const log$1 = new Logger("message:version-0");
-const OneMillion = BigInt(1000000);
+const log = new Logger("message:version-0");
+const OneMillion = BigInt(1_000_000);
 const Version = 0;
 let DecodedMessage$1 = class DecodedMessage {
     pubsubTopic;
@@ -4851,7 +5090,7 @@ let Decoder$1 = class Decoder {
         // https://rfc.vac.dev/spec/14/
         // > If omitted, the value SHOULD be interpreted as version 0.
         if (proto.version ?? 0 !== Version) {
-            log$1.error("Failed to decode due to incorrect version, expected:", Version, ", actual:", proto.version);
+            log.error("Failed to decode due to incorrect version, expected:", Version, ", actual:", proto.version);
             return Promise.resolve(undefined);
         }
         return new DecodedMessage$1(pubsubTopic, proto);
@@ -5074,124 +5313,4 @@ function postCipher(message) {
     return { payload, sig };
 }
 
-const log = new Logger("message-encryption:symmetric");
-class Encoder {
-    pubsubTopic;
-    contentTopic;
-    symKey;
-    sigPrivKey;
-    ephemeral;
-    metaSetter;
-    constructor(pubsubTopic, contentTopic, symKey, sigPrivKey, ephemeral = false, metaSetter) {
-        this.pubsubTopic = pubsubTopic;
-        this.contentTopic = contentTopic;
-        this.symKey = symKey;
-        this.sigPrivKey = sigPrivKey;
-        this.ephemeral = ephemeral;
-        this.metaSetter = metaSetter;
-        if (!contentTopic || contentTopic === "") {
-            throw new Error("Content topic must be specified");
-        }
-    }
-    async toWire(message) {
-        const protoMessage = await this.toProtoObj(message);
-        if (!protoMessage)
-            return;
-        return WakuMessage$3.encode(protoMessage);
-    }
-    async toProtoObj(message) {
-        const timestamp = message.timestamp ?? new Date();
-        const preparedPayload = await preCipher(message.payload, this.sigPrivKey);
-        const payload = await encryptSymmetric(preparedPayload, this.symKey);
-        const protoMessage = {
-            payload,
-            version: Version$1,
-            contentTopic: this.contentTopic,
-            timestamp: BigInt(timestamp.valueOf()) * OneMillion$1,
-            meta: undefined,
-            rateLimitProof: message.rateLimitProof,
-            ephemeral: this.ephemeral
-        };
-        if (this.metaSetter) {
-            const meta = this.metaSetter(protoMessage);
-            return { ...protoMessage, meta };
-        }
-        return protoMessage;
-    }
-}
-/**
- * Creates an encoder that encrypts messages using symmetric encryption for the
- * given key, as defined in [26/WAKU2-PAYLOAD](https://rfc.vac.dev/spec/26/).
- *
- * An encoder is used to encode messages in the [`14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
- * format to be sent over the Waku network. The resulting encoder can then be
- * pass to { @link @waku/interfaces!ISender.send } to automatically encrypt
- * and encode outgoing messages.
- *
- * The payload can optionally be signed with the given private key as defined
- * in [26/WAKU2-PAYLOAD](https://rfc.vac.dev/spec/26/).
- */
-function createEncoder({ pubsubTopic = DefaultPubsubTopic, pubsubTopicShardInfo, contentTopic, symKey, sigPrivKey, ephemeral = false, metaSetter }) {
-    return new Encoder(determinePubsubTopic(contentTopic, pubsubTopic ?? pubsubTopicShardInfo), contentTopic, symKey, sigPrivKey, ephemeral, metaSetter);
-}
-class Decoder extends Decoder$1 {
-    symKey;
-    constructor(pubsubTopic, contentTopic, symKey) {
-        super(pubsubTopic, contentTopic);
-        this.symKey = symKey;
-    }
-    async fromProtoObj(pubsubTopic, protoMessage) {
-        const cipherPayload = protoMessage.payload;
-        if (protoMessage.version !== Version$1) {
-            log.error("Failed to decrypt due to incorrect version, expected:", Version$1, ", actual:", protoMessage.version);
-            return;
-        }
-        let payload;
-        try {
-            payload = await decryptSymmetric(cipherPayload, this.symKey);
-        }
-        catch (e) {
-            log.error(`Failed to decrypt message using asymmetric decryption for contentTopic: ${this.contentTopic}`, e);
-            return;
-        }
-        if (!payload) {
-            log.error(`Failed to decrypt payload for contentTopic ${this.contentTopic}`);
-            return;
-        }
-        const res = postCipher(payload);
-        if (!res) {
-            log.error(`Failed to decode payload for contentTopic ${this.contentTopic}`);
-            return;
-        }
-        log.info("Message decrypted", protoMessage);
-        return new DecodedMessage(pubsubTopic, protoMessage, res.payload, res.sig?.signature, res.sig?.publicKey);
-    }
-}
-/**
- * Creates a decoder that decrypts messages using symmetric encryption, using
- * the given key as defined in [26/WAKU2-PAYLOAD](https://rfc.vac.dev/spec/26/).
- *
- * A decoder is used to decode messages from the [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
- * format when received from the Waku network. The resulting decoder can then be
- * pass to { @link @waku/interfaces!IReceiver.subscribe } to automatically decrypt and
- * decode incoming messages.
- *
- * @param contentTopic The resulting decoder will only decode messages with this content topic.
- * @param symKey The symmetric key used to decrypt the message.
- */
-function createDecoder(contentTopic, symKey, pubsubTopicShardInfo = DefaultPubsubTopic) {
-    return new Decoder(determinePubsubTopic(contentTopic, pubsubTopicShardInfo), contentTopic, symKey);
-}
-
-var symmetric = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createDecoder: createDecoder,
-    createEncoder: createEncoder,
-    decryptSymmetric: decryptSymmetric,
-    encryptSymmetric: encryptSymmetric,
-    generateSymmetricKey: generateSymmetricKey,
-    postCipher: postCipher,
-    preCipher: preCipher
-});
-
-export { DefaultPubsubTopic as D, Logger as L, WakuMessage$3 as W, Decoder$1 as a, decryptAsymmetric as b, postCipher as c, determinePubsubTopic as d, encryptAsymmetric as e, DecodedMessage as f, decryptSymmetric as g, encryptSymmetric as h, createEncoder as i, createDecoder as j, preCipher as p, symmetric as s };
+export { DefaultPubsubTopic as D, Logger as L, WakuMessage$3 as W, Decoder$1 as a, decryptAsymmetric as b, postCipher as c, determinePubsubTopic as d, encryptAsymmetric as e, DecodedMessage as f, encryptSymmetric as g, decryptSymmetric as h, preCipher as p };