@libp2p/peer-store 7.0.2 → 8.1.0

package/src/key-book.ts

@@ -1,140 +0,0 @@
-import { logger } from '@libp2p/logger'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { codes } from './errors.js'
-import { peerIdFromPeerId } from '@libp2p/peer-id'
-import { equals as uint8arrayEquals } from 'uint8arrays/equals'
-import { CustomEvent } from '@libp2p/interfaces/events'
-import type { Store } from './store.js'
-import type { PeerStore, KeyBook, PeerPublicKeyChangeData, Peer } from '@libp2p/interface-peer-store'
-import type { PeerId } from '@libp2p/interface-peer-id'
-
-const log = logger('libp2p:peer-store:key-book')
-
-const EVENT_NAME = 'change:pubkey'
-
-export class PeerStoreKeyBook implements KeyBook {
-  private readonly dispatchEvent: PeerStore['dispatchEvent']
-  private readonly store: Store
-
-  /**
-   * The KeyBook is responsible for keeping the known public keys of a peer
-   */
-  constructor (dispatchEvent: PeerStore['dispatchEvent'], store: Store) {
-    this.dispatchEvent = dispatchEvent
-    this.store = store
-  }
-
-  /**
-   * Set the Peer public key
-   */
-  async set (peerId: PeerId, publicKey: Uint8Array): Promise<void> {
-    peerId = peerIdFromPeerId(peerId)
-
-    if (!(publicKey instanceof Uint8Array)) {
-      log.error('publicKey must be an instance of Uint8Array to store data')
-      throw new CodeError('publicKey must be an instance of PublicKey', codes.ERR_INVALID_PARAMETERS)
-    }
-
-    log.trace('set await write lock')
-    const release = await this.store.lock.writeLock()
-    log.trace('set got write lock')
-
-    let updatedKey = false
-    let peer: Peer | undefined
-
-    try {
-      try {
-        peer = await this.store.load(peerId)
-
-        if ((peer.pubKey != null) && uint8arrayEquals(peer.pubKey, publicKey)) {
-          return
-        }
-      } catch (err: any) {
-        if (err.code !== codes.ERR_NOT_FOUND) {
-          throw err
-        }
-      }
-
-      await this.store.patchOrCreate(peerId, {
-        pubKey: publicKey
-      })
-      updatedKey = true
-    } finally {
-      log.trace('set release write lock')
-      release()
-    }
-
-    if (updatedKey) {
-      this.dispatchEvent(new CustomEvent<PeerPublicKeyChangeData>(EVENT_NAME, {
-        detail: {
-          peerId,
-          publicKey,
-          oldPublicKey: peer == null ? undefined : peer.pubKey
-        }
-      }))
-    }
-  }
-
-  /**
-   * Get Public key of the given PeerId, if stored
-   */
-  async get (peerId: PeerId): Promise<Uint8Array | undefined> {
-    peerId = peerIdFromPeerId(peerId)
-
-    log.trace('get await write lock')
-    const release = await this.store.lock.readLock()
-    log.trace('get got write lock')
-
-    try {
-      const peer = await this.store.load(peerId)
-
-      return peer.pubKey
-    } catch (err: any) {
-      if (err.code !== codes.ERR_NOT_FOUND) {
-        throw err
-      }
-    } finally {
-      log('get release write lock')
-      release()
-    }
-  }
-
-  async delete (peerId: PeerId): Promise<void> {
-    peerId = peerIdFromPeerId(peerId)
-
-    log.trace('delete await write lock')
-    const release = await this.store.lock.writeLock()
-    log.trace('delete got write lock')
-
-    let peer: Peer | undefined
-
-    try {
-      try {
-        peer = await this.store.load(peerId)
-      } catch (err: any) {
-        if (err.code !== codes.ERR_NOT_FOUND) {
-          throw err
-        }
-      }
-
-      await this.store.patchOrCreate(peerId, {
-        pubKey: undefined
-      })
-    } catch (err: any) {
-      if (err.code !== codes.ERR_NOT_FOUND) {
-        throw err
-      }
-    } finally {
-      log.trace('delete release write lock')
-      release()
-    }
-
-    this.dispatchEvent(new CustomEvent<PeerPublicKeyChangeData>(EVENT_NAME, {
-      detail: {
-        peerId,
-        publicKey: undefined,
-        oldPublicKey: peer == null ? undefined : peer.pubKey
-      }
-    }))
-  }
-}

package/src/metadata-book.ts

@@ -1,244 +0,0 @@
-import { logger } from '@libp2p/logger'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { codes } from './errors.js'
-import { peerIdFromPeerId } from '@libp2p/peer-id'
-import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { CustomEvent } from '@libp2p/interfaces/events'
-import type { Store } from './store.js'
-import type { PeerStore, MetadataBook, PeerMetadataChangeData, Peer } from '@libp2p/interface-peer-store'
-import type { PeerId } from '@libp2p/interface-peer-id'
-
-const log = logger('libp2p:peer-store:metadata-book')
-
-const EVENT_NAME = 'change:metadata'
-
-export class PeerStoreMetadataBook implements MetadataBook {
-  private readonly dispatchEvent: PeerStore['dispatchEvent']
-  private readonly store: Store
-
-  /**
-   * The MetadataBook is responsible for keeping metadata
-   * about known peers
-   */
-  constructor (dispatchEvent: PeerStore['dispatchEvent'], store: Store) {
-    this.dispatchEvent = dispatchEvent
-    this.store = store
-  }
-
-  /**
-   * Get the known data of a provided peer
-   */
-  async get (peerId: PeerId): Promise<Map<string, Uint8Array>> {
-    peerId = peerIdFromPeerId(peerId)
-
-    log.trace('get await read lock')
-    const release = await this.store.lock.readLock()
-    log.trace('get got read lock')
-
-    try {
-      const peer = await this.store.load(peerId)
-
-      return peer.metadata
-    } catch (err: any) {
-      if (err.code !== codes.ERR_NOT_FOUND) {
-        throw err
-      }
-    } finally {
-      log.trace('get release read lock')
-      release()
-    }
-
-    return new Map()
-  }
-
-  /**
-   * Get specific metadata value, if it exists
-   */
-  async getValue (peerId: PeerId, key: string): Promise<Uint8Array | undefined> {
-    peerId = peerIdFromPeerId(peerId)
-
-    log.trace('getValue await read lock')
-    const release = await this.store.lock.readLock()
-    log.trace('getValue got read lock')
-
-    try {
-      const peer = await this.store.load(peerId)
-
-      return peer.metadata.get(key)
-    } catch (err: any) {
-      if (err.code !== codes.ERR_NOT_FOUND) {
-        throw err
-      }
-    } finally {
-      log.trace('getValue release write lock')
-      release()
-    }
-  }
-
-  async set (peerId: PeerId, metadata: Map<string, Uint8Array>): Promise<void> {
-    peerId = peerIdFromPeerId(peerId)
-
-    if (!(metadata instanceof Map)) {
-      log.error('valid metadata must be provided to store data')
-      throw new CodeError('valid metadata must be provided', codes.ERR_INVALID_PARAMETERS)
-    }
-
-    log.trace('set await write lock')
-    const release = await this.store.lock.writeLock()
-    log.trace('set got write lock')
-
-    let peer: Peer | undefined
-
-    try {
-      try {
-        peer = await this.store.load(peerId)
-      } catch (err: any) {
-        if (err.code !== codes.ERR_NOT_FOUND) {
-          throw err
-        }
-      }
-
-      await this.store.mergeOrCreate(peerId, {
-        metadata
-      })
-    } finally {
-      log.trace('set release write lock')
-      release()
-    }
-
-    this.dispatchEvent(new CustomEvent<PeerMetadataChangeData>(EVENT_NAME, {
-      detail: {
-        peerId,
-        metadata,
-        oldMetadata: peer == null ? new Map() : peer.metadata
-      }
-    }))
-  }
-
-  /**
-   * Set metadata key and value of a provided peer
-   */
-  async setValue (peerId: PeerId, key: string, value: Uint8Array): Promise<void> {
-    peerId = peerIdFromPeerId(peerId)
-
-    if (typeof key !== 'string' || !(value instanceof Uint8Array)) {
-      log.error('valid key and value must be provided to store data')
-      throw new CodeError('valid key and value must be provided', codes.ERR_INVALID_PARAMETERS)
-    }
-
-    log.trace('setValue await write lock')
-    const release = await this.store.lock.writeLock()
-    log.trace('setValue got write lock')
-
-    let peer: Peer | undefined
-    let updatedPeer
-
-    try {
-      try {
-        peer = await this.store.load(peerId)
-        const existingValue = peer.metadata.get(key)
-
-        if (existingValue != null && uint8ArrayEquals(value, existingValue)) {
-          return
-        }
-      } catch (err: any) {
-        if (err.code !== codes.ERR_NOT_FOUND) {
-          throw err
-        }
-      }
-
-      updatedPeer = await this.store.mergeOrCreate(peerId, {
-        metadata: new Map([[key, value]])
-      })
-    } finally {
-      log.trace('setValue release write lock')
-      release()
-    }
-
-    this.dispatchEvent(new CustomEvent<PeerMetadataChangeData>(EVENT_NAME, {
-      detail: {
-        peerId,
-        metadata: updatedPeer.metadata,
-        oldMetadata: peer == null ? new Map() : peer.metadata
-      }
-    }))
-  }
-
-  async delete (peerId: PeerId): Promise<void> {
-    peerId = peerIdFromPeerId(peerId)
-
-    log.trace('delete await write lock')
-    const release = await this.store.lock.writeLock()
-    log.trace('delete got write lock')
-
-    let peer: Peer | undefined
-
-    try {
-      try {
-        peer = await this.store.load(peerId)
-      } catch (err: any) {
-        if (err.code !== codes.ERR_NOT_FOUND) {
-          throw err
-        }
-      }
-
-      if (peer != null) {
-        await this.store.patch(peerId, {
-          metadata: new Map()
-        })
-      }
-    } finally {
-      log.trace('delete release write lock')
-      release()
-    }
-
-    if (peer != null) {
-      this.dispatchEvent(new CustomEvent<PeerMetadataChangeData>(EVENT_NAME, {
-        detail: {
-          peerId,
-          metadata: new Map(),
-          oldMetadata: peer.metadata
-        }
-      }))
-    }
-  }
-
-  async deleteValue (peerId: PeerId, key: string): Promise<void> {
-    peerId = peerIdFromPeerId(peerId)
-
-    log.trace('deleteValue await write lock')
-    const release = await this.store.lock.writeLock()
-    log.trace('deleteValue got write lock')
-
-    let metadata
-    let peer: Peer | undefined
-
-    try {
-      peer = await this.store.load(peerId)
-      metadata = peer.metadata
-
-      metadata.delete(key)
-
-      await this.store.patch(peerId, {
-        metadata
-      })
-    } catch (err: any) {
-      if (err.code !== codes.ERR_NOT_FOUND) {
-        throw err
-      }
-    } finally {
-      log.trace('deleteValue release write lock')
-      release()
-    }
-
-    if (metadata != null) {
-      this.dispatchEvent(new CustomEvent<PeerMetadataChangeData>(EVENT_NAME, {
-        detail: {
-          peerId,
-          metadata,
-          oldMetadata: peer == null ? new Map() : peer.metadata
-        }
-      }))
-    }
-  }
-}

package/src/pb/tags.proto

@@ -1,11 +0,0 @@
-syntax = "proto3";
-
-message Tags {
-  repeated Tag tags = 1;
-}
-
-message Tag {
-  string name = 1; // e.g. 'priority'
-  optional uint32 value = 2; // tag value 0-100
-  optional uint64 expiry = 3; // ms timestamp after which the tag is no longer valid
-}

package/src/pb/tags.ts

@@ -1,145 +0,0 @@
-/* eslint-disable import/export */
-/* eslint-disable complexity */
-/* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
-/* eslint-disable @typescript-eslint/no-empty-interface */
-
-import { encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-export interface Tags {
-  tags: Tag[]
-}
-
-export namespace Tags {
-  let _codec: Codec<Tags>
-
-  export const codec = (): Codec<Tags> => {
-    if (_codec == null) {
-      _codec = message<Tags>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.tags != null) {
-          for (const value of obj.tags) {
-            w.uint32(10)
-            Tag.codec().encode(value, w)
-          }
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length) => {
-        const obj: any = {
-          tags: []
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1:
-              obj.tags.push(Tag.codec().decode(reader, reader.uint32()))
-              break
-            default:
-              reader.skipType(tag & 7)
-              break
-          }
-        }
-
-        return obj
-      })
-    }
-
-    return _codec
-  }
-
-  export const encode = (obj: Partial<Tags>): Uint8Array => {
-    return encodeMessage(obj, Tags.codec())
-  }
-
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Tags => {
-    return decodeMessage(buf, Tags.codec())
-  }
-}
-
-export interface Tag {
-  name: string
-  value?: number
-  expiry?: bigint
-}
-
-export namespace Tag {
-  let _codec: Codec<Tag>
-
-  export const codec = (): Codec<Tag> => {
-    if (_codec == null) {
-      _codec = message<Tag>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if ((obj.name != null && obj.name !== '')) {
-          w.uint32(10)
-          w.string(obj.name)
-        }
-
-        if (obj.value != null) {
-          w.uint32(16)
-          w.uint32(obj.value)
-        }
-
-        if (obj.expiry != null) {
-          w.uint32(24)
-          w.uint64(obj.expiry)
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length) => {
-        const obj: any = {
-          name: ''
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1:
-              obj.name = reader.string()
-              break
-            case 2:
-              obj.value = reader.uint32()
-              break
-            case 3:
-              obj.expiry = reader.uint64()
-              break
-            default:
-              reader.skipType(tag & 7)
-              break
-          }
-        }
-
-        return obj
-      })
-    }
-
-    return _codec
-  }
-
-  export const encode = (obj: Partial<Tag>): Uint8Array => {
-    return encodeMessage(obj, Tag.codec())
-  }
-
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Tag => {
-    return decodeMessage(buf, Tag.codec())
-  }
-}