@libp2p/daemon-protocol 3.0.1 → 3.0.3

package/src/index.ts

@@ -1,5 +1,7 @@
 /* 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'
@@ -54,60 +56,74 @@ 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')
+        if (opts.writeDefaults === true || (obj.type != null && __TypeValues[obj.type] !== 0)) {
+          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 = {
@@ -153,10 +169,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
       })
     }
@@ -205,59 +217,69 @@ 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')
+        if (opts.writeDefaults === true || (obj.type != null && __TypeValues[obj.type] !== 0)) {
+          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 = {
@@ -301,10 +323,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 +349,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 +393,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 +420,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 +472,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 +499,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 +551,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 +577,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 +621,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 +646,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 +679,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 +706,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 +757,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
       })
     }
@@ -856,50 +818,48 @@ 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')
+        if (opts.writeDefaults === true || (obj.type != null && __TypeValues[obj.type] !== 0)) {
+          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 = {
@@ -939,10 +899,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
       })
     }
@@ -988,30 +944,30 @@ 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')
+        if (opts.writeDefaults === true || (obj.type != null && __TypeValues[obj.type] !== 0)) {
+          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 = {
@@ -1039,10 +995,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 +1021,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 +1065,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
       })
     }
@@ -1167,35 +1111,33 @@ 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')
+        if (opts.writeDefaults === true || (obj.type != null && __TypeValues[obj.type] !== 0)) {
+          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 = {
@@ -1226,10 +1168,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 +1193,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 +1226,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
       })
     }
@@ -1341,30 +1273,28 @@ 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')
+        if (opts.writeDefaults === true || (obj.type != null && __TypeValues[obj.type] !== 0)) {
+          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 = {
@@ -1392,10 +1322,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 +1352,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 +1453,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 = {
@@ -1624,34 +1544,30 @@ 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')
+        if (opts.writeDefaults === true || (obj.type != null && __TypeValues[obj.type] !== 0)) {
+          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 = {
@@ -1680,10 +1596,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 +1622,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 = {