libp2p 0.36.2 → 0.37.0

package/dist/src/record/peer-record/peer-record.d.ts

@@ -1,133 +0,0 @@
-import * as $protobuf from "protobufjs";
-/** Properties of a PeerRecord. */
-export interface IPeerRecord {
-
-    /** PeerRecord peerId */
-    peerId?: (Uint8Array|null);
-
-    /** PeerRecord seq */
-    seq?: (number|null);
-
-    /** PeerRecord addresses */
-    addresses?: (PeerRecord.IAddressInfo[]|null);
-}
-
-/** Represents a PeerRecord. */
-export class PeerRecord implements IPeerRecord {
-
-    /**
-     * Constructs a new PeerRecord.
-     * @param [p] Properties to set
-     */
-    constructor(p?: IPeerRecord);
-
-    /** PeerRecord peerId. */
-    public peerId: Uint8Array;
-
-    /** PeerRecord seq. */
-    public seq: number;
-
-    /** PeerRecord addresses. */
-    public addresses: PeerRecord.IAddressInfo[];
-
-    /**
-     * Encodes the specified PeerRecord message. Does not implicitly {@link PeerRecord.verify|verify} messages.
-     * @param m PeerRecord message or plain object to encode
-     * @param [w] Writer to encode to
-     * @returns Writer
-     */
-    public static encode(m: IPeerRecord, w?: $protobuf.Writer): $protobuf.Writer;
-
-    /**
-     * Decodes a PeerRecord message from the specified reader or buffer.
-     * @param r Reader or buffer to decode from
-     * @param [l] Message length if known beforehand
-     * @returns PeerRecord
-     * @throws {Error} If the payload is not a reader or valid buffer
-     * @throws {$protobuf.util.ProtocolError} If required fields are missing
-     */
-    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): PeerRecord;
-
-    /**
-     * Creates a PeerRecord message from a plain object. Also converts values to their respective internal types.
-     * @param d Plain object
-     * @returns PeerRecord
-     */
-    public static fromObject(d: { [k: string]: any }): PeerRecord;
-
-    /**
-     * Creates a plain object from a PeerRecord message. Also converts values to other types if specified.
-     * @param m PeerRecord
-     * @param [o] Conversion options
-     * @returns Plain object
-     */
-    public static toObject(m: PeerRecord, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-    /**
-     * Converts this PeerRecord to JSON.
-     * @returns JSON object
-     */
-    public toJSON(): { [k: string]: any };
-}
-
-export namespace PeerRecord {
-
-    /** Properties of an AddressInfo. */
-    interface IAddressInfo {
-
-        /** AddressInfo multiaddr */
-        multiaddr?: (Uint8Array|null);
-    }
-
-    /** Represents an AddressInfo. */
-    class AddressInfo implements IAddressInfo {
-
-        /**
-         * Constructs a new AddressInfo.
-         * @param [p] Properties to set
-         */
-        constructor(p?: PeerRecord.IAddressInfo);
-
-        /** AddressInfo multiaddr. */
-        public multiaddr: Uint8Array;
-
-        /**
-         * Encodes the specified AddressInfo message. Does not implicitly {@link PeerRecord.AddressInfo.verify|verify} messages.
-         * @param m AddressInfo message or plain object to encode
-         * @param [w] Writer to encode to
-         * @returns Writer
-         */
-        public static encode(m: PeerRecord.IAddressInfo, w?: $protobuf.Writer): $protobuf.Writer;
-
-        /**
-         * Decodes an AddressInfo message from the specified reader or buffer.
-         * @param r Reader or buffer to decode from
-         * @param [l] Message length if known beforehand
-         * @returns AddressInfo
-         * @throws {Error} If the payload is not a reader or valid buffer
-         * @throws {$protobuf.util.ProtocolError} If required fields are missing
-         */
-        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): PeerRecord.AddressInfo;
-
-        /**
-         * Creates an AddressInfo message from a plain object. Also converts values to their respective internal types.
-         * @param d Plain object
-         * @returns AddressInfo
-         */
-        public static fromObject(d: { [k: string]: any }): PeerRecord.AddressInfo;
-
-        /**
-         * Creates a plain object from an AddressInfo message. Also converts values to other types if specified.
-         * @param m AddressInfo
-         * @param [o] Conversion options
-         * @returns Plain object
-         */
-        public static toObject(m: PeerRecord.AddressInfo, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-        /**
-         * Converts this AddressInfo to JSON.
-         * @returns JSON object
-         */
-        public toJSON(): { [k: string]: any };
-    }
-}

package/dist/src/record/utils.d.ts

@@ -1,12 +0,0 @@
-export type Libp2p = import('../');
-/**
- * @typedef {import('../')} Libp2p
- */
-/**
- * Create (or update if existing) self peer record and store it in the AddressBook.
- *
- * @param {Libp2p} libp2p
- * @returns {Promise<void>}
- */
-export function updateSelfPeerRecord(libp2p: Libp2p): Promise<void>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/src/record/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/record/utils.js"],"names":[],"mappings":"qBAMa,OAAO,KAAK,CAAC;AAD1B;;GAEG;AAEH;;;;;GAKG;AACH,6CAHW,MAAM,GACJ,QAAQ,IAAI,CAAC,CASzB"}

package/dist/src/types.d.ts

@@ -1,90 +0,0 @@
-import type PeerId from 'peer-id';
-import type { Multiaddr } from 'multiaddr';
-import type { MultiaddrConnection } from 'libp2p-interfaces/src/transport/types';
-export interface ConnectionGater {
-    /**
-     * denyDialMultiaddr tests whether we're permitted to Dial the
-     * specified peer.
-     *
-     * This is called by the dialer.connectToPeer implementation before
-     * dialling a peer.
-     *
-     * Return true to prevent dialing the passed peer.
-     */
-    denyDialPeer: (peerId: PeerId) => Promise<boolean>;
-    /**
-     * denyDialMultiaddr tests whether we're permitted to dial the specified
-     * multiaddr for the given peer.
-     *
-     * This is called by the dialer.connectToPeer implementation after it has
-     * resolved the peer's addrs, and prior to dialling each.
-     *
-     * Return true to prevent dialing the passed peer on the passed multiaddr.
-     */
-    denyDialMultiaddr: (peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>;
-    /**
-     * denyInboundConnection tests whether an incipient inbound connection is allowed.
-     *
-     * This is called by the upgrader, or by the transport directly (e.g. QUIC,
-     * Bluetooth), straight after it has accepted a connection from its socket.
-     *
-     * Return true to deny the incoming passed connection.
-     */
-    denyInboundConnection: (maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyOutboundConnection tests whether an incipient outbound connection is allowed.
-     *
-     * This is called by the upgrader, or by the transport directly (e.g. QUIC,
-     * Bluetooth), straight after it has created a connection with its socket.
-     *
-     * Return true to deny the incoming passed connection.
-     */
-    denyOutboundConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyInboundEncryptedConnection tests whether a given connection, now encrypted,
-     * is allowed.
-     *
-     * This is called by the upgrader, after it has performed the security
-     * handshake, and before it negotiates the muxer, or by the directly by the
-     * transport, at the exact same checkpoint.
-     *
-     * Return true to deny the passed secured connection.
-     */
-    denyInboundEncryptedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyOutboundEncryptedConnection tests whether a given connection, now encrypted,
-     * is allowed.
-     *
-     * This is called by the upgrader, after it has performed the security
-     * handshake, and before it negotiates the muxer, or by the directly by the
-     * transport, at the exact same checkpoint.
-     *
-     * Return true to deny the passed secured connection.
-     */
-    denyOutboundEncryptedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyInboundUpgradedConnection tests whether a fully capable connection is allowed.
-     *
-     * This is called after encryption has been negotiated and the connection has been
-     * multiplexed, if a multiplexer is configured.
-     *
-     * Return true to deny the passed upgraded connection.
-     */
-    denyInboundUpgradedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyOutboundUpgradedConnection tests whether a fully capable connection is allowed.
-     *
-     * This is called after encryption has been negotiated and the connection has been
-     * multiplexed, if a multiplexer is configured.
-     *
-     * Return true to deny the passed upgraded connection.
-     */
-    denyOutboundUpgradedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * Used by the address book to filter passed addresses.
-     *
-     * Return true to allow storing the passed multiaddr for the passed peer.
-     */
-    filterMultiaddrForPeer: (peer: PeerId, multiaddr: Multiaddr) => Promise<boolean>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,SAAS,CAAA;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAA;AAEhF,MAAM,WAAW,eAAe;IAC9B;;;;;;;;OAQG;IACH,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAElD;;;;;;;;OAQG;IACH,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAE7E;;;;;;;OAOG;IACH,qBAAqB,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAExE;;;;;;;OAOG;IACH,sBAAsB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEzF;;;;;;;;;OASG;IACH,8BAA8B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEjG;;;;;;;;;OASG;IACH,+BAA+B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAElG;;;;;;;OAOG;IACH,6BAA6B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEhG;;;;;;;OAOG;IACH,8BAA8B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEjG;;;;OAIG;IACH,sBAAsB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACjF"}

package/src/address-manager/index.js

@@ -1,96 +0,0 @@
-'use strict'
-
-const { EventEmitter } = require('events')
-const { Multiaddr } = require('multiaddr')
-const PeerId = require('peer-id')
-
-/**
- * @typedef {Object} AddressManagerOptions
- * @property {string[]} [listen = []] - list of multiaddrs string representation to listen.
- * @property {string[]} [announce = []] - list of multiaddrs string representation to announce.
- */
-
-/**
- * @fires AddressManager#change:addresses Emitted when a addresses change.
- */
-class AddressManager extends EventEmitter {
-  /**
-   * Responsible for managing the peer addresses.
-   * Peers can specify their listen and announce addresses.
-   * The listen addresses will be used by the libp2p transports to listen for new connections,
-   * while the announce addresses will be used for the peer addresses' to other peers in the network.
-   *
-   * @class
-   * @param {PeerId} peerId - The Peer ID of the node
-   * @param {object} [options]
-   * @param {Array<string>} [options.listen = []] - list of multiaddrs string representation to listen.
-   * @param {Array<string>} [options.announce = []] - list of multiaddrs string representation to announce.
-   */
-  constructor (peerId, { listen = [], announce = [] } = {}) {
-    super()
-
-    this.peerId = peerId
-    this.listen = new Set(listen.map(ma => ma.toString()))
-    this.announce = new Set(announce.map(ma => ma.toString()))
-    this.observed = new Set()
-  }
-
-  /**
-   * Get peer listen multiaddrs.
-   *
-   * @returns {Multiaddr[]}
-   */
-  getListenAddrs () {
-    return Array.from(this.listen).map((a) => new Multiaddr(a))
-  }
-
-  /**
-   * Get peer announcing multiaddrs.
-   *
-   * @returns {Multiaddr[]}
-   */
-  getAnnounceAddrs () {
-    return Array.from(this.announce).map((a) => new Multiaddr(a))
-  }
-
-  /**
-   * Get observed multiaddrs.
-   *
-   * @returns {Array<Multiaddr>}
-   */
-  getObservedAddrs () {
-    return Array.from(this.observed).map((a) => new Multiaddr(a))
-  }
-
-  /**
-   * Add peer observed addresses
-   *
-   * @param {string | Multiaddr} addr
-   */
-  addObservedAddr (addr) {
-    let ma = new Multiaddr(addr)
-    const remotePeer = ma.getPeerId()
-
-    // strip our peer id if it has been passed
-    if (remotePeer) {
-      const remotePeerId = PeerId.createFromB58String(remotePeer)
-
-      // use same encoding for comparison
-      if (remotePeerId.equals(this.peerId)) {
-        ma = ma.decapsulate(new Multiaddr(`/p2p/${this.peerId}`))
-      }
-    }
-
-    const addrString = ma.toString()
-
-    // do not trigger the change:addresses event if we already know about this address
-    if (this.observed.has(addrString)) {
-      return
-    }
-
-    this.observed.add(addrString)
-    this.emit('change:addresses')
-  }
-}
-
-module.exports = AddressManager

package/src/circuit/auto-relay.js

@@ -1,302 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:auto-relay'), {
-  error: debug('libp2p:auto-relay:err')
-})
-
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-const { Multiaddr } = require('multiaddr')
-const all = require('it-all')
-
-const { relay: multicodec } = require('./multicodec')
-const { canHop } = require('./circuit/hop')
-const { namespaceToCid } = require('./utils')
-const {
-  CIRCUIT_PROTO_CODE,
-  HOP_METADATA_KEY,
-  HOP_METADATA_VALUE,
-  RELAY_RENDEZVOUS_NS
-} = require('./constants')
-
-/**
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('../peer-store/types').Address} Address
- * @typedef {import('peer-id')} PeerId
- */
-
-/**
- * @typedef {Object} AutoRelayProperties
- * @property {import('../')} libp2p
- *
- * @typedef {Object} AutoRelayOptions
- * @property {number} [maxListeners = 1] - maximum number of relays to listen.
- * @property {(error: Error, msg?: string) => {}} [onError]
- */
-
-class AutoRelay {
-  /**
-   * Creates an instance of AutoRelay.
-   *
-   * @class
-   * @param {AutoRelayProperties & AutoRelayOptions} props
-   */
-  constructor ({ libp2p, maxListeners = 1, onError }) {
-    this._libp2p = libp2p
-    this._peerId = libp2p.peerId
-    this._peerStore = libp2p.peerStore
-    this._connectionManager = libp2p.connectionManager
-    this._transportManager = libp2p.transportManager
-    this._addressSorter = libp2p.dialer.addressSorter
-
-    this.maxListeners = maxListeners
-
-    /**
-     * @type {Set<string>}
-     */
-    this._listenRelays = new Set()
-
-    this._onProtocolChange = this._onProtocolChange.bind(this)
-    this._onPeerDisconnected = this._onPeerDisconnected.bind(this)
-
-    this._peerStore.on('change:protocols', this._onProtocolChange)
-    this._connectionManager.on('peer:disconnect', this._onPeerDisconnected)
-
-    /**
-     * @param {Error} error
-     * @param {string} [msg]
-     */
-    this._onError = (error, msg) => {
-      log.error(msg || error)
-      onError && onError(error, msg)
-    }
-  }
-
-  /**
-   * Check if a peer supports the relay protocol.
-   * If the protocol is not supported, check if it was supported before and remove it as a listen relay.
-   * If the protocol is supported, check if the peer supports **HOP** and add it as a listener if
-   * inside the threshold.
-   *
-   * @param {Object} props
-   * @param {PeerId} props.peerId
-   * @param {string[]} props.protocols
-   * @returns {Promise<void>}
-   */
-  async _onProtocolChange ({ peerId, protocols }) {
-    const id = peerId.toB58String()
-
-    // Check if it has the protocol
-    const hasProtocol = protocols.find(protocol => protocol === multicodec)
-
-    // If no protocol, check if we were keeping the peer before as a listenRelay
-    if (!hasProtocol && this._listenRelays.has(id)) {
-      await this._removeListenRelay(id)
-      return
-    } else if (!hasProtocol || this._listenRelays.has(id)) {
-      return
-    }
-
-    // If protocol, check if can hop, store info in the metadataBook and listen on it
-    try {
-      const connection = this._connectionManager.get(peerId)
-      if (!connection) {
-        return
-      }
-
-      // Do not hop on a relayed connection
-      if (connection.remoteAddr.protoCodes().includes(CIRCUIT_PROTO_CODE)) {
-        log(`relayed connection to ${id} will not be used to hop on`)
-        return
-      }
-
-      const supportsHop = await canHop({ connection })
-
-      if (supportsHop) {
-        await this._peerStore.metadataBook.setValue(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
-        await this._addListenRelay(connection, id)
-      }
-    } catch (/** @type {any} */ err) {
-      this._onError(err)
-    }
-  }
-
-  /**
-   * Peer disconnects.
-   *
-   * @param {Connection} connection - connection to the peer
-   */
-  _onPeerDisconnected (connection) {
-    const peerId = connection.remotePeer
-    const id = peerId.toB58String()
-
-    // Not listening on this relay
-    if (!this._listenRelays.has(id)) {
-      return
-    }
-
-    this._removeListenRelay(id).catch(err => {
-      log.error(err)
-    })
-  }
-
-  /**
-   * Attempt to listen on the given relay connection.
-   *
-   * @private
-   * @param {Connection} connection - connection to the peer
-   * @param {string} id - peer identifier string
-   * @returns {Promise<void>}
-   */
-  async _addListenRelay (connection, id) {
-    try {
-      // Check if already listening on enough relays
-      if (this._listenRelays.size >= this.maxListeners) {
-        return
-      }
-
-      // Get peer known addresses and sort them per public addresses first
-      const remoteAddrs = await this._peerStore.addressBook.getMultiaddrsForPeer(
-        connection.remotePeer, this._addressSorter
-      )
-
-      // Attempt to listen on relay
-      const result = await Promise.all(
-        remoteAddrs.map(async addr => {
-          try {
-            // Announce multiaddrs will update on listen success by TransportManager event being triggered
-            await this._transportManager.listen([new Multiaddr(`${addr.toString()}/p2p-circuit`)])
-            return true
-          } catch (/** @type {any} */ err) {
-            this._onError(err)
-          }
-
-          return false
-        })
-      )
-
-      if (result.includes(true)) {
-        this._listenRelays.add(id)
-      }
-    } catch (/** @type {any} */ err) {
-      this._onError(err)
-      this._listenRelays.delete(id)
-    }
-  }
-
-  /**
-   * Remove listen relay.
-   *
-   * @private
-   * @param {string} id - peer identifier string.
-   */
-  async _removeListenRelay (id) {
-    if (this._listenRelays.delete(id)) {
-      // TODO: this should be responsibility of the connMgr
-      await this._listenOnAvailableHopRelays([id])
-    }
-  }
-
-  /**
-   * Try to listen on available hop relay connections.
-   * The following order will happen while we do not have enough relays.
-   * 1. Check the metadata store for known relays, try to listen on the ones we are already connected.
-   * 2. Dial and try to listen on the peers we know that support hop but are not connected.
-   * 3. Search the network.
-   *
-   * @param {string[]} [peersToIgnore]
-   */
-  async _listenOnAvailableHopRelays (peersToIgnore = []) {
-    // TODO: The peer redial issue on disconnect should be handled by connection gating
-    // Check if already listening on enough relays
-    if (this._listenRelays.size >= this.maxListeners) {
-      return
-    }
-
-    const knownHopsToDial = []
-    const peers = await all(this._peerStore.getPeers())
-
-    // Check if we have known hop peers to use and attempt to listen on the already connected
-    for await (const { id, metadata } of peers) {
-      const idStr = id.toB58String()
-
-      // Continue to next if listening on this or peer to ignore
-      if (this._listenRelays.has(idStr)) {
-        continue
-      }
-
-      if (peersToIgnore.includes(idStr)) {
-        continue
-      }
-
-      const supportsHop = metadata.get(HOP_METADATA_KEY)
-
-      // Continue to next if it does not support Hop
-      if (!supportsHop || uint8ArrayToString(supportsHop) !== HOP_METADATA_VALUE) {
-        continue
-      }
-
-      const connection = this._connectionManager.get(id)
-
-      // If not connected, store for possible later use.
-      if (!connection) {
-        knownHopsToDial.push(id)
-        continue
-      }
-
-      await this._addListenRelay(connection, idStr)
-
-      // Check if already listening on enough relays
-      if (this._listenRelays.size >= this.maxListeners) {
-        return
-      }
-    }
-
-    // Try to listen on known peers that are not connected
-    for (const peerId of knownHopsToDial) {
-      await this._tryToListenOnRelay(peerId)
-
-      // Check if already listening on enough relays
-      if (this._listenRelays.size >= this.maxListeners) {
-        return
-      }
-    }
-
-    // Try to find relays to hop on the network
-    try {
-      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
-      for await (const provider of this._libp2p.contentRouting.findProviders(cid)) {
-        if (!provider.multiaddrs.length) {
-          continue
-        }
-
-        const peerId = provider.id
-        await this._peerStore.addressBook.add(peerId, provider.multiaddrs)
-
-        await this._tryToListenOnRelay(peerId)
-
-        // Check if already listening on enough relays
-        if (this._listenRelays.size >= this.maxListeners) {
-          return
-        }
-      }
-    } catch (/** @type {any} */ err) {
-      this._onError(err)
-    }
-  }
-
-  /**
-   * @param {PeerId} peerId
-   */
-  async _tryToListenOnRelay (peerId) {
-    try {
-      const connection = await this._libp2p.dial(peerId)
-      await this._addListenRelay(connection, peerId.toB58String())
-    } catch (/** @type {any} */ err) {
-      this._onError(err, `could not connect and listen on known hop relay ${peerId.toB58String()}`)
-    }
-  }
-}
-
-module.exports = AutoRelay