@libp2p/floodsub 11.0.25 → 11.0.26-02fcf704d

package/src/message/rpc.ts

@@ -5,7 +5,6 @@ import type { Uint8ArrayList } from 'uint8arraylist'
 export interface RPC {
   subscriptions: RPC.SubOpts[]
   messages: RPC.Message[]
-  control?: ControlMessage
 }
 
 export namespace RPC {
@@ -338,11 +337,6 @@ export namespace RPC {
           }
         }
 
-        if (obj.control != null) {
-          w.uint32(26)
-          ControlMessage.codec().encode(obj.control, w)
-        }
-
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
@@ -378,12 +372,6 @@ export namespace RPC {
               }))
               break
             }
-            case 3: {
-              obj.control = ControlMessage.codec().decode(reader, reader.uint32(), {
-                limits: opts.limits?.control
-              })
-              break
-            }
             default: {
               reader.skipType(tag & 7)
               break
@@ -440,13 +428,6 @@ export namespace RPC {
 
               break
             }
-            case 3: {
-              yield * ControlMessage.codec().stream(reader, reader.uint32(), `${prefix}.control`, {
-                limits: opts.limits?.control
-              })
-
-              break
-            }
             default: {
               reader.skipType(tag & 7)
               break
@@ -507,54 +488,6 @@ export namespace RPC {
     index: number
   }
 
-  export interface RPCControlIhaveTopicFieldEvent {
-    field: '$.control.ihave[].topic'
-    value: string
-    index: number
-  }
-
-  export interface RPCControlIhaveMessageIDsFieldEvent {
-    field: '$.control.ihave[].messageIDs[]'
-    index: number
-    value: Uint8Array
-  }
-
-  export interface RPCControlIwantMessageIDsFieldEvent {
-    field: '$.control.iwant[].messageIDs[]'
-    index: number
-    value: Uint8Array
-  }
-
-  export interface RPCControlGraftTopicFieldEvent {
-    field: '$.control.graft[].topic'
-    value: string
-    index: number
-  }
-
-  export interface RPCControlPruneTopicFieldEvent {
-    field: '$.control.prune[].topic'
-    value: string
-    index: number
-  }
-
-  export interface RPCControlPrunePeersPeerIDFieldEvent {
-    field: '$.control.prune[].peers[].peerID'
-    value: Uint8Array
-    index: number
-  }
-
-  export interface RPCControlPrunePeersSignedPeerRecordFieldEvent {
-    field: '$.control.prune[].peers[].signedPeerRecord'
-    value: Uint8Array
-    index: number
-  }
-
-  export interface RPCControlPruneBackoffFieldEvent {
-    field: '$.control.prune[].backoff'
-    value: bigint
-    index: number
-  }
-
   export function encode (obj: Partial<RPC>): Uint8Array {
     return encodeMessage(obj, RPC.codec())
   }
@@ -563,873 +496,7 @@ export namespace RPC {
     return decodeMessage(buf, RPC.codec(), opts)
   }
 
-  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<RPC>): Generator<RPCSubscriptionsSubscribeFieldEvent | RPCSubscriptionsTopicFieldEvent | RPCMessagesFromFieldEvent | RPCMessagesDataFieldEvent | RPCMessagesSequenceNumberFieldEvent | RPCMessagesTopicFieldEvent | RPCMessagesSignatureFieldEvent | RPCMessagesKeyFieldEvent | RPCControlIhaveTopicFieldEvent | RPCControlIhaveMessageIDsFieldEvent | RPCControlIwantMessageIDsFieldEvent | RPCControlGraftTopicFieldEvent | RPCControlPruneTopicFieldEvent | RPCControlPrunePeersPeerIDFieldEvent | RPCControlPrunePeersSignedPeerRecordFieldEvent | RPCControlPruneBackoffFieldEvent> {
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<RPC>): Generator<RPCSubscriptionsSubscribeFieldEvent | RPCSubscriptionsTopicFieldEvent | RPCMessagesFromFieldEvent | RPCMessagesDataFieldEvent | RPCMessagesSequenceNumberFieldEvent | RPCMessagesTopicFieldEvent | RPCMessagesSignatureFieldEvent | RPCMessagesKeyFieldEvent> {
     return streamMessage(buf, RPC.codec(), opts)
   }
 }
-
-export interface ControlMessage {
-  ihave: ControlIHave[]
-  iwant: ControlIWant[]
-  graft: ControlGraft[]
-  prune: ControlPrune[]
-}
-
-export namespace ControlMessage {
-  let _codec: Codec<ControlMessage>
-
-  export const codec = (): Codec<ControlMessage> => {
-    if (_codec == null) {
-      _codec = message<ControlMessage>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.ihave != null && obj.ihave.length > 0) {
-          for (const value of obj.ihave) {
-            w.uint32(10)
-            ControlIHave.codec().encode(value, w)
-          }
-        }
-
-        if (obj.iwant != null && obj.iwant.length > 0) {
-          for (const value of obj.iwant) {
-            w.uint32(18)
-            ControlIWant.codec().encode(value, w)
-          }
-        }
-
-        if (obj.graft != null && obj.graft.length > 0) {
-          for (const value of obj.graft) {
-            w.uint32(26)
-            ControlGraft.codec().encode(value, w)
-          }
-        }
-
-        if (obj.prune != null && obj.prune.length > 0) {
-          for (const value of obj.prune) {
-            w.uint32(34)
-            ControlPrune.codec().encode(value, w)
-          }
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length, opts = {}) => {
-        const obj: any = {
-          ihave: [],
-          iwant: [],
-          graft: [],
-          prune: []
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              if (opts.limits?.ihave != null && obj.ihave.length === opts.limits.ihave) {
-                throw new MaxLengthError('Decode error - repeated field "ihave" had too many elements')
-              }
-
-              obj.ihave.push(ControlIHave.codec().decode(reader, reader.uint32(), {
-                limits: opts.limits?.ihave$
-              }))
-              break
-            }
-            case 2: {
-              if (opts.limits?.iwant != null && obj.iwant.length === opts.limits.iwant) {
-                throw new MaxLengthError('Decode error - repeated field "iwant" had too many elements')
-              }
-
-              obj.iwant.push(ControlIWant.codec().decode(reader, reader.uint32(), {
-                limits: opts.limits?.iwant$
-              }))
-              break
-            }
-            case 3: {
-              if (opts.limits?.graft != null && obj.graft.length === opts.limits.graft) {
-                throw new MaxLengthError('Decode error - repeated field "graft" had too many elements')
-              }
-
-              obj.graft.push(ControlGraft.codec().decode(reader, reader.uint32(), {
-                limits: opts.limits?.graft$
-              }))
-              break
-            }
-            case 4: {
-              if (opts.limits?.prune != null && obj.prune.length === opts.limits.prune) {
-                throw new MaxLengthError('Decode error - repeated field "prune" had too many elements')
-              }
-
-              obj.prune.push(ControlPrune.codec().decode(reader, reader.uint32(), {
-                limits: opts.limits?.prune$
-              }))
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-
-        return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const obj = {
-          ihave: 0,
-          iwant: 0,
-          graft: 0,
-          prune: 0
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              if (opts.limits?.ihave != null && obj.ihave === opts.limits.ihave) {
-                throw new MaxLengthError('Streaming decode error - repeated field "ihave" had too many elements')
-              }
-
-              for (const evt of ControlIHave.codec().stream(reader, reader.uint32(), `${prefix}.ihave[]`, {
-                limits: opts.limits?.ihave$
-              })) {
-                yield {
-                  ...evt,
-                  index: obj.ihave
-                }
-              }
-
-              obj.ihave++
-
-              break
-            }
-            case 2: {
-              if (opts.limits?.iwant != null && obj.iwant === opts.limits.iwant) {
-                throw new MaxLengthError('Streaming decode error - repeated field "iwant" had too many elements')
-              }
-
-              for (const evt of ControlIWant.codec().stream(reader, reader.uint32(), `${prefix}.iwant[]`, {
-                limits: opts.limits?.iwant$
-              })) {
-                yield {
-                  ...evt,
-                  index: obj.iwant
-                }
-              }
-
-              obj.iwant++
-
-              break
-            }
-            case 3: {
-              if (opts.limits?.graft != null && obj.graft === opts.limits.graft) {
-                throw new MaxLengthError('Streaming decode error - repeated field "graft" had too many elements')
-              }
-
-              for (const evt of ControlGraft.codec().stream(reader, reader.uint32(), `${prefix}.graft[]`, {
-                limits: opts.limits?.graft$
-              })) {
-                yield {
-                  ...evt,
-                  index: obj.graft
-                }
-              }
-
-              obj.graft++
-
-              break
-            }
-            case 4: {
-              if (opts.limits?.prune != null && obj.prune === opts.limits.prune) {
-                throw new MaxLengthError('Streaming decode error - repeated field "prune" had too many elements')
-              }
-
-              for (const evt of ControlPrune.codec().stream(reader, reader.uint32(), `${prefix}.prune[]`, {
-                limits: opts.limits?.prune$
-              })) {
-                yield {
-                  ...evt,
-                  index: obj.prune
-                }
-              }
-
-              obj.prune++
-
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-      })
-    }
-
-    return _codec
-  }
-
-  export interface ControlMessageIhaveTopicFieldEvent {
-    field: '$.ihave[].topic'
-    value: string
-    index: number
-  }
-
-  export interface ControlMessageIhaveMessageIDsFieldEvent {
-    field: '$.ihave[].messageIDs[]'
-    index: number
-    value: Uint8Array
-  }
-
-  export interface ControlMessageIwantMessageIDsFieldEvent {
-    field: '$.iwant[].messageIDs[]'
-    index: number
-    value: Uint8Array
-  }
-
-  export interface ControlMessageGraftTopicFieldEvent {
-    field: '$.graft[].topic'
-    value: string
-    index: number
-  }
-
-  export interface ControlMessagePruneTopicFieldEvent {
-    field: '$.prune[].topic'
-    value: string
-    index: number
-  }
-
-  export interface ControlMessagePrunePeersPeerIDFieldEvent {
-    field: '$.prune[].peers[].peerID'
-    value: Uint8Array
-    index: number
-  }
-
-  export interface ControlMessagePrunePeersSignedPeerRecordFieldEvent {
-    field: '$.prune[].peers[].signedPeerRecord'
-    value: Uint8Array
-    index: number
-  }
-
-  export interface ControlMessagePruneBackoffFieldEvent {
-    field: '$.prune[].backoff'
-    value: bigint
-    index: number
-  }
-
-  export function encode (obj: Partial<ControlMessage>): Uint8Array {
-    return encodeMessage(obj, ControlMessage.codec())
-  }
-
-  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlMessage>): ControlMessage {
-    return decodeMessage(buf, ControlMessage.codec(), opts)
-  }
-
-  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlMessage>): Generator<ControlMessageIhaveTopicFieldEvent | ControlMessageIhaveMessageIDsFieldEvent | ControlMessageIwantMessageIDsFieldEvent | ControlMessageGraftTopicFieldEvent | ControlMessagePruneTopicFieldEvent | ControlMessagePrunePeersPeerIDFieldEvent | ControlMessagePrunePeersSignedPeerRecordFieldEvent | ControlMessagePruneBackoffFieldEvent> {
-    return streamMessage(buf, ControlMessage.codec(), opts)
-  }
-}
-
-export interface ControlIHave {
-  topic?: string
-  messageIDs: Uint8Array[]
-}
-
-export namespace ControlIHave {
-  let _codec: Codec<ControlIHave>
-
-  export const codec = (): Codec<ControlIHave> => {
-    if (_codec == null) {
-      _codec = message<ControlIHave>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.topic != null) {
-          w.uint32(10)
-          w.string(obj.topic)
-        }
-
-        if (obj.messageIDs != null && obj.messageIDs.length > 0) {
-          for (const value of obj.messageIDs) {
-            w.uint32(18)
-            w.bytes(value)
-          }
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length, opts = {}) => {
-        const obj: any = {
-          messageIDs: []
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              obj.topic = reader.string()
-              break
-            }
-            case 2: {
-              if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) {
-                throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements')
-              }
-
-              obj.messageIDs.push(reader.bytes())
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-
-        return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const obj = {
-          messageIDs: 0
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              yield {
-                field: `${prefix}.topic`,
-                value: reader.string()
-              }
-              break
-            }
-            case 2: {
-              if (opts.limits?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) {
-                throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements')
-              }
-
-              yield {
-                field: `${prefix}.messageIDs[]`,
-                index: obj.messageIDs,
-                value: reader.bytes()
-              }
-
-              obj.messageIDs++
-
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-      })
-    }
-
-    return _codec
-  }
-
-  export interface ControlIHaveTopicFieldEvent {
-    field: '$.topic'
-    value: string
-  }
-
-  export interface ControlIHaveMessageIDsFieldEvent {
-    field: '$.messageIDs[]'
-    index: number
-    value: Uint8Array
-  }
-
-  export function encode (obj: Partial<ControlIHave>): Uint8Array {
-    return encodeMessage(obj, ControlIHave.codec())
-  }
-
-  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIHave>): ControlIHave {
-    return decodeMessage(buf, ControlIHave.codec(), opts)
-  }
-
-  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIHave>): Generator<ControlIHaveTopicFieldEvent | ControlIHaveMessageIDsFieldEvent> {
-    return streamMessage(buf, ControlIHave.codec(), opts)
-  }
-}
-
-export interface ControlIWant {
-  messageIDs: Uint8Array[]
-}
-
-export namespace ControlIWant {
-  let _codec: Codec<ControlIWant>
-
-  export const codec = (): Codec<ControlIWant> => {
-    if (_codec == null) {
-      _codec = message<ControlIWant>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.messageIDs != null && obj.messageIDs.length > 0) {
-          for (const value of obj.messageIDs) {
-            w.uint32(10)
-            w.bytes(value)
-          }
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length, opts = {}) => {
-        const obj: any = {
-          messageIDs: []
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) {
-                throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements')
-              }
-
-              obj.messageIDs.push(reader.bytes())
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-
-        return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const obj = {
-          messageIDs: 0
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              if (opts.limits?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) {
-                throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements')
-              }
-
-              yield {
-                field: `${prefix}.messageIDs[]`,
-                index: obj.messageIDs,
-                value: reader.bytes()
-              }
-
-              obj.messageIDs++
-
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-      })
-    }
-
-    return _codec
-  }
-
-  export interface ControlIWantMessageIDsFieldEvent {
-    field: '$.messageIDs[]'
-    index: number
-    value: Uint8Array
-  }
-
-  export function encode (obj: Partial<ControlIWant>): Uint8Array {
-    return encodeMessage(obj, ControlIWant.codec())
-  }
-
-  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIWant>): ControlIWant {
-    return decodeMessage(buf, ControlIWant.codec(), opts)
-  }
-
-  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIWant>): Generator<ControlIWantMessageIDsFieldEvent> {
-    return streamMessage(buf, ControlIWant.codec(), opts)
-  }
-}
-
-export interface ControlGraft {
-  topic?: string
-}
-
-export namespace ControlGraft {
-  let _codec: Codec<ControlGraft>
-
-  export const codec = (): Codec<ControlGraft> => {
-    if (_codec == null) {
-      _codec = message<ControlGraft>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.topic != null) {
-          w.uint32(10)
-          w.string(obj.topic)
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length, opts = {}) => {
-        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.topic = reader.string()
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-
-        return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              yield {
-                field: `${prefix}.topic`,
-                value: reader.string()
-              }
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-      })
-    }
-
-    return _codec
-  }
-
-  export interface ControlGraftTopicFieldEvent {
-    field: '$.topic'
-    value: string
-  }
-
-  export function encode (obj: Partial<ControlGraft>): Uint8Array {
-    return encodeMessage(obj, ControlGraft.codec())
-  }
-
-  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlGraft>): ControlGraft {
-    return decodeMessage(buf, ControlGraft.codec(), opts)
-  }
-
-  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlGraft>): Generator<ControlGraftTopicFieldEvent> {
-    return streamMessage(buf, ControlGraft.codec(), opts)
-  }
-}
-
-export interface ControlPrune {
-  topic?: string
-  peers: PeerInfo[]
-  backoff?: bigint
-}
-
-export namespace ControlPrune {
-  let _codec: Codec<ControlPrune>
-
-  export const codec = (): Codec<ControlPrune> => {
-    if (_codec == null) {
-      _codec = message<ControlPrune>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.topic != null) {
-          w.uint32(10)
-          w.string(obj.topic)
-        }
-
-        if (obj.peers != null && obj.peers.length > 0) {
-          for (const value of obj.peers) {
-            w.uint32(18)
-            PeerInfo.codec().encode(value, w)
-          }
-        }
-
-        if (obj.backoff != null) {
-          w.uint32(24)
-          w.uint64(obj.backoff)
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length, opts = {}) => {
-        const obj: any = {
-          peers: []
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              obj.topic = reader.string()
-              break
-            }
-            case 2: {
-              if (opts.limits?.peers != null && obj.peers.length === opts.limits.peers) {
-                throw new MaxLengthError('Decode error - repeated field "peers" had too many elements')
-              }
-
-              obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32(), {
-                limits: opts.limits?.peers$
-              }))
-              break
-            }
-            case 3: {
-              obj.backoff = reader.uint64()
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-
-        return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const obj = {
-          peers: 0
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              yield {
-                field: `${prefix}.topic`,
-                value: reader.string()
-              }
-              break
-            }
-            case 2: {
-              if (opts.limits?.peers != null && obj.peers === opts.limits.peers) {
-                throw new MaxLengthError('Streaming decode error - repeated field "peers" had too many elements')
-              }
-
-              for (const evt of PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peers[]`, {
-                limits: opts.limits?.peers$
-              })) {
-                yield {
-                  ...evt,
-                  index: obj.peers
-                }
-              }
-
-              obj.peers++
-
-              break
-            }
-            case 3: {
-              yield {
-                field: `${prefix}.backoff`,
-                value: reader.uint64()
-              }
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-      })
-    }
-
-    return _codec
-  }
-
-  export interface ControlPruneTopicFieldEvent {
-    field: '$.topic'
-    value: string
-  }
-
-  export interface ControlPrunePeersPeerIDFieldEvent {
-    field: '$.peers[].peerID'
-    value: Uint8Array
-    index: number
-  }
-
-  export interface ControlPrunePeersSignedPeerRecordFieldEvent {
-    field: '$.peers[].signedPeerRecord'
-    value: Uint8Array
-    index: number
-  }
-
-  export interface ControlPruneBackoffFieldEvent {
-    field: '$.backoff'
-    value: bigint
-  }
-
-  export function encode (obj: Partial<ControlPrune>): Uint8Array {
-    return encodeMessage(obj, ControlPrune.codec())
-  }
-
-  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlPrune>): ControlPrune {
-    return decodeMessage(buf, ControlPrune.codec(), opts)
-  }
-
-  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlPrune>): Generator<ControlPruneTopicFieldEvent | ControlPrunePeersPeerIDFieldEvent | ControlPrunePeersSignedPeerRecordFieldEvent | ControlPruneBackoffFieldEvent> {
-    return streamMessage(buf, ControlPrune.codec(), opts)
-  }
-}
-
-export interface PeerInfo {
-  peerID?: Uint8Array
-  signedPeerRecord?: Uint8Array
-}
-
-export namespace PeerInfo {
-  let _codec: Codec<PeerInfo>
-
-  export const codec = (): Codec<PeerInfo> => {
-    if (_codec == null) {
-      _codec = message<PeerInfo>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.peerID != null) {
-          w.uint32(10)
-          w.bytes(obj.peerID)
-        }
-
-        if (obj.signedPeerRecord != null) {
-          w.uint32(18)
-          w.bytes(obj.signedPeerRecord)
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length, opts = {}) => {
-        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.peerID = reader.bytes()
-              break
-            }
-            case 2: {
-              obj.signedPeerRecord = reader.bytes()
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-
-        return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1: {
-              yield {
-                field: `${prefix}.peerID`,
-                value: reader.bytes()
-              }
-              break
-            }
-            case 2: {
-              yield {
-                field: `${prefix}.signedPeerRecord`,
-                value: reader.bytes()
-              }
-              break
-            }
-            default: {
-              reader.skipType(tag & 7)
-              break
-            }
-          }
-        }
-      })
-    }
-
-    return _codec
-  }
-
-  export interface PeerInfoPeerIDFieldEvent {
-    field: '$.peerID'
-    value: Uint8Array
-  }
-
-  export interface PeerInfoSignedPeerRecordFieldEvent {
-    field: '$.signedPeerRecord'
-    value: Uint8Array
-  }
-
-  export function encode (obj: Partial<PeerInfo>): Uint8Array {
-    return encodeMessage(obj, PeerInfo.codec())
-  }
-
-  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): PeerInfo {
-    return decodeMessage(buf, PeerInfo.codec(), opts)
-  }
-
-  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): Generator<PeerInfoPeerIDFieldEvent | PeerInfoSignedPeerRecordFieldEvent> {
-    return streamMessage(buf, PeerInfo.codec(), opts)
-  }
-}