@libp2p/peer-store 7.0.2 → 8.0.0

package/src/store.ts

@@ -1,241 +1,154 @@
-import { logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { codes } from './errors.js'
-import { Key } from 'interface-datastore/key'
 import { base32 } from 'multiformats/bases/base32'
-import { multiaddr } from '@multiformats/multiaddr'
-import { Metadata, Peer as PeerPB } from './pb/peer.js'
-import mortice from 'mortice'
-import { equals as uint8arrayEquals } from 'uint8arrays/equals'
-import type { Peer } from '@libp2p/interface-peer-store'
+import { Peer as PeerPB } from './pb/peer.js'
+import type { Peer, PeerData } from '@libp2p/interface-peer-store'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PersistentPeerStoreComponents } from './index.js'
-
-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>
-  }
+import type { AddressFilter, PersistentPeerStoreComponents, PersistentPeerStoreInit } from './index.js'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { NAMESPACE_COMMON, peerIdToDatastoreKey } from './utils/peer-id-to-datastore-key.js'
+import { bytesToPeer } from './utils/bytes-to-peer.js'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { codes } from './errors.js'
+import type { Datastore } from 'interface-datastore'
+import type { PeerUpdate as PeerUpdateExternal } from '@libp2p/interface-libp2p'
+import mortice, { Mortice } from 'mortice'
+import { toPeerPB } from './utils/to-peer-pb.js'
+
+/**
+ * Event detail emitted when peer data changes
+ */
+export interface PeerUpdate extends PeerUpdateExternal {
+  updated: boolean
 }
 
 export class PersistentStore {
-  private readonly components: PersistentPeerStoreComponents
-  public lock: any
-
-  constructor (components: PersistentPeerStoreComponents) {
-    this.components = components
+  private readonly peerId: PeerId
+  private readonly datastore: Datastore
+  public readonly lock: Mortice
+  private readonly addressFilter?: AddressFilter
+
+  constructor (components: PersistentPeerStoreComponents, init: PersistentPeerStoreInit = {}) {
+    this.peerId = components.peerId
+    this.datastore = components.datastore
+    this.addressFilter = init.addressFilter
     this.lock = mortice({
       name: 'peer-store',
       singleProcess: true
     })
   }
 
-  _peerIdToDatastoreKey (peerId: PeerId): Key {
-    if (peerId.type == null) {
-      log.error('peerId must be an instance of peer-id to store data')
-      throw new CodeError('peerId must be an instance of peer-id', codes.ERR_INVALID_PARAMETERS)
-    }
-
-    const b32key = peerId.toCID().toString()
-    return new Key(`${NAMESPACE_COMMON}${b32key}`)
-  }
-
   async has (peerId: PeerId): Promise<boolean> {
-    return await this.components.datastore.has(this._peerIdToDatastoreKey(peerId))
+    return await this.datastore.has(peerIdToDatastoreKey(peerId))
   }
 
   async delete (peerId: PeerId): Promise<void> {
-    await this.components.datastore.delete(this._peerIdToDatastoreKey(peerId))
+    if (this.peerId.equals(peerId)) {
+      throw new CodeError('Cannot delete self peer', codes.ERR_INVALID_PARAMETERS)
+    }
+
+    await this.datastore.delete(peerIdToDatastoreKey(peerId))
   }
 
   async load (peerId: PeerId): Promise<Peer> {
-    const buf = await this.components.datastore.get(this._peerIdToDatastoreKey(peerId))
-    const peer = PeerPB.decode(buf)
-    const metadata = new Map()
+    const buf = await this.datastore.get(peerIdToDatastoreKey(peerId))
 
-    for (const meta of peer.metadata) {
-      metadata.set(meta.key, meta.value)
-    }
-
-    return {
-      ...peer,
-      id: peerId,
-      addresses: peer.addresses.map(({ multiaddr: ma, isCertified }) => {
-        return {
-          multiaddr: multiaddr(ma),
-          isCertified: isCertified ?? false
-        }
-      }),
-      metadata,
-      pubKey: peer.pubKey ?? undefined,
-      peerRecordEnvelope: peer.peerRecordEnvelope ?? undefined
-    }
+    return await bytesToPeer(peerId, buf)
   }
 
-  async save (peer: Peer): Promise<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 new CodeError('publicKey bytes do not match peer id publicKey bytes', codes.ERR_INVALID_PARAMETERS)
-    }
-
-    // dedupe addresses
-    const addressSet = new Set()
-    const 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
-      }))
-
-    const metadata: Metadata[] = []
-
-    ;[...peer.metadata.keys()].sort().forEach(key => {
-      const value = peer.metadata.get(key)
-
-      if (value != null) {
-        metadata.push({ key, value })
-      }
-    })
+  async save (peerId: PeerId, data: PeerData): Promise<PeerUpdate> {
+    const {
+      existingBuf,
+      existingPeer
+    } = await this.#findExistingPeer(peerId)
 
-    const buf = PeerPB.encode({
-      addresses,
-      protocols: peer.protocols.sort(),
-      pubKey: peer.pubKey,
-      metadata,
-      peerRecordEnvelope: peer.peerRecordEnvelope
+    const peerPb: PeerPB = await toPeerPB(peerId, data, 'patch', {
+      addressFilter: this.addressFilter
     })
 
-    await this.components.datastore.put(this._peerIdToDatastoreKey(peer.id), buf.subarray())
-
-    return await this.load(peer.id)
+    return await this.#saveIfDifferent(peerId, peerPb, existingBuf, existingPeer)
   }
 
-  async patch (peerId: PeerId, data: Partial<Peer>): Promise<Peer> {
-    const peer = await this.load(peerId)
+  async patch (peerId: PeerId, data: Partial<PeerData>): Promise<PeerUpdate> {
+    const {
+      existingBuf,
+      existingPeer
+    } = await this.#findExistingPeer(peerId)
+
+    const peerPb: PeerPB = await toPeerPB(peerId, data, 'patch', {
+      addressFilter: this.addressFilter,
+      existingPeer
+    })
 
-    return await this._patch(peerId, data, peer)
+    return await this.#saveIfDifferent(peerId, peerPb, existingBuf, existingPeer)
   }
 
-  async patchOrCreate (peerId: PeerId, data: Partial<Peer>): Promise<Peer> {
-    let peer: Peer
+  async merge (peerId: PeerId, data: PeerData): Promise<PeerUpdate> {
+    const {
+      existingBuf,
+      existingPeer
+    } = await this.#findExistingPeer(peerId)
 
-    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() }
-    }
+    const peerPb: PeerPB = await toPeerPB(peerId, data, 'merge', {
+      addressFilter: this.addressFilter,
+      existingPeer
+    })
 
-    return await this._patch(peerId, data, peer)
+    return await this.#saveIfDifferent(peerId, peerPb, existingBuf, existingPeer)
   }
 
-  async _patch (peerId: PeerId, data: Partial<Peer>, peer: Peer): Promise<Peer> {
-    return await this.save({
-      ...peer,
-      ...data,
-      id: peerId
-    })
-  }
+  async * all (): AsyncGenerator<Peer, void, unknown> {
+    for await (const { key, value } of this.datastore.query({
+      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)
+      const peerId = peerIdFromBytes(buf)
 
-  async merge (peerId: PeerId, data: Partial<Peer>): Promise<Peer> {
-    const peer = await this.load(peerId)
+      if (peerId.equals(this.peerId)) {
+        // Skip self peer if present
+        continue
+      }
 
-    return await this._merge(peerId, data, peer)
+      yield bytesToPeer(peerId, value)
+    }
   }
 
-  async mergeOrCreate (peerId: PeerId, data: Partial<Peer>): Promise<Peer> {
-    /** @type {Peer} */
-    let peer
-
+  async #findExistingPeer (peerId: PeerId): Promise<{ existingBuf?: Uint8Array, existingPeer?: Peer }> {
     try {
-      peer = await this.load(peerId)
+      const existingBuf = await this.datastore.get(peerIdToDatastoreKey(peerId))
+      const existingPeer = await bytesToPeer(peerId, existingBuf)
+
+      return {
+        existingBuf,
+        existingPeer
+      }
     } catch (err: any) {
-      if (err.code !== codes.ERR_NOT_FOUND) {
+      if (err.code !== 'ERR_NOT_FOUND') {
         throw err
       }
-
-      peer = { id: peerId, addresses: [], protocols: [], metadata: new Map() }
     }
 
-    return await this._merge(peerId, data, peer)
+    return {}
   }
 
-  async _merge (peerId: PeerId, data: Partial<Peer>, peer: Peer): Promise<Peer> {
-    // if the peer has certified addresses, use those in
-    // favour of the supplied versions
-    const addresses = new Map<string, boolean>()
-
-    peer.addresses.forEach((addr) => {
-      addresses.set(addr.multiaddr.toString(), addr.isCertified)
-    })
-
-    ;(data.addresses ?? []).forEach(addr => {
-      const addrString = addr.multiaddr.toString()
-      const isAlreadyCertified = Boolean(addresses.get(addrString))
-
-      const isCertified = isAlreadyCertified || addr.isCertified
+  async #saveIfDifferent (peerId: PeerId, peer: PeerPB, existingBuf?: Uint8Array, existingPeer?: Peer): Promise<PeerUpdate> {
+    const buf = PeerPB.encode(peer)
 
-      addresses.set(addrString, isCertified)
-    })
+    if (existingBuf != null && uint8ArrayEquals(buf, existingBuf)) {
+      return {
+        peer: await bytesToPeer(peerId, buf),
+        previous: existingPeer,
+        updated: false
+      }
+    }
 
-    return await this.save({
-      id: peerId,
-      addresses: Array.from(addresses.entries()).map(([addrStr, isCertified]) => {
-        return {
-          multiaddr: multiaddr(addrStr),
-          isCertified
-        }
-      }),
-      protocols: Array.from(new Set([
-        ...(peer.protocols ?? []),
-        ...(data.protocols ?? [])
-      ])),
-      metadata: new Map([
-        ...(peer.metadata?.entries() ?? []),
-        ...(data.metadata?.entries() ?? [])
-      ]),
-      pubKey: data.pubKey ?? (peer != null ? peer.pubKey : undefined),
-      peerRecordEnvelope: data.peerRecordEnvelope ?? (peer != null ? peer.peerRecordEnvelope : undefined)
-    })
-  }
+    await this.datastore.put(peerIdToDatastoreKey(peerId), buf)
 
-  async * all (): AsyncGenerator<Peer, void, unknown> {
-    for await (const key of this.components.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(peerIdFromBytes(buf))
+    return {
+      peer: await bytesToPeer(peerId, buf),
+      previous: existingPeer,
+      updated: true
     }
   }
 }

package/src/utils/bytes-to-peer.ts

@@ -0,0 +1,41 @@
+import { multiaddr } from '@multiformats/multiaddr'
+import { Peer as PeerPB } from '../pb/peer.js'
+import type { Peer, Tag } from '@libp2p/interface-peer-store'
+import { createFromPubKey } from '@libp2p/peer-id-factory'
+import { unmarshalPublicKey } from '@libp2p/crypto/keys'
+import type { PeerId } from '@libp2p/interface-peer-id'
+
+export async function bytesToPeer (peerId: PeerId, buf: Uint8Array): Promise<Peer> {
+  const peer = PeerPB.decode(buf)
+
+  if (peer.publicKey != null && peerId.publicKey == null) {
+    peerId = await createFromPubKey(unmarshalPublicKey(peer.publicKey))
+  }
+
+  const tags = new Map<string, Tag>()
+
+  // remove any expired tags
+  const now = BigInt(Date.now())
+
+  for (const [key, tag] of peer.tags.entries()) {
+    if (tag.expiry != null && tag.expiry < now) {
+      continue
+    }
+
+    tags.set(key, tag)
+  }
+
+  return {
+    ...peer,
+    id: peerId,
+    addresses: peer.addresses.map(({ multiaddr: ma, isCertified }) => {
+      return {
+        multiaddr: multiaddr(ma),
+        isCertified: isCertified ?? false
+      }
+    }),
+    metadata: peer.metadata,
+    peerRecordEnvelope: peer.peerRecordEnvelope ?? undefined,
+    tags
+  }
+}

package/src/utils/dedupe-addresses.ts

@@ -0,0 +1,51 @@
+import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
+import type { Address as AddressPB } from '../pb/peer.js'
+import type { Address } from '@libp2p/interface-peer-store'
+import type { AddressFilter } from '../index.js'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { codes } from '../errors.js'
+
+export async function dedupeFilterAndSortAddresses (peerId: PeerId, filter: AddressFilter, addresses: Array<Address | AddressPB | undefined>): Promise<AddressPB[]> {
+  const addressMap = new Map<string, Address>()
+
+  for (const addr of addresses) {
+    if (addr == null) {
+      continue
+    }
+
+    if (addr.multiaddr instanceof Uint8Array) {
+      addr.multiaddr = multiaddr(addr.multiaddr)
+    }
+
+    if (!isMultiaddr(addr.multiaddr)) {
+      throw new CodeError('Multiaddr was invalid', codes.ERR_INVALID_PARAMETERS)
+    }
+
+    if (!(await filter(peerId, addr.multiaddr))) {
+      continue
+    }
+
+    const isCertified = addr.isCertified ?? false
+    const maStr = addr.multiaddr.toString()
+    const existingAddr = addressMap.get(maStr)
+
+    if (existingAddr != null) {
+      addr.isCertified = existingAddr.isCertified || isCertified
+    } else {
+      addressMap.set(maStr, {
+        multiaddr: addr.multiaddr,
+        isCertified
+      })
+    }
+  }
+
+  return [...addressMap.values()]
+    .sort((a, b) => {
+      return a.multiaddr.toString().localeCompare(b.multiaddr.toString())
+    })
+    .map(({ isCertified, multiaddr }) => ({
+      isCertified,
+      multiaddr: multiaddr.bytes
+    }))
+}

package/src/utils/peer-data-to-datastore-peer.ts

@@ -0,0 +1,116 @@
+
+import { CodeError } from '@libp2p/interfaces/errors'
+import { codes } from '../errors.js'
+import { isMultiaddr } from '@multiformats/multiaddr'
+import type { Peer as PeerPB } from '../pb/peer.js'
+import { equals as uint8arrayEquals } from 'uint8arrays/equals'
+import type { PeerData } from '@libp2p/interface-peer-store'
+import type { PeerId } from '@libp2p/interface-peer-id'
+
+export function toDatastorePeer (peerId: PeerId, data: PeerData): PeerPB {
+  if (data == null) {
+    throw new CodeError('Invalid PeerData', codes.ERR_INVALID_PARAMETERS)
+  }
+
+  if (data.publicKey != null && peerId.publicKey != null && !uint8arrayEquals(data.publicKey, peerId.publicKey)) {
+    throw new CodeError('publicKey bytes do not match peer id publicKey bytes', codes.ERR_INVALID_PARAMETERS)
+  }
+
+  // merge addresses and multiaddrs, and dedupe
+  const addressSet = new Set()
+
+  const output: PeerPB = {
+    addresses: (data.addresses ?? [])
+      .concat((data.multiaddrs ?? []).map(multiaddr => ({ multiaddr, isCertified: false })))
+      .filter(address => {
+        if (!isMultiaddr(address.multiaddr)) {
+          throw new CodeError('Invalid mulitaddr', codes.ERR_INVALID_PARAMETERS)
+        }
+
+        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: (data.protocols ?? []).sort(),
+    metadata: new Map(),
+    tags: new Map(),
+    publicKey: data.publicKey,
+    peerRecordEnvelope: data.peerRecordEnvelope
+  }
+
+  // remove invalid metadata
+  if (data.metadata != null) {
+    const metadataEntries = data.metadata instanceof Map ? data.metadata.entries() : Object.entries(data.metadata)
+
+    for (const [key, value] of metadataEntries) {
+      if (typeof key !== 'string') {
+        throw new CodeError('Peer metadata keys must be strings', codes.ERR_INVALID_PARAMETERS)
+      }
+
+      if (value == null) {
+        continue
+      }
+
+      if (!(value instanceof Uint8Array)) {
+        throw new CodeError('Peer metadata values must be Uint8Arrays', codes.ERR_INVALID_PARAMETERS)
+      }
+
+      output.metadata.set(key, value)
+    }
+  }
+
+  if (data.tags != null) {
+    const tagsEntries = data.tags instanceof Map ? data.tags.entries() : Object.entries(data.tags)
+
+    for (const [key, value] of tagsEntries) {
+      if (typeof key !== 'string') {
+        throw new CodeError('Peer tag keys must be strings', codes.ERR_INVALID_PARAMETERS)
+      }
+
+      if (value == null) {
+        continue
+      }
+
+      const tag = {
+        name: key,
+        ttl: value.ttl,
+        value: value.value ?? 0
+      }
+
+      if (tag.value < 0 || tag.value > 100) {
+        throw new CodeError('Tag value must be between 0-100', codes.ERR_INVALID_PARAMETERS)
+      }
+
+      if (parseInt(`${tag.value}`, 10) !== tag.value) {
+        throw new CodeError('Tag value must be an integer', codes.ERR_INVALID_PARAMETERS)
+      }
+
+      if (tag.ttl != null) {
+        if (tag.ttl < 0) {
+          throw new CodeError('Tag ttl must be between greater than 0', codes.ERR_INVALID_PARAMETERS)
+        }
+
+        if (parseInt(`${tag.ttl}`, 10) !== tag.ttl) {
+          throw new CodeError('Tag ttl must be an integer', codes.ERR_INVALID_PARAMETERS)
+        }
+      }
+
+      output.tags.set(tag.name, {
+        value: tag.value,
+        expiry: tag.ttl == null ? undefined : BigInt(Date.now() + tag.ttl)
+      })
+    }
+  }
+
+  return output
+}

package/src/utils/peer-id-to-datastore-key.ts

@@ -0,0 +1,15 @@
+import { CodeError } from '@libp2p/interfaces/errors'
+import { codes } from '../errors.js'
+import { Key } from 'interface-datastore/key'
+import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
+
+export const NAMESPACE_COMMON = '/peers/'
+
+export function peerIdToDatastoreKey (peerId: PeerId): Key {
+  if (!isPeerId(peerId) || peerId.type == null) {
+    throw new CodeError('Invalid PeerId', codes.ERR_INVALID_PARAMETERS)
+  }
+
+  const b32key = peerId.toCID().toString()
+  return new Key(`${NAMESPACE_COMMON}${b32key}`)
+}