libp2p 0.42.2 → 0.43.0

package/src/identify/index.ts

@@ -1,10 +1,10 @@
 import { logger } from '@libp2p/logger'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { multiaddr, protocols } from '@multiformats/multiaddr'
+import { Multiaddr, multiaddr, protocols } from '@multiformats/multiaddr'
 import { Identify } from './pb/message.js'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import {
@@ -65,6 +65,7 @@ export interface IdentifyServiceInit {
 
   maxPushIncomingStreams: number
   maxPushOutgoingStreams: number
+  maxObservedAddresses?: number
 }
 
 export interface IdentifyServiceComponents {
@@ -112,7 +113,7 @@ export class IdentifyService implements Startable {
       const { peerId } = evt.detail
 
       if (this.components.peerId.equals(peerId)) {
-        void this.pushToPeerStore().catch(err => log.error(err))
+        void this.pushToPeerStore().catch(err => { log.error(err) })
       }
     })
 
@@ -121,16 +122,16 @@ export class IdentifyService implements Startable {
       const { peerId } = evt.detail
 
       if (this.components.peerId.equals(peerId)) {
-        void this.pushToPeerStore().catch(err => log.error(err))
+        void this.pushToPeerStore().catch(err => { log.error(err) })
       }
     })
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     if (this.started) {
       return
     }
@@ -158,7 +159,7 @@ export class IdentifyService implements Startable {
     this.started = true
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     await this.components.registrar.unhandle(this.identifyProtocolStr)
     await this.components.registrar.unhandle(this.identifyPushProtocolStr)
 
@@ -216,7 +217,7 @@ export class IdentifyService implements Startable {
   /**
    * Calls `push` on all peer connections
    */
-  async pushToPeerStore () {
+  async pushToPeerStore (): Promise<void> {
     // Do not try to push if we are not running
     if (!this.isStarted()) {
       return
@@ -272,13 +273,13 @@ export class IdentifyService implements Startable {
       )
 
       if (data == null) {
-        throw errCode(new Error('No data could be retrieved'), codes.ERR_CONNECTION_ENDED)
+        throw new CodeError('No data could be retrieved', codes.ERR_CONNECTION_ENDED)
       }
 
       try {
         return Identify.decode(data)
       } catch (err: any) {
-        throw errCode(err, codes.ERR_INVALID_MESSAGE)
+        throw new CodeError(String(err), codes.ERR_INVALID_MESSAGE)
       }
     } finally {
       if (timeoutController != null) {
@@ -310,17 +311,17 @@ export class IdentifyService implements Startable {
     } = message
 
     if (publicKey == null) {
-      throw errCode(new Error('public key was missing from identify message'), codes.ERR_MISSING_PUBLIC_KEY)
+      throw new CodeError('public key was missing from identify message', codes.ERR_MISSING_PUBLIC_KEY)
     }
 
     const id = await peerIdFromKeys(publicKey)
 
     if (!connection.remotePeer.equals(id)) {
-      throw errCode(new Error('identified peer does not match the expected peer'), codes.ERR_INVALID_PEER)
+      throw new CodeError('identified peer does not match the expected peer', codes.ERR_INVALID_PEER)
     }
 
     if (this.components.peerId.equals(id)) {
-      throw errCode(new Error('identified peer is our own peer id?'), codes.ERR_INVALID_PEER)
+      throw new CodeError('identified peer is our own peer id?', codes.ERR_INVALID_PEER)
     }
 
     // Get the observedAddr if there is one
@@ -333,7 +334,7 @@ export class IdentifyService implements Startable {
         const envelope = await RecordEnvelope.openAndCertify(signedPeerRecord, PeerRecord.DOMAIN)
 
         if (!envelope.peerId.equals(id)) {
-          throw errCode(new Error('identified peer does not match the expected peer'), codes.ERR_INVALID_PEER)
+          throw new CodeError('identified peer does not match the expected peer', codes.ERR_INVALID_PEER)
         }
 
         if (await this.components.peerStore.addressBook.consumePeerRecord(envelope)) {
@@ -378,17 +379,20 @@ export class IdentifyService implements Startable {
     }
 
     log('identify completed for peer %p and protocols %o', id, protocols)
+    log('our observed address is %s', cleanObservedAddr)
 
-    // TODO: Add and score our observed addr
-    log('received observed address of %s', cleanObservedAddr?.toString())
-    // this.components.addressManager.addObservedAddr(observedAddr)
+    if (cleanObservedAddr != null &&
+        this.components.addressManager.getObservedAddrs().length < (this.init.maxObservedAddresses ?? Infinity)) {
+      log('storing our observed address %s', cleanObservedAddr?.toString())
+      this.components.addressManager.addObservedAddr(cleanObservedAddr)
+    }
   }
 
   /**
    * Sends the `Identify` response with the Signed Peer Record
    * to the requesting peer over the given `connection`
    */
-  async _handleIdentify (data: IncomingStreamData) {
+  async _handleIdentify (data: IncomingStreamData): Promise<void> {
     const { connection, stream } = data
     const timeoutController = new TimeoutController(this.init.timeout)
 
@@ -440,7 +444,7 @@ export class IdentifyService implements Startable {
   /**
    * Reads the Identify Push message from the given `connection`
    */
-  async _handlePush (data: IncomingStreamData) {
+  async _handlePush (data: IncomingStreamData): Promise<void> {
     const { connection, stream } = data
     const timeoutController = new TimeoutController(this.init.timeout)
 
@@ -467,14 +471,16 @@ export class IdentifyService implements Startable {
         message = Identify.decode(data)
       }
     } catch (err: any) {
-      return log.error('received invalid message', err)
+      log.error('received invalid message', err)
+      return
     } finally {
       stream.close()
       timeoutController.clear()
     }
 
     if (message == null) {
-      return log.error('received invalid message')
+      log.error('received invalid message')
+      return
     }
 
     const id = connection.remotePeer
@@ -509,8 +515,7 @@ export class IdentifyService implements Startable {
 
     // LEGACY: Update peers data in PeerStore
     try {
-      await this.components.peerStore.addressBook.set(id,
-        message.listenAddrs.map((addr) => multiaddr(addr)))
+      await this.components.peerStore.addressBook.set(id, message.listenAddrs.map((addr) => multiaddr(addr)))
     } catch (err: any) {
       log.error('received invalid addrs', err)
     }
@@ -528,7 +533,7 @@ export class IdentifyService implements Startable {
   /**
    * Takes the `addr` and converts it to a Multiaddr if possible
    */
-  static getCleanMultiaddr (addr: Uint8Array | string | null | undefined) {
+  static getCleanMultiaddr (addr: Uint8Array | string | null | undefined): Multiaddr | undefined {
     if (addr != null && addr.length > 0) {
       try {
         return multiaddr(addr)

package/src/identify/pb/message.ts

@@ -2,10 +2,11 @@
 /* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 
 import { encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Identify {
   protocolVersion?: string
@@ -115,7 +116,7 @@ export namespace Identify {
     return _codec
   }
 
-  export const encode = (obj: Identify): Uint8Array => {
+  export const encode = (obj: Partial<Identify>): Uint8Array => {
     return encodeMessage(obj, Identify.codec())
   }
 

package/src/index.ts

@@ -22,9 +22,9 @@ import type { DualDHT } from '@libp2p/interface-dht'
 import type { Datastore } from 'interface-datastore'
 import type { PeerStoreInit } from '@libp2p/interface-peer-store'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { RelayConfig } from './circuit/index.js'
 import type { PeerDiscovery } from '@libp2p/interface-peer-discovery'
-import type { ConnectionGater, ConnectionProtector } from '@libp2p/interface-connection'
+import type { ConnectionProtector } from '@libp2p/interface-connection'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 import type { Transport } from '@libp2p/interface-transport'
 import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
 import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
@@ -35,13 +35,15 @@ import type { Metrics } from '@libp2p/interface-metrics'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { PingServiceInit } from './ping/index.js'
 import type { FetchServiceInit } from './fetch/index.js'
+import type { AutonatServiceInit } from './autonat/index.js'
 import type { Components } from './components.js'
 import type { Libp2p } from '@libp2p/interface-libp2p'
-import type { KeyChainInit } from './keychain/index.js'
+import type { KeyChainInit } from '@libp2p/keychain'
 import type { NatManagerInit } from './nat-manager.js'
 import type { AddressManagerInit } from './address-manager/index.js'
 import type { PeerRoutingInit } from './peer-routing.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
+import type { CircuitRelayService } from './circuit/index.js'
 
 /**
  * For Libp2p configurations and modules details read the [Configuration Document](./CONFIGURATION.md).
@@ -65,7 +67,7 @@ export interface Libp2pInit {
   /**
    * A connection gater can deny new connections based on user criteria
    */
-  connectionGater: Partial<ConnectionGater>
+  connectionGater: ConnectionGater
 
   /**
    * libp2p transport manager configuration
@@ -103,23 +105,28 @@ export interface Libp2pInit {
    * If configured as a relay this node will relay certain
    * types of traffic for other peers
    */
-  relay: RelayConfig
+  relay: (components: Components) => CircuitRelayService
 
   /**
-   * libp2p identify protocol options
+   * identify protocol options
    */
   identify: IdentifyServiceInit
 
   /**
-   * libp2p ping protocol options
+   * ping protocol options
    */
   ping: PingServiceInit
 
   /**
-   * libp2p fetch protocol options
+   * fetch protocol options
    */
   fetch: FetchServiceInit
 
+  /**
+   * autonat protocol options
+   */
+  autonat: AutonatServiceInit
+
   /**
    * An array that must include at least 1 compliant transport
    */

package/src/insecure/index.ts

@@ -32,11 +32,12 @@ import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
 import type { Duplex } from 'it-stream-types'
 import map from 'it-map'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 const log = logger('libp2p:plaintext')
 const PROTOCOL = '/plaintext/2.0.0'
 
-function lpEncodeExchange (exchange: Exchange) {
+function lpEncodeExchange (exchange: Exchange): Uint8ArrayList {
   const pb = Exchange.encode(exchange)
 
   return lp.encode.single(pb)

package/src/insecure/pb/proto.ts

@@ -2,10 +2,11 @@
 /* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 
 import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
-import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Exchange {
   id?: Uint8Array
@@ -29,9 +30,7 @@ export namespace Exchange {
 
         if (obj.pubkey != null) {
           w.uint32(18)
-          PublicKey.codec().encode(obj.pubkey, w, {
-            writeDefaults: false
-          })
+          PublicKey.codec().encode(obj.pubkey, w)
         }
 
         if (opts.lengthDelimited !== false) {
@@ -65,7 +64,7 @@ export namespace Exchange {
     return _codec
   }
 
-  export const encode = (obj: Exchange): Uint8Array => {
+  export const encode = (obj: Partial<Exchange>): Uint8Array => {
     return encodeMessage(obj, Exchange.codec())
   }
 
@@ -89,7 +88,7 @@ enum __KeyTypeValues {
 }
 
 export namespace KeyType {
-  export const codec = () => {
+  export const codec = (): Codec<KeyType> => {
     return enumeration<KeyType>(__KeyTypeValues)
   }
 }
@@ -108,12 +107,12 @@ export namespace PublicKey {
           w.fork()
         }
 
-        if (opts.writeDefaults === true || (obj.Type != null && __KeyTypeValues[obj.Type] !== 0)) {
+        if (obj.Type != null && __KeyTypeValues[obj.Type] !== 0) {
           w.uint32(8)
           KeyType.codec().encode(obj.Type, w)
         }
 
-        if (opts.writeDefaults === true || (obj.Data != null && obj.Data.byteLength > 0)) {
+        if ((obj.Data != null && obj.Data.byteLength > 0)) {
           w.uint32(18)
           w.bytes(obj.Data)
         }
@@ -152,7 +151,7 @@ export namespace PublicKey {
     return _codec
   }
 
-  export const encode = (obj: PublicKey): Uint8Array => {
+  export const encode = (obj: Partial<PublicKey>): Uint8Array => {
     return encodeMessage(obj, PublicKey.codec())
   }
 

package/src/libp2p.ts

@@ -10,9 +10,7 @@ import { codes } from './errors.js'
 import { DefaultAddressManager } from './address-manager/index.js'
 import { DefaultConnectionManager } from './connection-manager/index.js'
 import { AutoDialler } from './connection-manager/auto-dialler.js'
-import { Circuit } from './circuit/transport.js'
-import { Relay } from './circuit/index.js'
-import { KeyChain } from './keychain/index.js'
+import { DefaultKeyChain } from '@libp2p/keychain'
 import { DefaultTransportManager } from './transport-manager.js'
 import { DefaultUpgrader } from './upgrader.js'
 import { DefaultRegistrar } from './registrar.js'
@@ -24,10 +22,11 @@ import { PeerRecordUpdater } from './peer-record-updater.js'
 import { DHTPeerRouting } from './dht/dht-peer-routing.js'
 import { PersistentPeerStore } from '@libp2p/peer-store'
 import { DHTContentRouting } from './dht/dht-content-routing.js'
+import { AutonatService } from './autonat/index.js'
 import { DefaultComponents } from './components.js'
 import type { Components } from './components.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Connection } from '@libp2p/interface-connection'
+import type { Connection, Stream } from '@libp2p/interface-connection'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { PubSub } from '@libp2p/interface-pubsub'
@@ -41,7 +40,7 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { DualDHT } from '@libp2p/interface-dht'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { unmarshalPublicKey } from '@libp2p/crypto/keys'
 import type { Metrics } from '@libp2p/interface-metrics'
 import { DummyDHT } from './dht/dummy-dht.js'
@@ -50,6 +49,9 @@ 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'
+import type { KeyChain } from '@libp2p/interface-keychain'
+import mergeOptions from 'merge-options'
+import type { CircuitRelayService } from './circuit/index.js'
 
 const log = logger('libp2p')
 
@@ -58,8 +60,10 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   public dht: DualDHT
   public pubsub: PubSub
   public identifyService: IdentifyService
+  public circuitService?: CircuitRelayService
   public fetchService: FetchService
   public pingService: PingService
+  public autonatService: AutonatService
   public components: Components
   public peerStore: PeerStore
   public contentRouting: ContentRouting
@@ -153,15 +157,9 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     // update our peer record when addresses change
     this.configureComponent(new PeerRecordUpdater(this.components))
 
-    this.configureComponent(new AutoDialler(this.components, {
-      enabled: init.connectionManager.autoDial,
-      minConnections: init.connectionManager.minConnections,
-      autoDialInterval: init.connectionManager.autoDialInterval
-    }))
-
     // Create keychain
-    const keychainOpts = KeyChain.generateOptions()
-    this.keychain = this.configureComponent(new KeyChain(this.components, {
+    const keychainOpts = DefaultKeyChain.generateOptions()
+    this.keychain = this.configureComponent(new DefaultKeyChain(this.components, {
       ...keychainOpts,
       ...init.keychain
     }))
@@ -169,10 +167,6 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     // Create the Nat Manager
     this.services.push(new NatManager(this.components, init.nat))
 
-    init.transports.forEach((fn) => {
-      this.components.transportManager.add(this.configureComponent(fn(this.components)))
-    })
-
     // Add the identify service
     this.identifyService = new IdentifyService(this.components, {
       ...init.identify
@@ -224,15 +218,6 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       routers: contentRouters
     }))
 
-    if (init.relay.enabled) {
-      this.components.transportManager.add(this.configureComponent(new Circuit(this.components, init.relay)))
-
-      this.configureComponent(new Relay(this.components, {
-        addressSorter: init.connectionManager.addressSorter,
-        ...init.relay
-      }))
-    }
-
     this.fetchService = this.configureComponent(new FetchService(this.components, {
       ...init.fetch
     }))
@@ -241,6 +226,19 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       ...init.ping
     }))
 
+    this.autonatService = this.configureComponent(new AutonatService(this.components, {
+      ...init.autonat
+    }))
+
+    this.configureComponent(new AutoDialler(this.components, {
+      minConnections: init.connectionManager.minConnections,
+      autoDialInterval: init.connectionManager.autoDialInterval
+    }))
+
+    if (init.relay != null) {
+      this.circuitService = this.configureComponent(init.relay(this.components))
+    }
+
     // Discovery modules
     for (const fn of init.peerDiscovery ?? []) {
       const service = this.configureComponent(fn(this.components))
@@ -249,6 +247,11 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
         this.onDiscoveryPeer(evt)
       })
     }
+
+    // Transport modules
+    init.transports.forEach((fn) => {
+      this.components.transportManager.add(this.configureComponent(fn(this.components)))
+    })
   }
 
   private configureComponent <T> (component: T): T {
@@ -262,7 +265,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   /**
    * Starts the libp2p node and all its subsystems
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.started) {
       return
     }
@@ -271,6 +274,13 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
     log('libp2p is starting')
 
+    const keys = await this.keychain.listKeys()
+
+    if (keys.find(key => key.name === 'self') == null) {
+      log('importing self key into keychain')
+      await this.keychain.importPeer('self', this.components.peerId)
+    }
+
     try {
       await Promise.all(
         this.services.map(async service => {
@@ -282,7 +292,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
       // start any startables
       await Promise.all(
-        this.services.map(service => service.start())
+        this.services.map(async service => { await service.start() })
       )
 
       await Promise.all(
@@ -304,7 +314,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   /**
    * Stop the libp2p node by closing its listeners and open connections
    */
-  async stop () {
+  async stop (): Promise<void> {
     if (!this.started) {
       return
     }
@@ -322,7 +332,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     )
 
     await Promise.all(
-      this.services.map(service => service.stop())
+      this.services.map(async service => { await service.stop() })
     )
 
     await Promise.all(
@@ -336,7 +346,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     log('libp2p has stopped')
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
@@ -358,15 +368,15 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     return await this.components.connectionManager.openConnection(peer, options)
   }
 
-  async dialProtocol (peer: PeerId | Multiaddr, protocols: string | string[], options: AbortOptions = {}) {
+  async dialProtocol (peer: PeerId | Multiaddr, protocols: string | string[], options: AbortOptions = {}): Promise<Stream> {
     if (protocols == null) {
-      throw errCode(new Error('no protocols were provided to open a stream'), codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
+      throw new CodeError('no protocols were provided to open a stream', codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
     }
 
     protocols = Array.isArray(protocols) ? protocols : [protocols]
 
     if (protocols.length === 0) {
-      throw errCode(new Error('no protocols were provided to open a stream'), codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
+      throw new CodeError('no protocols were provided to open a stream', codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
     }
 
     const connection = await this.dial(peer, options)
@@ -407,7 +417,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     }
 
     if (this.dht == null) {
-      throw errCode(new Error('Public key was not in the peer store and the DHT is not enabled'), codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new CodeError('Public key was not in the peer store and the DHT is not enabled', codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     const peerKey = uint8ArrayConcat([
@@ -426,7 +436,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       }
     }
 
-    throw errCode(new Error(`Node not responding with its public key: ${peer.toString()}`), codes.ERR_INVALID_RECORD)
+    throw new CodeError(`Node not responding with its public key: ${peer.toString()}`, codes.ERR_INVALID_RECORD)
   }
 
   async fetch (peer: PeerId | Multiaddr, key: string, options: AbortOptions = {}): Promise<Uint8Array | null> {
@@ -477,7 +487,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     return await this.registrar.register(protocol, topology)
   }
 
-  unregister (id: string) {
+  unregister (id: string): void {
     this.registrar.unregister(id)
   }
 
@@ -485,7 +495,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
    * Called whenever peer discovery services emit `peer` events.
    * Known peers may be emitted.
    */
-  onDiscoveryPeer (evt: CustomEvent<PeerInfo>) {
+  onDiscoveryPeer (evt: CustomEvent<PeerInfo>): void {
     const { detail: peer } = evt
 
     if (peer.id.toString() === this.peerId.toString()) {
@@ -494,11 +504,11 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     }
 
     if (peer.multiaddrs.length > 0) {
-      void this.components.peerStore.addressBook.add(peer.id, peer.multiaddrs).catch(err => log.error(err))
+      void this.components.peerStore.addressBook.add(peer.id, peer.multiaddrs).catch(err => { log.error(err) })
     }
 
     if (peer.protocols.length > 0) {
-      void this.components.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => log.error(err))
+      void this.components.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => { log.error(err) })
     }
 
     this.dispatchEvent(new CustomEvent<PeerInfo>('peer:discovery', { detail: peer }))
@@ -516,13 +526,9 @@ export async function createLibp2pNode (options: Libp2pOptions): Promise<Libp2pN
     if (datastore != null) {
       try {
         // try load the peer id from the keychain
-        // @ts-expect-error missing the peer id property
-        const keyChain = new KeyChain({
+        const keyChain = new DefaultKeyChain({
           datastore
-        }, {
-          ...KeyChain.generateOptions(),
-          ...(options.keychain ?? {})
-        })
+        }, mergeOptions(DefaultKeyChain.generateOptions(), options.keychain))
 
         options.peerId = await keyChain.exportPeerId('self')
       } catch (err: any) {