libp2p 0.44.0 → 0.45.0

package/src/index.ts

@@ -17,10 +17,7 @@
 import { createLibp2pNode } from './libp2p.js'
 import type { RecursivePartial } from '@libp2p/interfaces'
 import type { TransportManagerInit } from './transport-manager.js'
-import type { IdentifyServiceInit } from './identify/index.js'
-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 { PeerDiscovery } from '@libp2p/interface-peer-discovery'
 import type { ConnectionProtector } from '@libp2p/interface-connection'
@@ -30,25 +27,22 @@ import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
 import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { PubSub } from '@libp2p/interface-pubsub'
 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 { Libp2p, ServiceMap } from '@libp2p/interface-libp2p'
 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-relay/index.js'
+import type { PersistentPeerStoreInit } from '@libp2p/peer-store'
+
+export type ServiceFactoryMap<T extends Record<string, unknown> = Record<string, unknown>> = {
+  [Property in keyof T]: (components: Components) => T[Property]
+}
 
 /**
  * For Libp2p configurations and modules details read the [Configuration Document](./CONFIGURATION.md).
  */
-export interface Libp2pInit {
+export interface Libp2pInit<T extends ServiceMap = {}> {
   /**
    * peerId instance (it will be created if not provided)
    */
@@ -84,49 +78,13 @@ export interface Libp2pInit {
   /**
    * libp2p PeerStore configuration
    */
-  peerStore: PeerStoreInit
-
-  /**
-   * libp2p Peer routing service configuration
-   */
-  peerRouting: PeerRoutingInit
+  peerStore: PersistentPeerStoreInit
 
   /**
    * keychain configuration
    */
   keychain: KeyChainInit
 
-  /**
-   * The NAT manager controls uPNP hole punching
-   */
-  nat: NatManagerInit
-
-  /**
-   * If configured as a relay this node will relay certain
-   * types of traffic for other peers
-   */
-  relay: (components: Components) => CircuitRelayService
-
-  /**
-   * identify protocol options
-   */
-  identify: IdentifyServiceInit
-
-  /**
-   * ping protocol options
-   */
-  ping: PingServiceInit
-
-  /**
-   * fetch protocol options
-   */
-  fetch: FetchServiceInit
-
-  /**
-   * autonat protocol options
-   */
-  autonat: AutonatServiceInit
-
   /**
    * An array that must include at least 1 compliant transport
    */
@@ -137,47 +95,25 @@ export interface Libp2pInit {
   peerRouters?: Array<(components: Components) => PeerRouting>
   contentRouters?: Array<(components: Components) => ContentRouting>
 
-  /**
-   * Pass a DHT implementation to enable DHT operations
-   */
-  dht?: (components: Components) => DualDHT
-
   /**
    * A Metrics implementation can be supplied to collect metrics on this node
    */
   metrics?: (components: Components) => Metrics
 
-  /**
-   * If a PubSub implmentation is supplied, PubSub operations will become available
-   */
-  pubsub?: (components: Components) => PubSub
-
   /**
    * A ConnectionProtector can be used to create a secure overlay on top of the network using pre-shared keys
    */
   connectionProtector?: (components: Components) => ConnectionProtector
-}
 
-/**
- * Once you have a libp2p instance, you can listen to several events it emits, so that you can be notified of relevant network events.
- */
-export interface Libp2pEvents {
   /**
-   * @example
-   *
-   * ```js
-   * libp2p.addEventListener('peer:discovery', (event) => {
-   *    const peerInfo = event.detail
-   *    // ...
-   * })
-   * ```
+   * Arbitrary libp2p modules
    */
-  'peer:discovery': CustomEvent<PeerInfo>
+  services: ServiceFactoryMap<T>
 }
 
 export type { Libp2p }
 
-export type Libp2pOptions = RecursivePartial<Libp2pInit> & { start?: boolean }
+export type Libp2pOptions<T extends ServiceMap = {}> = RecursivePartial<Libp2pInit<T>> & { start?: boolean }
 
 /**
  * Returns a new instance of the Libp2p interface, generating a new PeerId
@@ -192,11 +128,12 @@ export type Libp2pOptions = RecursivePartial<Libp2pInit> & { start?: boolean }
  * import { tcp } from '@libp2p/tcp'
  * import { mplex } from '@libp2p/mplex'
  * import { noise } from '@chainsafe/libp2p-noise'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
  *
  * // specify options
  * const options = {
  *   transports: [tcp()],
- *   streamMuxers: [mplex()],
+ *   streamMuxers: [yamux(), mplex()],
  *   connectionEncryption: [noise()]
  * }
  *
@@ -204,7 +141,7 @@ export type Libp2pOptions = RecursivePartial<Libp2pInit> & { start?: boolean }
  * const libp2p = await createLibp2p(options)
  * ```
  */
-export async function createLibp2p (options: Libp2pOptions): Promise<Libp2p> {
+export async function createLibp2p <T extends ServiceMap = {}> (options: Libp2pOptions<T>): Promise<Libp2p<T>> {
   const node = await createLibp2pNode(options)
 
   if (options.start !== false) {

package/src/insecure/index.ts

@@ -30,7 +30,7 @@ import { Exchange, KeyType } from './pb/proto.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
-import type { Duplex } from 'it-stream-types'
+import type { Duplex, Source } from 'it-stream-types'
 import map from 'it-map'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -46,7 +46,7 @@ function lpEncodeExchange (exchange: Exchange): Uint8ArrayList {
 /**
  * Encrypt connection
  */
-async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: PeerId): Promise<SecuredConnection> {
+async function encrypt (localId: PeerId, conn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, remoteId?: PeerId): Promise<SecuredConnection> {
   const shake = handshake(conn)
 
   let type = KeyType.RSA
@@ -124,11 +124,11 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
 class Plaintext implements ConnectionEncrypter {
   public protocol: string = PROTOCOL
 
-  async secureInbound (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: PeerId): Promise<SecuredConnection> {
+  async secureInbound (localId: PeerId, conn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, remoteId?: PeerId): Promise<SecuredConnection> {
     return await encrypt(localId, conn, remoteId)
   }
 
-  async secureOutbound (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: PeerId): Promise<SecuredConnection> {
+  async secureOutbound (localId: PeerId, conn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, remoteId?: PeerId): Promise<SecuredConnection> {
     return await encrypt(localId, conn, remoteId)
   }
 }