libp2p 0.36.2 → 0.37.0

package/src/peer-store/types.ts

@@ -1,245 +0,0 @@
-import type PeerId from 'peer-id'
-import type { Multiaddr } from 'multiaddr'
-import type Envelope from '../record/envelope'
-import type { PublicKey } from 'libp2p-interfaces/src/keys/types'
-
-export interface Address {
-  /**
-   * Peer multiaddr
-   */
-  multiaddr: Multiaddr
-
-  /**
-   * Obtained from a signed peer record
-   */
-  isCertified: boolean
-}
-
-export interface Peer {
-  /**
-   * Peer's peer-id instance
-   */
-  id: PeerId
-
-  /**
-   * Peer's addresses containing its multiaddrs and metadata
-   */
-  addresses: Address[]
-
-  /**
-   * Peer's supported protocols
-   */
-  protocols: string[]
-
-  /**
-   * Peer's metadata map
-   */
-  metadata: Map<string, Uint8Array>
-
-  /**
-   * May be set if the key that this Peer has is an RSA key
-   */
-  pubKey?: PublicKey
-
-  /**
-   * The last peer record envelope received
-   */
-  peerRecordEnvelope?: Uint8Array
-}
-
-export interface CertifiedRecord {
-  raw: Uint8Array
-  seqNumber: number
-}
-
-export interface AddressBookEntry {
-  addresses: Address[]
-  record: CertifiedRecord
-}
-
-export interface Book<Type> {
-  /**
-   * Get the known data of a peer
-   */
-  get: (peerId: PeerId) => Promise<Type>
-
-  /**
-   * Set the known data of a peer
-   */
-  set: (peerId: PeerId, data: Type) => Promise<void>
-
-  /**
-   * Remove the known data of a peer
-   */
-  delete: (peerId: PeerId) => Promise<void>
-}
-
-/**
- * AddressBook containing a map of peerIdStr to Address.
- */
-export interface AddressBook {
-  /**
-   * ConsumePeerRecord adds addresses from a signed peer record contained in a record envelope.
-   * This will return a boolean that indicates if the record was successfully processed and added
-   * into the AddressBook
-   */
-  consumePeerRecord: (envelope: Envelope) => Promise<boolean>
-
-  /**
-   * Get the raw Envelope for a peer. Returns
-   * undefined if no Envelope is found
-   */
-  getRawEnvelope: (peerId: PeerId) => Promise<Uint8Array | undefined>
-
-  /**
-   * Get an Envelope containing a PeerRecord for the given peer.
-   * Returns undefined if no record exists.
-   */
-  getPeerRecord: (peerId: PeerId) => Promise<Envelope | undefined>
-
-  /**
-   * Add known addresses of a provided peer.
-   * If the peer is not known, it is set with the given addresses.
-   */
-  add: (peerId: PeerId, multiaddrs: Multiaddr[]) => Promise<void>
-
-  /**
-   * Set the known addresses of a peer
-   */
-  set: (peerId: PeerId, data: Multiaddr[]) => Promise<void>
-
-  /**
-   * Return the known addresses of a peer
-   */
-  get: (peerId: PeerId) => Promise<Address[]>
-
-  /**
-   * Get the known multiaddrs for a given peer. All returned multiaddrs
-   * will include the encapsulated `PeerId` of the peer.
-   */
-  getMultiaddrsForPeer: (peerId: PeerId, addressSorter?: (ms: Address[]) => Address[]) => Promise<Multiaddr[]>
-}
-
-/**
- * KeyBook containing a map of peerIdStr to their PeerId with public keys.
- */
-export interface KeyBook {
-  /**
-   * Get the known data of a peer
-   */
-  get: (peerId: PeerId) => Promise<PublicKey | undefined>
-
-  /**
-   * Set the known data of a peer
-   */
-  set: (peerId: PeerId, data: PublicKey) => Promise<void>
-
-  /**
-   * Remove the known data of a peer
-   */
-  delete: (peerId: PeerId) => Promise<void>
-}
-
-/**
- * MetadataBook containing a map of peerIdStr to their metadata Map.
- */
-export interface MetadataBook extends Book<Map<string, Uint8Array>> {
-  /**
-   * Set a specific metadata value
-   */
-  setValue: (peerId: PeerId, key: string, value: Uint8Array) => Promise<void>
-
-  /**
-   * Get specific metadata value, if it exists
-   */
-  getValue: (peerId: PeerId, key: string) => Promise<Uint8Array | undefined>
-
-  /**
-   * Deletes the provided peer metadata key from the book
-   */
-  deleteValue: (peerId: PeerId, key: string) => Promise<void>
-}
-
-/**
- * ProtoBook containing a map of peerIdStr to supported protocols.
- */
-export interface ProtoBook extends Book<string[]> {
-  /**
-   * Adds known protocols of a provided peer.
-   * If the peer was not known before, it will be added.
-   */
-  add: (peerId: PeerId, protocols: string[]) => Promise<void>
-
-  /**
-   * Removes known protocols of a provided peer.
-   * If the protocols did not exist before, nothing will be done.
-   */
-  remove: (peerId: PeerId, protocols: string[]) => Promise<void>
-}
-
-export interface PeerProtocolsChangeEvent {
-  peerId: PeerId
-  protocols: string[]
-}
-
-export interface PeerMultiaddrsChangeEvent {
-  peerId: PeerId
-  multiaddrs: Multiaddr[]
-}
-
-export interface PeerPublicKeyChangeEvent {
-  peerId: PeerId
-  pubKey?: PublicKey
-}
-
-export interface PeerMetadataChangeEvent {
-  peerId: PeerId
-  metadata: Map<string, Uint8Array>
-}
-
-export type EventName = 'peer' | 'change:protocols' | 'change:multiaddrs' | 'change:pubkey' | 'change:metadata'
-
-export interface PeerStoreEvents {
-  'peer': (event: PeerId) => void
-  'change:protocols': (event: PeerProtocolsChangeEvent) => void
-  'change:multiaddrs': (event: PeerMultiaddrsChangeEvent) => void
-  'change:pubkey': (event: PeerPublicKeyChangeEvent) => void
-  'change:metadata': (event: PeerMetadataChangeEvent) => void
-}
-
-export interface PeerStore {
-  addressBook: AddressBook
-  keyBook: KeyBook
-  metadataBook: MetadataBook
-  protoBook: ProtoBook
-
-  getPeers: () => AsyncIterable<Peer>
-  delete: (peerId: PeerId) => Promise<void>
-  has: (peerId: PeerId) => Promise<boolean>
-  get: (peerId: PeerId) => Promise<Peer>
-  on: <U extends keyof PeerStoreEvents>(
-    event: U, listener: PeerStoreEvents[U]
-  ) => this
-  once: <U extends keyof PeerStoreEvents>(
-    event: U, listener: PeerStoreEvents[U]
-  ) => this
-  emit: <U extends keyof PeerStoreEvents>(
-    event: U, ...args: Parameters<PeerStoreEvents[U]>
-  ) => boolean
-}
-
-export interface Store {
-  has: (peerId: PeerId) => Promise<boolean>
-  save: (peer: Peer) => Promise<Peer>
-  load: (peerId: PeerId) => Promise<Peer>
-  merge: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
-  mergeOrCreate: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
-  patch: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
-  patchOrCreate: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
-  all: () => AsyncIterable<Peer>
-
-  lock: {
-    readLock: () => Promise<() => void>
-    writeLock: () => Promise<() => void>
-  }
-}

package/src/ping/constants.js

@@ -1,8 +0,0 @@
-'use strict'
-
-module.exports = {
-  PROTOCOL: '/ipfs/ping/1.0.0', // deprecated
-  PING_LENGTH: 32,
-  PROTOCOL_VERSION: '1.0.0',
-  PROTOCOL_NAME: 'ping'
-}

package/src/ping/index.js

@@ -1,84 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:ping'), {
-  error: debug('libp2p:ping:err')
-})
-const errCode = require('err-code')
-const { codes } = require('../errors')
-const crypto = require('libp2p-crypto')
-const { pipe } = require('it-pipe')
-// @ts-ignore it-buffer has no types exported
-const { toBuffer } = require('it-buffer')
-const { collect, take } = require('streaming-iterables')
-const { equals } = require('uint8arrays/equals')
-
-const { PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION } = require('./constants')
-
-/**
- * @typedef {import('../')} Libp2p
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- * @typedef {import('peer-id')} PeerId
- * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
- */
-
-class PingService {
-  /**
-   * @param {import('../')} libp2p
-   */
-  static getProtocolStr (libp2p) {
-    return `/${libp2p._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
-  }
-
-  /**
-   * @param {Libp2p} libp2p
-   */
-  constructor (libp2p) {
-    this._libp2p = libp2p
-  }
-
-  /**
-   * A handler to register with Libp2p to process ping messages
-   *
-   * @param {Object} options
-   * @param {MuxedStream} options.stream
-   */
-  handleMessage ({ stream }) {
-    return pipe(stream, stream)
-  }
-
-  /**
-   * Ping a given peer and wait for its response, getting the operation latency.
-   *
-   * @param {PeerId|Multiaddr} peer
-   * @returns {Promise<number>}
-   */
-  async ping (peer) {
-    const protocol = `/${this._libp2p._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
-    // @ts-ignore multiaddr might not have toB58String
-    log('dialing %s to %s', protocol, peer.toB58String ? peer.toB58String() : peer)
-
-    const connection = await this._libp2p.dial(peer)
-    const { stream } = await connection.newStream(protocol)
-
-    const start = Date.now()
-    const data = crypto.randomBytes(PING_LENGTH)
-
-    const [result] = await pipe(
-      [data],
-      stream,
-      (/** @type {MuxedStream} */ stream) => take(1, stream),
-      toBuffer,
-      collect
-    )
-    const end = Date.now()
-
-    if (!equals(data, result)) {
-      throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
-    }
-
-    return end - start
-  }
-}
-
-module.exports = PingService

package/src/ping/util.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const crypto = require('libp2p-crypto')
-const constants = require('./constants')
-
-/**
- * @param {number} length
- */
-function rnd (length) {
-  if (!length) {
-    length = constants.PING_LENGTH
-  }
-  return crypto.randomBytes(length)
-}
-
-module.exports = {
-  rnd
-}

package/src/pnet/crypto.js

@@ -1,84 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:pnet'), {
-  trace: debug('libp2p:pnet:trace'),
-  error: debug('libp2p:pnet:err')
-})
-
-const Errors = require('./errors')
-// @ts-ignore xsalsa20 has no types exported
-const xsalsa20 = require('xsalsa20')
-const KEY_LENGTH = require('./key-generator').KEY_LENGTH
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-
-/**
- * Creates a stream iterable to encrypt messages in a private network
- *
- * @param {Uint8Array} nonce - The nonce to use in encryption
- * @param {Uint8Array} psk - The private shared key to use in encryption
- * @returns {*} a through iterable
- */
-module.exports.createBoxStream = (nonce, psk) => {
-  const xor = xsalsa20(nonce, psk)
-
-  return (/** @type {AsyncIterable<Uint8Array>} */ source) => (async function * () {
-    for await (const chunk of source) {
-      yield Uint8Array.from(xor.update(chunk.slice()))
-    }
-  })()
-}
-
-/**
- * Creates a stream iterable to decrypt messages in a private network
- *
- * @param {Uint8Array} nonce - The nonce of the remote peer
- * @param {Uint8Array} psk - The private shared key to use in decryption
- * @returns {*} a through iterable
- */
-module.exports.createUnboxStream = (nonce, psk) => {
-  return (/** @type {AsyncIterable<Uint8Array>} */ source) => (async function * () {
-    const xor = xsalsa20(nonce, psk)
-    log.trace('Decryption enabled')
-
-    for await (const chunk of source) {
-      yield Uint8Array.from(xor.update(chunk.slice()))
-    }
-  })()
-}
-
-/**
- * Decode the version 1 psk from the given Uint8Array
- *
- * @param {Uint8Array} pskBuffer
- * @throws {INVALID_PSK}
- * @returns {{ tag?: string, codecName?: string, psk: Uint8Array }} The PSK metadata (tag, codecName, psk)
- */
-module.exports.decodeV1PSK = (pskBuffer) => {
-  try {
-    // This should pull from multibase/multicodec to allow for
-    // more encoding flexibility. Ideally we'd consume the codecs
-    // from the buffer line by line to evaluate the next line
-    // programmatically instead of making assumptions about the
-    // encodings of each line.
-    const metadata = uint8ArrayToString(pskBuffer).split(/(?:\r\n|\r|\n)/g)
-    const pskTag = metadata.shift()
-    const codec = metadata.shift()
-    const pskString = metadata.shift()
-    const psk = pskString && uint8ArrayFromString(pskString, 'base16')
-
-    if (!psk || psk.byteLength !== KEY_LENGTH) {
-      throw new Error(Errors.INVALID_PSK)
-    }
-
-    return {
-      tag: pskTag,
-      codecName: codec,
-      psk: psk
-    }
-  } catch (/** @type {any} */ err) {
-    log.error(err)
-    throw new Error(Errors.INVALID_PSK)
-  }
-}

package/src/pnet/errors.js

@@ -1,7 +0,0 @@
-'use strict'
-
-module.exports.INVALID_PEER = 'Not a valid peer connection'
-module.exports.INVALID_PSK = 'Your private shared key is invalid'
-module.exports.NO_LOCAL_ID = 'No local private key provided'
-module.exports.NO_HANDSHAKE_CONNECTION = 'No connection for the handshake provided'
-module.exports.STREAM_ENDED = 'Stream ended prematurely'

package/src/pnet/index.js

@@ -1,86 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:pnet'), {
-  error: debug('libp2p:pnet:err')
-})
-const { pipe } = require('it-pipe')
-const errcode = require('err-code')
-// @ts-ignore it-pair has no types exported
-const duplexPair = require('it-pair/duplex')
-const crypto = require('libp2p-crypto')
-const Errors = require('./errors')
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
-const {
-  createBoxStream,
-  createUnboxStream,
-  decodeV1PSK
-} = require('./crypto')
-// @ts-ignore it-handshake has no types exported
-const handshake = require('it-handshake')
-const { NONCE_LENGTH } = require('./key-generator')
-
-/**
- * @typedef {import('libp2p-interfaces/src/transport/types').MultiaddrConnection} MultiaddrConnection
- */
-
-class Protector {
-  /**
-   * Takes a Private Shared Key (psk) and provides a `protect` method
-   * for wrapping existing connections in a private encryption stream.
-   *
-   * @param {Uint8Array} keyBuffer - The private shared key buffer
-   * @class
-   */
-  constructor (keyBuffer) {
-    const decodedPSK = decodeV1PSK(keyBuffer)
-    this.psk = decodedPSK.psk
-    this.tag = decodedPSK.tag
-  }
-
-  /**
-   * Takes a given Connection and creates a private encryption stream
-   * between its two peers from the PSK the Protector instance was
-   * created with.
-   *
-   * @param {MultiaddrConnection} connection - The connection to protect
-   * @returns {Promise<MultiaddrConnection>} A protected duplex iterable
-   */
-  async protect (connection) {
-    if (!connection) {
-      throw errcode(new Error(Errors.NO_HANDSHAKE_CONNECTION), ERR_INVALID_PARAMETERS)
-    }
-
-    // Exchange nonces
-    log('protecting the connection')
-    const localNonce = crypto.randomBytes(NONCE_LENGTH)
-
-    const shake = handshake(connection)
-    shake.write(localNonce)
-
-    const result = await shake.reader.next(NONCE_LENGTH)
-    const remoteNonce = result.value.slice()
-    shake.rest()
-
-    // Create the boxing/unboxing pipe
-    log('exchanged nonces')
-    const [internal, external] = duplexPair()
-    pipe(
-      external,
-      // Encrypt all outbound traffic
-      createBoxStream(localNonce, this.psk),
-      shake.stream,
-      // Decrypt all inbound traffic
-      createUnboxStream(remoteNonce, this.psk),
-      external
-    ).catch(log.error)
-
-    return internal
-  }
-}
-
-module.exports = Protector
-module.exports.errors = Errors
-module.exports.generate = require('./key-generator')

package/src/pnet/key-generator.js

@@ -1,33 +0,0 @@
-'use strict'
-
-const crypto = require('libp2p-crypto')
-const KEY_LENGTH = 32
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-
-/**
- * Generates a PSK that can be used in a libp2p-pnet private network
- *
- * @param {Uint8Array} bytes - An object to write the psk into
- * @returns {void}
- */
-function generate (bytes) {
-  const psk = uint8ArrayToString(crypto.randomBytes(KEY_LENGTH), 'base16')
-  const key = uint8ArrayFromString('/key/swarm/psk/1.0.0/\n/base16/\n' + psk)
-
-  bytes.set(key)
-}
-
-module.exports = generate
-module.exports.NONCE_LENGTH = 24
-module.exports.KEY_LENGTH = KEY_LENGTH
-
-try {
-  // @ts-ignore This condition will always return 'false' since the types 'Module | undefined'
-  if (require.main === module) {
-    // @ts-ignore
-    generate(process.stdout)
-  }
-} catch (/** @type {any} */ error) {
-
-}

package/src/pubsub-adapter.js

@@ -1,61 +0,0 @@
-'use strict'
-
-// Pubsub adapter to keep API with handlers while not removed.
-/**
- * @typedef {import('libp2p-interfaces/src/pubsub').InMessage} InMessage
- * @typedef {import('libp2p-interfaces/src/pubsub')} PubsubRouter
- */
-
-/**
- * @param {{new(...args: any[]): PubsubRouter}} PubsubRouter
- * @param {import('.')} libp2p
- * @param {{ enabled: boolean; } & import(".").PubsubLocalOptions & import("libp2p-interfaces/src/pubsub").PubsubOptions} options
- */
-function pubsubAdapter (PubsubRouter, libp2p, options) {
-  /** @type {PubsubRouter & { _subscribeAdapter: PubsubRouter['subscribe'], _unsubscribeAdapter: PubsubRouter['unsubscribe'] }} */
-  // @ts-ignore we set the extra _subscribeAdapter and _unsubscribeAdapter properties afterwards
-  const pubsub = new PubsubRouter(libp2p, options)
-  pubsub._subscribeAdapter = pubsub.subscribe
-  pubsub._unsubscribeAdapter = pubsub.unsubscribe
-
-  /**
-   * Subscribes to a given topic.
-   *
-   * @override
-   * @param {string} topic
-   * @param {(msg: InMessage) => void} [handler]
-   * @returns {void}
-   */
-  function subscribe (topic, handler) {
-    // Bind provided handler
-    handler && pubsub.on(topic, handler)
-    pubsub._subscribeAdapter(topic)
-  }
-
-  /**
-   * Unsubscribe from the given topic.
-   *
-   * @override
-   * @param {string} topic
-   * @param {(msg: InMessage) => void} [handler]
-   * @returns {void}
-   */
-  function unsubscribe (topic, handler) {
-    if (!handler) {
-      pubsub.removeAllListeners(topic)
-    } else {
-      pubsub.removeListener(topic, handler)
-    }
-
-    if (pubsub.listenerCount(topic) === 0) {
-      pubsub._unsubscribeAdapter(topic)
-    }
-  }
-
-  pubsub.subscribe = subscribe
-  pubsub.unsubscribe = unsubscribe
-
-  return pubsub
-}
-
-module.exports = pubsubAdapter