@libp2p/peer-store 0.0.0

package/src/key-book.ts

@@ -0,0 +1,117 @@
+import { logger } from '@libp2p/logger'
+import errcode from 'err-code'
+import { codes } from './errors.js'
+import { PeerId } from '@libp2p/peer-id'
+import { equals as uint8arrayEquals } from 'uint8arrays/equals'
+import type { Store } from './store.js'
+import type { PeerStore, KeyBook } from '@libp2p/interfaces/src/peer-store'
+
+/**
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').KeyBook} KeyBook
+ * @typedef {import('libp2p-interfaces/src/keys/types').PublicKey} PublicKey
+ */
+
+const log = logger('libp2p:peer-store:key-book')
+
+const EVENT_NAME = 'change:pubkey'
+
+export class PeerStoreKeyBook implements KeyBook {
+  private emit: PeerStore["emit"]
+  private store: Store
+
+  /**
+   * The KeyBook is responsible for keeping the known public keys of a peer
+   */
+  constructor (emit: PeerStore["emit"], store: Store) {
+    this.emit = emit
+    this.store = store
+  }
+
+  /**
+   * Set the Peer public key
+   */
+  async set (peerId: PeerId, publicKey: Uint8Array) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    if (!publicKey) {
+      log.error('publicKey must be an instance of PublicKey to store data')
+      throw errcode(new Error('publicKey must be an instance of PublicKey'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('set await write lock')
+    const release = await this.store.lock.writeLock()
+    log('set got write lock')
+
+    let updatedKey = false
+
+    try {
+      try {
+        const existing = await this.store.load(peerId)
+
+        if (existing.pubKey && uint8arrayEquals(existing.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('set release write lock')
+      release()
+    }
+
+    if (updatedKey) {
+      this.emit(EVENT_NAME, { peerId, pubKey: publicKey })
+    }
+  }
+
+  /**
+   * Get Public key of the given PeerId, if stored
+   */
+  async get (peerId: PeerId) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    log('get await write lock')
+    const release = await this.store.lock.readLock()
+    log('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) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    log('delete await write lock')
+    const release = await this.store.lock.writeLock()
+    log('delete got write lock')
+
+    try {
+      await this.store.patchOrCreate(peerId, {
+        pubKey: undefined
+      })
+    } finally {
+      log('delete release write lock')
+      release()
+    }
+
+    this.emit(EVENT_NAME, { peerId, pubKey: undefined })
+  }
+}

package/src/metadata-book.ts

@@ -0,0 +1,200 @@
+import { logger } from '@libp2p/logger'
+import errcode from 'err-code'
+import { codes } from './errors.js'
+import { PeerId } from '@libp2p/peer-id'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import type { Store } from './store.js'
+import type { PeerStore, MetadataBook } from '@libp2p/interfaces/src/peer-store'
+
+const log = logger('libp2p:peer-store:metadata-book')
+
+const EVENT_NAME = 'change:metadata'
+
+export class PeerStoreMetadataBook implements MetadataBook {
+  private emit: PeerStore["emit"]
+  private store: Store
+
+  /**
+   * The MetadataBook is responsible for keeping metadata
+   * about known peers
+   */
+  constructor (emit: PeerStore["emit"], store: Store) {
+    this.emit = emit
+    this.store = store
+  }
+
+  /**
+   * Get the known data of a provided peer
+   */
+  async get (peerId: PeerId) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    log('get await read lock')
+    const release = await this.store.lock.readLock()
+    log('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('get release read lock')
+      release()
+    }
+
+    return new Map()
+  }
+
+  /**
+   * Get specific metadata value, if it exists
+   */
+  async getValue (peerId: PeerId, key: string) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    log('getValue await read lock')
+    const release = await this.store.lock.readLock()
+    log('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('getValue release write lock')
+      release()
+    }
+  }
+
+  async set (peerId: PeerId, metadata: Map<string, Uint8Array>) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    if (!metadata || !(metadata instanceof Map)) {
+      log.error('valid metadata must be provided to store data')
+      throw errcode(new Error('valid metadata must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('set await write lock')
+    const release = await this.store.lock.writeLock()
+    log('set got write lock')
+
+    try {
+      await this.store.mergeOrCreate(peerId, {
+        metadata
+      })
+    } finally {
+      log('set release write lock')
+      release()
+    }
+
+    this.emit(EVENT_NAME, { peerId, metadata })
+  }
+
+  /**
+   * Set metadata key and value of a provided peer
+   */
+  async setValue (peerId: PeerId, key: string, value: Uint8Array) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    if (typeof key !== 'string' || !(value instanceof Uint8Array)) {
+      log.error('valid key and value must be provided to store data')
+      throw errcode(new Error('valid key and value must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('setValue await write lock')
+    const release = await this.store.lock.writeLock()
+    log('setValue got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const existingPeer = await this.store.load(peerId)
+        const existingValue = existingPeer.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('setValue release write lock')
+      release()
+    }
+
+    this.emit(EVENT_NAME, { peerId, metadata: updatedPeer.metadata })
+  }
+
+  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)
+
+      if (has) {
+        await this.store.patch(peerId, {
+          metadata: new Map()
+        })
+      }
+    } finally {
+      log('delete release write lock')
+      release()
+    }
+
+    if (has) {
+      this.emit(EVENT_NAME, { peerId, metadata: new Map() })
+    }
+  }
+
+  async deleteValue (peerId: PeerId, key: string) {
+    peerId = PeerId.fromPeerId(peerId)
+
+    log('deleteValue await write lock')
+    const release = await this.store.lock.writeLock()
+    log('deleteValue got write lock')
+
+    let metadata
+
+    try {
+      const 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('deleteValue release write lock')
+      release()
+    }
+
+    if (metadata) {
+      this.emit(EVENT_NAME, { peerId, metadata })
+    }
+  }
+}

package/src/pb/peer.d.ts

@@ -0,0 +1,222 @@
+import * as $protobuf from "protobufjs";
+/** Properties of a Peer. */
+export interface IPeer {
+
+    /** Peer addresses */
+    addresses?: (IAddress[]|null);
+
+    /** Peer protocols */
+    protocols?: (string[]|null);
+
+    /** Peer metadata */
+    metadata?: (IMetadata[]|null);
+
+    /** Peer pubKey */
+    pubKey?: (Uint8Array|null);
+
+    /** Peer peerRecordEnvelope */
+    peerRecordEnvelope?: (Uint8Array|null);
+}
+
+/** Represents a Peer. */
+export class Peer implements IPeer {
+
+    /**
+     * Constructs a new Peer.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IPeer);
+
+    /** Peer addresses. */
+    public addresses: IAddress[];
+
+    /** Peer protocols. */
+    public protocols: string[];
+
+    /** Peer metadata. */
+    public metadata: IMetadata[];
+
+    /** Peer pubKey. */
+    public pubKey?: (Uint8Array|null);
+
+    /** Peer peerRecordEnvelope. */
+    public peerRecordEnvelope?: (Uint8Array|null);
+
+    /** Peer _pubKey. */
+    public _pubKey?: "pubKey";
+
+    /** Peer _peerRecordEnvelope. */
+    public _peerRecordEnvelope?: "peerRecordEnvelope";
+
+    /**
+     * Encodes the specified Peer message. Does not implicitly {@link Peer.verify|verify} messages.
+     * @param m Peer message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IPeer, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a Peer message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Peer
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Peer;
+
+    /**
+     * Creates a Peer message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Peer
+     */
+    public static fromObject(d: { [k: string]: any }): Peer;
+
+    /**
+     * Creates a plain object from a Peer message. Also converts values to other types if specified.
+     * @param m Peer
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Peer, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Peer to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+/** Properties of an Address. */
+export interface IAddress {
+
+    /** Address multiaddr */
+    multiaddr?: (Uint8Array|null);
+
+    /** Address isCertified */
+    isCertified?: (boolean|null);
+}
+
+/** Represents an Address. */
+export class Address implements IAddress {
+
+    /**
+     * Constructs a new Address.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IAddress);
+
+    /** Address multiaddr. */
+    public multiaddr: Uint8Array;
+
+    /** Address isCertified. */
+    public isCertified?: (boolean|null);
+
+    /** Address _isCertified. */
+    public _isCertified?: "isCertified";
+
+    /**
+     * Encodes the specified Address message. Does not implicitly {@link Address.verify|verify} messages.
+     * @param m Address message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IAddress, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes an Address message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Address
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Address;
+
+    /**
+     * Creates an Address message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Address
+     */
+    public static fromObject(d: { [k: string]: any }): Address;
+
+    /**
+     * Creates a plain object from an Address message. Also converts values to other types if specified.
+     * @param m Address
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Address, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Address to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+/** Properties of a Metadata. */
+export interface IMetadata {
+
+    /** Metadata key */
+    key?: (string|null);
+
+    /** Metadata value */
+    value?: (Uint8Array|null);
+}
+
+/** Represents a Metadata. */
+export class Metadata implements IMetadata {
+
+    /**
+     * Constructs a new Metadata.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IMetadata);
+
+    /** Metadata key. */
+    public key: string;
+
+    /** Metadata value. */
+    public value: Uint8Array;
+
+    /**
+     * Encodes the specified Metadata message. Does not implicitly {@link Metadata.verify|verify} messages.
+     * @param m Metadata message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IMetadata, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a Metadata message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Metadata
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Metadata;
+
+    /**
+     * Creates a Metadata message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Metadata
+     */
+    public static fromObject(d: { [k: string]: any }): Metadata;
+
+    /**
+     * Creates a plain object from a Metadata message. Also converts values to other types if specified.
+     * @param m Metadata
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Metadata, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Metadata to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}