@libp2p/daemon-protocol 2.0.0 → 3.0.0

package/src/index.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/export */
 /* eslint-disable @typescript-eslint/no-namespace */
 
-import { enumeration, encodeMessage, decodeMessage, message, bytes, int64, string, int32 } from 'protons-runtime'
+import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
 
 export interface Request {
@@ -45,29 +46,127 @@ export namespace Request {
 
   export namespace Type {
     export const codec = () => {
-      return enumeration<typeof Type>(__TypeValues)
+      return enumeration<Type>(__TypeValues)
     }
   }
 
+  let _codec: Codec<Request>
+
   export const codec = (): Codec<Request> => {
-    return message<Request>({
-      1: { name: 'type', codec: Request.Type.codec() },
-      2: { name: 'connect', codec: ConnectRequest.codec(), optional: true },
-      3: { name: 'streamOpen', codec: StreamOpenRequest.codec(), optional: true },
-      4: { name: 'streamHandler', codec: StreamHandlerRequest.codec(), optional: true },
-      5: { name: 'dht', codec: DHTRequest.codec(), optional: true },
-      6: { name: 'connManager', codec: ConnManagerRequest.codec(), optional: true },
-      7: { name: 'disconnect', codec: DisconnectRequest.codec(), optional: true },
-      8: { name: 'pubsub', codec: PSRequest.codec(), optional: true },
-      9: { name: 'peerStore', codec: PeerstoreRequest.codec(), optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<Request>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          Request.Type.codec().encode(obj.type, writer)
+        } else {
+          throw new Error('Protocol error: required field "type" was not found in object')
+        }
+
+        if (obj.connect != null) {
+          writer.uint32(18)
+          ConnectRequest.codec().encode(obj.connect, writer)
+        }
+
+        if (obj.streamOpen != null) {
+          writer.uint32(26)
+          StreamOpenRequest.codec().encode(obj.streamOpen, writer)
+        }
+
+        if (obj.streamHandler != null) {
+          writer.uint32(34)
+          StreamHandlerRequest.codec().encode(obj.streamHandler, writer)
+        }
+
+        if (obj.dht != null) {
+          writer.uint32(42)
+          DHTRequest.codec().encode(obj.dht, writer)
+        }
+
+        if (obj.connManager != null) {
+          writer.uint32(50)
+          ConnManagerRequest.codec().encode(obj.connManager, writer)
+        }
+
+        if (obj.disconnect != null) {
+          writer.uint32(58)
+          DisconnectRequest.codec().encode(obj.disconnect, writer)
+        }
+
+        if (obj.pubsub != null) {
+          writer.uint32(66)
+          PSRequest.codec().encode(obj.pubsub, writer)
+        }
+
+        if (obj.peerStore != null) {
+          writer.uint32(74)
+          PeerstoreRequest.codec().encode(obj.peerStore, writer)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = Request.Type.codec().decode(reader)
+              break
+            case 2:
+              obj.connect = ConnectRequest.codec().decode(reader, reader.uint32())
+              break
+            case 3:
+              obj.streamOpen = StreamOpenRequest.codec().decode(reader, reader.uint32())
+              break
+            case 4:
+              obj.streamHandler = StreamHandlerRequest.codec().decode(reader, reader.uint32())
+              break
+            case 5:
+              obj.dht = DHTRequest.codec().decode(reader, reader.uint32())
+              break
+            case 6:
+              obj.connManager = ConnManagerRequest.codec().decode(reader, reader.uint32())
+              break
+            case 7:
+              obj.disconnect = DisconnectRequest.codec().decode(reader, reader.uint32())
+              break
+            case 8:
+              obj.pubsub = PSRequest.codec().decode(reader, reader.uint32())
+              break
+            case 9:
+              obj.peerStore = PeerstoreRequest.codec().decode(reader, reader.uint32())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.type == null) {
+          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: Request): Uint8Array => {
     return encodeMessage(obj, Request.codec())
   }
 
-  export const decode = (buf: Uint8Array): Request => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Request => {
     return decodeMessage(buf, Request.codec())
   }
 }
@@ -96,28 +195,130 @@ export namespace Response {
 
   export namespace Type {
     export const codec = () => {
-      return enumeration<typeof Type>(__TypeValues)
+      return enumeration<Type>(__TypeValues)
     }
   }
 
+  let _codec: Codec<Response>
+
   export const codec = (): Codec<Response> => {
-    return message<Response>({
-      1: { name: 'type', codec: Response.Type.codec() },
-      2: { name: 'error', codec: ErrorResponse.codec(), optional: true },
-      3: { name: 'streamInfo', codec: StreamInfo.codec(), optional: true },
-      4: { name: 'identify', codec: IdentifyResponse.codec(), optional: true },
-      5: { name: 'dht', codec: DHTResponse.codec(), optional: true },
-      6: { name: 'peers', codec: PeerInfo.codec(), repeats: true },
-      7: { name: 'pubsub', codec: PSResponse.codec(), optional: true },
-      8: { name: 'peerStore', codec: PeerstoreResponse.codec(), optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<Response>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          Response.Type.codec().encode(obj.type, writer)
+        } else {
+          throw new Error('Protocol error: required field "type" was not found in object')
+        }
+
+        if (obj.error != null) {
+          writer.uint32(18)
+          ErrorResponse.codec().encode(obj.error, writer)
+        }
+
+        if (obj.streamInfo != null) {
+          writer.uint32(26)
+          StreamInfo.codec().encode(obj.streamInfo, writer)
+        }
+
+        if (obj.identify != null) {
+          writer.uint32(34)
+          IdentifyResponse.codec().encode(obj.identify, writer)
+        }
+
+        if (obj.dht != null) {
+          writer.uint32(42)
+          DHTResponse.codec().encode(obj.dht, writer)
+        }
+
+        if (obj.peers != null) {
+          for (const value of obj.peers) {
+            writer.uint32(50)
+            PeerInfo.codec().encode(value, writer)
+          }
+        } else {
+          throw new Error('Protocol error: required field "peers" was not found in object')
+        }
+
+        if (obj.pubsub != null) {
+          writer.uint32(58)
+          PSResponse.codec().encode(obj.pubsub, writer)
+        }
+
+        if (obj.peerStore != null) {
+          writer.uint32(66)
+          PeerstoreResponse.codec().encode(obj.peerStore, writer)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = Response.Type.codec().decode(reader)
+              break
+            case 2:
+              obj.error = ErrorResponse.codec().decode(reader, reader.uint32())
+              break
+            case 3:
+              obj.streamInfo = StreamInfo.codec().decode(reader, reader.uint32())
+              break
+            case 4:
+              obj.identify = IdentifyResponse.codec().decode(reader, reader.uint32())
+              break
+            case 5:
+              obj.dht = DHTResponse.codec().decode(reader, reader.uint32())
+              break
+            case 6:
+              obj.peers = obj.peers ?? []
+              obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32()))
+              break
+            case 7:
+              obj.pubsub = PSResponse.codec().decode(reader, reader.uint32())
+              break
+            case 8:
+              obj.peerStore = PeerstoreResponse.codec().decode(reader, reader.uint32())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.peers = obj.peers ?? []
+
+        if (obj.type == null) {
+          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
+        }
+
+        if (obj.peers == null) {
+          throw new Error('Protocol error: value for required field "peers" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: Response): Uint8Array => {
     return encodeMessage(obj, Response.codec())
   }
 
-  export const decode = (buf: Uint8Array): Response => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Response => {
     return decodeMessage(buf, Response.codec())
   }
 }
@@ -128,18 +329,78 @@ export interface IdentifyResponse {
 }
 
 export namespace IdentifyResponse {
+  let _codec: Codec<IdentifyResponse>
+
   export const codec = (): Codec<IdentifyResponse> => {
-    return message<IdentifyResponse>({
-      1: { name: 'id', codec: bytes },
-      2: { name: 'addrs', codec: bytes, repeats: true }
-    })
+    if (_codec == null) {
+      _codec = message<IdentifyResponse>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.id != null) {
+          writer.uint32(10)
+          writer.bytes(obj.id)
+        } else {
+          throw new Error('Protocol error: required field "id" was not found in object')
+        }
+
+        if (obj.addrs != null) {
+          for (const value of obj.addrs) {
+            writer.uint32(18)
+            writer.bytes(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "addrs" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.id = reader.bytes()
+              break
+            case 2:
+              obj.addrs = obj.addrs ?? []
+              obj.addrs.push(reader.bytes())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.addrs = obj.addrs ?? []
+
+        if (obj.id == null) {
+          throw new Error('Protocol error: value for required field "id" was not found in protobuf')
+        }
+
+        if (obj.addrs == null) {
+          throw new Error('Protocol error: value for required field "addrs" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: IdentifyResponse): Uint8Array => {
     return encodeMessage(obj, IdentifyResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array): IdentifyResponse => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): IdentifyResponse => {
     return decodeMessage(buf, IdentifyResponse.codec())
   }
 }
@@ -151,19 +412,86 @@ export interface ConnectRequest {
 }
 
 export namespace ConnectRequest {
+  let _codec: Codec<ConnectRequest>
+
   export const codec = (): Codec<ConnectRequest> => {
-    return message<ConnectRequest>({
-      1: { name: 'peer', codec: bytes },
-      2: { name: 'addrs', codec: bytes, repeats: true },
-      3: { name: 'timeout', codec: int64, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<ConnectRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.peer != null) {
+          writer.uint32(10)
+          writer.bytes(obj.peer)
+        } else {
+          throw new Error('Protocol error: required field "peer" was not found in object')
+        }
+
+        if (obj.addrs != null) {
+          for (const value of obj.addrs) {
+            writer.uint32(18)
+            writer.bytes(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "addrs" was not found in object')
+        }
+
+        if (obj.timeout != null) {
+          writer.uint32(24)
+          writer.int64(obj.timeout)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.peer = reader.bytes()
+              break
+            case 2:
+              obj.addrs = obj.addrs ?? []
+              obj.addrs.push(reader.bytes())
+              break
+            case 3:
+              obj.timeout = reader.int64()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.addrs = obj.addrs ?? []
+
+        if (obj.peer == null) {
+          throw new Error('Protocol error: value for required field "peer" was not found in protobuf')
+        }
+
+        if (obj.addrs == null) {
+          throw new Error('Protocol error: value for required field "addrs" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: ConnectRequest): Uint8Array => {
     return encodeMessage(obj, ConnectRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): ConnectRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): ConnectRequest => {
     return decodeMessage(buf, ConnectRequest.codec())
   }
 }
@@ -175,19 +503,86 @@ export interface StreamOpenRequest {
 }
 
 export namespace StreamOpenRequest {
+  let _codec: Codec<StreamOpenRequest>
+
   export const codec = (): Codec<StreamOpenRequest> => {
-    return message<StreamOpenRequest>({
-      1: { name: 'peer', codec: bytes },
-      2: { name: 'proto', codec: string, repeats: true },
-      3: { name: 'timeout', codec: int64, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<StreamOpenRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.peer != null) {
+          writer.uint32(10)
+          writer.bytes(obj.peer)
+        } else {
+          throw new Error('Protocol error: required field "peer" was not found in object')
+        }
+
+        if (obj.proto != null) {
+          for (const value of obj.proto) {
+            writer.uint32(18)
+            writer.string(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "proto" was not found in object')
+        }
+
+        if (obj.timeout != null) {
+          writer.uint32(24)
+          writer.int64(obj.timeout)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.peer = reader.bytes()
+              break
+            case 2:
+              obj.proto = obj.proto ?? []
+              obj.proto.push(reader.string())
+              break
+            case 3:
+              obj.timeout = reader.int64()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.proto = obj.proto ?? []
+
+        if (obj.peer == null) {
+          throw new Error('Protocol error: value for required field "peer" was not found in protobuf')
+        }
+
+        if (obj.proto == null) {
+          throw new Error('Protocol error: value for required field "proto" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: StreamOpenRequest): Uint8Array => {
     return encodeMessage(obj, StreamOpenRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): StreamOpenRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): StreamOpenRequest => {
     return decodeMessage(buf, StreamOpenRequest.codec())
   }
 }
@@ -198,18 +593,78 @@ export interface StreamHandlerRequest {
 }
 
 export namespace StreamHandlerRequest {
+  let _codec: Codec<StreamHandlerRequest>
+
   export const codec = (): Codec<StreamHandlerRequest> => {
-    return message<StreamHandlerRequest>({
-      1: { name: 'addr', codec: bytes },
-      2: { name: 'proto', codec: string, repeats: true }
-    })
+    if (_codec == null) {
+      _codec = message<StreamHandlerRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.addr != null) {
+          writer.uint32(10)
+          writer.bytes(obj.addr)
+        } else {
+          throw new Error('Protocol error: required field "addr" was not found in object')
+        }
+
+        if (obj.proto != null) {
+          for (const value of obj.proto) {
+            writer.uint32(18)
+            writer.string(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "proto" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.addr = reader.bytes()
+              break
+            case 2:
+              obj.proto = obj.proto ?? []
+              obj.proto.push(reader.string())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.proto = obj.proto ?? []
+
+        if (obj.addr == null) {
+          throw new Error('Protocol error: value for required field "addr" was not found in protobuf')
+        }
+
+        if (obj.proto == null) {
+          throw new Error('Protocol error: value for required field "proto" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: StreamHandlerRequest): Uint8Array => {
     return encodeMessage(obj, StreamHandlerRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): StreamHandlerRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): StreamHandlerRequest => {
     return decodeMessage(buf, StreamHandlerRequest.codec())
   }
 }
@@ -219,17 +674,59 @@ export interface ErrorResponse {
 }
 
 export namespace ErrorResponse {
+  let _codec: Codec<ErrorResponse>
+
   export const codec = (): Codec<ErrorResponse> => {
-    return message<ErrorResponse>({
-      1: { name: 'msg', codec: string }
-    })
+    if (_codec == null) {
+      _codec = message<ErrorResponse>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.msg != null) {
+          writer.uint32(10)
+          writer.string(obj.msg)
+        } else {
+          throw new Error('Protocol error: required field "msg" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.msg = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.msg == null) {
+          throw new Error('Protocol error: value for required field "msg" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: ErrorResponse): Uint8Array => {
     return encodeMessage(obj, ErrorResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array): ErrorResponse => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): ErrorResponse => {
     return decodeMessage(buf, ErrorResponse.codec())
   }
 }
@@ -241,19 +738,87 @@ export interface StreamInfo {
 }
 
 export namespace StreamInfo {
+  let _codec: Codec<StreamInfo>
+
   export const codec = (): Codec<StreamInfo> => {
-    return message<StreamInfo>({
-      1: { name: 'peer', codec: bytes },
-      2: { name: 'addr', codec: bytes },
-      3: { name: 'proto', codec: string }
-    })
+    if (_codec == null) {
+      _codec = message<StreamInfo>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.peer != null) {
+          writer.uint32(10)
+          writer.bytes(obj.peer)
+        } else {
+          throw new Error('Protocol error: required field "peer" was not found in object')
+        }
+
+        if (obj.addr != null) {
+          writer.uint32(18)
+          writer.bytes(obj.addr)
+        } else {
+          throw new Error('Protocol error: required field "addr" was not found in object')
+        }
+
+        if (obj.proto != null) {
+          writer.uint32(26)
+          writer.string(obj.proto)
+        } else {
+          throw new Error('Protocol error: required field "proto" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.peer = reader.bytes()
+              break
+            case 2:
+              obj.addr = reader.bytes()
+              break
+            case 3:
+              obj.proto = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.peer == null) {
+          throw new Error('Protocol error: value for required field "peer" was not found in protobuf')
+        }
+
+        if (obj.addr == null) {
+          throw new Error('Protocol error: value for required field "addr" was not found in protobuf')
+        }
+
+        if (obj.proto == null) {
+          throw new Error('Protocol error: value for required field "proto" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: StreamInfo): Uint8Array => {
     return encodeMessage(obj, StreamInfo.codec())
   }
 
-  export const decode = (buf: Uint8Array): StreamInfo => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): StreamInfo => {
     return decodeMessage(buf, StreamInfo.codec())
   }
 }
@@ -295,27 +860,111 @@ export namespace DHTRequest {
 
   export namespace Type {
     export const codec = () => {
-      return enumeration<typeof Type>(__TypeValues)
+      return enumeration<Type>(__TypeValues)
     }
   }
 
+  let _codec: Codec<DHTRequest>
+
   export const codec = (): Codec<DHTRequest> => {
-    return message<DHTRequest>({
-      1: { name: 'type', codec: DHTRequest.Type.codec() },
-      2: { name: 'peer', codec: bytes, optional: true },
-      3: { name: 'cid', codec: bytes, optional: true },
-      4: { name: 'key', codec: bytes, optional: true },
-      5: { name: 'value', codec: bytes, optional: true },
-      6: { name: 'count', codec: int32, optional: true },
-      7: { name: 'timeout', codec: int64, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<DHTRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          DHTRequest.Type.codec().encode(obj.type, writer)
+        } else {
+          throw new Error('Protocol error: required field "type" was not found in object')
+        }
+
+        if (obj.peer != null) {
+          writer.uint32(18)
+          writer.bytes(obj.peer)
+        }
+
+        if (obj.cid != null) {
+          writer.uint32(26)
+          writer.bytes(obj.cid)
+        }
+
+        if (obj.key != null) {
+          writer.uint32(34)
+          writer.bytes(obj.key)
+        }
+
+        if (obj.value != null) {
+          writer.uint32(42)
+          writer.bytes(obj.value)
+        }
+
+        if (obj.count != null) {
+          writer.uint32(48)
+          writer.int32(obj.count)
+        }
+
+        if (obj.timeout != null) {
+          writer.uint32(56)
+          writer.int64(obj.timeout)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = DHTRequest.Type.codec().decode(reader)
+              break
+            case 2:
+              obj.peer = reader.bytes()
+              break
+            case 3:
+              obj.cid = reader.bytes()
+              break
+            case 4:
+              obj.key = reader.bytes()
+              break
+            case 5:
+              obj.value = reader.bytes()
+              break
+            case 6:
+              obj.count = reader.int32()
+              break
+            case 7:
+              obj.timeout = reader.int64()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.type == null) {
+          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: DHTRequest): Uint8Array => {
     return encodeMessage(obj, DHTRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): DHTRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): DHTRequest => {
     return decodeMessage(buf, DHTRequest.codec())
   }
 }
@@ -341,23 +990,79 @@ export namespace DHTResponse {
 
   export namespace Type {
     export const codec = () => {
-      return enumeration<typeof Type>(__TypeValues)
+      return enumeration<Type>(__TypeValues)
     }
   }
 
+  let _codec: Codec<DHTResponse>
+
   export const codec = (): Codec<DHTResponse> => {
-    return message<DHTResponse>({
-      1: { name: 'type', codec: DHTResponse.Type.codec() },
-      2: { name: 'peer', codec: PeerInfo.codec(), optional: true },
-      3: { name: 'value', codec: bytes, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<DHTResponse>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          DHTResponse.Type.codec().encode(obj.type, writer)
+        } else {
+          throw new Error('Protocol error: required field "type" was not found in object')
+        }
+
+        if (obj.peer != null) {
+          writer.uint32(18)
+          PeerInfo.codec().encode(obj.peer, writer)
+        }
+
+        if (obj.value != null) {
+          writer.uint32(26)
+          writer.bytes(obj.value)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = DHTResponse.Type.codec().decode(reader)
+              break
+            case 2:
+              obj.peer = PeerInfo.codec().decode(reader, reader.uint32())
+              break
+            case 3:
+              obj.value = reader.bytes()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.type == null) {
+          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: DHTResponse): Uint8Array => {
     return encodeMessage(obj, DHTResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array): DHTResponse => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): DHTResponse => {
     return decodeMessage(buf, DHTResponse.codec())
   }
 }
@@ -368,18 +1073,78 @@ export interface PeerInfo {
 }
 
 export namespace PeerInfo {
+  let _codec: Codec<PeerInfo>
+
   export const codec = (): Codec<PeerInfo> => {
-    return message<PeerInfo>({
-      1: { name: 'id', codec: bytes },
-      2: { name: 'addrs', codec: bytes, repeats: true }
-    })
+    if (_codec == null) {
+      _codec = message<PeerInfo>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.id != null) {
+          writer.uint32(10)
+          writer.bytes(obj.id)
+        } else {
+          throw new Error('Protocol error: required field "id" was not found in object')
+        }
+
+        if (obj.addrs != null) {
+          for (const value of obj.addrs) {
+            writer.uint32(18)
+            writer.bytes(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "addrs" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.id = reader.bytes()
+              break
+            case 2:
+              obj.addrs = obj.addrs ?? []
+              obj.addrs.push(reader.bytes())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.addrs = obj.addrs ?? []
+
+        if (obj.id == null) {
+          throw new Error('Protocol error: value for required field "id" was not found in protobuf')
+        }
+
+        if (obj.addrs == null) {
+          throw new Error('Protocol error: value for required field "addrs" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: PeerInfo): Uint8Array => {
     return encodeMessage(obj, PeerInfo.codec())
   }
 
-  export const decode = (buf: Uint8Array): PeerInfo => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): PeerInfo => {
     return decodeMessage(buf, PeerInfo.codec())
   }
 }
@@ -406,24 +1171,87 @@ export namespace ConnManagerRequest {
 
   export namespace Type {
     export const codec = () => {
-      return enumeration<typeof Type>(__TypeValues)
+      return enumeration<Type>(__TypeValues)
     }
   }
 
+  let _codec: Codec<ConnManagerRequest>
+
   export const codec = (): Codec<ConnManagerRequest> => {
-    return message<ConnManagerRequest>({
-      1: { name: 'type', codec: ConnManagerRequest.Type.codec() },
-      2: { name: 'peer', codec: bytes, optional: true },
-      3: { name: 'tag', codec: string, optional: true },
-      4: { name: 'weight', codec: int64, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<ConnManagerRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          ConnManagerRequest.Type.codec().encode(obj.type, writer)
+        } else {
+          throw new Error('Protocol error: required field "type" was not found in object')
+        }
+
+        if (obj.peer != null) {
+          writer.uint32(18)
+          writer.bytes(obj.peer)
+        }
+
+        if (obj.tag != null) {
+          writer.uint32(26)
+          writer.string(obj.tag)
+        }
+
+        if (obj.weight != null) {
+          writer.uint32(32)
+          writer.int64(obj.weight)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = ConnManagerRequest.Type.codec().decode(reader)
+              break
+            case 2:
+              obj.peer = reader.bytes()
+              break
+            case 3:
+              obj.tag = reader.string()
+              break
+            case 4:
+              obj.weight = reader.int64()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.type == null) {
+          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: ConnManagerRequest): Uint8Array => {
     return encodeMessage(obj, ConnManagerRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): ConnManagerRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): ConnManagerRequest => {
     return decodeMessage(buf, ConnManagerRequest.codec())
   }
 }
@@ -433,17 +1261,59 @@ export interface DisconnectRequest {
 }
 
 export namespace DisconnectRequest {
+  let _codec: Codec<DisconnectRequest>
+
   export const codec = (): Codec<DisconnectRequest> => {
-    return message<DisconnectRequest>({
-      1: { name: 'peer', codec: bytes }
-    })
+    if (_codec == null) {
+      _codec = message<DisconnectRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.peer != null) {
+          writer.uint32(10)
+          writer.bytes(obj.peer)
+        } else {
+          throw new Error('Protocol error: required field "peer" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.peer = reader.bytes()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.peer == null) {
+          throw new Error('Protocol error: value for required field "peer" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: DisconnectRequest): Uint8Array => {
     return encodeMessage(obj, DisconnectRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): DisconnectRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): DisconnectRequest => {
     return decodeMessage(buf, DisconnectRequest.codec())
   }
 }
@@ -471,23 +1341,79 @@ export namespace PSRequest {
 
   export namespace Type {
     export const codec = () => {
-      return enumeration<typeof Type>(__TypeValues)
+      return enumeration<Type>(__TypeValues)
     }
   }
 
+  let _codec: Codec<PSRequest>
+
   export const codec = (): Codec<PSRequest> => {
-    return message<PSRequest>({
-      1: { name: 'type', codec: PSRequest.Type.codec() },
-      2: { name: 'topic', codec: string, optional: true },
-      3: { name: 'data', codec: bytes, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<PSRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          PSRequest.Type.codec().encode(obj.type, writer)
+        } else {
+          throw new Error('Protocol error: required field "type" was not found in object')
+        }
+
+        if (obj.topic != null) {
+          writer.uint32(18)
+          writer.string(obj.topic)
+        }
+
+        if (obj.data != null) {
+          writer.uint32(26)
+          writer.bytes(obj.data)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = PSRequest.Type.codec().decode(reader)
+              break
+            case 2:
+              obj.topic = reader.string()
+              break
+            case 3:
+              obj.data = reader.bytes()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.type == null) {
+          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: PSRequest): Uint8Array => {
     return encodeMessage(obj, PSRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): PSRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): PSRequest => {
     return decodeMessage(buf, PSRequest.codec())
   }
 }
@@ -502,22 +1428,104 @@ export interface PSMessage {
 }
 
 export namespace PSMessage {
+  let _codec: Codec<PSMessage>
+
   export const codec = (): Codec<PSMessage> => {
-    return message<PSMessage>({
-      1: { name: 'from', codec: bytes, optional: true },
-      2: { name: 'data', codec: bytes, optional: true },
-      3: { name: 'seqno', codec: bytes, optional: true },
-      4: { name: 'topicIDs', codec: string, repeats: true },
-      5: { name: 'signature', codec: bytes, optional: true },
-      6: { name: 'key', codec: bytes, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<PSMessage>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.from != null) {
+          writer.uint32(10)
+          writer.bytes(obj.from)
+        }
+
+        if (obj.data != null) {
+          writer.uint32(18)
+          writer.bytes(obj.data)
+        }
+
+        if (obj.seqno != null) {
+          writer.uint32(26)
+          writer.bytes(obj.seqno)
+        }
+
+        if (obj.topicIDs != null) {
+          for (const value of obj.topicIDs) {
+            writer.uint32(34)
+            writer.string(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "topicIDs" was not found in object')
+        }
+
+        if (obj.signature != null) {
+          writer.uint32(42)
+          writer.bytes(obj.signature)
+        }
+
+        if (obj.key != null) {
+          writer.uint32(50)
+          writer.bytes(obj.key)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.from = reader.bytes()
+              break
+            case 2:
+              obj.data = reader.bytes()
+              break
+            case 3:
+              obj.seqno = reader.bytes()
+              break
+            case 4:
+              obj.topicIDs = obj.topicIDs ?? []
+              obj.topicIDs.push(reader.string())
+              break
+            case 5:
+              obj.signature = reader.bytes()
+              break
+            case 6:
+              obj.key = reader.bytes()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.topicIDs = obj.topicIDs ?? []
+
+        if (obj.topicIDs == null) {
+          throw new Error('Protocol error: value for required field "topicIDs" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: PSMessage): Uint8Array => {
     return encodeMessage(obj, PSMessage.codec())
   }
 
-  export const decode = (buf: Uint8Array): PSMessage => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): PSMessage => {
     return decodeMessage(buf, PSMessage.codec())
   }
 }
@@ -528,18 +1536,82 @@ export interface PSResponse {
 }
 
 export namespace PSResponse {
+  let _codec: Codec<PSResponse>
+
   export const codec = (): Codec<PSResponse> => {
-    return message<PSResponse>({
-      1: { name: 'topics', codec: string, repeats: true },
-      2: { name: 'peerIDs', codec: bytes, repeats: true }
-    })
+    if (_codec == null) {
+      _codec = message<PSResponse>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.topics != null) {
+          for (const value of obj.topics) {
+            writer.uint32(10)
+            writer.string(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "topics" was not found in object')
+        }
+
+        if (obj.peerIDs != null) {
+          for (const value of obj.peerIDs) {
+            writer.uint32(18)
+            writer.bytes(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "peerIDs" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.topics = obj.topics ?? []
+              obj.topics.push(reader.string())
+              break
+            case 2:
+              obj.peerIDs = obj.peerIDs ?? []
+              obj.peerIDs.push(reader.bytes())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.topics = obj.topics ?? []
+        obj.peerIDs = obj.peerIDs ?? []
+
+        if (obj.topics == null) {
+          throw new Error('Protocol error: value for required field "topics" was not found in protobuf')
+        }
+
+        if (obj.peerIDs == null) {
+          throw new Error('Protocol error: value for required field "peerIDs" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: PSResponse): Uint8Array => {
     return encodeMessage(obj, PSResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array): PSResponse => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): PSResponse => {
     return decodeMessage(buf, PSResponse.codec())
   }
 }
@@ -563,23 +1635,90 @@ export namespace PeerstoreRequest {
 
   export namespace Type {
     export const codec = () => {
-      return enumeration<typeof Type>(__TypeValues)
+      return enumeration<Type>(__TypeValues)
     }
   }
 
+  let _codec: Codec<PeerstoreRequest>
+
   export const codec = (): Codec<PeerstoreRequest> => {
-    return message<PeerstoreRequest>({
-      1: { name: 'type', codec: PeerstoreRequest.Type.codec() },
-      2: { name: 'id', codec: bytes, optional: true },
-      3: { name: 'protos', codec: string, repeats: true }
-    })
+    if (_codec == null) {
+      _codec = message<PeerstoreRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          PeerstoreRequest.Type.codec().encode(obj.type, writer)
+        } else {
+          throw new Error('Protocol error: required field "type" was not found in object')
+        }
+
+        if (obj.id != null) {
+          writer.uint32(18)
+          writer.bytes(obj.id)
+        }
+
+        if (obj.protos != null) {
+          for (const value of obj.protos) {
+            writer.uint32(26)
+            writer.string(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "protos" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = PeerstoreRequest.Type.codec().decode(reader)
+              break
+            case 2:
+              obj.id = reader.bytes()
+              break
+            case 3:
+              obj.protos = obj.protos ?? []
+              obj.protos.push(reader.string())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.protos = obj.protos ?? []
+
+        if (obj.type == null) {
+          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
+        }
+
+        if (obj.protos == null) {
+          throw new Error('Protocol error: value for required field "protos" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: PeerstoreRequest): Uint8Array => {
     return encodeMessage(obj, PeerstoreRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): PeerstoreRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): PeerstoreRequest => {
     return decodeMessage(buf, PeerstoreRequest.codec())
   }
 }
@@ -590,18 +1729,72 @@ export interface PeerstoreResponse {
 }
 
 export namespace PeerstoreResponse {
+  let _codec: Codec<PeerstoreResponse>
+
   export const codec = (): Codec<PeerstoreResponse> => {
-    return message<PeerstoreResponse>({
-      1: { name: 'peer', codec: PeerInfo.codec(), optional: true },
-      2: { name: 'protos', codec: string, repeats: true }
-    })
+    if (_codec == null) {
+      _codec = message<PeerstoreResponse>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.peer != null) {
+          writer.uint32(10)
+          PeerInfo.codec().encode(obj.peer, writer)
+        }
+
+        if (obj.protos != null) {
+          for (const value of obj.protos) {
+            writer.uint32(18)
+            writer.string(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "protos" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.peer = PeerInfo.codec().decode(reader, reader.uint32())
+              break
+            case 2:
+              obj.protos = obj.protos ?? []
+              obj.protos.push(reader.string())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.protos = obj.protos ?? []
+
+        if (obj.protos == null) {
+          throw new Error('Protocol error: value for required field "protos" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: PeerstoreResponse): Uint8Array => {
     return encodeMessage(obj, PeerstoreResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array): PeerstoreResponse => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): PeerstoreResponse => {
     return decodeMessage(buf, PeerstoreResponse.codec())
   }
 }