libp2p 0.42.1-c6718b2e → 0.42.2

package/src/connection-manager/index.ts

@@ -12,14 +12,14 @@ import type { Connection, MultiaddrConnection } from '@libp2p/interface-connecti
 import type { ConnectionManager, ConnectionManagerEvents, Dialer } from '@libp2p/interface-connection-manager'
 import * as STATUS from '@libp2p/interface-connection/status'
 import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
-import { isMultiaddr, multiaddr, Multiaddr, Resolver } from '@multiformats/multiaddr'
+import { multiaddr, Multiaddr, Resolver } from '@multiformats/multiaddr'
 import { PeerMap } from '@libp2p/peer-collections'
 import { TimeoutController } from 'timeout-abort-controller'
 import { KEEP_ALIVE } from '@libp2p/interface-peer-store/tags'
 import { RateLimiterMemory } from 'rate-limiter-flexible'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { Upgrader } from '@libp2p/interface-transport'
-import { getPeer } from '../get-peer.js'
+import { getPeerAddress } from '../get-peer.js'
 
 const log = logger('libp2p:connection-manager')
 
@@ -471,24 +471,22 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   }
 
   async openConnection (peerIdOrMultiaddr: PeerId | Multiaddr, options: AbortOptions = {}): Promise<Connection> {
-    let peerId: PeerId
+    const { peerId, multiaddr } = getPeerAddress(peerIdOrMultiaddr)
 
-    if (isPeerId(peerIdOrMultiaddr)) {
-      peerId = peerIdOrMultiaddr
-    } else if (isMultiaddr(peerIdOrMultiaddr)) {
-      const info = getPeer(peerIdOrMultiaddr)
-      peerId = info.id
-    } else {
+    if (peerId == null && multiaddr == null) {
       throw errCode(new TypeError('Can only open connections to PeerIds or Multiaddrs'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    log('dial to %p', peerId)
-    const existingConnections = this.getConnections(peerId)
+    if (peerId != null) {
+      log('dial to', peerId)
+
+      const existingConnections = this.getConnections(peerId)
 
-    if (existingConnections.length > 0) {
-      log('had an existing connection to %p', peerId)
+      if (existingConnections.length > 0) {
+        log('had an existing connection to %p', peerId)
 
-      return existingConnections[0]
+        return existingConnections[0]
+      }
     }
 
     let timeoutController: TimeoutController | undefined
@@ -505,11 +503,11 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     try {
       const connection = await this.components.dialer.dial(peerIdOrMultiaddr, options)
-      let peerConnections = this.connections.get(peerId.toString())
+      let peerConnections = this.connections.get(connection.remotePeer.toString())
 
       if (peerConnections == null) {
         peerConnections = []
-        this.connections.set(peerId.toString(), peerConnections)
+        this.connections.set(connection.remotePeer.toString(), peerConnections)
       }
 
       // we get notified of connections via the Upgrader emitting "connection"

package/src/get-peer.ts

@@ -5,50 +5,28 @@ import errCode from 'err-code'
 import { codes } from './errors.js'
 import { isPeerId } from '@libp2p/interface-peer-id'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-
-function peerIdFromMultiaddr (ma: Multiaddr) {
-  const idStr = ma.getPeerId()
-
-  if (idStr == null) {
-    throw errCode(
-      new Error(`${ma.toString()} does not have a valid peer type`),
-      codes.ERR_INVALID_MULTIADDR
-    )
-  }
-
-  try {
-    return peerIdFromString(idStr)
-  } catch (err: any) {
-    throw errCode(
-      new Error(`${ma.toString()} is not a valid peer type`),
-      codes.ERR_INVALID_MULTIADDR
-    )
-  }
-}
 
 /**
- * Converts the given `peer` to a `PeerInfo` object.
+ * Extracts a PeerId and/or multiaddr from the passed PeerId or Multiaddr
  */
-export function getPeer (peer: PeerId | Multiaddr): PeerInfo {
+export function getPeerAddress (peer: PeerId | Multiaddr): { peerId?: PeerId, multiaddr?: Multiaddr } {
   if (isPeerId(peer)) {
     return {
-      id: peer,
-      multiaddrs: [],
-      protocols: []
+      peerId: peer
     }
   }
 
-  let addr
-
   if (isMultiaddr(peer)) {
-    addr = peer
-    peer = peerIdFromMultiaddr(peer)
-  }
+    const peerId = peer.getPeerId()
 
-  return {
-    id: peer,
-    multiaddrs: addr != null ? [addr] : [],
-    protocols: []
+    return {
+      multiaddr: peer,
+      peerId: peerId == null ? undefined : peerIdFromString(peerId)
+    }
   }
+
+  throw errCode(
+    new Error(`${peer} is not a PeerId or a Multiaddr`), // eslint-disable-line @typescript-eslint/restrict-template-expressions
+    codes.ERR_INVALID_MULTIADDR
+  )
 }

package/src/keychain/index.ts

@@ -14,6 +14,8 @@ import type { PeerId } from '@libp2p/interface-peer-id'
 import { pbkdf2, randomBytes } from '@libp2p/crypto'
 import type { Startable } from '@libp2p/interfaces/dist/src/startable'
 import type { Datastore } from 'interface-datastore'
+import { peerIdFromKeys } from '@libp2p/peer-id'
+import type { KeyTypes } from '@libp2p/crypto/keys'
 
 const log = logger('libp2p:keychain')
 
@@ -222,7 +224,7 @@ export class KeyChain implements Startable {
    * @param {string} type - One of the key types; 'rsa'.
    * @param {number} [size = 2048] - The key size in bits. Used for rsa keys only
    */
-  async createKey (name: string, type: 'RSA' | 'Ed25519', size = 2048): Promise<KeyInfo> {
+  async createKey (name: string, type: KeyTypes, size = 2048): Promise<KeyInfo> {
     if (!validateKeyName(name) || name === 'self') {
       await randomDelay()
       throw errCode(new Error('Invalid key name'), codes.ERR_INVALID_KEY_NAME)
@@ -432,6 +434,17 @@ export class KeyChain implements Startable {
     }
   }
 
+  /**
+   * Export an existing key as a PeerId
+   */
+  async exportPeerId (name: string) {
+    const password = 'temporary-password'
+    const pem = await this.exportKey(name, password)
+    const privateKey = await importKey(pem, password)
+
+    return await peerIdFromKeys(privateKey.public.bytes, privateKey.bytes)
+  }
+
   /**
    * Import a new key from a PEM encoded PKCS #8 string
    *

package/src/libp2p.ts

@@ -2,11 +2,10 @@ import { logger } from '@libp2p/logger'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
 import { Startable, isStartable } from '@libp2p/interfaces/startable'
-import type { Multiaddr } from '@multiformats/multiaddr'
+import { isMultiaddr, Multiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { DefaultPeerRouting } from './peer-routing.js'
 import { CompoundContentRouting } from './content-routing/index.js'
-import { getPeer } from './get-peer.js'
 import { codes } from './errors.js'
 import { DefaultAddressManager } from './address-manager/index.js'
 import { DefaultConnectionManager } from './connection-manager/index.js'
@@ -49,6 +48,8 @@ import { DummyDHT } from './dht/dummy-dht.js'
 import { DummyPubSub } from './pubsub/dummy-pubsub.js'
 import { PeerSet } from '@libp2p/peer-collections'
 import { DefaultDialer } from './connection-manager/dialer/index.js'
+import { peerIdFromString } from '@libp2p/peer-id'
+import type { Datastore } from 'interface-datastore'
 
 const log = logger('libp2p')
 
@@ -354,11 +355,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   }
 
   async dial (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<Connection> {
-    const { id, multiaddrs } = getPeer(peer)
-
-    await this.components.peerStore.addressBook.add(id, multiaddrs)
-
-    return await this.components.connectionManager.openConnection(id, options)
+    return await this.components.connectionManager.openConnection(peer, options)
   }
 
   async dialProtocol (peer: PeerId | Multiaddr, protocols: string | string[], options: AbortOptions = {}) {
@@ -386,9 +383,11 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   }
 
   async hangUp (peer: PeerId | Multiaddr): Promise<void> {
-    const { id } = getPeer(peer)
+    if (isMultiaddr(peer)) {
+      peer = peerIdFromString(peer.getPeerId() ?? '')
+    }
 
-    await this.components.connectionManager.closeConnections(id)
+    await this.components.connectionManager.closeConnections(peer)
   }
 
   /**
@@ -431,23 +430,23 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   }
 
   async fetch (peer: PeerId | Multiaddr, key: string, options: AbortOptions = {}): Promise<Uint8Array | null> {
-    const { id, multiaddrs } = getPeer(peer)
-
-    if (multiaddrs != null) {
-      await this.components.peerStore.addressBook.add(id, multiaddrs)
+    if (isMultiaddr(peer)) {
+      const peerId = peerIdFromString(peer.getPeerId() ?? '')
+      await this.components.peerStore.addressBook.add(peerId, [peer])
+      peer = peerId
     }
 
-    return await this.fetchService.fetch(id, key, options)
+    return await this.fetchService.fetch(peer, key, options)
   }
 
   async ping (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<number> {
-    const { id, multiaddrs } = getPeer(peer)
-
-    if (multiaddrs.length > 0) {
-      await this.components.peerStore.addressBook.add(id, multiaddrs)
+    if (isMultiaddr(peer)) {
+      const peerId = peerIdFromString(peer.getPeerId() ?? '')
+      await this.components.peerStore.addressBook.add(peerId, [peer])
+      peer = peerId
     }
 
-    return await this.pingService.ping(id, options)
+    return await this.pingService.ping(peer, options)
   }
 
   async handle (protocols: string | string[], handler: StreamHandler, options?: StreamHandlerOptions): Promise<void> {
@@ -512,6 +511,30 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
  */
 export async function createLibp2pNode (options: Libp2pOptions): Promise<Libp2pNode> {
   if (options.peerId == null) {
+    const datastore = options.datastore as Datastore | undefined
+
+    if (datastore != null) {
+      try {
+        // try load the peer id from the keychain
+        // @ts-expect-error missing the peer id property
+        const keyChain = new KeyChain({
+          datastore
+        }, {
+          ...KeyChain.generateOptions(),
+          ...(options.keychain ?? {})
+        })
+
+        options.peerId = await keyChain.exportPeerId('self')
+      } catch (err: any) {
+        if (err.code !== 'ERR_NOT_FOUND') {
+          throw err
+        }
+      }
+    }
+  }
+
+  if (options.peerId == null) {
+    // no peer id in the keychain, create a new peer id
     options.peerId = await createEd25519PeerId()
   }
 

package/src/upgrader.ts

@@ -250,18 +250,18 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    */
   async upgradeOutbound (maConn: MultiaddrConnection, opts?: UpgraderOptions): Promise<Connection> {
     const idStr = maConn.remoteAddr.getPeerId()
-    if (idStr == null) {
-      throw errCode(new Error('outbound connection must have a peer id'), codes.ERR_INVALID_MULTIADDR)
-    }
+    let remotePeerId: PeerId | undefined
 
-    const remotePeerId = peerIdFromString(idStr)
+    if (idStr != null) {
+      remotePeerId = peerIdFromString(idStr)
 
-    if (await this.components.connectionGater.denyOutboundConnection(remotePeerId, maConn)) {
-      throw errCode(new Error('The multiaddr connection is blocked by connectionGater.denyOutboundConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+      if (await this.components.connectionGater.denyOutboundConnection(remotePeerId, maConn)) {
+        throw errCode(new Error('The multiaddr connection is blocked by connectionGater.denyOutboundConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+      }
     }
 
     let encryptedConn
-    let remotePeer
+    let remotePeer: PeerId
     let upgradedConn
     let cryptoProtocol
     let muxerFactory
@@ -300,6 +300,10 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
           throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
         }
       } else {
+        if (remotePeerId == null) {
+          throw errCode(new Error('Encryption was skipped but no peer id was passed'), codes.ERR_INVALID_PEER)
+        }
+
         cryptoProtocol = 'native'
         remotePeer = remotePeerId
       }
@@ -593,7 +597,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * Attempts to encrypt the given `connection` with the provided connection encrypters.
    * The first `ConnectionEncrypter` module to succeed will be used
    */
-  async _encryptOutbound (connection: MultiaddrConnection, remotePeerId: PeerId): Promise<CryptoResult> {
+  async _encryptOutbound (connection: MultiaddrConnection, remotePeerId?: PeerId): Promise<CryptoResult> {
     const protocols = Array.from(this.connectionEncryption.keys())
     log('selecting outbound crypto protocol', protocols)
 

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.42.1-c6718b2e'
+export const version = '0.42.2'
 export const name = 'libp2p'