chore: use 0.30 rc

Author: vasco-santos

packages/ipfs-core/package.json

@@ -88,7 +88,7 @@
     "it-first": "^1.0.4",
     "it-last": "^1.0.4",
     "it-pipe": "^1.1.0",
-    "libp2p": "libp2p/js-libp2p#0.30.x",
+    "libp2p": "libp2p/js-libp2p#fix/types-with-dist",
     "libp2p-bootstrap": "^0.12.1",
     "libp2p-crypto": "^0.18.0",
     "libp2p-floodsub": "^0.24.0",

packages/ipfs-core/src/components/index.js

@@ -70,6 +70,8 @@ class IPFS {
     })
     const dns = createDNSAPI()
     const isOnline = createIsOnlineAPI({ network })
+    // @ts-ignore This type check fails as options.
+    // libp2p can be a function, while IPNS router config expects libp2p config
     const ipns = new IPNSAPI(options)
     const dagReader = DagAPI.reader({ ipld, preload })
 

packages/ipfs-core/src/components/is-online.js

@@ -10,5 +10,5 @@ module.exports = ({ network }) =>
    */
   () => {
     const net = network.try()
-    return net != null && net.libp2p.isStarted()
+    return net != null && Boolean(net.libp2p.isStarted())
   }

packages/ipfs-core/src/components/key/export.js

@@ -23,11 +23,10 @@ module.exports = ({ keychain }) => {
    * ```
    * @param {string} name - The name of the key to export
    * @param {string} password - Password to set on the PEM output
-   * @param {import('.').AbortOptions} options
    * @returns {Promise<string>} - The string representation of the key
    */
-  const exportKey = (name, password, options) =>
-    keychain.exportKey(name, password, options)
+  const exportKey = (name, password) =>
+    keychain.exportKey(name, password)
 
   return withTimeoutOption(exportKey)
 }

packages/ipfs-core/src/components/key/import.js

@@ -21,11 +21,10 @@ module.exports = ({ keychain }) => {
    * @param {string} name - The name of the key to import
    * @param {string} pem - The PEM encoded key
    * @param {string} password - The password that protects the PEM key
-   * @param {import('.').AbortOptions} options
    * @returns {Promise<import('.').Key>} - An object that describes the new key
    */
-  const importKey = (name, pem, password, options) => {
-    return keychain.importKey(name, pem, password, options)
+  const importKey = (name, pem, password) => {
+    return keychain.importKey(name, pem, password)
   }
 
   return withTimeoutOption(importKey)

packages/ipfs-core/src/components/key/info.js

@@ -9,10 +9,9 @@ const withTimeoutOption = require('ipfs-core-utils/src/with-timeout-option')
 module.exports = ({ keychain }) => {
   /**
    * @param {string} name
-   * @param {AbortOptions} [options]
    * @returns {Promise<Key>}
    */
-  const info = (name, options = {}) => keychain.findKeyByName(name, options)
+  const info = (name) => keychain.findKeyByName(name)
 
   return withTimeoutOption(info)
 }

packages/ipfs-core/src/components/key/list.js

@@ -23,18 +23,9 @@ module.exports = ({ keychain }) => {
    * // ]
    * ```
    *
-   * @param {AbortOptions} [options]
-   * @returns {Promise<KeyEntry[]>}
+   * @returns {Promise<import('libp2p/src/keychain').KeyInfo[]>}
    */
-  const list = (options = {}) => keychain.listKeys(options)
+  const list = () => keychain.listKeys()
 
   return withTimeoutOption(list)
 }
-
-/**
- * @typedef {Object} KeyEntry
- * @property {string} name - The name of the key
- * @property {string} hash -  The hash of the key
- *
- * @typedef {import('.').AbortOptions} AbortOptions
- */

packages/ipfs-core/src/components/key/rename.js

@@ -22,11 +22,11 @@ module.exports = ({ keychain }) => {
    * ```
    * @param {string} oldName - The current key name
    * @param {string} newName - The desired key name
-   * @param {AbortOptions} [options]
    * @returns {Promise<RenamedKey>}
    */
-  const rename = async (oldName, newName, options = {}) => {
-    const key = await keychain.renameKey(oldName, newName, options)
+  const rename = async (oldName, newName) => {
+    const key = await keychain.renameKey(oldName, newName)
+
     return {
       was: oldName,
       now: key.name,

packages/ipfs-core/src/components/key/rm.js

@@ -20,10 +20,9 @@ module.exports = ({ keychain }) => {
    * ```
    *
    * @param {string} name - The name of the key to remove
-   * @param {import('.').AbortOptions} options
    * @returns {Promise<RemovedKey>} - An object that describes the removed key
    */
-  const rm = (name, options) => keychain.removeKey(name, options)
+  const rm = (name) => keychain.removeKey(name)
 
   return withTimeoutOption(rm)
 }

packages/ipfs-core/src/components/libp2p.js

@@ -164,6 +164,6 @@ function getLibp2pOptions ({ options, config, datastore, keys, keychainConfig, p
  * @typedef {import('.').PeerId} PeerId
  * @typedef {import('.').Options} IPFSOptions
  * @typedef {import('libp2p')} LibP2P
- * @typedef {import('libp2p').Options} Options
+ * @typedef {import('libp2p').Libp2pOptions} Options
  * @typedef {import('.').IPFSConfig} IPFSConfig
  */

packages/ipfs-core/src/components/ping.js

@@ -35,21 +35,28 @@ module.exports = ({ network }) => {
       peerId = PeerId.createFromCID(peerId)
     }
 
-    let peer = libp2p.peerStore.get(peerId)
+    const storedPeer = libp2p.peerStore.get(peerId)
+    let id = storedPeer && storedPeer.id
 
-    if (!peer) {
+    if (!id) {
       yield { ...basePacket, text: `Looking up peer ${peerId}` }
-      peer = await libp2p.peerRouting.findPeer(peerId)
+      const remotePeer = await libp2p.peerRouting.findPeer(peerId)
+
+      id = remotePeer && remotePeer.id
+    }
+
+    if (!id) {
+      throw new Error('Peer was not found')
     }
 
-    yield { ...basePacket, text: `PING ${peer.id.toB58String()}` }
+    yield { ...basePacket, text: `PING ${id.toB58String()}` }
 
     let packetCount = 0
     let totalTime = 0
 
     for (let i = 0; i < options.count; i++) {
       try {
-        const time = await libp2p.ping(peer.id)
+        const time = await libp2p.ping(id)
         totalTime += time
         packetCount++
         yield { ...basePacket, time }

packages/ipfs-core/src/components/pubsub.js

@@ -41,6 +41,7 @@ module.exports = ({ network, config }) => {
    */
   async function subscribe (topic, handler, options) {
     const { libp2p } = await network.use(options)
+    // @ts-ignore Libp2p Pubsub is deprecating the handler, using the EventEmitter
     return libp2p.pubsub.subscribe(topic, handler, options)
   }
 
@@ -75,6 +76,7 @@ module.exports = ({ network, config }) => {
    */
   async function unsubscribe (topic, handler, options) {
     const { libp2p } = await network.use(options)
+    // @ts-ignore Libp2p Pubsub is deprecating the handler, using the EventEmitter
     libp2p.pubsub.unsubscribe(topic, handler, options)
   }
 
@@ -111,7 +113,7 @@ module.exports = ({ network, config }) => {
    */
   async function ls (options) {
     const { libp2p } = await network.use(options)
-    return libp2p.pubsub.getTopics(options)
+    return libp2p.pubsub.getTopics()
   }
 
   /**
@@ -131,7 +133,7 @@ module.exports = ({ network, config }) => {
    */
   async function peers (topic, options) {
     const { libp2p } = await network.use(options)
-    return libp2p.pubsub.getSubscribers(topic, options)
+    return libp2p.pubsub.getSubscribers(topic)
   }
 }
 

packages/ipfs-core/src/components/stats/bw.js

@@ -13,7 +13,9 @@ const withTimeoutOption = require('ipfs-core-utils/src/with-timeout-option')
 function getBandwidthStats (libp2p, opts) {
   let stats
 
-  if (opts.peer) {
+  if (!libp2p.metrics) {
+    stats = undefined
+  } else if (opts.peer) {
     stats = libp2p.metrics.forPeer(opts.peer)
   } else if (opts.proto) {
     stats = libp2p.metrics.forProtocol(opts.proto)
@@ -85,7 +87,7 @@ module.exports = ({ network }) => {
 
 /**
  * @typedef {Object} BWOptions
- * @property {PeerId|CID|string} [peer] - Specifies a peer to print bandwidth for
+ * @property {PeerId} [peer] - Specifies a peer to print bandwidth for
  * @property {string} [proto] - Specifies a protocol to print bandwidth for
  * @property {boolean} [poll] - Is used to yield bandwidth info at an interval
  * @property {number|string} [interval=1000] - The time interval to wait between updating output, if `poll` is `true`.

packages/ipfs-core/src/components/storage.js

@@ -43,6 +43,8 @@ class Storage {
 
     const { peerId, keychain, isNew } = await loadRepo(repo, options)
 
+    // TODO: throw error?
+    // @ts-ignore On start, keychain will always be available
     return new Storage(peerId, keychain, repo, print, isNew)
   }
 }
@@ -52,7 +54,7 @@ module.exports = Storage
  *
  * @param {Repo} repo
  * @param {RepoOptions & InitOptions} options
- * @returns {Promise<{peerId: PeerId, keychain:Keychain, isNew:boolean }>}
+ * @returns {Promise<{peerId: PeerId, keychain: Keychain | undefined, isNew:boolean }>}
  */
 const loadRepo = async (repo, options) => {
   const openError = await openRepo(repo)
@@ -96,7 +98,7 @@ const openRepo = async (repo) => {
 /**
  * @param {Repo} repo
  * @param {RepoOptions & InitOptions} options
- * @returns {Promise<{peerId: PeerId, keychain:Keychain}>}
+ * @returns {Promise<{peerId: PeerId, keychain: Keychain | undefined}>}
  */
 const initRepo = async (repo, options) => {
   // 1. Verify that repo does not exist yet (if it does and we could not
@@ -197,7 +199,7 @@ const peerIdToIdentity = (peerId) => ({
  *
  * @param {Repo} repo
  * @param {ConfigureOptions} options
- * @returns {Promise<{peerId: PeerId, keychain:Keychain}>}
+ * @returns {Promise<{peerId: PeerId, keychain: Keychain | undefined}>}
  */
 const configureRepo = async (repo, { config, profiles, pass }) => {
   const original = await repo.config.getAll()
@@ -297,5 +299,5 @@ const applyProfiles = (config, profiles) => {
  * @typedef {import('.').IPFSConfig} IPFSConfig
  * @typedef {import('../interface/repo').Repo<IPFSConfig>} Repo
  * @typedef {import('libp2p-crypto').KeyType} KeyType
- * @typedef {import('libp2p').LibP2PKeychain} Keychain
+ * @typedef {import('libp2p/src/keychain')} Keychain
  */

packages/ipfs-core/src/components/swarm/addrs.js

@@ -16,7 +16,7 @@ module.exports = ({ network }) => {
   async function addrs (options) { // eslint-disable-line require-await
     const peers = []
     const { libp2p } = await network.use(options)
-    for (const [peerId, peer] of libp2p.peerStore.peers.entries(options)) {
+    for (const [peerId, peer] of libp2p.peerStore.peers.entries()) {
       peers.push({
         id: peerId,
         addrs: peer.addresses.map((mi) => mi.multiaddr)

packages/ipfs-core/src/components/swarm/connect.js

@@ -16,7 +16,7 @@ module.exports = ({ network }) => {
    */
   async function connect (addr, options) {
     const { libp2p } = await network.use(options)
-    return libp2p.dial(addr, options)
+    await libp2p.dial(addr, options)
   }
 
   return withTimeoutOption(connect)

packages/ipfs-core/src/components/swarm/disconnect.js

@@ -16,7 +16,7 @@ module.exports = ({ network }) => {
    */
   async function disconnect (addr, options) {
     const { libp2p } = await network.use(options)
-    return libp2p.hangUp(addr, options)
+    return libp2p.hangUp(addr)
   }
 
   return withTimeoutOption(disconnect)