@libp2p/peer-store 12.0.13 → 12.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/peer-store",
-  "version": "12.0.13",
+  "version": "12.0.14",
   "description": "Stores information about peers libp2p knows on the network",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/peer-store#readme",
@@ -48,23 +48,23 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.1.13",
-    "@libp2p/interface": "^3.1.0",
-    "@libp2p/peer-collections": "^7.0.13",
-    "@libp2p/peer-id": "^6.0.4",
-    "@libp2p/peer-record": "^9.0.5",
+    "@libp2p/crypto": "^5.1.14",
+    "@libp2p/interface": "^3.1.1",
+    "@libp2p/peer-collections": "^7.0.14",
+    "@libp2p/peer-id": "^6.0.5",
+    "@libp2p/peer-record": "^9.0.6",
     "@multiformats/multiaddr": "^13.0.1",
     "interface-datastore": "^9.0.1",
     "it-all": "^3.0.9",
     "main-event": "^1.0.1",
     "mortice": "^3.3.1",
     "multiformats": "^13.4.0",
-    "protons-runtime": "^5.6.0",
+    "protons-runtime": "^6.0.1",
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/logger": "^6.2.2",
+    "@libp2p/logger": "^6.2.3",
     "@types/sinon": "^20.0.0",
     "aegir": "^47.0.22",
     "benchmark": "^2.1.4",
@@ -72,7 +72,7 @@
     "delay": "^7.0.0",
     "p-defer": "^4.0.1",
     "p-event": "^7.0.0",
-    "protons": "^7.7.0",
+    "protons": "^8.1.1",
     "sinon": "^21.0.0"
   },
   "sideEffects": false

package/src/pb/peer.ts

@@ -1,6 +1,4 @@
-/* eslint-disable complexity */
-
-import { decodeMessage, encodeMessage, MaxLengthError, MaxSizeError, message } from 'protons-runtime'
+import { decodeMessage, encodeMessage, MaxLengthError, MaxSizeError, message, streamMessage } from 'protons-runtime'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Codec, DecodeOptions } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -72,19 +70,60 @@ export namespace Peer {
           }
 
           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}.key`,
+                  value: reader.string()
+                }
+                break
+              }
+              case 2: {
+                yield {
+                  field: `${prefix}.value`,
+                  value: reader.bytes()
+                }
+                break
+              }
+              default: {
+                reader.skipType(tag & 7)
+                break
+              }
+            }
+          }
         })
       }
 
       return _codec
     }
 
-    export const encode = (obj: Partial<Peer$metadataEntry>): Uint8Array => {
+    export interface Peer$metadataEntryKeyFieldEvent {
+      field: '$.key'
+      value: string
+    }
+
+    export interface Peer$metadataEntryValueFieldEvent {
+      field: '$.value'
+      value: Uint8Array
+    }
+
+    export function encode (obj: Partial<Peer$metadataEntry>): Uint8Array {
       return encodeMessage(obj, Peer$metadataEntry.codec())
     }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer$metadataEntry>): Peer$metadataEntry => {
+    export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer$metadataEntry>): Peer$metadataEntry {
       return decodeMessage(buf, Peer$metadataEntry.codec(), opts)
     }
+
+    export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer$metadataEntry>): Generator<Peer$metadataEntryKeyFieldEvent | Peer$metadataEntryValueFieldEvent> {
+      return streamMessage(buf, Peer$metadataEntry.codec(), opts)
+    }
   }
 
   export interface Peer$tagsEntry {
@@ -144,19 +183,65 @@ export namespace Peer {
           }
 
           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}.key`,
+                  value: reader.string()
+                }
+                break
+              }
+              case 2: {
+                yield * Tag.codec().stream(reader, reader.uint32(), `${prefix}.value`, {
+                  limits: opts.limits?.value
+                })
+
+                break
+              }
+              default: {
+                reader.skipType(tag & 7)
+                break
+              }
+            }
+          }
         })
       }
 
       return _codec
     }
 
-    export const encode = (obj: Partial<Peer$tagsEntry>): Uint8Array => {
+    export interface Peer$tagsEntryKeyFieldEvent {
+      field: '$.key'
+      value: string
+    }
+
+    export interface Peer$tagsEntryValueValueFieldEvent {
+      field: '$.value.value'
+      value: number
+    }
+
+    export interface Peer$tagsEntryValueExpiryFieldEvent {
+      field: '$.value.expiry'
+      value: bigint
+    }
+
+    export function encode (obj: Partial<Peer$tagsEntry>): Uint8Array {
       return encodeMessage(obj, Peer$tagsEntry.codec())
     }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer$tagsEntry>): Peer$tagsEntry => {
+    export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer$tagsEntry>): Peer$tagsEntry {
       return decodeMessage(buf, Peer$tagsEntry.codec(), opts)
     }
+
+    export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer$tagsEntry>): Generator<Peer$tagsEntryKeyFieldEvent | Peer$tagsEntryValueValueFieldEvent | Peer$tagsEntryValueExpiryFieldEvent> {
+      return streamMessage(buf, Peer$tagsEntry.codec(), opts)
+    }
   }
 
   let _codec: Codec<Peer>
@@ -168,14 +253,14 @@ export namespace Peer {
           w.fork()
         }
 
-        if (obj.addresses != null) {
+        if (obj.addresses != null && obj.addresses.length > 0) {
           for (const value of obj.addresses) {
             w.uint32(10)
             Address.codec().encode(value, w)
           }
         }
 
-        if (obj.protocols != null) {
+        if (obj.protocols != null && obj.protocols.length > 0) {
           for (const value of obj.protocols) {
             w.uint32(18)
             w.string(value)
@@ -192,14 +277,14 @@ export namespace Peer {
           w.bytes(obj.peerRecordEnvelope)
         }
 
-        if (obj.metadata != null && obj.metadata.size !== 0) {
+        if (obj.metadata != null && obj.metadata.size > 0) {
           for (const [key, value] of obj.metadata.entries()) {
             w.uint32(50)
             Peer.Peer$metadataEntry.codec().encode({ key, value }, w)
           }
         }
 
-        if (obj.tags != null && obj.tags.size !== 0) {
+        if (obj.tags != null && obj.tags.size > 0) {
           for (const [key, value] of obj.tags.entries()) {
             w.uint32(58)
             Peer.Peer$tagsEntry.codec().encode({ key, value }, w)
@@ -219,7 +304,7 @@ export namespace Peer {
           addresses: [],
           protocols: [],
           metadata: new Map<string, Uint8Array>(),
-          tags: new Map<string, undefined>()
+          tags: new Map<string, Tag>()
         }
 
         const end = length == null ? reader.len : reader.pos + length
@@ -230,7 +315,7 @@ export namespace Peer {
           switch (tag >>> 3) {
             case 1: {
               if (opts.limits?.addresses != null && obj.addresses.length === opts.limits.addresses) {
-                throw new MaxLengthError('Decode error - map field "addresses" had too many elements')
+                throw new MaxLengthError('Decode error - repeated field "addresses" had too many elements')
               }
 
               obj.addresses.push(Address.codec().decode(reader, reader.uint32(), {
@@ -240,7 +325,7 @@ export namespace Peer {
             }
             case 2: {
               if (opts.limits?.protocols != null && obj.protocols.length === opts.limits.protocols) {
-                throw new MaxLengthError('Decode error - map field "protocols" had too many elements')
+                throw new MaxLengthError('Decode error - repeated field "protocols" had too many elements')
               }
 
               obj.protocols.push(reader.string())
@@ -259,7 +344,11 @@ export namespace Peer {
                 throw new MaxSizeError('Decode error - map field "metadata" had too many elements')
               }
 
-              const entry = Peer.Peer$metadataEntry.codec().decode(reader, reader.uint32())
+              const entry = Peer.Peer$metadataEntry.codec().decode(reader, reader.uint32(), {
+                limits: {
+                  value: opts.limits?.metadata$value
+                }
+              })
               obj.metadata.set(entry.key, entry.value)
               break
             }
@@ -288,19 +377,184 @@ export namespace Peer {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const obj = {
+          addresses: 0,
+          protocols: 0,
+          metadata: 0,
+          tags: 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?.addresses != null && obj.addresses === opts.limits.addresses) {
+                throw new MaxLengthError('Streaming decode error - repeated field "addresses" had too many elements')
+              }
+
+              for (const evt of Address.codec().stream(reader, reader.uint32(), `${prefix}.addresses[]`, {
+                limits: opts.limits?.addresses$
+              })) {
+                yield {
+                  ...evt,
+                  index: obj.addresses
+                }
+              }
+
+              obj.addresses++
+
+              break
+            }
+            case 2: {
+              if (opts.limits?.protocols != null && obj.protocols === opts.limits.protocols) {
+                throw new MaxLengthError('Streaming decode error - repeated field "protocols" had too many elements')
+              }
+
+              yield {
+                field: `${prefix}.protocols[]`,
+                index: obj.protocols,
+                value: reader.string()
+              }
+
+              obj.protocols++
+
+              break
+            }
+            case 4: {
+              yield {
+                field: `${prefix}.publicKey`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 5: {
+              yield {
+                field: `${prefix}.peerRecordEnvelope`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 6: {
+              if (opts.limits?.metadata != null && obj.metadata === opts.limits.metadata) {
+                throw new MaxLengthError('Decode error - map field "metadata" had too many elements')
+              }
+
+              yield * Peer.Peer$metadataEntry.codec().stream(reader, reader.uint32(), `${prefix}.metadata{}`, {
+                limits: {
+                  value: opts.limits?.metadata$value
+                }
+              })
+
+              obj.metadata++
+
+              break
+            }
+            case 7: {
+              if (opts.limits?.tags != null && obj.tags === opts.limits.tags) {
+                throw new MaxLengthError('Decode error - map field "tags" had too many elements')
+              }
+
+              yield * Peer.Peer$tagsEntry.codec().stream(reader, reader.uint32(), `${prefix}.tags{}`, {
+                limits: {
+                  value: opts.limits?.tags$value
+                }
+              })
+
+              obj.tags++
+
+              break
+            }
+            case 8: {
+              yield {
+                field: `${prefix}.updated`,
+                value: reader.uint64Number()
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<Peer>): Uint8Array => {
+  export interface PeerAddressesMultiaddrFieldEvent {
+    field: '$.addresses[].multiaddr'
+    value: Uint8Array
+    index: number
+  }
+
+  export interface PeerAddressesIsCertifiedFieldEvent {
+    field: '$.addresses[].isCertified'
+    value: boolean
+    index: number
+  }
+
+  export interface PeerAddressesObservedFieldEvent {
+    field: '$.addresses[].observed'
+    value: number
+    index: number
+  }
+
+  export interface PeerProtocolsFieldEvent {
+    field: '$.protocols[]'
+    index: number
+    value: string
+  }
+
+  export interface PeerPublicKeyFieldEvent {
+    field: '$.publicKey'
+    value: Uint8Array
+  }
+
+  export interface PeerPeerRecordEnvelopeFieldEvent {
+    field: '$.peerRecordEnvelope'
+    value: Uint8Array
+  }
+
+  export interface PeerMetadataFieldEvent {
+    field: '$.metadata{}'
+    key: string
+    value: Uint8Array
+  }
+
+  export interface PeerTagsValueFieldEvent {
+    field: '$.tags{}.value'
+    value: Tag
+    key: string
+  }
+
+  export interface PeerTagsExpiryFieldEvent {
+    field: '$.tags{}.expiry'
+    value: Tag
+    key: string
+  }
+
+  export interface PeerUpdatedFieldEvent {
+    field: '$.updated'
+    value: number
+  }
+
+  export function encode (obj: Partial<Peer>): Uint8Array {
     return encodeMessage(obj, Peer.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer>): Peer => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer>): Peer {
     return decodeMessage(buf, Peer.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Peer>): Generator<PeerAddressesMultiaddrFieldEvent | PeerAddressesIsCertifiedFieldEvent | PeerAddressesObservedFieldEvent | PeerProtocolsFieldEvent | PeerPublicKeyFieldEvent | PeerPeerRecordEnvelopeFieldEvent | PeerMetadataFieldEvent | PeerTagsValueFieldEvent | PeerTagsExpiryFieldEvent | PeerUpdatedFieldEvent> {
+    return streamMessage(buf, Peer.codec(), opts)
+  }
 }
 
 export interface Address {
@@ -368,19 +622,72 @@ export namespace Address {
         }
 
         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}.multiaddr`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 2: {
+              yield {
+                field: `${prefix}.isCertified`,
+                value: reader.bool()
+              }
+              break
+            }
+            case 3: {
+              yield {
+                field: `${prefix}.observed`,
+                value: reader.uint64Number()
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<Address>): Uint8Array => {
+  export interface AddressMultiaddrFieldEvent {
+    field: '$.multiaddr'
+    value: Uint8Array
+  }
+
+  export interface AddressIsCertifiedFieldEvent {
+    field: '$.isCertified'
+    value: boolean
+  }
+
+  export interface AddressObservedFieldEvent {
+    field: '$.observed'
+    value: number
+  }
+
+  export function encode (obj: Partial<Address>): Uint8Array {
     return encodeMessage(obj, Address.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Address>): Address => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Address>): Address {
     return decodeMessage(buf, Address.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Address>): Generator<AddressMultiaddrFieldEvent | AddressIsCertifiedFieldEvent | AddressObservedFieldEvent> {
+    return streamMessage(buf, Address.codec(), opts)
+  }
 }
 
 export interface Tag {
@@ -438,17 +745,58 @@ export namespace Tag {
         }
 
         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}.value`,
+                value: reader.uint32()
+              }
+              break
+            }
+            case 2: {
+              yield {
+                field: `${prefix}.expiry`,
+                value: reader.uint64()
+              }
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<Tag>): Uint8Array => {
+  export interface TagValueFieldEvent {
+    field: '$.value'
+    value: number
+  }
+
+  export interface TagExpiryFieldEvent {
+    field: '$.expiry'
+    value: bigint
+  }
+
+  export function encode (obj: Partial<Tag>): Uint8Array {
     return encodeMessage(obj, Tag.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Tag>): Tag => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Tag>): Tag {
     return decodeMessage(buf, Tag.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Tag>): Generator<TagValueFieldEvent | TagExpiryFieldEvent> {
+    return streamMessage(buf, Tag.codec(), opts)
+  }
 }