@libp2p/peer-id 4.2.4 → 5.0.0-18dd3cb26

package/src/index.ts

@@ -14,333 +14,114 @@
  * ```
  */
 
-import { CodeError } from '@libp2p/interface'
-import { type Ed25519PeerId, type PeerIdType, type RSAPeerId, type URLPeerId, type Secp256k1PeerId, peerIdSymbol, type PeerId } from '@libp2p/interface'
+import { publicKeyFromMultihash } from '@libp2p/crypto/keys'
+import { InvalidCIDError, InvalidMultihashError, InvalidParametersError, UnsupportedKeyTypeError } from '@libp2p/interface'
 import { base58btc } from 'multiformats/bases/base58'
-import { bases } from 'multiformats/basics'
-import { CID } from 'multiformats/cid'
+import { type CID, type MultibaseDecoder } from 'multiformats/cid'
 import * as Digest from 'multiformats/hashes/digest'
 import { identity } from 'multiformats/hashes/identity'
 import { sha256 } from 'multiformats/hashes/sha2'
-import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import type { MultibaseDecoder } from 'multiformats/bases/interface'
+import { RSAPeerId as RSAPeerIdClass, Ed25519PeerId as Ed25519PeerIdClass, Secp256k1PeerId as Secp256k1PeerIdClass, URLPeerId as URLPeerIdClass } from './peer-id.js'
+import type { Ed25519PeerId, RSAPeerId, URLPeerId, Secp256k1PeerId, PeerId, PublicKey, Ed25519PublicKey, Secp256k1PublicKey, RSAPublicKey, Ed25519PrivateKey, Secp256k1PrivateKey, RSAPrivateKey, PrivateKey } from '@libp2p/interface'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 
-const inspect = Symbol.for('nodejs.util.inspect.custom')
-
-const baseDecoder = Object
-  .values(bases)
-  .map(codec => codec.decoder)
-  // @ts-expect-error https://github.com/multiformats/js-multiformats/issues/141
-  .reduce((acc, curr) => acc.or(curr), bases.identity.decoder)
-
 // these values are from https://github.com/multiformats/multicodec/blob/master/table.csv
 const LIBP2P_KEY_CODE = 0x72
-
-const MARSHALLED_ED225519_PUBLIC_KEY_LENGTH = 36
-const MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH = 37
-
-interface PeerIdInit {
-  type: PeerIdType
-  multihash: MultihashDigest
-  privateKey?: Uint8Array
-}
-
-interface RSAPeerIdInit {
-  multihash: MultihashDigest
-  privateKey?: Uint8Array
-  publicKey?: Uint8Array
-}
-
-interface Ed25519PeerIdInit {
-  multihash: MultihashDigest
-  privateKey?: Uint8Array
-}
-
-interface Secp256k1PeerIdInit {
-  multihash: MultihashDigest
-  privateKey?: Uint8Array
-}
-
-class PeerIdImpl {
-  public type: PeerIdType
-  public readonly multihash: MultihashDigest
-  public readonly privateKey?: Uint8Array
-  public readonly publicKey?: Uint8Array
-  private string?: string
-
-  constructor (init: PeerIdInit) {
-    this.type = init.type
-    this.multihash = init.multihash
-    this.privateKey = init.privateKey
-
-    // mark string cache as non-enumerable
-    Object.defineProperty(this, 'string', {
-      enumerable: false,
-      writable: true
-    })
-  }
-
-  get [Symbol.toStringTag] (): string {
-    return `PeerId(${this.toString()})`
-  }
-
-  readonly [peerIdSymbol] = true
-
-  toString (): string {
-    if (this.string == null) {
-      this.string = base58btc.encode(this.multihash.bytes).slice(1)
-    }
-
-    return this.string
-  }
-
-  // return self-describing String representation
-  // in default format from RFC 0001: https://github.com/libp2p/specs/pull/209
-  toCID (): CID {
-    return CID.createV1(LIBP2P_KEY_CODE, this.multihash)
-  }
-
-  toBytes (): Uint8Array {
-    return this.multihash.bytes
-  }
-
-  /**
-   * Returns Multiaddr as a JSON string
-   */
-  toJSON (): string {
-    return this.toString()
-  }
-
-  /**
-   * Checks the equality of `this` peer against a given PeerId
-   */
-  equals (id?: PeerId | Uint8Array | string): boolean {
-    if (id == null) {
-      return false
-    }
-
-    if (id instanceof Uint8Array) {
-      return uint8ArrayEquals(this.multihash.bytes, id)
-    } else if (typeof id === 'string') {
-      return peerIdFromString(id).equals(this as PeerId)
-    } else if (id?.multihash?.bytes != null) {
-      return uint8ArrayEquals(this.multihash.bytes, id.multihash.bytes)
-    } else {
-      throw new Error('not valid Id')
-    }
-  }
-
-  /**
-   * Returns PeerId as a human-readable string
-   * https://nodejs.org/api/util.html#utilinspectcustom
-   *
-   * @example
-   * ```TypeScript
-   * import { peerIdFromString } from '@libp2p/peer-id'
-   *
-   * console.info(peerIdFromString('QmFoo'))
-   * // 'PeerId(QmFoo)'
-   * ```
-   */
-  [inspect] (): string {
-    return `PeerId(${this.toString()})`
-  }
-}
-
-class RSAPeerIdImpl extends PeerIdImpl implements RSAPeerId {
-  public readonly type = 'RSA'
-  public readonly publicKey?: Uint8Array
-
-  constructor (init: RSAPeerIdInit) {
-    super({ ...init, type: 'RSA' })
-
-    this.publicKey = init.publicKey
-  }
-}
-
-class Ed25519PeerIdImpl extends PeerIdImpl implements Ed25519PeerId {
-  public readonly type = 'Ed25519'
-  public readonly publicKey: Uint8Array
-
-  constructor (init: Ed25519PeerIdInit) {
-    super({ ...init, type: 'Ed25519' })
-
-    this.publicKey = init.multihash.digest
-  }
-}
-
-class Secp256k1PeerIdImpl extends PeerIdImpl implements Secp256k1PeerId {
-  public readonly type = 'secp256k1'
-  public readonly publicKey: Uint8Array
-
-  constructor (init: Secp256k1PeerIdInit) {
-    super({ ...init, type: 'secp256k1' })
-
-    this.publicKey = init.multihash.digest
-  }
-}
-
-// these values are from https://github.com/multiformats/multicodec/blob/master/table.csv
 const TRANSPORT_IPFS_GATEWAY_HTTP_CODE = 0x0920
 
-class URLPeerIdImpl implements URLPeerId {
-  readonly type = 'url'
-  readonly multihash: MultihashDigest
-  readonly privateKey?: Uint8Array
-  readonly publicKey?: Uint8Array
-  readonly url: string
-
-  constructor (url: URL) {
-    this.url = url.toString()
-    this.multihash = identity.digest(uint8ArrayFromString(this.url))
-  }
-
-  [inspect] (): string {
-    return `PeerId(${this.url})`
-  }
-
-  readonly [peerIdSymbol] = true
-
-  toString (): string {
-    return this.toCID().toString()
-  }
-
-  toCID (): CID {
-    return CID.createV1(TRANSPORT_IPFS_GATEWAY_HTTP_CODE, this.multihash)
-  }
-
-  toBytes (): Uint8Array {
-    return this.toCID().bytes
-  }
-
-  equals (other?: PeerId | Uint8Array | string): boolean {
-    if (other == null) {
-      return false
-    }
+export function peerIdFromString (str: string, decoder?: MultibaseDecoder<any>): Ed25519PeerId | Secp256k1PeerId | RSAPeerId | URLPeerId {
+  let multihash: MultihashDigest
 
-    if (other instanceof Uint8Array) {
-      other = uint8ArrayToString(other)
+  if (str.charAt(0) === '1' || str.charAt(0) === 'Q') {
+    // identity hash ed25519/secp256k1 key or sha2-256 hash of
+    // rsa public key - base58btc encoded either way
+    multihash = Digest.decode(base58btc.decode(`z${str}`))
+  } else {
+    if (decoder == null) {
+      throw new InvalidParametersError('Please pass a multibase decoder for strings that do not start with "1" or "Q"')
     }
 
-    return other.toString() === this.toString()
-  }
-}
-
-export function createPeerId (init: PeerIdInit): Ed25519PeerId | Secp256k1PeerId | RSAPeerId {
-  if (init.type === 'RSA') {
-    return new RSAPeerIdImpl(init)
+    multihash = Digest.decode(decoder.decode(str))
   }
 
-  if (init.type === 'Ed25519') {
-    return new Ed25519PeerIdImpl(init)
-  }
-
-  if (init.type === 'secp256k1') {
-    return new Secp256k1PeerIdImpl(init)
-  }
-
-  throw new CodeError('Type must be "RSA", "Ed25519" or "secp256k1"', 'ERR_INVALID_PARAMETERS')
+  return peerIdFromMultihash(multihash)
 }
 
-export function peerIdFromPeerId (other: any): Ed25519PeerId | Secp256k1PeerId | RSAPeerId {
-  if (other.type === 'RSA') {
-    return new RSAPeerIdImpl(other)
-  }
-
-  if (other.type === 'Ed25519') {
-    return new Ed25519PeerIdImpl(other)
-  }
-
-  if (other.type === 'secp256k1') {
-    return new Secp256k1PeerIdImpl(other)
+export function peerIdFromPublicKey (publicKey: Ed25519PublicKey): Ed25519PeerId
+export function peerIdFromPublicKey (publicKey: Secp256k1PublicKey): Secp256k1PeerId
+export function peerIdFromPublicKey (publicKey: RSAPublicKey): RSAPeerId
+export function peerIdFromPublicKey (publicKey: PublicKey): PeerId
+export function peerIdFromPublicKey (publicKey: PublicKey): PeerId {
+  if (publicKey.type === 'Ed25519') {
+    return new Ed25519PeerIdClass({
+      multihash: publicKey.toCID().multihash,
+      publicKey
+    })
+  } else if (publicKey.type === 'secp256k1') {
+    return new Secp256k1PeerIdClass({
+      multihash: publicKey.toCID().multihash,
+      publicKey
+    })
+  } else if (publicKey.type === 'RSA') {
+    return new RSAPeerIdClass({
+      multihash: publicKey.toCID().multihash,
+      publicKey
+    })
   }
 
-  throw new CodeError('Not a PeerId', 'ERR_INVALID_PARAMETERS')
+  throw new UnsupportedKeyTypeError()
 }
 
-export function peerIdFromString (str: string, decoder?: MultibaseDecoder<any>): Ed25519PeerId | Secp256k1PeerId | RSAPeerId | URLPeerId {
-  decoder = decoder ?? baseDecoder
-
-  if (str.charAt(0) === '1' || str.charAt(0) === 'Q') {
-    // identity hash ed25519/secp256k1 key or sha2-256 hash of
-    // rsa public key - base58btc encoded either way
-    const multihash = Digest.decode(base58btc.decode(`z${str}`))
-
-    if (str.startsWith('12D')) {
-      return new Ed25519PeerIdImpl({ multihash })
-    } else if (str.startsWith('16U')) {
-      return new Secp256k1PeerIdImpl({ multihash })
-    } else {
-      return new RSAPeerIdImpl({ multihash })
-    }
-  }
-
-  return peerIdFromBytes(baseDecoder.decode(str))
+export function peerIdFromPrivateKey (privateKey: Ed25519PrivateKey): Ed25519PeerId
+export function peerIdFromPrivateKey (privateKey: Secp256k1PrivateKey): Secp256k1PeerId
+export function peerIdFromPrivateKey (privateKey: RSAPrivateKey): RSAPeerId
+export function peerIdFromPrivateKey (privateKey: PrivateKey): PeerId
+export function peerIdFromPrivateKey (privateKey: PrivateKey): PeerId {
+  return peerIdFromPublicKey(privateKey.publicKey)
 }
 
-export function peerIdFromBytes (buf: Uint8Array): Ed25519PeerId | Secp256k1PeerId | RSAPeerId | URLPeerId {
-  try {
-    const multihash = Digest.decode(buf)
-
-    if (multihash.code === identity.code) {
-      if (multihash.digest.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
-        return new Ed25519PeerIdImpl({ multihash })
-      } else if (multihash.digest.length === MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH) {
-        return new Secp256k1PeerIdImpl({ multihash })
+export function peerIdFromMultihash (multihash: MultihashDigest): PeerId {
+  if (isSha256Multihash(multihash)) {
+    return new RSAPeerIdClass({ multihash })
+  } else if (isIdentityMultihash(multihash)) {
+    try {
+      const publicKey = publicKeyFromMultihash(multihash)
+
+      if (publicKey.type === 'Ed25519') {
+        return new Ed25519PeerIdClass({ multihash, publicKey })
+      } else if (publicKey.type === 'secp256k1') {
+        return new Secp256k1PeerIdClass({ multihash, publicKey })
       }
-    }
+    } catch (err) {
+      // was not Ed or secp key, try URL
+      const url = uint8ArrayToString(multihash.digest)
 
-    if (multihash.code === sha256.code) {
-      return new RSAPeerIdImpl({ multihash })
+      return new URLPeerIdClass(new URL(url))
     }
-  } catch {
-    return peerIdFromCID(CID.decode(buf))
   }
 
-  throw new Error('Supplied PeerID CID is invalid')
+  throw new InvalidMultihashError('Supplied PeerID Multihash is invalid')
 }
 
 export function peerIdFromCID (cid: CID): Ed25519PeerId | Secp256k1PeerId | RSAPeerId | URLPeerId {
   if (cid?.multihash == null || cid.version == null || (cid.version === 1 && (cid.code !== LIBP2P_KEY_CODE) && cid.code !== TRANSPORT_IPFS_GATEWAY_HTTP_CODE)) {
-    throw new Error('Supplied PeerID CID is invalid')
+    throw new InvalidCIDError('Supplied PeerID CID is invalid')
   }
 
   if (cid.code === TRANSPORT_IPFS_GATEWAY_HTTP_CODE) {
     const url = uint8ArrayToString(cid.multihash.digest)
 
-    return new URLPeerIdImpl(new URL(url))
-  }
-
-  const multihash = cid.multihash
-
-  if (multihash.code === sha256.code) {
-    return new RSAPeerIdImpl({ multihash: cid.multihash })
-  } else if (multihash.code === identity.code) {
-    if (multihash.digest.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
-      return new Ed25519PeerIdImpl({ multihash: cid.multihash })
-    } else if (multihash.digest.length === MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH) {
-      return new Secp256k1PeerIdImpl({ multihash: cid.multihash })
-    }
+    return new URLPeerIdClass(new URL(url))
   }
 
-  throw new Error('Supplied PeerID CID is invalid')
+  return peerIdFromMultihash(cid.multihash)
 }
 
-/**
- * @param publicKey - A marshalled public key
- * @param privateKey - A marshalled private key
- */
-export async function peerIdFromKeys (publicKey: Uint8Array, privateKey?: Uint8Array): Promise<Ed25519PeerId | Secp256k1PeerId | RSAPeerId> {
-  if (publicKey.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
-    return new Ed25519PeerIdImpl({ multihash: Digest.create(identity.code, publicKey), privateKey })
-  }
-
-  if (publicKey.length === MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH) {
-    return new Secp256k1PeerIdImpl({ multihash: Digest.create(identity.code, publicKey), privateKey })
-  }
+function isIdentityMultihash (multihash: MultihashDigest): multihash is MultihashDigest<0x0> {
+  return multihash.code === identity.code
+}
 
-  return new RSAPeerIdImpl({ multihash: await sha256.digest(publicKey), publicKey, privateKey })
+function isSha256Multihash (multihash: MultihashDigest): multihash is MultihashDigest<0x12> {
+  return multihash.code === sha256.code
 }

package/src/peer-id.ts

@@ -0,0 +1,213 @@
+/**
+ * @packageDocumentation
+ *
+ * An implementation of a peer id
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ * const peer = peerIdFromString('k51qzi5uqu5dkwkqm42v9j9kqcam2jiuvloi16g72i4i4amoo2m8u3ol3mqu6s')
+ *
+ * console.log(peer.toCID()) // CID(bafzaa...)
+ * console.log(peer.toString()) // "12D3K..."
+ * ```
+ */
+
+import { peerIdSymbol } from '@libp2p/interface'
+import { base58btc } from 'multiformats/bases/base58'
+import { CID } from 'multiformats/cid'
+import { identity } from 'multiformats/hashes/identity'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { Ed25519PeerId as Ed25519PeerIdInterface, PeerIdType, RSAPeerId as RSAPeerIdInterface, URLPeerId as URLPeerIdInterface, Secp256k1PeerId as Secp256k1PeerIdInterface, PeerId, PublicKey, Ed25519PublicKey, Secp256k1PublicKey, RSAPublicKey } from '@libp2p/interface'
+import type { MultihashDigest } from 'multiformats/hashes/interface'
+
+const inspect = Symbol.for('nodejs.util.inspect.custom')
+
+// these values are from https://github.com/multiformats/multicodec/blob/master/table.csv
+const LIBP2P_KEY_CODE = 0x72
+
+interface PeerIdInit <DigestCode extends number> {
+  type: PeerIdType
+  multihash: MultihashDigest<DigestCode>
+}
+
+interface RSAPeerIdInit {
+  multihash: MultihashDigest<0x12>
+  publicKey?: RSAPublicKey
+}
+
+interface Ed25519PeerIdInit {
+  multihash: MultihashDigest<0x0>
+  publicKey: Ed25519PublicKey
+}
+
+interface Secp256k1PeerIdInit {
+  multihash: MultihashDigest<0x0>
+  publicKey: Secp256k1PublicKey
+}
+
+class PeerIdImpl <DigestCode extends number> {
+  public type: PeerIdType
+  private readonly multihash: MultihashDigest<DigestCode>
+  public readonly publicKey?: PublicKey
+  private string?: string
+
+  constructor (init: PeerIdInit<DigestCode>) {
+    this.type = init.type
+    this.multihash = init.multihash
+
+    // mark string cache as non-enumerable
+    Object.defineProperty(this, 'string', {
+      enumerable: false,
+      writable: true
+    })
+  }
+
+  get [Symbol.toStringTag] (): string {
+    return `PeerId(${this.toString()})`
+  }
+
+  readonly [peerIdSymbol] = true
+
+  toString (): string {
+    if (this.string == null) {
+      this.string = base58btc.encode(this.multihash.bytes).slice(1)
+    }
+
+    return this.string
+  }
+
+  toMultihash (): MultihashDigest<DigestCode> {
+    return this.multihash
+  }
+
+  // return self-describing String representation
+  // in default format from RFC 0001: https://github.com/libp2p/specs/pull/209
+  toCID (): CID<Uint8Array, 0x72, DigestCode, 1> {
+    return CID.createV1(LIBP2P_KEY_CODE, this.multihash)
+  }
+
+  toJSON (): string {
+    return this.toString()
+  }
+
+  /**
+   * Checks the equality of `this` peer against a given PeerId
+   */
+  equals (id?: PeerId | Uint8Array | string): boolean {
+    if (id == null) {
+      return false
+    }
+
+    if (id instanceof Uint8Array) {
+      return uint8ArrayEquals(this.multihash.bytes, id)
+    } else if (typeof id === 'string') {
+      return this.toString() === id
+    } else if (id?.toMultihash()?.bytes != null) {
+      return uint8ArrayEquals(this.multihash.bytes, id.toMultihash().bytes)
+    } else {
+      throw new Error('not valid Id')
+    }
+  }
+
+  /**
+   * Returns PeerId as a human-readable string
+   * https://nodejs.org/api/util.html#utilinspectcustom
+   *
+   * @example
+   * ```TypeScript
+   * import { peerIdFromString } from '@libp2p/peer-id'
+   *
+   * console.info(peerIdFromString('QmFoo'))
+   * // 'PeerId(QmFoo)'
+   * ```
+   */
+  [inspect] (): string {
+    return `PeerId(${this.toString()})`
+  }
+}
+
+export class RSAPeerId extends PeerIdImpl<0x12> implements RSAPeerIdInterface {
+  public readonly type = 'RSA'
+  public readonly publicKey?: RSAPublicKey
+
+  constructor (init: RSAPeerIdInit) {
+    super({ ...init, type: 'RSA' })
+
+    this.publicKey = init.publicKey
+  }
+}
+
+export class Ed25519PeerId extends PeerIdImpl<0x0> implements Ed25519PeerIdInterface {
+  public readonly type = 'Ed25519'
+  public readonly publicKey: Ed25519PublicKey
+
+  constructor (init: Ed25519PeerIdInit) {
+    super({ ...init, type: 'Ed25519' })
+
+    this.publicKey = init.publicKey
+  }
+}
+
+export class Secp256k1PeerId extends PeerIdImpl<0x0> implements Secp256k1PeerIdInterface {
+  public readonly type = 'secp256k1'
+  public readonly publicKey: Secp256k1PublicKey
+
+  constructor (init: Secp256k1PeerIdInit) {
+    super({ ...init, type: 'secp256k1' })
+
+    this.publicKey = init.publicKey
+  }
+}
+
+// these values are from https://github.com/multiformats/multicodec/blob/master/table.csv
+const TRANSPORT_IPFS_GATEWAY_HTTP_CODE = 0x0920
+
+export class URLPeerId implements URLPeerIdInterface {
+  readonly type = 'url'
+  readonly multihash: MultihashDigest<0x0>
+  readonly publicKey: undefined
+  readonly url: string
+
+  constructor (url: URL) {
+    this.url = url.toString()
+    this.multihash = identity.digest(uint8ArrayFromString(this.url))
+  }
+
+  [inspect] (): string {
+    return `PeerId(${this.url})`
+  }
+
+  readonly [peerIdSymbol] = true
+
+  toString (): string {
+    return this.toCID().toString()
+  }
+
+  toMultihash (): MultihashDigest<0x0> {
+    return this.multihash
+  }
+
+  toCID (): CID<Uint8Array, 0x0920, 0x0, 1> {
+    return CID.createV1(TRANSPORT_IPFS_GATEWAY_HTTP_CODE, this.toMultihash())
+  }
+
+  toJSON (): string {
+    return this.toString()
+  }
+
+  equals (other?: PeerId | Uint8Array | string): boolean {
+    if (other == null) {
+      return false
+    }
+
+    if (other instanceof Uint8Array) {
+      other = uint8ArrayToString(other)
+    }
+
+    return other.toString() === this.toString()
+  }
+}

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "createPeerId": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.createPeerId.html",
-  ".:createPeerId": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.createPeerId.html",
-  "peerIdFromBytes": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromBytes.html",
-  ".:peerIdFromBytes": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromBytes.html",
-  "peerIdFromCID": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromCID.html",
-  ".:peerIdFromCID": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromCID.html",
-  "peerIdFromKeys": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromKeys.html",
-  ".:peerIdFromKeys": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromKeys.html",
-  "peerIdFromPeerId": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromPeerId.html",
-  ".:peerIdFromPeerId": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromPeerId.html",
-  "peerIdFromString": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromString.html",
-  ".:peerIdFromString": "https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_id.peerIdFromString.html"
-}