@libp2p/daemon-protocol 3.0.2 → 3.0.4

package/src/index.ts

@@ -1,12 +1,14 @@
 /* eslint-disable import/export */
+/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 
 import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
 
 export interface Request {
-  type: Request.Type
+  type?: Request.Type
   connect?: ConnectRequest
   streamOpen?: StreamOpenRequest
   streamHandler?: StreamHandlerRequest
@@ -54,65 +56,77 @@ export namespace Request {
 
   export const codec = (): Codec<Request> => {
     if (_codec == null) {
-      _codec = message<Request>((obj, writer, opts = {}) => {
+      _codec = message<Request>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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')
+          w.uint32(8)
+          Request.Type.codec().encode(obj.type, w)
         }
 
         if (obj.connect != null) {
-          writer.uint32(18)
-          ConnectRequest.codec().encode(obj.connect, writer)
+          w.uint32(18)
+          ConnectRequest.codec().encode(obj.connect, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.streamOpen != null) {
-          writer.uint32(26)
-          StreamOpenRequest.codec().encode(obj.streamOpen, writer)
+          w.uint32(26)
+          StreamOpenRequest.codec().encode(obj.streamOpen, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.streamHandler != null) {
-          writer.uint32(34)
-          StreamHandlerRequest.codec().encode(obj.streamHandler, writer)
+          w.uint32(34)
+          StreamHandlerRequest.codec().encode(obj.streamHandler, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.dht != null) {
-          writer.uint32(42)
-          DHTRequest.codec().encode(obj.dht, writer)
+          w.uint32(42)
+          DHTRequest.codec().encode(obj.dht, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.connManager != null) {
-          writer.uint32(50)
-          ConnManagerRequest.codec().encode(obj.connManager, writer)
+          w.uint32(50)
+          ConnManagerRequest.codec().encode(obj.connManager, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.disconnect != null) {
-          writer.uint32(58)
-          DisconnectRequest.codec().encode(obj.disconnect, writer)
+          w.uint32(58)
+          DisconnectRequest.codec().encode(obj.disconnect, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.pubsub != null) {
-          writer.uint32(66)
-          PSRequest.codec().encode(obj.pubsub, writer)
+          w.uint32(66)
+          PSRequest.codec().encode(obj.pubsub, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.peerStore != null) {
-          writer.uint32(74)
-          PeerstoreRequest.codec().encode(obj.peerStore, writer)
+          w.uint32(74)
+          PeerstoreRequest.codec().encode(obj.peerStore, w, {
+            writeDefaults: false
+          })
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {
-          type: Type.IDENTIFY
-        }
+        const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -153,10 +167,6 @@ export namespace Request {
           }
         }
 
-        if (obj.type == null) {
-          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -174,7 +184,7 @@ export namespace Request {
 }
 
 export interface Response {
-  type: Response.Type
+  type?: Response.Type
   error?: ErrorResponse
   streamInfo?: StreamInfo
   identify?: IdentifyResponse
@@ -205,63 +215,72 @@ export namespace Response {
 
   export const codec = (): Codec<Response> => {
     if (_codec == null) {
-      _codec = message<Response>((obj, writer, opts = {}) => {
+      _codec = message<Response>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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')
+          w.uint32(8)
+          Response.Type.codec().encode(obj.type, w)
         }
 
         if (obj.error != null) {
-          writer.uint32(18)
-          ErrorResponse.codec().encode(obj.error, writer)
+          w.uint32(18)
+          ErrorResponse.codec().encode(obj.error, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.streamInfo != null) {
-          writer.uint32(26)
-          StreamInfo.codec().encode(obj.streamInfo, writer)
+          w.uint32(26)
+          StreamInfo.codec().encode(obj.streamInfo, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.identify != null) {
-          writer.uint32(34)
-          IdentifyResponse.codec().encode(obj.identify, writer)
+          w.uint32(34)
+          IdentifyResponse.codec().encode(obj.identify, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.dht != null) {
-          writer.uint32(42)
-          DHTResponse.codec().encode(obj.dht, writer)
+          w.uint32(42)
+          DHTResponse.codec().encode(obj.dht, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.peers != null) {
           for (const value of obj.peers) {
-            writer.uint32(50)
-            PeerInfo.codec().encode(value, writer)
+            w.uint32(50)
+            PeerInfo.codec().encode(value, w, {
+              writeDefaults: true
+            })
           }
-        } 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)
+          w.uint32(58)
+          PSResponse.codec().encode(obj.pubsub, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.peerStore != null) {
-          writer.uint32(66)
-          PeerstoreResponse.codec().encode(obj.peerStore, writer)
+          w.uint32(66)
+          PeerstoreResponse.codec().encode(obj.peerStore, w, {
+            writeDefaults: false
+          })
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
-          type: Type.OK,
           peers: []
         }
 
@@ -301,10 +320,6 @@ export namespace Response {
           }
         }
 
-        if (obj.type == null) {
-          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -331,29 +346,25 @@ export namespace IdentifyResponse {
 
   export const codec = (): Codec<IdentifyResponse> => {
     if (_codec == null) {
-      _codec = message<IdentifyResponse>((obj, writer, opts = {}) => {
+      _codec = message<IdentifyResponse>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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 (opts.writeDefaults === true || (obj.id != null && obj.id.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.id)
         }
 
         if (obj.addrs != null) {
           for (const value of obj.addrs) {
-            writer.uint32(18)
-            writer.bytes(value)
+            w.uint32(18)
+            w.bytes(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "addrs" was not found in object')
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -379,10 +390,6 @@ export namespace IdentifyResponse {
           }
         }
 
-        if (obj.id == null) {
-          throw new Error('Protocol error: value for required field "id" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -410,34 +417,30 @@ export namespace ConnectRequest {
 
   export const codec = (): Codec<ConnectRequest> => {
     if (_codec == null) {
-      _codec = message<ConnectRequest>((obj, writer, opts = {}) => {
+      _codec = message<ConnectRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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.writeDefaults === true || (obj.peer != null && obj.peer.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.peer)
         }
 
         if (obj.addrs != null) {
           for (const value of obj.addrs) {
-            writer.uint32(18)
-            writer.bytes(value)
+            w.uint32(18)
+            w.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)
+          w.uint32(24)
+          w.int64(obj.timeout)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -466,10 +469,6 @@ export namespace ConnectRequest {
           }
         }
 
-        if (obj.peer == null) {
-          throw new Error('Protocol error: value for required field "peer" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -497,34 +496,30 @@ export namespace StreamOpenRequest {
 
   export const codec = (): Codec<StreamOpenRequest> => {
     if (_codec == null) {
-      _codec = message<StreamOpenRequest>((obj, writer, opts = {}) => {
+      _codec = message<StreamOpenRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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.writeDefaults === true || (obj.peer != null && obj.peer.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.peer)
         }
 
         if (obj.proto != null) {
           for (const value of obj.proto) {
-            writer.uint32(18)
-            writer.string(value)
+            w.uint32(18)
+            w.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)
+          w.uint32(24)
+          w.int64(obj.timeout)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -553,10 +548,6 @@ export namespace StreamOpenRequest {
           }
         }
 
-        if (obj.peer == null) {
-          throw new Error('Protocol error: value for required field "peer" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -583,29 +574,25 @@ export namespace StreamHandlerRequest {
 
   export const codec = (): Codec<StreamHandlerRequest> => {
     if (_codec == null) {
-      _codec = message<StreamHandlerRequest>((obj, writer, opts = {}) => {
+      _codec = message<StreamHandlerRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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 (opts.writeDefaults === true || (obj.addr != null && obj.addr.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.addr)
         }
 
         if (obj.proto != null) {
           for (const value of obj.proto) {
-            writer.uint32(18)
-            writer.string(value)
+            w.uint32(18)
+            w.string(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "proto" was not found in object')
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -631,10 +618,6 @@ export namespace StreamHandlerRequest {
           }
         }
 
-        if (obj.addr == null) {
-          throw new Error('Protocol error: value for required field "addr" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -660,20 +643,18 @@ export namespace ErrorResponse {
 
   export const codec = (): Codec<ErrorResponse> => {
     if (_codec == null) {
-      _codec = message<ErrorResponse>((obj, writer, opts = {}) => {
+      _codec = message<ErrorResponse>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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.writeDefaults === true || obj.msg !== '') {
+          w.uint32(10)
+          w.string(obj.msg)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -695,10 +676,6 @@ export namespace ErrorResponse {
           }
         }
 
-        if (obj.msg == null) {
-          throw new Error('Protocol error: value for required field "msg" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -726,34 +703,28 @@ export namespace StreamInfo {
 
   export const codec = (): Codec<StreamInfo> => {
     if (_codec == null) {
-      _codec = message<StreamInfo>((obj, writer, opts = {}) => {
+      _codec = message<StreamInfo>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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.writeDefaults === true || (obj.peer != null && obj.peer.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.peer)
         }
 
-        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 (opts.writeDefaults === true || (obj.addr != null && obj.addr.byteLength > 0)) {
+          w.uint32(18)
+          w.bytes(obj.addr)
         }
 
-        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.writeDefaults === true || obj.proto !== '') {
+          w.uint32(26)
+          w.string(obj.proto)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -783,18 +754,6 @@ export namespace StreamInfo {
           }
         }
 
-        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
       })
     }
@@ -812,7 +771,7 @@ export namespace StreamInfo {
 }
 
 export interface DHTRequest {
-  type: DHTRequest.Type
+  type?: DHTRequest.Type
   peer?: Uint8Array
   cid?: Uint8Array
   key?: Uint8Array
@@ -856,55 +815,51 @@ export namespace DHTRequest {
 
   export const codec = (): Codec<DHTRequest> => {
     if (_codec == null) {
-      _codec = message<DHTRequest>((obj, writer, opts = {}) => {
+      _codec = message<DHTRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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')
+          w.uint32(8)
+          DHTRequest.Type.codec().encode(obj.type, w)
         }
 
         if (obj.peer != null) {
-          writer.uint32(18)
-          writer.bytes(obj.peer)
+          w.uint32(18)
+          w.bytes(obj.peer)
         }
 
         if (obj.cid != null) {
-          writer.uint32(26)
-          writer.bytes(obj.cid)
+          w.uint32(26)
+          w.bytes(obj.cid)
         }
 
         if (obj.key != null) {
-          writer.uint32(34)
-          writer.bytes(obj.key)
+          w.uint32(34)
+          w.bytes(obj.key)
         }
 
         if (obj.value != null) {
-          writer.uint32(42)
-          writer.bytes(obj.value)
+          w.uint32(42)
+          w.bytes(obj.value)
         }
 
         if (obj.count != null) {
-          writer.uint32(48)
-          writer.int32(obj.count)
+          w.uint32(48)
+          w.int32(obj.count)
         }
 
         if (obj.timeout != null) {
-          writer.uint32(56)
-          writer.int64(obj.timeout)
+          w.uint32(56)
+          w.int64(obj.timeout)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {
-          type: Type.FIND_PEER
-        }
+        const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -939,10 +894,6 @@ export namespace DHTRequest {
           }
         }
 
-        if (obj.type == null) {
-          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -960,7 +911,7 @@ export namespace DHTRequest {
 }
 
 export interface DHTResponse {
-  type: DHTResponse.Type
+  type?: DHTResponse.Type
   peer?: PeerInfo
   value?: Uint8Array
 }
@@ -988,35 +939,33 @@ export namespace DHTResponse {
 
   export const codec = (): Codec<DHTResponse> => {
     if (_codec == null) {
-      _codec = message<DHTResponse>((obj, writer, opts = {}) => {
+      _codec = message<DHTResponse>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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')
+          w.uint32(8)
+          DHTResponse.Type.codec().encode(obj.type, w)
         }
 
         if (obj.peer != null) {
-          writer.uint32(18)
-          PeerInfo.codec().encode(obj.peer, writer)
+          w.uint32(18)
+          PeerInfo.codec().encode(obj.peer, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.value != null) {
-          writer.uint32(26)
-          writer.bytes(obj.value)
+          w.uint32(26)
+          w.bytes(obj.value)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {
-          type: Type.BEGIN
-        }
+        const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -1039,10 +988,6 @@ export namespace DHTResponse {
           }
         }
 
-        if (obj.type == null) {
-          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -1069,29 +1014,25 @@ export namespace PeerInfo {
 
   export const codec = (): Codec<PeerInfo> => {
     if (_codec == null) {
-      _codec = message<PeerInfo>((obj, writer, opts = {}) => {
+      _codec = message<PeerInfo>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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 (opts.writeDefaults === true || (obj.id != null && obj.id.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.id)
         }
 
         if (obj.addrs != null) {
           for (const value of obj.addrs) {
-            writer.uint32(18)
-            writer.bytes(value)
+            w.uint32(18)
+            w.bytes(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "addrs" was not found in object')
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -1117,10 +1058,6 @@ export namespace PeerInfo {
           }
         }
 
-        if (obj.id == null) {
-          throw new Error('Protocol error: value for required field "id" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -1138,7 +1075,7 @@ export namespace PeerInfo {
 }
 
 export interface ConnManagerRequest {
-  type: ConnManagerRequest.Type
+  type?: ConnManagerRequest.Type
   peer?: Uint8Array
   tag?: string
   weight?: bigint
@@ -1167,40 +1104,36 @@ export namespace ConnManagerRequest {
 
   export const codec = (): Codec<ConnManagerRequest> => {
     if (_codec == null) {
-      _codec = message<ConnManagerRequest>((obj, writer, opts = {}) => {
+      _codec = message<ConnManagerRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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')
+          w.uint32(8)
+          ConnManagerRequest.Type.codec().encode(obj.type, w)
         }
 
         if (obj.peer != null) {
-          writer.uint32(18)
-          writer.bytes(obj.peer)
+          w.uint32(18)
+          w.bytes(obj.peer)
         }
 
         if (obj.tag != null) {
-          writer.uint32(26)
-          writer.string(obj.tag)
+          w.uint32(26)
+          w.string(obj.tag)
         }
 
         if (obj.weight != null) {
-          writer.uint32(32)
-          writer.int64(obj.weight)
+          w.uint32(32)
+          w.int64(obj.weight)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {
-          type: Type.TAG_PEER
-        }
+        const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -1226,10 +1159,6 @@ export namespace ConnManagerRequest {
           }
         }
 
-        if (obj.type == null) {
-          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -1255,20 +1184,18 @@ export namespace DisconnectRequest {
 
   export const codec = (): Codec<DisconnectRequest> => {
     if (_codec == null) {
-      _codec = message<DisconnectRequest>((obj, writer, opts = {}) => {
+      _codec = message<DisconnectRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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.writeDefaults === true || (obj.peer != null && obj.peer.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.peer)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -1290,10 +1217,6 @@ export namespace DisconnectRequest {
           }
         }
 
-        if (obj.peer == null) {
-          throw new Error('Protocol error: value for required field "peer" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -1311,7 +1234,7 @@ export namespace DisconnectRequest {
 }
 
 export interface PSRequest {
-  type: PSRequest.Type
+  type?: PSRequest.Type
   topic?: string
   data?: Uint8Array
 }
@@ -1341,35 +1264,31 @@ export namespace PSRequest {
 
   export const codec = (): Codec<PSRequest> => {
     if (_codec == null) {
-      _codec = message<PSRequest>((obj, writer, opts = {}) => {
+      _codec = message<PSRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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')
+          w.uint32(8)
+          PSRequest.Type.codec().encode(obj.type, w)
         }
 
         if (obj.topic != null) {
-          writer.uint32(18)
-          writer.string(obj.topic)
+          w.uint32(18)
+          w.string(obj.topic)
         }
 
         if (obj.data != null) {
-          writer.uint32(26)
-          writer.bytes(obj.data)
+          w.uint32(26)
+          w.bytes(obj.data)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {
-          type: Type.GET_TOPICS
-        }
+        const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -1392,10 +1311,6 @@ export namespace PSRequest {
           }
         }
 
-        if (obj.type == null) {
-          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -1426,47 +1341,45 @@ export namespace PSMessage {
 
   export const codec = (): Codec<PSMessage> => {
     if (_codec == null) {
-      _codec = message<PSMessage>((obj, writer, opts = {}) => {
+      _codec = message<PSMessage>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.from != null) {
-          writer.uint32(10)
-          writer.bytes(obj.from)
+          w.uint32(10)
+          w.bytes(obj.from)
         }
 
         if (obj.data != null) {
-          writer.uint32(18)
-          writer.bytes(obj.data)
+          w.uint32(18)
+          w.bytes(obj.data)
         }
 
         if (obj.seqno != null) {
-          writer.uint32(26)
-          writer.bytes(obj.seqno)
+          w.uint32(26)
+          w.bytes(obj.seqno)
         }
 
         if (obj.topicIDs != null) {
           for (const value of obj.topicIDs) {
-            writer.uint32(34)
-            writer.string(value)
+            w.uint32(34)
+            w.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)
+          w.uint32(42)
+          w.bytes(obj.signature)
         }
 
         if (obj.key != null) {
-          writer.uint32(50)
-          writer.bytes(obj.key)
+          w.uint32(50)
+          w.bytes(obj.key)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -1529,31 +1442,27 @@ export namespace PSResponse {
 
   export const codec = (): Codec<PSResponse> => {
     if (_codec == null) {
-      _codec = message<PSResponse>((obj, writer, opts = {}) => {
+      _codec = message<PSResponse>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.topics != null) {
           for (const value of obj.topics) {
-            writer.uint32(10)
-            writer.string(value)
+            w.uint32(10)
+            w.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)
+            w.uint32(18)
+            w.bytes(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "peerIDs" was not found in object')
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -1596,7 +1505,7 @@ export namespace PSResponse {
 }
 
 export interface PeerstoreRequest {
-  type: PeerstoreRequest.Type
+  type?: PeerstoreRequest.Type
   id?: Uint8Array
   protos: string[]
 }
@@ -1624,38 +1533,33 @@ export namespace PeerstoreRequest {
 
   export const codec = (): Codec<PeerstoreRequest> => {
     if (_codec == null) {
-      _codec = message<PeerstoreRequest>((obj, writer, opts = {}) => {
+      _codec = message<PeerstoreRequest>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.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')
+          w.uint32(8)
+          PeerstoreRequest.Type.codec().encode(obj.type, w)
         }
 
         if (obj.id != null) {
-          writer.uint32(18)
-          writer.bytes(obj.id)
+          w.uint32(18)
+          w.bytes(obj.id)
         }
 
         if (obj.protos != null) {
           for (const value of obj.protos) {
-            writer.uint32(26)
-            writer.string(value)
+            w.uint32(26)
+            w.string(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "protos" was not found in object')
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
-          type: Type.UNSPECIFIED,
           protos: []
         }
 
@@ -1680,10 +1584,6 @@ export namespace PeerstoreRequest {
           }
         }
 
-        if (obj.type == null) {
-          throw new Error('Protocol error: value for required field "type" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -1710,27 +1610,27 @@ export namespace PeerstoreResponse {
 
   export const codec = (): Codec<PeerstoreResponse> => {
     if (_codec == null) {
-      _codec = message<PeerstoreResponse>((obj, writer, opts = {}) => {
+      _codec = message<PeerstoreResponse>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.peer != null) {
-          writer.uint32(10)
-          PeerInfo.codec().encode(obj.peer, writer)
+          w.uint32(10)
+          PeerInfo.codec().encode(obj.peer, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.protos != null) {
           for (const value of obj.protos) {
-            writer.uint32(18)
-            writer.string(value)
+            w.uint32(18)
+            w.string(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "protos" was not found in object')
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {