libp2p 0.36.2-cc60cfd → 0.36.2-fab4f13

package/src/fetch/index.ts

@@ -75,8 +75,7 @@ export class FetchService implements Startable {
     const shake = handshake(stream)
 
     // send message
-    const request = new FetchRequest({ identifier: key })
-    shake.write(lp.encode.single(FetchRequest.encode(request).finish()).slice())
+    shake.write(lp.encode.single(FetchRequest.encode({ identifier: key })).slice())
 
     // read response
     // @ts-expect-error fromReader returns a Source which has no .next method
@@ -109,21 +108,21 @@ export class FetchService implements Startable {
     // @ts-expect-error fromReader returns a Source which has no .next method
     const request = FetchRequest.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
 
-    let response
+    let response: FetchResponse
     const lookup = this._getLookupFunction(request.identifier)
     if (lookup != null) {
       const data = await lookup(request.identifier)
       if (data != null) {
-        response = new FetchResponse({ status: FetchResponse.StatusCode.OK, data })
+        response = { status: FetchResponse.StatusCode.OK, data }
       } else {
-        response = new FetchResponse({ status: FetchResponse.StatusCode.NOT_FOUND })
+        response = { status: FetchResponse.StatusCode.NOT_FOUND, data: new Uint8Array(0) }
       }
     } else {
       const errmsg = (new TextEncoder()).encode('No lookup function registered for key: ' + request.identifier)
-      response = new FetchResponse({ status: FetchResponse.StatusCode.ERROR, data: errmsg })
+      response = { status: FetchResponse.StatusCode.ERROR, data: errmsg }
     }
 
-    shake.write(lp.encode.single(FetchResponse.encode(response).finish()).slice())
+    shake.write(lp.encode.single(FetchResponse.encode(response)).slice())
   }
 
   /**

package/src/fetch/pb/proto.ts

@@ -0,0 +1,58 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { encodeMessage, decodeMessage, message, string, enumeration, bytes } from 'protons-runtime'
+
+export interface FetchRequest {
+  identifier: string
+}
+
+export namespace FetchRequest {
+  export const codec = () => {
+    return message<FetchRequest>({
+      1: { name: 'identifier', codec: string }
+    })
+  }
+
+  export const encode = (obj: FetchRequest): Uint8Array => {
+    return encodeMessage(obj, FetchRequest.codec())
+  }
+
+  export const decode = (buf: Uint8Array): FetchRequest => {
+    return decodeMessage(buf, FetchRequest.codec())
+  }
+}
+
+export interface FetchResponse {
+  status: FetchResponse.StatusCode
+  data: Uint8Array
+}
+
+export namespace FetchResponse {
+  export enum StatusCode {
+    OK = 'OK',
+    NOT_FOUND = 'NOT_FOUND',
+    ERROR = 'ERROR'
+  }
+
+  export namespace StatusCode {
+    export const codec = () => {
+      return enumeration<typeof StatusCode>(StatusCode)
+    }
+  }
+
+  export const codec = () => {
+    return message<FetchResponse>({
+      1: { name: 'status', codec: FetchResponse.StatusCode.codec() },
+      2: { name: 'data', codec: bytes }
+    })
+  }
+
+  export const encode = (obj: FetchResponse): Uint8Array => {
+    return encodeMessage(obj, FetchResponse.codec())
+  }
+
+  export const decode = (buf: Uint8Array): FetchResponse => {
+    return decodeMessage(buf, FetchResponse.codec())
+  }
+}

package/src/identify/index.ts

@@ -8,7 +8,7 @@ import drain from 'it-drain'
 import first from 'it-first'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { Multiaddr, protocols } from '@multiformats/multiaddr'
-import Message from './pb/message.js'
+import { Identify } from './pb/message.js'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import {
   MULTICODEC_IDENTIFY,
@@ -132,11 +132,11 @@ export class IdentifyService implements Startable {
         const { stream } = await connection.newStream([this.identifyPushProtocolStr])
 
         await pipe(
-          [Message.Identify.encode({
+          [Identify.encode({
             listenAddrs,
             signedPeerRecord,
             protocols
-          }).finish()],
+          })],
           lp.encode(),
           stream,
           drain
@@ -194,9 +194,9 @@ export class IdentifyService implements Startable {
       throw errCode(new Error('No data could be retrieved'), codes.ERR_CONNECTION_ENDED)
     }
 
-    let message
+    let message: Identify
     try {
-      message = Message.Identify.decode(data)
+      message = Identify.decode(data)
     } catch (err: any) {
       throw errCode(err, codes.ERR_INVALID_MESSAGE)
     }
@@ -325,7 +325,7 @@ export class IdentifyService implements Startable {
         signedPeerRecord = envelope.marshal()
       }
 
-      const message = Message.Identify.encode({
+      const message = Identify.encode({
         protocolVersion: this.host.protocolVersion,
         agentVersion: this.host.agentVersion,
         publicKey,
@@ -333,7 +333,7 @@ export class IdentifyService implements Startable {
         signedPeerRecord,
         observedAddr: connection.remoteAddr.bytes,
         protocols: peerData.protocols
-      }).finish()
+      })
 
       await pipe(
         [message],
@@ -352,7 +352,7 @@ export class IdentifyService implements Startable {
   async _handlePush (data: IncomingStreamData) {
     const { connection, stream } = data
 
-    let message
+    let message: Identify | undefined
     try {
       const data = await pipe(
         [],
@@ -362,7 +362,7 @@ export class IdentifyService implements Startable {
       )
 
       if (data != null) {
-        message = Message.Identify.decode(data)
+        message = Identify.decode(data)
       }
     } catch (err: any) {
       return log.error('received invalid message', err)
@@ -442,4 +442,4 @@ export const multicodecs = {
   IDENTIFY_PUSH: MULTICODEC_IDENTIFY_PUSH
 }
 
-export { Message }
+export const Message = { Identify }

package/src/identify/pb/message.ts

@@ -0,0 +1,36 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { encodeMessage, decodeMessage, message, string, bytes } from 'protons-runtime'
+
+export interface Identify {
+  protocolVersion?: string
+  agentVersion?: string
+  publicKey?: Uint8Array
+  listenAddrs: Uint8Array[]
+  observedAddr?: Uint8Array
+  protocols: string[]
+  signedPeerRecord?: Uint8Array
+}
+
+export namespace Identify {
+  export const codec = () => {
+    return message<Identify>({
+      5: { name: 'protocolVersion', codec: string, optional: true },
+      6: { name: 'agentVersion', codec: string, optional: true },
+      1: { name: 'publicKey', codec: bytes, optional: true },
+      2: { name: 'listenAddrs', codec: bytes, repeats: true },
+      4: { name: 'observedAddr', codec: bytes, optional: true },
+      3: { name: 'protocols', codec: string, repeats: true },
+      8: { name: 'signedPeerRecord', codec: bytes, optional: true }
+    })
+  }
+
+  export const encode = (obj: Identify): Uint8Array => {
+    return encodeMessage(obj, Identify.codec())
+  }
+
+  export const decode = (buf: Uint8Array): Identify => {
+    return decodeMessage(buf, Identify.codec())
+  }
+}

package/src/index.ts

@@ -16,8 +16,8 @@ import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypte
 import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
 import type { ContentRouting } from '@libp2p/interfaces/content-routing'
 import type { PubSub } from '@libp2p/interfaces/pubsub'
-import type { ConnectionManager, StreamHandler } from '@libp2p/interfaces/registrar'
-import type { MetricsInit } from '@libp2p/interfaces/metrics'
+import type { ConnectionManager, Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { Metrics, MetricsInit } from '@libp2p/interfaces/metrics'
 import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 import type { DialerInit } from '@libp2p/interfaces/dialer'
 import type { KeyChain } from './keychain/index.js'
@@ -152,9 +152,10 @@ export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
   contentRouting: ContentRouting
   keychain: KeyChain
   connectionManager: ConnectionManager
-
-  pubsub?: PubSub
-  dht?: DualDHT
+  registrar: Registrar
+  metrics?: Metrics
+  pubsub: PubSub
+  dht: DualDHT
 
   /**
    * Load keychain keys from the datastore.
@@ -221,6 +222,12 @@ export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
    * Sends a request to fetch the value associated with the given key from the given peer.
    */
   fetch: (peer: PeerId | Multiaddr | string, key: string) => Promise<Uint8Array | null>
+
+  /**
+   * Returns the public key for the passed PeerId. If the PeerId is of the 'RSA' type
+   * this may mean searching the DHT if the key is not present in the KeyStore.
+   */
+  getPublicKey: (peer: PeerId, options?: AbortOptions) => Promise<Uint8Array>
 }
 
 export type Libp2pOptions = RecursivePartial<Libp2pInit>

package/src/insecure/index.ts

@@ -2,7 +2,7 @@ import { logger } from '@libp2p/logger'
 import { handshake } from 'it-handshake'
 import * as lp from 'it-length-prefixed'
 import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interfaces/connection-encrypter/errors'
-import { Exchange, IExchange, KeyType } from './pb/proto.js'
+import { Exchange, KeyType } from './pb/proto.js'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
@@ -11,8 +11,8 @@ import type { Duplex } from 'it-stream-types'
 const log = logger('libp2p:plaintext')
 const PROTOCOL = '/plaintext/2.0.0'
 
-function lpEncodeExchange (exchange: IExchange) {
-  const pb = Exchange.encode(exchange).finish()
+function lpEncodeExchange (exchange: Exchange) {
+  const pb = Exchange.encode(exchange)
 
   return lp.encode.single(pb)
 }
@@ -37,7 +37,7 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
       id: localId.toBytes(),
       pubkey: {
         Type: type,
-        Data: localId.publicKey
+        Data: localId.publicKey ?? new Uint8Array(0)
       }
     }).slice()
   )
@@ -52,6 +52,10 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
 
   let peerId
   try {
+    if (id.pubkey == null) {
+      throw new Error('Public key missing')
+    }
+
     if (id.pubkey.Data.length === 0) {
       throw new Error('Public key data too short')
     }

package/src/insecure/pb/proto.ts

@@ -0,0 +1,61 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { encodeMessage, decodeMessage, message, bytes, enumeration } from 'protons-runtime'
+
+export interface Exchange {
+  id?: Uint8Array
+  pubkey?: PublicKey
+}
+
+export namespace Exchange {
+  export const codec = () => {
+    return message<Exchange>({
+      1: { name: 'id', codec: bytes, optional: true },
+      2: { name: 'pubkey', codec: PublicKey.codec(), optional: true }
+    })
+  }
+
+  export const encode = (obj: Exchange): Uint8Array => {
+    return encodeMessage(obj, Exchange.codec())
+  }
+
+  export const decode = (buf: Uint8Array): Exchange => {
+    return decodeMessage(buf, Exchange.codec())
+  }
+}
+
+export enum KeyType {
+  RSA = 'RSA',
+  Ed25519 = 'Ed25519',
+  Secp256k1 = 'Secp256k1',
+  ECDSA = 'ECDSA'
+}
+
+export namespace KeyType {
+  export const codec = () => {
+    return enumeration<typeof KeyType>(KeyType)
+  }
+}
+
+export interface PublicKey {
+  Type: KeyType
+  Data: Uint8Array
+}
+
+export namespace PublicKey {
+  export const codec = () => {
+    return message<PublicKey>({
+      1: { name: 'Type', codec: KeyType.codec() },
+      2: { name: 'Data', codec: bytes }
+    })
+  }
+
+  export const encode = (obj: PublicKey): Uint8Array => {
+    return encodeMessage(obj, PublicKey.codec())
+  }
+
+  export const decode = (buf: Uint8Array): PublicKey => {
+    return decodeMessage(buf, PublicKey.codec())
+  }
+}

package/src/keychain/index.ts

@@ -171,7 +171,7 @@ export class KeyChain {
   /**
    * Generates the options for a keychain.  A random salt is produced.
    *
-   * @returns {Object}
+   * @returns {object}
    */
   static generateOptions (): KeyChainInit {
     const options = Object.assign({}, defaultOptions)
@@ -184,7 +184,7 @@ export class KeyChain {
    * Gets an object that can encrypt/decrypt protected data.
    * The default options for a keychain.
    *
-   * @returns {Object}
+   * @returns {object}
    */
   static get options () {
     return defaultOptions

package/src/libp2p.ts

@@ -32,7 +32,7 @@ import type { Connection } from '@libp2p/interfaces/connection'
 import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
 import type { ContentRouting } from '@libp2p/interfaces/content-routing'
 import type { PubSub } from '@libp2p/interfaces/pubsub'
-import type { ConnectionManager, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { ConnectionManager, Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
 import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 import type { Libp2p, Libp2pEvents, Libp2pInit, Libp2pOptions } from './index.js'
 import { validateConfig } from './config.js'
@@ -43,13 +43,16 @@ import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import errCode from 'err-code'
 import { unmarshalPublicKey } from '@libp2p/crypto/keys'
+import type { Metrics } from '@libp2p/interfaces/metrics'
+import { DummyDHT } from './dht/dummy-dht.js'
+import { DummyPubSub } from './pubsub/dummy-pubsub.js'
 
 const log = logger('libp2p')
 
 export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   public peerId: PeerId
-  public dht?: DualDHT
-  public pubsub?: PubSub
+  public dht: DualDHT
+  public pubsub: PubSub
   public identifyService?: IdentifyService
   public fetchService: FetchService
   public pingService: PingService
@@ -59,6 +62,8 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   public peerRouting: PeerRouting
   public keychain: KeyChain
   public connectionManager: ConnectionManager
+  public registrar: Registrar
+  public metrics?: Metrics
 
   private started: boolean
   private readonly services: Startable[]
@@ -78,7 +83,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
     // Create Metrics
     if (init.metrics.enabled) {
-      this.components.setMetrics(this.configureComponent(new DefaultMetrics(init.metrics)))
+      this.metrics = this.components.setMetrics(this.configureComponent(new DefaultMetrics(init.metrics)))
     }
 
     this.components.setConnectionGater(this.configureComponent({
@@ -117,7 +122,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     this.connectionManager = this.components.setConnectionManager(this.configureComponent(new DefaultConnectionManager(this.components, init.connectionManager)))
 
     // Create the Registrar
-    this.components.setRegistrar(this.configureComponent(new DefaultRegistrar(this.components)))
+    this.registrar = this.components.setRegistrar(this.configureComponent(new DefaultRegistrar(this.components)))
 
     // Setup the transport manager
     this.components.setTransportManager(this.configureComponent(new DefaultTransportManager(this.components, init.transportManager)))
@@ -165,11 +170,15 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     // dht provided components (peerRouting, contentRouting, dht)
     if (init.dht != null) {
       this.dht = this.components.setDHT(this.configureComponent(init.dht))
+    } else {
+      this.dht = new DummyDHT()
     }
 
     // Create pubsub if provided
     if (init.pubsub != null) {
       this.pubsub = this.components.setPubSub(this.configureComponent(init.pubsub))
+    } else {
+      this.pubsub = new DummyPubSub()
     }
 
     // Attach remaining APIs
@@ -177,9 +186,14 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
     const peerRouters: PeerRouting[] = (init.peerRouters ?? []).map(component => this.configureComponent(component))
 
-    if (this.dht != null) {
+    if (init.dht != null) {
       // add dht to routers
       peerRouters.push(this.configureComponent(new DHTPeerRouting(this.dht)))
+
+      // use dht for peer discovery
+      this.dht.addEventListener('peer', (evt) => {
+        this.onDiscoveryPeer(evt)
+      })
     }
 
     this.peerRouting = this.components.setPeerRouting(this.configureComponent(new DefaultPeerRouting(this.components, {
@@ -189,7 +203,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
     const contentRouters: ContentRouting[] = (init.contentRouters ?? []).map(component => this.configureComponent(component))
 
-    if (this.dht != null) {
+    if (init.dht != null) {
       // add dht to routers
       contentRouters.push(this.configureComponent(new DHTContentRouting(this.dht)))
     }
@@ -404,9 +418,13 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   /**
    * Get the public key for the given peer id
    */
-  async getPublicKey (peer: PeerId, options: AbortOptions = {}) {
+  async getPublicKey (peer: PeerId, options: AbortOptions = {}): Promise<Uint8Array> {
     log('getPublicKey %p', peer)
 
+    if (peer.publicKey != null) {
+      return peer.publicKey
+    }
+
     const peerInfo = await this.peerStore.get(peer)
 
     if (peerInfo.pubKey != null) {
@@ -429,7 +447,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
         await this.peerStore.keyBook.set(peer, event.value)
 
-        return key
+        return key.bytes
       }
     }
 

package/src/metrics/stats.ts

@@ -2,7 +2,7 @@ import { CustomEvent, EventEmitter } from '@libp2p/interfaces'
 import { createMovingAverage } from './moving-average.js'
 // @ts-expect-error no types
 import retimer from 'retimer'
-import type { MovingAverages, Stats } from '@libp2p/interfaces/metrics'
+import type { MovingAverages, Stats, TransferStats } from '@libp2p/interfaces/metrics'
 
 export interface StatsEvents {
   'update': CustomEvent<TransferStats>
@@ -16,11 +16,6 @@ export interface StatsInit {
   computeThrottleTimeout: number
 }
 
-export interface TransferStats {
-  dataReceived: BigInt
-  dataSent: BigInt
-}
-
 export class DefaultStats extends EventEmitter<StatsEvents> implements Stats {
   private readonly enabled: boolean
   public queue: Array<[string, number, number]>

package/src/pubsub/dummy-pubsub.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from '@libp2p/interfaces'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interfaces/pubsub'
+import errCode from 'err-code'
+import { messages, codes } from '../errors.js'
+
+export class DummyPubSub extends EventEmitter<PubSubEvents> implements PubSub {
+  isStarted (): boolean {
+    return false
+  }
+
+  start (): void | Promise<void> {
+
+  }
+
+  stop (): void | Promise<void> {
+
+  }
+
+  get globalSignaturePolicy (): typeof StrictSign | typeof StrictNoSign {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  get multicodecs (): string[] {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  getPeers (): PeerId[] {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  getTopics (): string[] {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  subscribe (): void {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  unsubscribe (): void {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  getSubscribers (): PeerId[] {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  async publish (): Promise<PublishResult> {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+}