@libp2p/peer-store 0.0.0

package/src/proto-book.ts

@@ -0,0 +1,204 @@
+import { logger } from '@libp2p/logger'
+import errcode from 'err-code'
+import { codes } from './errors.js'
+import { PeerId } from '@libp2p/peer-id'
+import type { Store } from './store.js'
+import type { PeerStore, ProtoBook } from '@libp2p/interfaces/src/peer-store'
+import { base58btc } from 'multiformats/bases/base58'
+
+const log = logger('libp2p:peer-store:proto-book')
+
+const EVENT_NAME = 'change:protocols'
+
+export class PeerStoreProtoBook implements ProtoBook {
+  private emit: PeerStore["emit"]
+  private store: Store
+
+  /**
+   * The ProtoBook is responsible for keeping the known supported
+   * protocols of a peer
+   */
+  constructor (emit: PeerStore["emit"], store: Store) {
+    this.emit = emit
+    this.store = store
+  }
+
+  async get (peerId: PeerId) {
+    log('get wait for read lock')
+    const release = await this.store.lock.readLock()
+    log('get got read lock')
+
+    try {
+      const peer = await this.store.load(peerId)
+
+      return peer.protocols
+    } catch (err: any) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('get release read lock')
+      release()
+    }
+
+    return []
+  }
+
+  async set (peerId: PeerId, protocols: string[]) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    if (!Array.isArray(protocols)) {
+      log.error('protocols must be provided to store data')
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('set await write lock')
+    const release = await this.store.lock.writeLock()
+    log('set got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const peer = await this.store.load(peerId)
+
+        if (new Set([
+          ...protocols
+        ]).size === peer.protocols.length) {
+          return
+        }
+      } catch (err: any) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this.store.patchOrCreate(peerId, {
+        protocols
+      })
+
+      log(`stored provided protocols for ${peerId.toString(base58btc)}`)
+    } finally {
+      log('set release write lock')
+      release()
+    }
+
+    this.emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
+  }
+
+  async add (peerId: PeerId, protocols: string[]) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    if (!Array.isArray(protocols)) {
+      log.error('protocols must be provided to store data')
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('add await write lock')
+    const release = await this.store.lock.writeLock()
+    log('add got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const peer = await this.store.load(peerId)
+
+        if (new Set([
+          ...peer.protocols,
+          ...protocols
+        ]).size === peer.protocols.length) {
+          return
+        }
+      } catch (err: any) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this.store.mergeOrCreate(peerId, {
+        protocols
+      })
+
+      log(`added provided protocols for ${peerId.toString(base58btc)}`)
+    } finally {
+      log('add release write lock')
+      release()
+    }
+
+    this.emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
+  }
+
+  async remove (peerId: PeerId, protocols: string[]) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    if (!Array.isArray(protocols)) {
+      log.error('protocols must be provided to store data')
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('remove await write lock')
+    const release = await this.store.lock.writeLock()
+    log('remove got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const peer = await this.store.load(peerId)
+        const protocolSet = new Set(peer.protocols)
+
+        for (const protocol of protocols) {
+          protocolSet.delete(protocol)
+        }
+
+        if (peer.protocols.length === protocolSet.size) {
+          return
+        }
+
+        protocols = Array.from(protocolSet)
+      } catch (err: any) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this.store.patchOrCreate(peerId, {
+        protocols
+      })
+    } finally {
+      log('remove release write lock')
+      release()
+    }
+
+    this.emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
+  }
+
+  async delete (peerId: PeerId) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    log('delete await write lock')
+    const release = await this.store.lock.writeLock()
+    log('delete got write lock')
+    let has
+
+    try {
+      has = await this.store.has(peerId)
+
+      await this.store.patchOrCreate(peerId, {
+        protocols: []
+      })
+    } catch (err: any) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('delete release write lock')
+      release()
+    }
+
+    if (has) {
+      this.emit(EVENT_NAME, { peerId, protocols: [] })
+    }
+  }
+}

package/src/store.ts

@@ -0,0 +1,224 @@
+import { logger } from '@libp2p/logger'
+import { PeerId } from '@libp2p/peer-id'
+import errcode from 'err-code'
+import { codes } from './errors.js'
+import { Key } from 'interface-datastore/key'
+import { base32 } from 'multiformats/bases/base32'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { Peer as PeerPB } from './pb/peer.js'
+import mortice from 'mortice'
+import { equals as uint8arrayEquals } from 'uint8arrays/equals'
+import type { Peer } from '@libp2p/interfaces/peer-store'
+import type { Datastore } from 'interface-datastore'
+
+const log = logger('libp2p:peer-store:store')
+
+const NAMESPACE_COMMON = '/peers/'
+
+export interface Store {
+  has: (peerId: PeerId) => Promise<boolean>
+  save: (peer: Peer) => Promise<Peer>
+  load: (peerId: PeerId) => Promise<Peer>
+  delete (peerId: PeerId): Promise<void>
+  merge: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
+  mergeOrCreate: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
+  patch: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
+  patchOrCreate: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
+  all: () => AsyncIterable<Peer>
+
+  lock: {
+    readLock: () => Promise<() => void>
+    writeLock: () => Promise<() => void>
+  }
+}
+
+
+export class PersistentStore {
+  private datastore: Datastore
+  public lock: any
+
+  constructor (datastore: Datastore) {
+    this.datastore = datastore
+    this.lock = mortice({
+      name: 'peer-store',
+      singleProcess: true
+    })
+  }
+
+  _peerIdToDatastoreKey (peerId: PeerId) {
+    if (peerId.type == null) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    const b32key = peerId.toString(base32)
+    return new Key(`${NAMESPACE_COMMON}b${b32key}`)
+  }
+
+  async has (peerId: PeerId) {
+    return this.datastore.has(this._peerIdToDatastoreKey(peerId))
+  }
+
+  async delete (peerId: PeerId) {
+    await this.datastore.delete(this._peerIdToDatastoreKey(peerId))
+  }
+
+  async load (peerId: PeerId) {
+    const buf = await this.datastore.get(this._peerIdToDatastoreKey(peerId))
+    const peer = PeerPB.decode(buf)
+    const metadata = new Map()
+
+    for (const meta of peer.metadata) {
+      metadata.set(meta.key, meta.value)
+    }
+
+    return {
+      ...peer,
+      id: peerId,
+      addresses: peer.addresses.map(({ multiaddr, isCertified }) => ({
+        multiaddr: new Multiaddr(multiaddr),
+        isCertified: isCertified || false
+      })),
+      metadata,
+      peerRecordEnvelope: peer.peerRecordEnvelope || undefined
+    } as Peer
+  }
+
+  async save (peer: Peer) {
+    if (peer.pubKey != null && peer.id.publicKey != null && !uint8arrayEquals(peer.pubKey, peer.id.publicKey)) {
+      log.error('peer publicKey bytes do not match peer id publicKey bytes')
+      throw errcode(new Error('publicKey bytes do not match peer id publicKey bytes'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    // dedupe addresses
+    const addressSet = new Set()
+
+    const buf = PeerPB.encode({
+      addresses: peer.addresses
+        .filter(address => {
+          if (addressSet.has(address.multiaddr.toString())) {
+            return false
+          }
+
+          addressSet.add(address.multiaddr.toString())
+          return true
+        })
+        .sort((a, b) => {
+          return a.multiaddr.toString().localeCompare(b.multiaddr.toString())
+        })
+        .map(({ multiaddr, isCertified }) => ({
+          multiaddr: multiaddr.bytes,
+          isCertified
+        })),
+      protocols: peer.protocols.sort(),
+      pubKey: peer.pubKey,
+      metadata: [...peer.metadata.keys()].sort().map(key => ({ key, value: peer.metadata.get(key) })),
+      peerRecordEnvelope: peer.peerRecordEnvelope
+    }).finish()
+
+    await this.datastore.put(this._peerIdToDatastoreKey(peer.id), buf)
+
+    return this.load(peer.id)
+  }
+
+  async patch (peerId: PeerId, data: Partial<Peer>) {
+    const peer = await this.load(peerId)
+
+    return await this._patch(peerId, data, peer)
+  }
+
+  async patchOrCreate (peerId: PeerId, data: Partial<Peer>) {
+    let peer: Peer
+
+    try {
+      peer = await this.load(peerId)
+    } catch (err: any) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+
+      peer = { id: peerId, addresses: [], protocols: [], metadata: new Map() }
+    }
+
+    return await this._patch(peerId, data, peer)
+  }
+
+  async _patch (peerId: PeerId, data: Partial<Peer>, peer: Peer) {
+    return await this.save({
+      ...peer,
+      ...data,
+      id: peerId
+    })
+  }
+
+  async merge (peerId: PeerId, data: Partial<Peer>) {
+    const peer = await this.load(peerId)
+
+    return this._merge(peerId, data, peer)
+  }
+
+  async mergeOrCreate (peerId: PeerId, data: Partial<Peer>) {
+    /** @type {Peer} */
+    let peer
+
+    try {
+      peer = await this.load(peerId)
+    } catch (err: any) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+
+      peer = { id: peerId, addresses: [], protocols: [], metadata: new Map() }
+    }
+
+    return await this._merge(peerId, data, peer)
+  }
+
+  async _merge (peerId: PeerId, data: Partial<Peer>, peer: Peer) {
+    // if the peer has certified addresses, use those in
+    // favour of the supplied versions
+    /** @type {Map<string, boolean>} */
+    const addresses = new Map()
+
+    ;(data.addresses || []).forEach(addr => {
+      addresses.set(addr.multiaddr.toString(), addr.isCertified)
+    })
+
+    peer.addresses.forEach(({ multiaddr, isCertified }) => {
+      const addrStr = multiaddr.toString()
+      addresses.set(addrStr, Boolean(addresses.get(addrStr) || isCertified))
+    })
+
+    return await this.save({
+      id: peerId,
+      addresses: Array.from(addresses.entries()).map(([addrStr, isCertified]) => {
+        return {
+          multiaddr: new Multiaddr(addrStr),
+          isCertified
+        }
+      }),
+      protocols: Array.from(new Set([
+        ...(peer.protocols || []),
+        ...(data.protocols || [])
+      ])),
+      metadata: new Map([
+        ...(peer.metadata ? peer.metadata.entries() : []),
+        ...(data.metadata ? data.metadata.entries() : [])
+      ]),
+      pubKey: data.pubKey || (peer != null ? peer.pubKey : undefined),
+      peerRecordEnvelope: data.peerRecordEnvelope || (peer != null ? peer.peerRecordEnvelope : undefined)
+    })
+  }
+
+  async * all () {
+    for await (const key of this.datastore.queryKeys({
+      prefix: NAMESPACE_COMMON
+    })) {
+      // /peers/${peer-id-as-libp2p-key-cid-string-in-base-32}
+      const base32Str = key.toString().split('/')[2]
+      const buf = base32.decode(base32Str)
+
+      yield this.load(PeerId.fromBytes(buf))
+    }
+  }
+}