@libp2p/floodsub 9.1.5-dd7b329c4 → 9.1.5-e1ca9cced

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/floodsub",
-  "version": "9.1.5-dd7b329c4",
+  "version": "9.1.5-e1ca9cced",
   "description": "libp2p-floodsub, also known as pubsub-flood or just dumbsub, this implementation of pubsub focused on delivering an API for Publish/Subscribe, but with no CastTree Forming (it just floods the network).",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/pubsub-floodsub#readme",
@@ -60,17 +60,18 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/interface": "1.7.0-dd7b329c4",
-    "@libp2p/pubsub": "9.0.26-dd7b329c4",
+    "@libp2p/interface": "1.7.0-e1ca9cced",
+    "@libp2p/pubsub": "9.0.26-e1ca9cced",
     "protons-runtime": "^5.4.0",
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/interface-compliance-tests": "5.4.12-dd7b329c4",
-    "@libp2p/logger": "4.0.20-dd7b329c4",
-    "@libp2p/peer-collections": "5.2.9-dd7b329c4",
-    "@libp2p/peer-id-factory": "4.2.4-dd7b329c4",
+    "@libp2p/crypto": "4.1.9-e1ca9cced",
+    "@libp2p/interface-compliance-tests": "5.4.12-e1ca9cced",
+    "@libp2p/logger": "4.0.20-e1ca9cced",
+    "@libp2p/peer-collections": "5.2.9-e1ca9cced",
+    "@libp2p/peer-id": "4.2.4-e1ca9cced",
     "@multiformats/multiaddr": "^12.2.3",
     "@types/sinon": "^17.0.3",
     "aegir": "^44.0.1",

package/src/message/rpc.ts

@@ -4,8 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, MaxLengthError, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface RPC {
@@ -43,7 +42,7 @@ export namespace RPC {
           if (opts.lengthDelimited !== false) {
             w.ldelim()
           }
-        }, (reader, length) => {
+        }, (reader, length, opts = {}) => {
           const obj: any = {}
 
           const end = length == null ? reader.len : reader.pos + length
@@ -52,15 +51,18 @@ export namespace RPC {
             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
-              default:
+              }
+              default: {
                 reader.skipType(tag & 7)
                 break
+              }
             }
           }
 
@@ -75,8 +77,8 @@ export namespace RPC {
       return encodeMessage(obj, SubOpts.codec())
     }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList): SubOpts => {
-      return decodeMessage(buf, SubOpts.codec())
+    export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<SubOpts>): SubOpts => {
+      return decodeMessage(buf, SubOpts.codec(), opts)
     }
   }
 
@@ -132,7 +134,7 @@ export namespace RPC {
           if (opts.lengthDelimited !== false) {
             w.ldelim()
           }
-        }, (reader, length) => {
+        }, (reader, length, opts = {}) => {
           const obj: any = {}
 
           const end = length == null ? reader.len : reader.pos + length
@@ -141,27 +143,34 @@ export namespace RPC {
             const tag = reader.uint32()
 
             switch (tag >>> 3) {
-              case 1:
+              case 1: {
                 obj.from = reader.bytes()
                 break
-              case 2:
+              }
+              case 2: {
                 obj.data = reader.bytes()
                 break
-              case 3:
+              }
+              case 3: {
                 obj.sequenceNumber = reader.bytes()
                 break
-              case 4:
+              }
+              case 4: {
                 obj.topic = reader.string()
                 break
-              case 5:
+              }
+              case 5: {
                 obj.signature = reader.bytes()
                 break
-              case 6:
+              }
+              case 6: {
                 obj.key = reader.bytes()
                 break
-              default:
+              }
+              default: {
                 reader.skipType(tag & 7)
                 break
+              }
             }
           }
 
@@ -176,8 +185,8 @@ export namespace RPC {
       return encodeMessage(obj, Message.codec())
     }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
-      return decodeMessage(buf, Message.codec())
+    export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message => {
+      return decodeMessage(buf, Message.codec(), opts)
     }
   }
 
@@ -212,7 +221,7 @@ export namespace RPC {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           subscriptions: [],
           messages: []
@@ -224,18 +233,36 @@ export namespace RPC {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
-              obj.subscriptions.push(RPC.SubOpts.codec().decode(reader, reader.uint32()))
+            case 1: {
+              if (opts.limits?.subscriptions != null && obj.subscriptions.length === opts.limits.subscriptions) {
+                throw new MaxLengthError('Decode error - map field "subscriptions" had too many elements')
+              }
+
+              obj.subscriptions.push(RPC.SubOpts.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.subscriptions$
+              }))
               break
-            case 2:
-              obj.messages.push(RPC.Message.codec().decode(reader, reader.uint32()))
+            }
+            case 2: {
+              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(RPC.Message.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.messages$
+              }))
               break
-            case 3:
-              obj.control = ControlMessage.codec().decode(reader, reader.uint32())
+            }
+            case 3: {
+              obj.control = ControlMessage.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.control
+              })
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -250,8 +277,8 @@ export namespace RPC {
     return encodeMessage(obj, RPC.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): RPC => {
-    return decodeMessage(buf, RPC.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<RPC>): RPC => {
+    return decodeMessage(buf, RPC.codec(), opts)
   }
 }
 
@@ -303,7 +330,7 @@ export namespace ControlMessage {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           ihave: [],
           iwant: [],
@@ -317,21 +344,50 @@ export namespace ControlMessage {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
-              obj.ihave.push(ControlIHave.codec().decode(reader, reader.uint32()))
+            case 1: {
+              if (opts.limits?.ihave != null && obj.ihave.length === opts.limits.ihave) {
+                throw new MaxLengthError('Decode error - map field "ihave" had too many elements')
+              }
+
+              obj.ihave.push(ControlIHave.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.ihave$
+              }))
               break
-            case 2:
-              obj.iwant.push(ControlIWant.codec().decode(reader, reader.uint32()))
+            }
+            case 2: {
+              if (opts.limits?.iwant != null && obj.iwant.length === opts.limits.iwant) {
+                throw new MaxLengthError('Decode error - map field "iwant" had too many elements')
+              }
+
+              obj.iwant.push(ControlIWant.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.iwant$
+              }))
               break
-            case 3:
-              obj.graft.push(ControlGraft.codec().decode(reader, reader.uint32()))
+            }
+            case 3: {
+              if (opts.limits?.graft != null && obj.graft.length === opts.limits.graft) {
+                throw new MaxLengthError('Decode error - map field "graft" had too many elements')
+              }
+
+              obj.graft.push(ControlGraft.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.graft$
+              }))
               break
-            case 4:
-              obj.prune.push(ControlPrune.codec().decode(reader, reader.uint32()))
+            }
+            case 4: {
+              if (opts.limits?.prune != null && obj.prune.length === opts.limits.prune) {
+                throw new MaxLengthError('Decode error - map field "prune" had too many elements')
+              }
+
+              obj.prune.push(ControlPrune.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.prune$
+              }))
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -346,8 +402,8 @@ export namespace ControlMessage {
     return encodeMessage(obj, ControlMessage.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): ControlMessage => {
-    return decodeMessage(buf, ControlMessage.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlMessage>): ControlMessage => {
+    return decodeMessage(buf, ControlMessage.codec(), opts)
   }
 }
 
@@ -381,7 +437,7 @@ export namespace ControlIHave {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           messageIDs: []
         }
@@ -392,15 +448,22 @@ export namespace ControlIHave {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.topic = reader.string()
               break
-            case 2:
+            }
+            case 2: {
+              if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) {
+                throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements')
+              }
+
               obj.messageIDs.push(reader.bytes())
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -415,8 +478,8 @@ export namespace ControlIHave {
     return encodeMessage(obj, ControlIHave.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): ControlIHave => {
-    return decodeMessage(buf, ControlIHave.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIHave>): ControlIHave => {
+    return decodeMessage(buf, ControlIHave.codec(), opts)
   }
 }
 
@@ -444,7 +507,7 @@ export namespace ControlIWant {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           messageIDs: []
         }
@@ -455,12 +518,18 @@ export namespace ControlIWant {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
+              if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) {
+                throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements')
+              }
+
               obj.messageIDs.push(reader.bytes())
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -475,8 +544,8 @@ export namespace ControlIWant {
     return encodeMessage(obj, ControlIWant.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): ControlIWant => {
-    return decodeMessage(buf, ControlIWant.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIWant>): ControlIWant => {
+    return decodeMessage(buf, ControlIWant.codec(), opts)
   }
 }
 
@@ -502,7 +571,7 @@ export namespace ControlGraft {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -511,12 +580,14 @@ export namespace ControlGraft {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.topic = reader.string()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -531,8 +602,8 @@ export namespace ControlGraft {
     return encodeMessage(obj, ControlGraft.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): ControlGraft => {
-    return decodeMessage(buf, ControlGraft.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlGraft>): ControlGraft => {
+    return decodeMessage(buf, ControlGraft.codec(), opts)
   }
 }
 
@@ -572,7 +643,7 @@ export namespace ControlPrune {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           peers: []
         }
@@ -583,18 +654,28 @@ export namespace ControlPrune {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.topic = reader.string()
               break
-            case 2:
-              obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32()))
+            }
+            case 2: {
+              if (opts.limits?.peers != null && obj.peers.length === opts.limits.peers) {
+                throw new MaxLengthError('Decode error - map field "peers" had too many elements')
+              }
+
+              obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.peers$
+              }))
               break
-            case 3:
+            }
+            case 3: {
               obj.backoff = reader.uint64()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -609,8 +690,8 @@ export namespace ControlPrune {
     return encodeMessage(obj, ControlPrune.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): ControlPrune => {
-    return decodeMessage(buf, ControlPrune.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlPrune>): ControlPrune => {
+    return decodeMessage(buf, ControlPrune.codec(), opts)
   }
 }
 
@@ -642,7 +723,7 @@ export namespace PeerInfo {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -651,15 +732,18 @@ export namespace PeerInfo {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.peerID = reader.bytes()
               break
-            case 2:
+            }
+            case 2: {
               obj.signedPeerRecord = reader.bytes()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -674,7 +758,7 @@ export namespace PeerInfo {
     return encodeMessage(obj, PeerInfo.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): PeerInfo => {
-    return decodeMessage(buf, PeerInfo.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): PeerInfo => {
+    return decodeMessage(buf, PeerInfo.codec(), opts)
   }
 }