@libp2p/peer-store 7.0.2 → 8.1.0

package/src/index.ts

@@ -1,79 +1,80 @@
-import { logger } from '@libp2p/logger'
-import { EventEmitter } from '@libp2p/interfaces/events'
-import { PeerStoreAddressBook } from './address-book.js'
-import { PeerStoreKeyBook } from './key-book.js'
-import { PeerStoreMetadataBook } from './metadata-book.js'
-import { PeerStoreProtoBook } from './proto-book.js'
-import { PersistentStore, Store } from './store.js'
-import type { PeerStore, AddressBook, KeyBook, MetadataBook, ProtoBook, PeerStoreEvents, PeerStoreInit, Peer, TagOptions } from '@libp2p/interface-peer-store'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import { PersistentStore, PeerUpdate } from './store.js'
+import type { PeerStore, Peer, PeerData } from '@libp2p/interface-peer-store'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { Tag, Tags } from './pb/tags.js'
 import type { Datastore } from 'interface-datastore'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import { logger } from '@libp2p/logger'
+import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 
 const log = logger('libp2p:peer-store')
 
 export interface PersistentPeerStoreComponents {
   peerId: PeerId
   datastore: Datastore
+  events: EventEmitter<Libp2pEvents>
+}
+
+/**
+ * Return true to allow storing the passed multiaddr for the passed peer
+ */
+export interface AddressFilter {
+  (peerId: PeerId, multiaddr: Multiaddr): Promise<boolean>
+}
+
+export interface PersistentPeerStoreInit {
+  addressFilter?: AddressFilter
 }
 
 /**
  * An implementation of PeerStore that stores data in a Datastore
  */
-export class PersistentPeerStore extends EventEmitter<PeerStoreEvents> implements PeerStore {
-  public addressBook: AddressBook
-  public keyBook: KeyBook
-  public metadataBook: MetadataBook
-  public protoBook: ProtoBook
-
-  private readonly components: PersistentPeerStoreComponents
-  private readonly store: Store
-
-  constructor (components: PersistentPeerStoreComponents, init: PeerStoreInit = {}) {
-    super()
-
-    this.components = components
-    this.store = new PersistentStore(components)
-    this.addressBook = new PeerStoreAddressBook(this.dispatchEvent.bind(this), this.store, init.addressFilter)
-    this.keyBook = new PeerStoreKeyBook(this.dispatchEvent.bind(this), this.store)
-    this.metadataBook = new PeerStoreMetadataBook(this.dispatchEvent.bind(this), this.store)
-    this.protoBook = new PeerStoreProtoBook(this.dispatchEvent.bind(this), this.store)
+export class PersistentPeerStore implements PeerStore {
+  private readonly store: PersistentStore
+  private readonly events: EventEmitter<Libp2pEvents>
+  private readonly peerId: PeerId
+
+  constructor (components: PersistentPeerStoreComponents, init: PersistentPeerStoreInit = {}) {
+    this.events = components.events
+    this.peerId = components.peerId
+    this.store = new PersistentStore(components, init)
   }
 
   async forEach (fn: (peer: Peer) => void): Promise<void> {
-    log.trace('getPeers await read lock')
+    log.trace('forEach await read lock')
     const release = await this.store.lock.readLock()
-    log.trace('getPeers got read lock')
+    log.trace('forEach got read lock')
 
     try {
       for await (const peer of this.store.all()) {
-        if (peer.id.equals(this.components.peerId)) {
-          // Skip self peer if present
-          continue
-        }
-
         fn(peer)
       }
     } finally {
-      log.trace('getPeers release read lock')
+      log.trace('forEach release read lock')
       release()
     }
   }
 
   async all (): Promise<Peer[]> {
-    const output: Peer[] = []
+    log.trace('all await read lock')
+    const release = await this.store.lock.readLock()
+    log.trace('all got read lock')
 
-    await this.forEach(peer => {
-      output.push(peer)
-    })
+    try {
+      const output: Peer[] = []
 
-    return output
+      for await (const peer of this.store.all()) {
+        output.push(peer)
+      }
+
+      return output
+    } finally {
+      log.trace('all release read lock')
+      release()
+    }
   }
 
-  /**
-   * Delete the information of the given peer in every book
-   */
   async delete (peerId: PeerId): Promise<void> {
     log.trace('delete await write lock')
     const release = await this.store.lock.writeLock()
@@ -87,9 +88,19 @@ export class PersistentPeerStore extends EventEmitter<PeerStoreEvents> implement
     }
   }
 
-  /**
-   * Get the stored information of a given peer
-   */
+  async has (peerId: PeerId): Promise<boolean> {
+    log.trace('has await read lock')
+    const release = await this.store.lock.readLock()
+    log.trace('has got read lock')
+
+    try {
+      return await this.store.has(peerId)
+    } finally {
+      log.trace('has release read lock')
+      release()
+    }
+  }
+
   async get (peerId: PeerId): Promise<Peer> {
     log.trace('get await read lock')
     const release = await this.store.lock.readLock()
@@ -103,82 +114,107 @@ export class PersistentPeerStore extends EventEmitter<PeerStoreEvents> implement
     }
   }
 
-  /**
-   * Returns true if we have a record of the peer
-   */
-  async has (peerId: PeerId): Promise<boolean> {
-    log.trace('has await read lock')
-    const release = await this.store.lock.readLock()
-    log.trace('has got read lock')
+  async save (id: PeerId, data: PeerData): Promise<Peer> {
+    log.trace('save await write lock')
+    const release = await this.store.lock.writeLock()
+    log.trace('save got write lock')
 
     try {
-      return await this.store.has(peerId)
+      const result = await this.store.save(id, data)
+
+      this.#emitIfUpdated(id, result)
+
+      return result.peer
     } finally {
-      log.trace('has release read lock')
+      log.trace('save release write lock')
       release()
     }
   }
 
-  async tagPeer (peerId: PeerId, tag: string, options: TagOptions = {}): Promise<void> {
-    const providedValue = options.value ?? 0
-    const value = Math.round(providedValue)
-    const ttl = options.ttl ?? undefined
+  async patch (id: PeerId, data: PeerData): Promise<Peer> {
+    log.trace('patch await write lock')
+    const release = await this.store.lock.writeLock()
+    log.trace('patch got write lock')
 
-    if (value !== providedValue || value < 0 || value > 100) {
-      throw new CodeError('Tag value must be between 0-100', 'ERR_TAG_VALUE_OUT_OF_BOUNDS')
-    }
+    try {
+      const result = await this.store.patch(id, data)
 
-    const buf = await this.metadataBook.getValue(peerId, 'tags')
-    let tags: Tag[] = []
+      this.#emitIfUpdated(id, result)
 
-    if (buf != null) {
-      tags = Tags.decode(buf).tags
+      return result.peer
+    } finally {
+      log.trace('patch release write lock')
+      release()
     }
+  }
 
-    // do not allow duplicate tags
-    tags = tags.filter(t => t.name !== tag)
+  async merge (id: PeerId, data: PeerData): Promise<Peer> {
+    log.trace('merge await write lock')
+    const release = await this.store.lock.writeLock()
+    log.trace('merge got write lock')
 
-    tags.push({
-      name: tag,
-      value,
-      expiry: ttl == null ? undefined : BigInt(Date.now() + ttl)
-    })
+    try {
+      const result = await this.store.merge(id, data)
 
-    await this.metadataBook.setValue(peerId, 'tags', Tags.encode({ tags }).subarray())
+      this.#emitIfUpdated(id, result)
+
+      return result.peer
+    } finally {
+      log.trace('merge release write lock')
+      release()
+    }
   }
 
-  async unTagPeer (peerId: PeerId, tag: string): Promise<void> {
-    const buf = await this.metadataBook.getValue(peerId, 'tags')
-    let tags: Tag[] = []
+  async consumePeerRecord (buf: Uint8Array, expectedPeer?: PeerId): Promise<boolean> {
+    const envelope = await RecordEnvelope.openAndCertify(buf, PeerRecord.DOMAIN)
 
-    if (buf != null) {
-      tags = Tags.decode(buf).tags
+    if (expectedPeer?.equals(envelope.peerId) === false) {
+      log('envelope peer id was not the expected peer id - expected: %p received: %p', expectedPeer, envelope.peerId)
+      return false
     }
 
-    tags = tags.filter(t => t.name !== tag)
+    const peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
+    let peer: Peer | undefined
 
-    await this.metadataBook.setValue(peerId, 'tags', Tags.encode({ tags }).subarray())
-  }
+    try {
+      peer = await this.get(envelope.peerId)
+    } catch (err: any) {
+      if (err.code !== 'ERR_NOT_FOUND') {
+        throw err
+      }
+    }
 
-  async getTags (peerId: PeerId): Promise<Array<{ name: string, value: number }>> {
-    const buf = await this.metadataBook.getValue(peerId, 'tags')
-    let tags: Tag[] = []
+    // ensure seq is greater than, or equal to, the last received
+    if (peer?.peerRecordEnvelope != null) {
+      const storedEnvelope = await RecordEnvelope.createFromProtobuf(peer.peerRecordEnvelope)
+      const storedRecord = PeerRecord.createFromProtobuf(storedEnvelope.payload)
 
-    if (buf != null) {
-      tags = Tags.decode(buf).tags
+      if (storedRecord.seqNumber >= peerRecord.seqNumber) {
+        log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber)
+        return false
+      }
     }
 
-    const now = BigInt(Date.now())
-    const unexpiredTags = tags.filter(tag => tag.expiry == null || tag.expiry > now)
+    await this.patch(peerRecord.peerId, {
+      peerRecordEnvelope: buf,
+      addresses: peerRecord.multiaddrs.map(multiaddr => ({
+        isCertified: true,
+        multiaddr
+      }))
+    })
 
-    if (unexpiredTags.length !== tags.length) {
-      // remove any expired tags
-      await this.metadataBook.setValue(peerId, 'tags', Tags.encode({ tags: unexpiredTags }).subarray())
+    return true
+  }
+
+  #emitIfUpdated (id: PeerId, result: PeerUpdate): void {
+    if (!result.updated) {
+      return
     }
 
-    return unexpiredTags.map(t => ({
-      name: t.name,
-      value: t.value ?? 0
-    }))
+    if (this.peerId.equals(id)) {
+      this.events.safeDispatchEvent('self:peer:update', { detail: result })
+    } else {
+      this.events.safeDispatchEvent('peer:update', { detail: result })
+    }
   }
 }

package/src/pb/peer.proto

@@ -7,14 +7,17 @@ message Peer {
   // The protocols the peer supports
   repeated string protocols = 2;
 
-  // Any peer metadata
-  repeated Metadata metadata = 3;
-
   // The public key of the peer
-  optional bytes pub_key = 4;
+  optional bytes public_key = 4;
 
   // The most recently received signed PeerRecord
   optional bytes peer_record_envelope = 5;
+
+  // Any peer metadata
+  map<string, bytes> metadata = 6;
+
+  // Any tags the peer has
+  map<string, Tag> tags = 7;
 }
 
 // Address represents a single multiaddr
@@ -25,7 +28,7 @@ message Address {
   optional bool isCertified = 2;
 }
 
-message Metadata {
-  string key = 1;
-  bytes value = 2;
+message Tag {
+  uint32 value = 1; // tag value 0-100
+  optional uint64 expiry = 2; // ms timestamp after which the tag is no longer valid
 }

package/src/pb/peer.ts

@@ -11,12 +11,148 @@ import type { Uint8ArrayList } from 'uint8arraylist'
 export interface Peer {
   addresses: Address[]
   protocols: string[]
-  metadata: Metadata[]
-  pubKey?: Uint8Array
+  publicKey?: Uint8Array
   peerRecordEnvelope?: Uint8Array
+  metadata: Map<string, Uint8Array>
+  tags: Map<string, Tag>
 }
 
 export namespace Peer {
+  export interface Peer$metadataEntry {
+    key: string
+    value: Uint8Array
+  }
+
+  export namespace Peer$metadataEntry {
+    let _codec: Codec<Peer$metadataEntry>
+
+    export const codec = (): Codec<Peer$metadataEntry> => {
+      if (_codec == null) {
+        _codec = message<Peer$metadataEntry>((obj, w, opts = {}) => {
+          if (opts.lengthDelimited !== false) {
+            w.fork()
+          }
+
+          if ((obj.key != null && obj.key !== '')) {
+            w.uint32(10)
+            w.string(obj.key)
+          }
+
+          if ((obj.value != null && obj.value.byteLength > 0)) {
+            w.uint32(18)
+            w.bytes(obj.value)
+          }
+
+          if (opts.lengthDelimited !== false) {
+            w.ldelim()
+          }
+        }, (reader, length) => {
+          const obj: any = {
+            key: '',
+            value: new Uint8Array(0)
+          }
+
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1:
+                obj.key = reader.string()
+                break
+              case 2:
+                obj.value = reader.bytes()
+                break
+              default:
+                reader.skipType(tag & 7)
+                break
+            }
+          }
+
+          return obj
+        })
+      }
+
+      return _codec
+    }
+
+    export const encode = (obj: Partial<Peer$metadataEntry>): Uint8Array => {
+      return encodeMessage(obj, Peer$metadataEntry.codec())
+    }
+
+    export const decode = (buf: Uint8Array | Uint8ArrayList): Peer$metadataEntry => {
+      return decodeMessage(buf, Peer$metadataEntry.codec())
+    }
+  }
+
+  export interface Peer$tagsEntry {
+    key: string
+    value?: Tag
+  }
+
+  export namespace Peer$tagsEntry {
+    let _codec: Codec<Peer$tagsEntry>
+
+    export const codec = (): Codec<Peer$tagsEntry> => {
+      if (_codec == null) {
+        _codec = message<Peer$tagsEntry>((obj, w, opts = {}) => {
+          if (opts.lengthDelimited !== false) {
+            w.fork()
+          }
+
+          if ((obj.key != null && obj.key !== '')) {
+            w.uint32(10)
+            w.string(obj.key)
+          }
+
+          if (obj.value != null) {
+            w.uint32(18)
+            Tag.codec().encode(obj.value, w)
+          }
+
+          if (opts.lengthDelimited !== false) {
+            w.ldelim()
+          }
+        }, (reader, length) => {
+          const obj: any = {
+            key: ''
+          }
+
+          const end = length == null ? reader.len : reader.pos + length
+
+          while (reader.pos < end) {
+            const tag = reader.uint32()
+
+            switch (tag >>> 3) {
+              case 1:
+                obj.key = reader.string()
+                break
+              case 2:
+                obj.value = Tag.codec().decode(reader, reader.uint32())
+                break
+              default:
+                reader.skipType(tag & 7)
+                break
+            }
+          }
+
+          return obj
+        })
+      }
+
+      return _codec
+    }
+
+    export const encode = (obj: Partial<Peer$tagsEntry>): Uint8Array => {
+      return encodeMessage(obj, Peer$tagsEntry.codec())
+    }
+
+    export const decode = (buf: Uint8Array | Uint8ArrayList): Peer$tagsEntry => {
+      return decodeMessage(buf, Peer$tagsEntry.codec())
+    }
+  }
+
   let _codec: Codec<Peer>
 
   export const codec = (): Codec<Peer> => {
@@ -40,16 +176,9 @@ export namespace Peer {
           }
         }
 
-        if (obj.metadata != null) {
-          for (const value of obj.metadata) {
-            w.uint32(26)
-            Metadata.codec().encode(value, w)
-          }
-        }
-
-        if (obj.pubKey != null) {
+        if (obj.publicKey != null) {
           w.uint32(34)
-          w.bytes(obj.pubKey)
+          w.bytes(obj.publicKey)
         }
 
         if (obj.peerRecordEnvelope != null) {
@@ -57,6 +186,20 @@ export namespace Peer {
           w.bytes(obj.peerRecordEnvelope)
         }
 
+        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) {
+          for (const [key, value] of obj.tags.entries()) {
+            w.uint32(58)
+            Peer.Peer$tagsEntry.codec().encode({ key, value }, w)
+          }
+        }
+
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
@@ -64,7 +207,8 @@ export namespace Peer {
         const obj: any = {
           addresses: [],
           protocols: [],
-          metadata: []
+          metadata: new Map<string, Uint8Array>(),
+          tags: new Map<string, undefined>()
         }
 
         const end = length == null ? reader.len : reader.pos + length
@@ -79,15 +223,22 @@ export namespace Peer {
             case 2:
               obj.protocols.push(reader.string())
               break
-            case 3:
-              obj.metadata.push(Metadata.codec().decode(reader, reader.uint32()))
-              break
             case 4:
-              obj.pubKey = reader.bytes()
+              obj.publicKey = reader.bytes()
               break
             case 5:
               obj.peerRecordEnvelope = reader.bytes()
               break
+            case 6: {
+              const entry = Peer.Peer$metadataEntry.codec().decode(reader, reader.uint32())
+              obj.metadata.set(entry.key, entry.value)
+              break
+            }
+            case 7: {
+              const entry = Peer.Peer$tagsEntry.codec().decode(reader, reader.uint32())
+              obj.tags.set(entry.key, entry.value)
+              break
+            }
             default:
               reader.skipType(tag & 7)
               break
@@ -177,29 +328,29 @@ export namespace Address {
   }
 }
 
-export interface Metadata {
-  key: string
-  value: Uint8Array
+export interface Tag {
+  value: number
+  expiry?: bigint
 }
 
-export namespace Metadata {
-  let _codec: Codec<Metadata>
+export namespace Tag {
+  let _codec: Codec<Tag>
 
-  export const codec = (): Codec<Metadata> => {
+  export const codec = (): Codec<Tag> => {
     if (_codec == null) {
-      _codec = message<Metadata>((obj, w, opts = {}) => {
+      _codec = message<Tag>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
 
-        if ((obj.key != null && obj.key !== '')) {
-          w.uint32(10)
-          w.string(obj.key)
+        if ((obj.value != null && obj.value !== 0)) {
+          w.uint32(8)
+          w.uint32(obj.value)
         }
 
-        if ((obj.value != null && obj.value.byteLength > 0)) {
-          w.uint32(18)
-          w.bytes(obj.value)
+        if (obj.expiry != null) {
+          w.uint32(16)
+          w.uint64(obj.expiry)
         }
 
         if (opts.lengthDelimited !== false) {
@@ -207,8 +358,7 @@ export namespace Metadata {
         }
       }, (reader, length) => {
         const obj: any = {
-          key: '',
-          value: new Uint8Array(0)
+          value: 0
         }
 
         const end = length == null ? reader.len : reader.pos + length
@@ -218,10 +368,10 @@ export namespace Metadata {
 
           switch (tag >>> 3) {
             case 1:
-              obj.key = reader.string()
+              obj.value = reader.uint32()
               break
             case 2:
-              obj.value = reader.bytes()
+              obj.expiry = reader.uint64()
               break
             default:
               reader.skipType(tag & 7)
@@ -236,11 +386,11 @@ export namespace Metadata {
     return _codec
   }
 
-  export const encode = (obj: Partial<Metadata>): Uint8Array => {
-    return encodeMessage(obj, Metadata.codec())
+  export const encode = (obj: Partial<Tag>): Uint8Array => {
+    return encodeMessage(obj, Tag.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Metadata => {
-    return decodeMessage(buf, Metadata.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Tag => {
+    return decodeMessage(buf, Tag.codec())
   }
 }