@helia/libp2p 0.0.0

package/src/index.ts

@@ -0,0 +1,103 @@
+/**
+ * @packageDocumentation
+ *
+ * Adds libp2p functionality to Helia
+ *
+ * @example
+ *
+ * ```ts
+ * import { createHelia } from 'helia'
+ * import { withLibp2p } from '@helia/libp2p'
+ *
+ * const node = await withLibp2p(createHelia()).start()
+ *
+ * console.info(node.libp2p.peerId) // 12D3Koo...
+ * ```
+ */
+
+import { NotStartedError } from '@libp2p/interface'
+import { isLibp2p } from 'libp2p'
+import { libp2pRouting } from './routing.ts'
+import { createLibp2p } from './utils/libp2p.ts'
+import type { DefaultLibp2pServices } from './utils/libp2p-defaults.ts'
+import type { CreateLibp2pOptions } from './utils/libp2p.ts'
+import type { Helia, HeliaMixin } from '@helia/interface'
+import type { Libp2p, ServiceMap } from '@libp2p/interface'
+
+export { libp2pDefaults } from './utils/libp2p-defaults.ts'
+export type { DefaultLibp2pServices } from './utils/libp2p-defaults.ts'
+export type { CreateLibp2pOptions }
+
+export interface HeliaWithLibp2p<M extends ServiceMap = DefaultLibp2pServices> extends Helia {
+  /**
+   * Libp2p provides a peer identity and a networking layer
+   */
+  libp2p: Libp2p<M>
+}
+
+async function getLibp2p <H extends Helia, M extends ServiceMap = ServiceMap> (helia: H, opts?: CreateLibp2pOptions<M>): Promise<Libp2p<M>> {
+  if (isLibp2p(opts)) {
+    return opts as any
+  }
+
+  return createLibp2p(helia, {
+    ...opts,
+    dns: helia.dns,
+    logger: helia.logger,
+    datastore: helia.datastore
+  })
+}
+
+/**
+ * Return a Helia node augmented with a libp2p instance
+ */
+export function withLibp2p <H extends Helia, M extends ServiceMap = ServiceMap, L extends Libp2p = Libp2p<M>> (helia: H, opts: L): HeliaWithLibp2p<M>
+export function withLibp2p <H extends Helia, M extends ServiceMap = ServiceMap> (helia: H, opts?: CreateLibp2pOptions<M>): HeliaWithLibp2p<M>
+export function withLibp2p <H extends Helia, M extends ServiceMap = ServiceMap> (helia: H, opts?: CreateLibp2pOptions<M>): HeliaWithLibp2p {
+  let libp2p: any
+
+  // add a getter that informs the user they need to start Helia
+  Object.defineProperty(helia, 'libp2p', {
+    configurable: true,
+    enumerable: true,
+    get () {
+      if (libp2p != null) {
+        return libp2p
+      }
+
+      throw new NotStartedError()
+    }
+  })
+
+  const mixin: HeliaMixin<H & { libp2p?: Libp2p<M> }, H & { libp2p?: Libp2p<M> }> = {
+    start: async (helia) => {
+      if (libp2p == null) {
+        libp2p = await getLibp2p(helia, opts)
+      }
+
+      try {
+        if (!helia.hasRouter('libp2p-router')) {
+          helia.addRouter(libp2pRouting(libp2p))
+        }
+
+        if (isLibp2p(helia.libp2p)) {
+          // already configured libp2p
+          await helia.libp2p.start()
+        }
+      } catch (err: any) {
+        if (err.name !== 'NotStartedError') {
+          throw err
+        }
+      }
+    },
+
+    stop: async () => {
+      await libp2p?.stop()
+    }
+  }
+
+  helia.addMixin(mixin)
+
+  // @ts-expect-error libp2p property is missing, even though we just defined it
+  return helia
+}

package/src/routing.ts

@@ -0,0 +1,60 @@
+import { peerIdFromCID } from '@libp2p/peer-id'
+import map from 'it-map'
+import type { Peer, Provider, Router, RoutingOptions } from '@helia/interface'
+import type { Libp2p, PeerInfo } from '@libp2p/interface'
+import type { CID } from 'multiformats'
+
+function peerInfoToPeer (info: PeerInfo): Peer {
+  return {
+    ...info,
+    id: info.id.toCID()
+  }
+}
+
+class Libp2pRouter implements Router {
+  public readonly name = 'libp2p-router'
+  private readonly libp2p: Libp2p
+
+  constructor (libp2p: Libp2p) {
+    this.libp2p = libp2p
+  }
+
+  async provide (cid: CID, options?: RoutingOptions): Promise<void> {
+    await this.libp2p.contentRouting.provide(cid, options)
+  }
+
+  async cancelReprovide (key: CID, options?: RoutingOptions): Promise<void> {
+    await this.libp2p.contentRouting.cancelReprovide(key, options)
+  }
+
+  async * findProviders (cid: CID, options?: RoutingOptions): AsyncIterable<Provider> {
+    yield * map(this.libp2p.contentRouting.findProviders(cid, options), prov => ({
+      routing: this.name,
+      ...peerInfoToPeer(prov)
+    }))
+  }
+
+  async put (key: Uint8Array, value: Uint8Array, options?: RoutingOptions): Promise<void> {
+    await this.libp2p.contentRouting.put(key, value, options)
+  }
+
+  async get (key: Uint8Array, options?: RoutingOptions): Promise<Uint8Array> {
+    return this.libp2p.contentRouting.get(key, options)
+  }
+
+  async findPeer (peerId: CID, options?: RoutingOptions): Promise<Peer> {
+    return peerInfoToPeer(await this.libp2p.peerRouting.findPeer(peerIdFromCID(peerId), options))
+  }
+
+  async * getClosestPeers (key: Uint8Array, options?: RoutingOptions): AsyncIterable<Peer> {
+    yield * map(this.libp2p.peerRouting.getClosestPeers(key, options), peerInfoToPeer)
+  }
+
+  toString (): string {
+    return 'Libp2pRouter()'
+  }
+}
+
+export function libp2pRouting (libp2p: Libp2p): Router {
+  return new Libp2pRouter(libp2p)
+}

package/src/utils/bootstrappers.ts

@@ -0,0 +1,12 @@
+// this list comes from https://github.com/ipfs/kubo/blob/da28fbc65a2e0f1ce59f9923823326ae2bc4f713/config/bootstrap_peers.go#L17
+export const bootstrapConfig = {
+  list: [
+    '/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN',
+    '/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb',
+    '/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt',
+    // va1 is not in the TXT records for _dnsaddr.bootstrap.libp2p.io yet
+    // so use the host name directly
+    '/dnsaddr/va1.bootstrap.libp2p.io/p2p/12D3KooWKnDdG3iXw9eTFijk3EWSunZcFi54Zka4wmtqtt6rPxc8',
+    '/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ'
+  ]
+}

package/src/utils/libp2p-defaults.browser.ts

@@ -0,0 +1,85 @@
+import { noise } from '@chainsafe/libp2p-noise'
+import { yamux } from '@chainsafe/libp2p-yamux'
+import { delegatedHTTPRoutingDefaults } from '@helia/delegated-routing-client'
+import { delegatedRoutingV1HttpApiClientContentRouting, delegatedRoutingV1HttpApiClientPeerRouting } from '@helia/delegated-routing-v1-http-api-client'
+import { autoNAT } from '@libp2p/autonat'
+import { bootstrap } from '@libp2p/bootstrap'
+import { circuitRelayTransport } from '@libp2p/circuit-relay-v2'
+import { dcutr } from '@libp2p/dcutr'
+import { http } from '@libp2p/http'
+import { identify, identifyPush } from '@libp2p/identify'
+import { kadDHT } from '@libp2p/kad-dht'
+import { mplex } from '@libp2p/mplex'
+import { ping } from '@libp2p/ping'
+import { webRTC, webRTCDirect } from '@libp2p/webrtc'
+import { webSockets } from '@libp2p/websockets'
+import { userAgent } from 'libp2p/user-agent'
+import { bootstrapConfig } from './bootstrappers.ts'
+import type { Libp2pDefaultsOptions } from './libp2p.ts'
+import type { HTTP } from '@libp2p/http'
+import type { Identify } from '@libp2p/identify'
+import type { KadDHT } from '@libp2p/kad-dht'
+import type { Ping } from '@libp2p/ping'
+import type { Libp2pOptions } from 'libp2p'
+
+export interface DefaultLibp2pServices extends Record<string, unknown> {
+  autoNAT: unknown
+  dcutr: unknown
+  delegatedContentRouting: unknown
+  delegatedPeerRouting: unknown
+  dht: KadDHT
+  identify: Identify
+  ping: Ping
+  http: HTTP
+}
+
+export function libp2pDefaults (options: Libp2pDefaultsOptions = {}): Libp2pOptions<DefaultLibp2pServices> & Required<Pick<Libp2pOptions<DefaultLibp2pServices>, 'services'>> {
+  let agentVersion: string | undefined
+
+  if (options.name != null && options.version != null) {
+    agentVersion = `${options.name}/${options.version} ${userAgent()}`
+  }
+
+  return {
+    privateKey: options.privateKey,
+    dns: options.dns,
+    nodeInfo: {
+      userAgent: agentVersion
+    },
+    addresses: {
+      listen: [
+        '/p2p-circuit',
+        '/webrtc'
+      ]
+    },
+    transports: [
+      circuitRelayTransport(),
+      webRTC(),
+      webRTCDirect(),
+      webSockets()
+    ],
+    connectionEncrypters: [
+      noise()
+    ],
+    streamMuxers: [
+      yamux(),
+      mplex()
+    ],
+    peerDiscovery: [
+      bootstrap(bootstrapConfig)
+    ],
+    services: {
+      autoNAT: autoNAT(),
+      dcutr: dcutr(),
+      delegatedContentRouting: delegatedRoutingV1HttpApiClientContentRouting(delegatedHTTPRoutingDefaults()),
+      delegatedPeerRouting: delegatedRoutingV1HttpApiClientPeerRouting(delegatedHTTPRoutingDefaults()),
+      dht: kadDHT({
+        clientMode: true
+      }),
+      identify: identify(),
+      identifyPush: identifyPush(),
+      ping: ping(),
+      http: http()
+    }
+  }
+}

package/src/utils/libp2p-defaults.ts

@@ -0,0 +1,133 @@
+import { noise } from '@chainsafe/libp2p-noise'
+import { yamux } from '@chainsafe/libp2p-yamux'
+import { delegatedHTTPRoutingDefaults } from '@helia/delegated-routing-client'
+import { delegatedRoutingV1HttpApiClientContentRouting, delegatedRoutingV1HttpApiClientPeerRouting } from '@helia/delegated-routing-v1-http-api-client'
+import { autoTLS } from '@ipshipyard/libp2p-auto-tls'
+import { autoNAT } from '@libp2p/autonat'
+import { bootstrap } from '@libp2p/bootstrap'
+import { circuitRelayTransport, circuitRelayServer } from '@libp2p/circuit-relay-v2'
+import { dcutr } from '@libp2p/dcutr'
+import { http } from '@libp2p/http'
+import { identify, identifyPush } from '@libp2p/identify'
+import { kadDHT } from '@libp2p/kad-dht'
+import { keychain } from '@libp2p/keychain'
+import { mdns } from '@libp2p/mdns'
+import { mplex } from '@libp2p/mplex'
+import { ping } from '@libp2p/ping'
+import { tcp } from '@libp2p/tcp'
+import { tls } from '@libp2p/tls'
+import { uPnPNAT } from '@libp2p/upnp-nat'
+import { webRTC, webRTCDirect } from '@libp2p/webrtc'
+import { webSockets } from '@libp2p/websockets'
+import { userAgent } from 'libp2p/user-agent'
+import { bootstrapConfig } from './bootstrappers.ts'
+import type { Libp2pDefaultsOptions } from './libp2p.ts'
+import type { AutoTLS } from '@ipshipyard/libp2p-auto-tls'
+import type { CircuitRelayService } from '@libp2p/circuit-relay-v2'
+import type { HTTP } from '@libp2p/http'
+import type { Identify } from '@libp2p/identify'
+import type { KadDHT } from '@libp2p/kad-dht'
+import type { Keychain } from '@libp2p/keychain'
+import type { Ping } from '@libp2p/ping'
+import type { Libp2pOptions } from 'libp2p'
+
+export interface DefaultLibp2pServices extends Record<string, unknown> {
+  autoNAT: unknown
+  autoTLS: AutoTLS
+  dcutr: unknown
+  delegatedContentRouting: unknown
+  delegatedPeerRouting: unknown
+  dht: KadDHT
+  identify: Identify
+  keychain: Keychain
+  ping: Ping
+  relay: CircuitRelayService
+  upnp: unknown
+  http: HTTP
+}
+
+/**
+ * Returns the default libp2p config used by Helia which can then be modified or
+ * extended to suit individual applications.
+ *
+ * @example Adding an additional libp2p service
+ *
+ * ```ts
+ * import { myService } from '@example/my-service'
+ * import { createHelia, libp2pDefaults } from 'helia'
+ *
+ * // get a copy of the default libp2p config
+ * const libp2p = libp2pDefaults()
+ *
+ * // add the custom service to the service map
+ * libp2p.services.myService = myService()
+ *
+ * // create a Helia node with the custom libp2p config
+ * const helia = await createHelia({
+ *   libp2p
+ * })
+ *
+ * //... use service
+ * helia.libp2p.services.myService.serviceMethod()
+ * ```
+ */
+export function libp2pDefaults (options: Libp2pDefaultsOptions = {}): Libp2pOptions<DefaultLibp2pServices> & Required<Pick<Libp2pOptions<DefaultLibp2pServices>, 'services'>> {
+  let agentVersion: string | undefined
+
+  if (options.name != null && options.version != null) {
+    agentVersion = `${options.name}/${options.version} ${userAgent()}`
+  }
+
+  return {
+    privateKey: options.privateKey,
+    dns: options.dns,
+    nodeInfo: {
+      userAgent: agentVersion
+    },
+    addresses: {
+      listen: [
+        '/ip4/0.0.0.0/tcp/0',
+        '/ip4/0.0.0.0/tcp/0/ws',
+        '/ip4/0.0.0.0/udp/0/webrtc-direct',
+        '/ip6/::/tcp/0',
+        '/ip6/::/tcp/0/ws',
+        '/ip6/::/udp/0/webrtc-direct',
+        '/p2p-circuit'
+      ]
+    },
+    transports: [
+      circuitRelayTransport(),
+      tcp(),
+      webRTC(),
+      webRTCDirect(),
+      webSockets()
+    ],
+    connectionEncrypters: [
+      noise(),
+      tls()
+    ],
+    streamMuxers: [
+      yamux(),
+      mplex()
+    ],
+    peerDiscovery: [
+      mdns(),
+      bootstrap(bootstrapConfig)
+    ],
+    services: {
+      autoNAT: autoNAT(),
+      autoTLS: autoTLS(),
+      dcutr: dcutr(),
+      delegatedPeerRouting: delegatedRoutingV1HttpApiClientPeerRouting(delegatedHTTPRoutingDefaults()),
+      delegatedContentRouting: delegatedRoutingV1HttpApiClientContentRouting(delegatedHTTPRoutingDefaults()),
+      dht: kadDHT(),
+      identify: identify(),
+      identifyPush: identifyPush(),
+      keychain: keychain(options.keychain),
+      ping: ping(),
+      relay: circuitRelayServer(),
+      upnp: uPnPNAT(),
+      http: http()
+    }
+  }
+}

package/src/utils/libp2p.ts

@@ -0,0 +1,43 @@
+import { loadOrCreateSelfKey } from '@libp2p/config'
+import { createLibp2p as create } from 'libp2p'
+import { libp2pDefaults } from './libp2p-defaults.ts'
+import type { Helia } from '@helia/interface'
+import type { Libp2p, PrivateKey } from '@libp2p/interface'
+import type { KeychainInit } from '@libp2p/keychain'
+import type { DNS } from '@multiformats/dns'
+import type { Libp2pOptions } from 'libp2p'
+
+export interface CreateLibp2pOptions<T extends Record<string, unknown>> extends Libp2pOptions<T> {
+  keychain?: KeychainInit
+}
+
+export interface Libp2pDefaultsOptions {
+  privateKey?: PrivateKey
+  keychain?: KeychainInit
+  dns?: DNS
+  name?: string
+  version?: string
+}
+
+export async function createLibp2p <T extends Record<string, unknown>> (helia: Helia, options: CreateLibp2pOptions<T>): Promise<Libp2p<T>> {
+  const libp2pOptions = options ?? {}
+
+  // if no peer id was passed, try to load it from the keychain
+  if (libp2pOptions.privateKey == null && options.datastore != null) {
+    libp2pOptions.privateKey = await loadOrCreateSelfKey(options.datastore, options.keychain)
+  }
+
+  const defaults: any = libp2pDefaults({
+    ...libp2pOptions,
+    name: libp2pOptions.nodeInfo?.name ?? helia.info.name,
+    version: libp2pOptions.nodeInfo?.version ?? helia.info.version
+  })
+  defaults.datastore = defaults.datastore ?? options.datastore
+
+  const node = await create<T>({
+    ...defaults,
+    ...libp2pOptions
+  })
+
+  return node
+}