feat!: upgrade to esm libp2p/ipfs (#462)

Updates all dependencies and adds types to tests.

BREAKING CHANGE: uses ESM release of ipfs/libp2p

Author: achingbrain

.aegir.cjs .aegir.js

@@ -1,8 +1,23 @@
-'use strict'
+import path from 'path'
+import { createServer } from 'ipfsd-ctl'
+import { sigServer } from '@libp2p/webrtc-star-signalling-server'
+import { fileURLToPath } from 'url'
+import { resolve } from 'import-meta-resolve'
 
-const path = require('path')
-const createServer = require('ipfsd-ctl').createServer
-const signaller = require('libp2p-webrtc-star-signalling-server')
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const ipfsModule = await resolve(process.env.IPFS_JS_HTTP_MODULE || 'ipfs', import.meta.url)
+const ipfsHttpModule = await resolve(process.env.IPFS_JS_HTTP_MODULE || 'ipfs-http-client', import.meta.url)
+
+async function findGoIpfsBin () {
+  if (process.env.IPFS_GO_EXEC != null) {
+    return process.env.IPFS_GO_EXEC
+  }
+
+  const modulePath = await resolve(process.env.IPFS_GO_IPFS_MODULE || 'go-ipfs', import.meta.url)
+  const module = await import(modulePath.replace('file://', ''))
+
+  return module.path()
+}
 
 /** @type {import('aegir').Options["build"]["config"]} */
 const esbuild = {
@@ -11,33 +26,29 @@ const esbuild = {
     {
       name: 'node built ins',
       setup (build) {
-        build.onResolve({ filter: /^stream$/ }, () => {
-          return { path: require.resolve('readable-stream') }
-        })
-
         build.onResolve({ filter: /^ipfs$/ }, () => {
-          return { path: require.resolve(process.env.IPFS_JS_MODULE || 'ipfs') }
+          return { path: ipfsModule.replace('file://', '') }
         })
         build.onResolve({ filter: /^ipfs-http-client$/ }, () => {
-          return { path: require.resolve(process.env.IPFS_JS_HTTP_MODULE || 'ipfs-http-client') }
+          return { path: ipfsHttpModule.replace('file://', '') }
         })
       }
     }
   ]
 }
 
-const ipfsHttpModule = require(process.env.IPFS_JS_HTTP_MODULE || 'ipfs-http-client')
-const ipfsModule = require(process.env.IPFS_JS_MODULE || 'ipfs')
-
 /** @type {import('aegir').PartialOptions} */
-module.exports = {
+export default {
   test: {
     browser: {
       config: {
         buildConfig: esbuild
       }
     },
     async before (options) {
+      const ipfsHttpModule = await import(process.env.IPFS_JS_HTTP_MODULE || 'ipfs-http-client')
+      const ipfsModule = await import(process.env.IPFS_JS_MODULE || 'ipfs')
+
       if (options.runner !== 'node') {
         const ipfsdServer = await createServer({
           host: '127.0.0.1',
@@ -48,7 +59,7 @@ module.exports = {
           ipfsHttpModule
         }, {
           go: {
-            ipfsBin: process.env.IPFS_GO_EXEC || require(process.env.IPFS_GO_IPFS_MODULE || 'go-ipfs').path()
+            ipfsBin: await findGoIpfsBin()
           },
           js: {
             ipfsOptions: {
@@ -65,11 +76,12 @@ module.exports = {
           }
         }).start()
 
-        const signallingServer = await signaller.start({
+        const signallingServer = await sigServer({
           port: 24642,
           host: '0.0.0.0',
           metrics: false
         })
+
         return {
           ipfsdServer,
           signallingServer

.github/dependabot.yml

@@ -6,3 +6,6 @@ updates:
     interval: daily
     time: "10:00"
   open-pull-requests-limit: 10
+  commit-message:
+    prefix: "deps"
+    prefix-development: "deps(dev)"

.github/workflows/automerge.yml

@@ -0,0 +1,8 @@
+name: Automerge
+on: [ pull_request ]
+
+jobs:
+  automerge:
+    uses: protocol/.github/.github/workflows/automerge.yml@master
+    with:
+      job: 'automerge'

.github/workflows/js-test-and-release.yml

@@ -0,0 +1,145 @@
+name: test & maybe release
+on:
+  push:
+    branches:
+      - master # with #262 - ${{{ github.default_branch }}}
+  pull_request:
+    branches:
+      - master # with #262 - ${{{ github.default_branch }}}
+
+jobs:
+
+  check:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v2
+      with:
+        node-version: lts/*
+    - uses: ipfs/aegir/actions/cache-node-modules@master
+    - run: npm run --if-present lint
+    - run: npm run --if-present dep-check
+
+  test-node:
+    needs: check
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest]
+        node: [16]
+      fail-fast: true
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run --if-present test:node
+      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0
+        with:
+          flags: node
+
+  test-chrome:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run --if-present test:chrome
+      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0
+        with:
+          flags: chrome
+
+  test-chrome-webworker:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run --if-present test:chrome-webworker
+      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0
+        with:
+          flags: chrome-webworker
+
+  test-firefox:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run --if-present test:firefox
+      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0
+        with:
+          flags: firefox
+
+  test-firefox-webworker:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run --if-present test:firefox-webworker
+      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0
+        with:
+          flags: firefox-webworker
+
+  test-electron-main:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npx xvfb-maybe npm run --if-present test:electron-main
+      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0
+        with:
+          flags: electron-main
+
+  test-electron-renderer:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npx xvfb-maybe npm run --if-present test:electron-renderer
+      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0
+        with:
+          flags: electron-renderer
+
+  release:
+    needs: [test-node, test-chrome, test-chrome-webworker, test-firefox, test-firefox-webworker, test-electron-main, test-electron-renderer]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master' # with #262 - 'refs/heads/${{{ github.default_branch }}}'
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - uses: ipfs/aegir/actions/docker-login@master
+        with:
+          docker-token: ${{ secrets.DOCKER_TOKEN }}
+          docker-username: ${{ secrets.DOCKER_USERNAME }}
+      - run: npm run --if-present release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/test.yml

@@ -8,6 +8,7 @@ logs
 *.log
 
 coverage
+.coverage
 
 # Runtime data
 pids

.gitignore

@@ -1,23 +1,39 @@
-# Interoperability Tests for IPFS
+# ipfs-interop <!-- omit in toc -->
+
+[![ipfs.io](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io)
+[![IRC](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
+[![Discord](https://img.shields.io/discord/806902334369824788?style=flat-square)](https://discord.gg/ipfs)
+[![codecov](https://img.shields.io/codecov/c/github/ipfs/interop.svg?style=flat-square)](https://codecov.io/gh/ipfs/interop)
+[![CI](https://img.shields.io/github/workflow/status/ipfs/interop/test%20&%20maybe%20release/master?style=flat-square)](https://github.com/ipfs/interop/actions/workflows/js-test-and-release.yml)
+
+> Interoperability Tests for IPFS
+
+## Table of contents <!-- omit in toc -->
+
+- [Install](#install)
+- [Usage](#usage)
+  - [Run the tests](#run-the-tests)
+  - [Run a particular test locally](#run-a-particular-test-locally)
+- [Testing with different versions of go/js IPFS](#testing-with-different-versions-of-gojs-ipfs)
+  - [As a project](#as-a-project)
+  - [As environmental variables](#as-environmental-variables)
+  - [As a custom runtime](#as-a-custom-runtime)
+- [Releasing a new version](#releasing-a-new-version)
+- [Interop release process for when breaking changes are introduced](#interop-release-process-for-when-breaking-changes-are-introduced)
+- [Contribute](#contribute)
+- [License](#license)
+- [Contribute](#contribute-1)
+
+## Install
 
-[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
-[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/)
-[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
-[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
-[![Travis CI](https://travis-ci.com/ipfs/interop.svg?branch=master)](https://travis-ci.com/ipfs/interop)
-
-> Interoperability tests for IPFS Implementations
+```console
+$ npm i ipfs-interop
+```
 
 This repository will be used for interop tests. Please jump into the issues if you'd like to help out setting this up!
 
 ## Usage
 
-### Install
-
-```console
-$ npm install -g ipfs-interop
-```
-
 ### Run the tests
 
 ```console
@@ -76,7 +92,7 @@ $ IPFS_GO_EXEC=/path IPFS_JS_EXEC=/path IPFS_JS_MODULE=/path IPFS_JS_HTTP_MODULE
 ### As a custom runtime
 
 If you want to run interop on CI against specific repo and git revision of
-go-ipfs or js-ipfs* then set everything up in `./scripts/custom-runtime.sh`
+go-ipfs or js-ipfs\* then set everything up in `./scripts/custom-runtime.sh`
 and enable it by uncommenting `env:` `IPFS_(..)` definitions in `.github/workflows/test.yml`
 
 If you want to test against unrelased things locally, make sure the same env
@@ -85,25 +101,21 @@ variables are set on your machine.
 For example, to run pubsub tests against go-ipfs and js-ipfs revision defined
 in `./scripts/custom-runtime.sh`, one can:
 
-```
-export IPFS_GO_EXEC=/tmp/go-ipfs/cmd/ipfs/ipfs
-export IPFS_JS_EXEC=/tmp/js-ipfs/packages/ipfs/src/cli.js
-export IPFS_JS_MODULE=/tmp/js-ipfs/packages/ipfs/dist/cjs/src/index.js
-export IPFS_JS_HTTP_MODULE=/tmp/js-ipfs/packages/ipfs-http-client/dist/cjs/src/index.js
-./scripts/custom-runtime.sh
-node bin/ipfs-interop.js -- -t node --grep "pubsub"
-```
+    export IPFS_GO_EXEC=/tmp/go-ipfs/cmd/ipfs/ipfs
+    export IPFS_JS_EXEC=/tmp/js-ipfs/packages/ipfs/src/cli.js
+    export IPFS_JS_MODULE=/tmp/js-ipfs/packages/ipfs/src/index.js
+    export IPFS_JS_HTTP_MODULE=/tmp/js-ipfs/packages/ipfs-http-client/src/index.js
+    ./scripts/custom-runtime.sh
+    node bin/ipfs-interop.js -- -t node --grep "pubsub"
 
 ## Releasing a new version
 
 This repo does not use aegir for releases.
 Use `npm` directly  and publish entire root (CI in go-ipfs requires it).
 
-```
-npm version [major|minor|patch]
-npm publish
-npm push origin && npm push origin v[N.N.N]
-```
+    npm version [major|minor|patch]
+    npm publish
+    npm push origin && npm push origin v[N.N.N]
 
 ## Interop release process for when breaking changes are introduced
 
@@ -124,4 +136,15 @@ This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/c
 
 ## License
 
-[MIT](./LICENSE)
+Licensed under either of
+
+- Apache 2.0, ([LICENSE-APACHE](LICENSE-APACHE) / <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT ([LICENSE-MIT](LICENSE-MIT) / <http://opensource.org/licenses/MIT>)
+
+## Contribute
+
+Feel free to join in. All welcome. Open an [issue](https://github.com/ipfs/js-ipfs-unixfs-importer/issues)!
+
+This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+[![](https://cdn.rawgit.com/jbenet/contribute-ipfs-gif/master/img/contribute.gif)](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md)

README.md

@@ -22,37 +22,43 @@
   "bin": {
     "ipfs-interop": "bin/ipfs-interop.js"
   },
-  "main": "src/index.js",
   "type": "module",
-  "types": "types/src/index.d.ts",
+  "types": "./dist/src/index.d.ts",
   "typesVersions": {
     "*": {
       "*": [
-        "types/*",
-        "types/src/*"
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
       ],
-      "types/*": [
-        "types/*",
-        "types/src/*"
+      "src/*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
       ]
     }
   },
   "files": [
-    "*",
-    "!**/*.tsbuildinfo",
-    "!**/browser-test",
-    "!**/node-test"
+    ".aegir.js",
+    "bin",
+    "src",
+    "scripts",
+    "test",
+    "dist",
+    "!**/*.tsbuildinfo"
   ],
   "exports": {
     ".": {
+      "types": "./dist/src/index.d.ts",
       "import": "./src/index.js"
     }
   },
   "eslintConfig": {
     "extends": "ipfs",
     "parserOptions": {
-      "sourceType": "module",
-      "ecmaVersion": "2020"
+      "sourceType": "module"
     },
     "ignorePatterns": [
       "package.json"
@@ -85,15 +91,15 @@
               "release": "patch"
             },
             {
-              "type": "chore",
+              "type": "docs",
               "release": "patch"
             },
             {
-              "type": "docs",
+              "type": "test",
               "release": "patch"
             },
             {
-              "type": "test",
+              "type": "deps",
               "release": "patch"
             },
             {
@@ -123,7 +129,11 @@
               },
               {
                 "type": "docs",
-                "section": "Trivial Changes"
+                "section": "Documentation"
+              },
+              {
+                "type": "deps",
+                "section": "Dependencies"
               },
               {
                 "type": "test",
@@ -134,77 +144,77 @@
         }
       ],
       "@semantic-release/changelog",
-      [
-        "@semantic-release/npm",
-        {
-          "pkgRoot": "dist"
-        }
-      ],
+      "@semantic-release/npm",
       "@semantic-release/github",
       "@semantic-release/git"
     ]
   },
   "scripts": {
-    "clean": "rimraf /tmp/js-ipfs /tmp/go-ipfs ./go-libp2p-relay-daemon dist types",
+    "clean": "rimraf scripts/libp2p-relay-daemon dist",
     "lint": "aegir lint",
-    "build": "aegir build --esm-tests && cp -R types scripts bin test src .aegir.cjs dist && cp bin/package.json dist/src && cp bin/package.json dist/test && npx json -I -f dist/package.json -e 'this.browser.execa=false; this.browser.fs=false; this.browser[\"go-ipfs\"]=false'",
-    "release": "semantic-release",
-    "postinstall": "cross-env node ./scripts/setup-libp2p-relay-daemon.js",
-    "pretest": "aegir build --esm-tests",
+    "build": "aegir build",
+    "release": "aegir release",
     "test": "cross-env LIBP2P_TCP_REUSEPORT=false aegir test",
-    "test:node": "cross-env LIBP2P_TCP_REUSEPORT=false aegir test -t node -f test/node.js",
-    "test:browser": "cross-env LIBP2P_TCP_REUSEPORT=false aegir test -t browser -f test/browser.js",
-    "dep-check": "aegir dep-check package.json"
+    "test:node": "cross-env LIBP2P_TCP_REUSEPORT=false aegir test -t node -f test/node.js --cov",
+    "test:chrome": "cross-env LIBP2P_TCP_REUSEPORT=false aegir test -t browser -f test/browser.js --cov",
+    "test:electron-main": "LIBP2P_TCP_REUSEPORT=false aegir test -t electron-main -f test/node.js",
+    "dep-check": "aegir dep-check"
   },
   "dependencies": {
-    "aegir": "^36.2.3",
+    "@libp2p/interface-peer-id": "^1.0.4",
+    "@libp2p/peer-id": "^1.1.10",
+    "@libp2p/webrtc-star-signalling-server": "^2.0.1",
+    "@libp2p/websockets": "^3.0.0",
+    "@multiformats/multiaddr": "^10.4.3",
+    "@types/is-ci": "^3.0.0",
+    "aegir": "^37.0.15",
     "assert": "^2.0.0",
     "buffer": "^6.0.3",
     "cachedir": "^2.3.0",
     "cross-env": "^7.0.2",
     "delay": "^5.0.0",
-    "detect-node": "^2.0.4",
-    "execa": "^5.1.1",
+    "execa": "^6.1.0",
     "go-platform": "^1.0.0",
     "got": "^12.0.0",
     "gunzip-maybe": "^1.4.2",
     "hasha": "^5.2.2",
-    "ipfs-unixfs": "^6.0.3",
+    "import-meta-resolve": "^2.0.3",
+    "ipfs-unixfs": "^7.0.0",
     "ipfs-utils": "^9.0.1",
-    "ipfsd-ctl": "^10.0.3",
-    "ipns": "^0.16.0",
+    "ipfsd-ctl": "^12.0.0",
+    "ipns": "^2.0.0",
     "is-ci": "^3.0.0",
-    "is-os": "^1.0.1",
     "iso-random-stream": "^2.0.0",
     "it-all": "^1.0.1",
     "it-concat": "^2.0.0",
     "it-drain": "^1.0.0",
     "it-last": "^1.0.1",
     "it-to-buffer": "^2.0.1",
-    "libp2p-webrtc-star-signalling-server": "^0.1.0",
-    "libp2p-websockets": "^0.16.1",
     "multiformats": "^9.3.0",
-    "nanoid": "^3.1.10",
-    "p-defer": "^3.0.0",
-    "p-retry": "^4.1.0",
-    "peer-id": "^0.16.0",
-    "pretty-bytes": "^5.1.0",
+    "nanoid": "^4.0.0",
+    "p-defer": "^4.0.0",
+    "p-retry": "^5.1.1",
+    "p-timeout": "^6.0.0",
+    "p-wait-for": "^5.0.0",
+    "pretty-bytes": "^6.0.0",
     "promisify-es6": "^1.0.3",
-    "random-fs": "^1.0.3",
-    "rimraf": "^3.0.2",
     "tar-fs": "^2.1.1",
     "uint8arrays": "^3.0.0",
     "unzip-stream": "^0.3.1",
-    "wherearewe": "^1.0.0"
+    "wherearewe": "^2.0.1"
   },
   "devDependencies": {
-    "go-ipfs": "^0.12.2",
-    "ipfs": "^0.61.0",
-    "ipfs-http-client": "^55.0.0"
+    "go-ipfs": "^0.15.0",
+    "ipfs": "^0.64.0",
+    "ipfs-http-client": "^58.0.0"
   },
   "browser": {
     "go-ipfs": false,
     "fs": false,
-    "execa": false
+    "execa": false,
+    "os": false,
+    "path": false,
+    "./scripts/download-relay-daemon.js": false,
+    "./test/utils/is-windows.js": "./test/utils/is-windows.browser.js"
   }
 }

bin/package.json

@@ -10,8 +10,8 @@
 #
 #  export IPFS_GO_EXEC=/tmp/go-ipfs/cmd/ipfs/ipfs
 #  export IPFS_JS_EXEC=/tmp/js-ipfs/packages/ipfs/src/cli.js
-#  export IPFS_JS_MODULE=/tmp/js-ipfs/packages/ipfs/dist/cjs/src/index.js
-#  export IPFS_JS_HTTP_MODULE=/tmp/js-ipfs/packages/ipfs-http-client/dist/cjs/src/index.js
+#  export IPFS_JS_MODULE=/tmp/js-ipfs/packages/ipfs/src/index.js
+#  export IPFS_JS_HTTP_MODULE=/tmp/js-ipfs/packages/ipfs-http-client/src/index.js
 #  ./scripts/custom-runtime.sh
 #  node bin/ipfs-interop.js -- -t node --grep "pubsub"
 

package-lock.json

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+// this script will download the libp2p-relay-daemon binary
+// for windows/macos/linux. based on parts of https://github.com/ipfs/npm-go-ipfs
+
+// @ts-expect-error no types
+import gunzip from 'gunzip-maybe'
+import got from 'got'
+import path from 'path'
+// @ts-expect-error no types
+import tarFS from 'tar-fs'
+// @ts-expect-error no types
+import unzip from 'unzip-stream'
+// @ts-expect-error no types
+import cachedir from 'cachedir'
+import fs from 'fs'
+import os from 'os'
+import hasha from 'hasha'
+
+// libp2p-relay-daemon version from https://dist.ipfs.io/libp2p-relay-daemon/
+export const LIBP2P_RELAY_DAEMON_VERSION = 'v0.1.0'
+
+/**
+ * avoid expensive fetch if file is already in cache
+ * @param {string} url
+ */
+async function cachingFetchAndVerify (url) {
+  const cacheDir = process.env.NPM_GO_LIBP2P_RELAY_DAEMON_CACHE || cachedir('npm-go-libp2p-relay-daemon')
+  const filename = url.split('/').pop()
+
+  if (!filename) {
+    throw new Error('Invalid URL')
+  }
+
+  const cachedFilePath = path.join(cacheDir, filename)
+  const cachedHashPath = `${cachedFilePath}.sha512`
+
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true })
+  }
+  if (!fs.existsSync(cachedFilePath)) {
+    console.info(`Downloading ${url} to ${cacheDir}`)
+    // download file
+    fs.writeFileSync(cachedFilePath, await got(url).buffer())
+    console.info(`Downloaded ${url}`)
+
+    // ..and checksum
+    console.info(`Downloading ${filename}.sha512`)
+    fs.writeFileSync(cachedHashPath, await got(`${url}.sha512`).buffer())
+    console.info(`Downloaded ${filename}.sha512`)
+  } else {
+    console.info(`Found ${cachedFilePath}`)
+  }
+
+  console.info(`Verifying ${filename}.sha512`)
+
+  const digest = Buffer.alloc(128)
+  const fd = fs.openSync(cachedHashPath, 'r')
+  fs.readSync(fd, digest, 0, digest.length, 0)
+  fs.closeSync(fd)
+  const expectedSha = digest.toString('utf8')
+  const calculatedSha = await hasha.fromFile(cachedFilePath, { encoding: 'hex', algorithm: 'sha512' })
+  if (calculatedSha !== expectedSha) {
+    console.log(`Expected   SHA512: ${expectedSha}`)
+    console.log(`Calculated SHA512: ${calculatedSha}`)
+    throw new Error(`SHA512 of ${cachedFilePath}' (${calculatedSha}) does not match expected value from ${cachedFilePath}.sha512 (${expectedSha})`)
+  }
+  console.log(`OK (${expectedSha})`)
+
+  return fs.createReadStream(cachedFilePath)
+}
+
+/**
+ * @param {string} version
+ * @param {string} platform
+ * @param {string} arch
+ * @param {string} distUrl
+ */
+async function getDownloadURL (version, platform, arch, distUrl) {
+  const data = await got(`${distUrl}/libp2p-relay-daemon/${version}/dist.json`).json()
+
+  if (!data.platforms[platform]) {
+    throw new Error(`No binary available for platform '${platform}'. Available platforms: ${Object.keys(data.platforms).join(', ')}`)
+  }
+
+  if (!data.platforms[platform].archs[arch]) {
+    throw new Error(`No binary available for platform '${platform}' and arch '${arch}'. Available architectures: ${Object.keys(data.platforms[platform].archs)}`)
+  }
+
+  const link = data.platforms[platform].archs[arch].link
+  return `${distUrl}/libp2p-relay-daemon/${version}${link}`
+}
+
+/**
+ * @param {string} url
+ * @param {string} installPath
+ * @param {import('stream').Readable} stream
+ */
+function unpack (url, installPath, stream) {
+  return new Promise((resolve, reject) => {
+    if (url.endsWith('.zip')) {
+      return stream.pipe(
+        unzip
+          .Extract({ path: installPath })
+          .on('close', resolve)
+          .on('error', reject)
+      )
+    }
+
+    return stream
+      .pipe(gunzip())
+      .pipe(
+        tarFS
+          .extract(installPath)
+          .on('finish', resolve)
+          .on('error', reject)
+      )
+  })
+}
+
+/**
+ * @param {object} options
+ * @param {string} options.version
+ * @param {string} options.platform
+ * @param {string} options.arch
+ * @param {string} options.installPath
+ * @param {string} options.distUrl
+ */
+export async function download ({ version, platform, arch, installPath, distUrl }) {
+  const url = await getDownloadURL(version, platform, arch, distUrl)
+  const data = await cachingFetchAndVerify(url)
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmp-libp2p-relay-daemon'))
+  await unpack(url, tmpDir, data)
+
+  const filename = `libp2p-relay-daemon${platform === 'windows' ? '.exe' : ''}`
+  const tmpPath = path.join(tmpDir, 'libp2p-relay-daemon', filename)
+  const finalPath = path.join(installPath, filename)
+  try {
+    // will throw if the file cannot be accessed
+    fs.accessSync(finalPath)
+    // remove old binary, just to be sure we always use the correct version
+    fs.rmSync(finalPath, { recursive: true })
+  } catch (e) {}
+  fs.cpSync(tmpPath, finalPath)
+  fs.rmSync(tmpDir, { recursive: true })
+  console.info(`Unpacked binary placed in ${finalPath}`)
+
+  return finalPath
+}

package.json

@@ -3,148 +3,11 @@
 // this script will download the libp2p-relay-daemon binary
 // for windows/macos/linux. based on parts of https://github.com/ipfs/npm-go-ipfs
 
-import goenv from 'go-platform'
-import gunzip from 'gunzip-maybe'
-import got from 'got'
-import path from 'path'
-import tarFS from 'tar-fs'
-import unzip from 'unzip-stream'
-import cachedir from 'cachedir'
-import fs from 'fs'
+import { download, LIBP2P_RELAY_DAEMON_VERSION } from './download-relay-daemon.js'
 import os from 'os'
-import hasha from 'hasha'
-
-// libp2p-relay-daemon version from https://dist.ipfs.io/libp2p-relay-daemon/
-const LIBP2P_RELAY_DAEMON_VERSION = 'v0.1.0'
-
-/**
- * avoid expensive fetch if file is already in cache
- * @param {string} url
- */
-async function cachingFetchAndVerify (url) {
-  const cacheDir = process.env.NPM_GO_LIBP2P_RELAY_DAEMON_CACHE || cachedir('npm-go-libp2p-relay-daemon')
-  const filename = url.split('/').pop()
-
-  if (!filename) {
-    throw new Error('Invalid URL')
-  }
-
-  const cachedFilePath = path.join(cacheDir, filename)
-  const cachedHashPath = `${cachedFilePath}.sha512`
-
-  if (!fs.existsSync(cacheDir)) {
-    fs.mkdirSync(cacheDir, { recursive: true })
-  }
-  if (!fs.existsSync(cachedFilePath)) {
-    console.info(`Downloading ${url} to ${cacheDir}`)
-    // download file
-    fs.writeFileSync(cachedFilePath, await got(url).buffer())
-    console.info(`Downloaded ${url}`)
-
-    // ..and checksum
-    console.info(`Downloading ${filename}.sha512`)
-    fs.writeFileSync(cachedHashPath, await got(`${url}.sha512`).buffer())
-    console.info(`Downloaded ${filename}.sha512`)
-  } else {
-    console.info(`Found ${cachedFilePath}`)
-  }
-
-  console.info(`Verifying ${filename}.sha512`)
-
-  const digest = Buffer.alloc(128)
-  const fd = fs.openSync(cachedHashPath, 'r')
-  fs.readSync(fd, digest, 0, digest.length, 0)
-  fs.closeSync(fd)
-  const expectedSha = digest.toString('utf8')
-  const calculatedSha = await hasha.fromFile(cachedFilePath, { encoding: 'hex', algorithm: 'sha512' })
-  if (calculatedSha !== expectedSha) {
-    console.log(`Expected   SHA512: ${expectedSha}`)
-    console.log(`Calculated SHA512: ${calculatedSha}`)
-    throw new Error(`SHA512 of ${cachedFilePath}' (${calculatedSha}) does not match expected value from ${cachedFilePath}.sha512 (${expectedSha})`)
-  }
-  console.log(`OK (${expectedSha})`)
-
-  return fs.createReadStream(cachedFilePath)
-}
-
-/**
- * @param {string} version
- * @param {string} platform
- * @param {string} arch
- * @param {string} distUrl
- */
-async function getDownloadURL (version, platform, arch, distUrl) {
-  const data = await got(`${distUrl}/libp2p-relay-daemon/${version}/dist.json`).json()
-
-  if (!data.platforms[platform]) {
-    throw new Error(`No binary available for platform '${platform}'. Available platforms: ${Object.keys(data.platforms).join(', ')}`)
-  }
-
-  if (!data.platforms[platform].archs[arch]) {
-    throw new Error(`No binary available for platform '${platform}' and arch '${arch}'. Available architectures: ${Object.keys(data.platforms[platform].archs)}`)
-  }
-
-  const link = data.platforms[platform].archs[arch].link
-  return `${distUrl}/libp2p-relay-daemon/${version}${link}`
-}
-
-/**
- * @param {string} url
- * @param {string} installPath
- * @param {import('stream').Readable} stream
- */
-function unpack (url, installPath, stream) {
-  return new Promise((resolve, reject) => {
-    if (url.endsWith('.zip')) {
-      return stream.pipe(
-        unzip
-          .Extract({ path: installPath })
-          .on('close', resolve)
-          .on('error', reject)
-      )
-    }
-
-    return stream
-      .pipe(gunzip())
-      .pipe(
-        tarFS
-          .extract(installPath)
-          .on('finish', resolve)
-          .on('error', reject)
-      )
-  })
-}
-
-/**
- * @param {object} options
- * @param {string} options.version
- * @param {string} options.platform
- * @param {string} options.arch
- * @param {string} options.installPath
- * @param {string} options.distUrl
- */
-async function download ({ version, platform, arch, installPath, distUrl }) {
-  const url = await getDownloadURL(version, platform, arch, distUrl)
-  const data = await cachingFetchAndVerify(url)
-
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmp-libp2p-relay-daemon'))
-  await unpack(url, tmpDir, data)
-
-  const filename = `libp2p-relay-daemon${platform === 'windows' ? '.exe' : ''}`
-  const tmpPath = path.join(tmpDir, 'libp2p-relay-daemon', filename)
-  const finalPath = path.join(installPath, filename)
-  try {
-    // remove old binary, just to be sure we always use the correct version
-    if (fs.accessSync(finalPath)) {
-      fs.rmSync(finalPath, { recursive: true })
-    }
-  } catch (e) {}
-  fs.cpSync(tmpPath, finalPath)
-  fs.rmSync(tmpDir, { recursive: true })
-  console.info(`Unpacked binary placed in ${finalPath}`)
-
-  return finalPath
-}
+import path from 'path'
+// @ts-expect-error no types
+import goenv from 'go-platform'
 
 download({
   version: LIBP2P_RELAY_DAEMON_VERSION,

scripts/custom-runtime.sh

@@ -2,13 +2,22 @@
 
 import { nanoid } from 'nanoid'
 import concat from 'it-concat'
-import { expect } from 'aegir/utils/chai.js'
+import { expect } from 'aegir/chai'
 import { daemonFactory } from './utils/daemon-factory.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
+
 describe('CID version agnostic', function () {
-  this.timeout(50 * 1000)
+  this.timeout(50e3)
+  /** @type {Record<string, Controller>} */
   const daemons = {}
+  /**
+   * @type {Factory}
+   */
   let factory
 
   before(async function () {
@@ -23,12 +32,12 @@ describe('CID version agnostic', function () {
     Object.assign(daemons, { js0, js1, go0, go1 })
 
     await Promise.all([
-      js0.api.swarm.connect(js1.api.peerId.addresses[0]),
-      js1.api.swarm.connect(js0.api.peerId.addresses[0]),
-      go0.api.swarm.connect(go1.api.peerId.addresses[0]),
-      go1.api.swarm.connect(go0.api.peerId.addresses[0]),
-      js0.api.swarm.connect(go0.api.peerId.addresses[0]),
-      go0.api.swarm.connect(js0.api.peerId.addresses[0])
+      js0.api.swarm.connect(js1.peer.addresses[0]),
+      js1.api.swarm.connect(js0.peer.addresses[0]),
+      go0.api.swarm.connect(go1.peer.addresses[0]),
+      go1.api.swarm.connect(go0.peer.addresses[0]),
+      js0.api.swarm.connect(go0.peer.addresses[0]),
+      go0.api.swarm.connect(js0.peer.addresses[0])
     ])
   })
 

scripts/download-relay-daemon.js

@@ -5,11 +5,16 @@ import allV1 from './circuit/v1/all.js'
 import allV2 from './circuit/v2/all.js'
 import browserV1 from './circuit/v1/browser.js'
 import browserV2 from './circuit/v2/browser.js'
-import isNode from 'detect-node'
+import { isNode, isElectronMain } from 'wherearewe'
 import { connect, send, clean } from './utils/circuit.js'
 import { closeRelays } from './utils/relayd.js'
 import { daemonFactory } from './utils/daemon-factory.js'
 
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
+
 const timeout = 80 * 1000
 const baseTest = {
   connect,
@@ -22,17 +27,22 @@ describe('circuit', () => {
 
   // Legacy v1 (unlimited relay)
   describe('v1', () => {
+    /** @type {Factory} */
     let factory
 
     before(async () => {
       factory = await daemonFactory()
     })
 
-    const tests = isNode ? allV1 : browserV1
+    /** @type {*} */
+    const tests = isNode || isElectronMain ? allV1 : browserV1
 
     Object.keys(tests).forEach((test) => {
+      /** @type {Controller} */
       let nodeA
+      /** @type {Controller} */
       let relay
+      /** @type {Controller} */
       let nodeB
 
       tests[test] = Object.assign({}, baseTest, tests[test])
@@ -64,17 +74,22 @@ describe('circuit', () => {
   // Modern v2 (limited relay)
   // https://github.com/libp2p/specs/blob/master/relay/circuit-v2.md
   describe('v2', () => {
+    /** @type {Factory} */
     let factory
 
     before(async () => {
       factory = await daemonFactory()
     })
 
-    const tests = isNode ? allV2 : browserV2
+    /** @type {*} */
+    const tests = isNode || isElectronMain ? allV2 : browserV2
 
     Object.keys(tests).forEach((test) => {
+      /** @type {Controller} */
       let nodeA
+      /** @type {Controller} */
       let relay
+      /** @type {Controller} */
       let nodeB
 
       tests[test] = Object.assign({}, baseTest, tests[test])

scripts/package.json

@@ -4,12 +4,19 @@
 import { createJs, createGo, randomWsAddr } from '../../utils/circuit.js'
 import { getRelayV } from '../../utils/relayd.js'
 
+/**
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
+
 export default {
 
   // rv1 is a standalone, reference implementation of circuit relay v1
   // (https://github.com/libp2p/go-libp2p-relay-daemon)
 
   'go-rv1-go': {
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await getRelayV(1)
       return Promise.all([
@@ -21,6 +28,9 @@ export default {
   },
 
   'js-rv1-js': {
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await getRelayV(1)
       return Promise.all([
@@ -32,6 +42,9 @@ export default {
   },
 
   'js-rv1-go': {
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await getRelayV(1)
       return Promise.all([
@@ -43,6 +56,9 @@ export default {
   },
 
   'go-rv1-js': {
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await getRelayV(1)
       return Promise.all([
@@ -58,6 +74,9 @@ export default {
   // FIXME: remove after js-ipfs migrates to v2
 
   'go-js-go': {
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       return Promise.all([
         createGo([randomWsAddr], factory),
@@ -67,6 +86,9 @@ export default {
     }
   },
   'js-js-go': {
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       return Promise.all([
         createJs([randomWsAddr], factory),
@@ -76,13 +98,19 @@ export default {
     }
   },
   'go-js-js': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createGo([randomWsAddr], factory),
       createJs([randomWsAddr], factory),
       createJs([randomWsAddr], factory)
     ])
   },
   'js-js-js': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createJs([randomWsAddr], factory),
       createJs([randomWsAddr], factory),

scripts/setup-libp2p-relay-daemon.js

@@ -13,10 +13,19 @@ import {
   getWsAddr,
   getWrtcStarAddr
 } from '../../utils/circuit.js'
+import { Multiaddr } from '@multiformats/multiaddr'
+
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
 
 export default {
   'browser-go-js': {
     skip: () => true, // FIXME when we have circuit v2 in js-ipfs and webrtc signaling
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await createGoRelay([randomWsAddr], factory)
       return Promise.all([
@@ -29,6 +38,9 @@ export default {
   },
   'browser-go-go': {
     skip: () => true, // FIXME when we have circuit v2 in js-ipfs and webrtc signaling
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await createGoRelay([randomWsAddr], factory)
       return Promise.all([
@@ -40,6 +52,9 @@ export default {
     connect: connWithTimeout(1500)
   },
   'browser-js-js': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createProc([], factory),
       createJs([randomWsAddr], factory),
@@ -48,6 +63,9 @@ export default {
     connect: connWithTimeout(1500)
   },
   'browser-js-go': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createProc([], factory),
       createJs([randomWsAddr], factory),
@@ -57,6 +75,9 @@ export default {
   },
   'js-go-browser': {
     skip: () => true, // FIXME when we have circuit v2 in js-ipfs and webrtc signaling
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await createGoRelay([randomWsAddr], factory)
       return Promise.all([
@@ -69,6 +90,9 @@ export default {
   },
   'go-go-browser': {
     skip: () => true, // FIXME when we have circuit v2 in js-ipfs and webrtc signaling
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await createGoRelay([randomWsAddr], factory)
       return Promise.all([
@@ -80,6 +104,9 @@ export default {
     connect: connWithTimeout(1500)
   },
   'js-js-browser': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createJs([randomWsAddr], factory),
       createJs([randomWsAddr], factory),
@@ -88,6 +115,9 @@ export default {
     connect: connWithTimeout(1500)
   },
   'go-js-browser': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createGo([randomWsAddr], factory),
       createJs([randomWsAddr], factory),
@@ -96,65 +126,97 @@ export default {
     connect: connWithTimeout(1500)
   },
   'go-browser-browser': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createGo([randomWsAddr], factory),
       createProc(['/ip4/127.0.0.1/tcp/24642/ws/p2p-webrtc-star'], factory),
       createProc(['/ip4/127.0.0.1/tcp/24642/ws/p2p-webrtc-star'], factory)
     ]),
+    /**
+     * @param {Controller} nodeA
+     * @param {Controller} nodeB
+     * @param {Controller} relay
+     */
     connect: async (nodeA, nodeB, relay) => {
       await relay.api.swarm.connect(await getWsAddr(nodeA.api))
       await relay.api.swarm.connect(await getWrtcStarAddr(nodeB.api))
       // TODO: needed until https://github.com/ipfs/interop/issues/17 is resolved
       await delay(5000)
-      const nodeBCircuitAddr = `${await getWrtcStarAddr(relay.api)}/p2p-circuit/p2p/${nodeB.api.peerId.id}`
+      const nodeBCircuitAddr = new Multiaddr(`${await getWrtcStarAddr(relay.api)}/p2p-circuit/p2p/${nodeB.peer.id.toString()}`)
       await nodeA.api.swarm.connect(nodeBCircuitAddr)
     },
     skip: () => true // go-ipfs does not know what p2p-webrtc-star is
   },
   'js-browser-browser': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createJs([randomWsAddr], factory),
       createProc(['/ip4/127.0.0.1/tcp/24642/ws/p2p-webrtc-star'], factory),
       createProc(['/ip4/127.0.0.1/tcp/24642/ws/p2p-webrtc-star'], factory)
     ]),
+    /**
+     * @param {Controller} nodeA
+     * @param {Controller} nodeB
+     * @param {Controller} relay
+     */
     connect: async (nodeA, nodeB, relay) => {
       await relay.api.swarm.connect(await getWsAddr(nodeA.api))
       await relay.api.swarm.connect(await getWrtcStarAddr(nodeB.api))
       // TODO: needed until https://github.com/ipfs/interop/issues/17 is resolved
       await delay(3000)
-      const nodeBCircuitAddr = `${await getWrtcStarAddr(relay.api)}/p2p-circuit/p2p/${nodeB.api.peerId.id}`
+      const nodeBCircuitAddr = new Multiaddr(`${await getWrtcStarAddr(relay.api)}/p2p-circuit/p2p/${(await nodeB.api.id()).id.toString()}`)
       await nodeA.api.swarm.connect(nodeBCircuitAddr)
     },
     skip: () => isWebWorker // no webrtc support in webworkers
   },
   'browser-browser-go': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createProc(['/ip4/127.0.0.1/tcp/24642/wss/p2p-webrtc-star'], factory),
       createProc(['/ip4/127.0.0.1/tcp/24642/wss/p2p-webrtc-star'], factory),
       createGo([randomWsAddr], factory)
     ]),
+    /**
+     * @param {Controller} nodeA
+     * @param {Controller} nodeB
+     * @param {Controller} relay
+     */
     connect: async (nodeA, nodeB, relay) => {
       await relay.api.swarm.connect(await getWrtcStarAddr(nodeA.api))
       await relay.api.swarm.connect(await getWsAddr(nodeB.api))
       // TODO: needed until https://github.com/ipfs/interop/issues/17 is resolved
       await delay(5000)
-      const nodeBCircuitAddr = `${await getWrtcStarAddr(relay.api)}/p2p-circuit/p2p/${nodeB.api.peerId.id}`
+      const nodeBCircuitAddr = new Multiaddr(`${await getWrtcStarAddr(relay.api)}/p2p-circuit/p2p/${(await nodeB.api.id()).id.toString()}`)
       await nodeA.api.swarm.connect(nodeBCircuitAddr)
     },
     skip: () => isWebWorker // no webrtc support in webworkers
   },
   'browser-browser-js': {
+    /**
+     * @param {Factory} factory
+     */
     create: (factory) => Promise.all([
       createProc(['/ip4/127.0.0.1/tcp/24642/wss/p2p-webrtc-star'], factory),
       createProc(['/ip4/127.0.0.1/tcp/24642/wss/p2p-webrtc-star'], factory),
       createJs([randomWsAddr], factory)
     ]),
+    /**
+     * @param {Controller} nodeA
+     * @param {Controller} nodeB
+     * @param {Controller} relay
+     */
     connect: async (nodeA, nodeB, relay) => {
       await relay.api.swarm.connect(await getWrtcStarAddr(nodeA.api))
       await relay.api.swarm.connect(await getWsAddr(nodeB.api))
       // TODO: needed until https://github.com/ipfs/interop/issues/17 is resolved
       await delay(3000)
-      const nodeBCircuitAddr = `${await getWrtcStarAddr(relay.api)}/p2p-circuit/p2p/${nodeB.api.peerId.id}`
+      const nodeBCircuitAddr = new Multiaddr(`${await getWrtcStarAddr(relay.api)}/p2p-circuit/p2p/${(await nodeB.api.id()).id.toString()}`)
       await nodeA.api.swarm.connect(nodeBCircuitAddr)
     },
     skip: () => isWebWorker // no webrtc support in webworkers

test/cid-version-agnostic.js

@@ -4,12 +4,19 @@
 import { createGo, createGoRelay, randomWsAddr } from '../../utils/circuit.js'
 import { getRelayV } from '../../utils/relayd.js'
 
+/**
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
+
 export default {
 
   // rv2 is a standalone, reference implementation of circuit relay v2
   // (https://github.com/libp2p/go-libp2p-relay-daemon)
 
   'go-rv2-go': {
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await getRelayV(2)
       return Promise.all([
@@ -35,6 +42,9 @@ export default {
   // relay v2 implementation in go-ipfs 0.11+
 
   'go-go-go': {
+    /**
+     * @param {Factory} factory
+     */
     create: async (factory) => {
       const relay = await createGoRelay([randomWsAddr], factory)
       return Promise.all([

test/circuit.js

@@ -3,24 +3,35 @@
 
 import randomBytes from 'iso-random-stream/src/random.js'
 import pretty from 'pretty-bytes'
-import randomFs from 'random-fs'
-import { promisify } from 'util'
-import rimraf from 'rimraf'
-import { join } from 'path'
 import { nanoid } from 'nanoid'
 import isCi from 'is-ci'
-import { isWindows } from 'is-os'
-import os from 'os'
 import concat from 'it-concat'
-import globSource from 'ipfs-utils/src/files/glob-source.js'
-import { expect } from 'aegir/utils/chai.js'
+import { expect } from 'aegir/chai'
 import { daemonFactory } from './utils/daemon-factory.js'
 import last from 'it-last'
 
-const rmDir = promisify(rimraf)
-
-function tmpDir () {
-  return join(os.tmpdir(), `ipfs_${nanoid()}`)
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
+
+/**
+ * @param {string} dir
+ * @param {number} depth
+ * @param {number} num
+ */
+async function * randomDir (dir, depth, num) {
+  const dirs = new Array(depth).fill(0).map(() => nanoid())
+
+  for (let i = 0; i < num; i++) {
+    const index = Math.round(Math.random() * depth)
+    const path = `${dir}/${dirs.slice(0, index).join('/')}/${nanoid()}.txt`
+
+    yield {
+      path,
+      content: randomBytes(5)
+    }
+  }
 }
 
 const KB = 1024
@@ -89,18 +100,20 @@ if (isCi) {
 }
 
 const min = 60 * 1000
-const timeout = isCi ? 15 * min : 10 * min
+const timeout = isCi ? 2 * min : min
 
 describe('exchange files', function () {
   this.timeout(timeout)
 
+  /** @type {Record<string, ('go' | 'js')[]>} */
   const tests = {
     'go -> js': ['go', 'js'],
     'go -> go2': ['go', 'go'],
     'js -> go': ['js', 'go'],
     'js -> js2': ['js', 'js']
   }
 
+  /** @type {Factory} */
   let factory
 
   before(async () => {
@@ -109,7 +122,9 @@ describe('exchange files', function () {
 
   Object.keys(tests).forEach((name) => {
     describe(name, () => {
+      /** @type {Controller} */
       let daemon1
+      /** @type {Controller} */
       let daemon2
 
       before('spawn nodes', async function () {
@@ -119,24 +134,22 @@ describe('exchange files', function () {
       before('connect', async function () {
         this.timeout(timeout); // eslint-disable-line
 
-        await daemon1.api.swarm.connect(daemon2.api.peerId.addresses[0])
-        await daemon2.api.swarm.connect(daemon1.api.peerId.addresses[0])
+        await daemon1.api.swarm.connect(daemon2.peer.addresses[0])
+        await daemon2.api.swarm.connect(daemon1.peer.addresses[0])
 
         const [peer1, peer2] = await Promise.all([
           daemon1.api.swarm.peers(),
           daemon2.api.swarm.peers()
         ])
 
-        expect(peer1.map((p) => p.peer.toString())).to.include(daemon2.api.peerId.id)
-        expect(peer2.map((p) => p.peer.toString())).to.include(daemon1.api.peerId.id)
+        expect(peer1.map((p) => p.peer.toString())).to.include(daemon2.peer.id.toString())
+        expect(peer2.map((p) => p.peer.toString())).to.include(daemon1.peer.id.toString())
       })
 
       after(() => factory.clean())
 
       describe('cat file', () => sizes.forEach((size) => {
         it(`${name}: ${pretty(size)}`, async function () {
-          this.timeout(timeout)
-
           const data = randomBytes(size)
 
           const { cid } = await daemon1.api.add(data)
@@ -146,36 +159,31 @@ describe('exchange files', function () {
         })
       }))
 
-      if (isWindows()) { return }
-      // TODO fix dir tests on Windows
-
       describe('get directory', () => depth.forEach((d) => dirs.forEach((num) => {
         it(`${name}: depth: ${d}, num: ${num}`, async function () {
-          this.timeout(timeout)
+          const dir = `/${nanoid()}`
 
-          const dir = tmpDir()
+          const res = await last(daemon1.api.addAll(randomDir(dir, d, num), {
+            wrapWithDirectory: true
+          }))
 
-          try {
-            await randomFs({
-              path: dir,
-              depth: d,
-              number: num
-            })
+          if (res == null) {
+            throw new Error('Nothing added')
+          }
 
-            const { cid } = await last(daemon1.api.addAll(globSource(dir, '**/*'), {
-              wrapWithDirectory: true
-            }))
+          const { cid } = res
 
-            await expect(countFiles(cid, daemon2.api)).to.eventually.equal(num)
-          } finally {
-            await rmDir(dir)
-          }
+          await expect(countFiles(cid, daemon2.api)).to.eventually.equal(num)
         })
       })))
     })
   })
 })
 
+/**
+ * @param {import('multiformats/cid').CID} cid
+ * @param {Controller["api"]} ipfs
+ */
 async function countFiles (cid, ipfs) {
   let fileCount = 0
 

test/circuit/v1/all.js

@@ -6,7 +6,12 @@ import { daemonFactory } from './utils/daemon-factory.js'
 import concat from 'it-concat'
 import all from 'it-all'
 import last from 'it-last'
-import { expect } from 'aegir/utils/chai.js'
+import { expect } from 'aegir/chai'
+
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
 
 const SHARD_THRESHOLD = 1000
 
@@ -30,13 +35,30 @@ const jsOptions = {
   args: ['--enable-sharding-experiment']
 }
 
+/**
+ * @param {Controller} daemon
+ * @param {string} path
+ * @param {Parameters<Controller["api"]["files"]["mkdir"]>[1]} [options]
+ */
 const createDirectory = (daemon, path, options) => {
   return daemon.api.files.mkdir(path, options)
 }
 
+/**
+ * @param {Controller} daemon
+ * @param {Awaited<ReturnType<Controller["api"]["add"]>>} [file]
+ */
 async function checkNodeTypes (daemon, file) {
+  if (file == null) {
+    throw new Error('No file specified')
+  }
+
   const node = await daemon.api.object.get(file.cid)
 
+  if (node.Data == null) {
+    throw new Error('No data found on pb node')
+  }
+
   const meta = UnixFS.unmarshal(node.Data)
 
   expect(meta.type).to.equal('file')
@@ -45,13 +67,22 @@ async function checkNodeTypes (daemon, file) {
   return Promise.all(
     node.Links.map(async (link) => {
       const child = await daemon.api.object.get(link.Hash)
+
+      if (child.Data == null) {
+        throw new Error('No data found on pb node')
+      }
+
       const childMeta = UnixFS.unmarshal(child.Data)
 
       expect(childMeta.type).to.equal('raw')
     })
   )
 }
 
+/**
+ * @param {Controller} daemon
+ * @param {Uint8Array} data
+ */
 async function addFile (daemon, data) {
   const fileName = 'test-file'
 
@@ -72,6 +103,9 @@ function createDataStream (size = 262144) {
   }())
 }
 
+/**
+ * @param {...any} ops
+ */
 const compare = async (...ops) => {
   expect(ops).to.have.property('length').that.is.above(1)
 
@@ -84,6 +118,10 @@ const compare = async (...ops) => {
   results.forEach(res => expect(res).to.deep.equal(result))
 }
 
+/**
+ * @param {string} expectedMessage
+ * @param {...any} ops
+ */
 const compareErrors = async (expectedMessage, ...ops) => {
   expect(ops).to.have.property('length').that.is.above(1)
 
@@ -92,7 +130,7 @@ const compareErrors = async (expectedMessage, ...ops) => {
       try {
         await op
         throw new ExpectedError('Expected operation to fail')
-      } catch (error) {
+      } catch (/** @type {any} */ error) {
         if (error instanceof ExpectedError) {
           throw error
         }
@@ -113,18 +151,24 @@ const compareErrors = async (expectedMessage, ...ops) => {
 
   const result = results.pop()
 
+  if (result == null) {
+    throw new Error('No result found')
+  }
+
   // all implementations should have the same error code
   results.forEach(res => {
     expect(res).to.have.property('code', result.code)
   })
 }
 
 describe('files', function () {
-  this.timeout(500 * 1000)
+  this.timeout(500e3)
 
+  /** @type {Controller} */
   let go
+  /** @type {Controller} */
   let js
-
+  /** @type {Factory} */
   let factory
 
   before(async () => {
@@ -145,6 +189,9 @@ describe('files', function () {
   after(() => factory.clean())
 
   it('returns an error when reading non-existent files', () => {
+    /**
+     * @param {Controller} daemon
+     */
     const readNonExistentFile = (daemon) => {
       return concat(daemon.api.files.read(`/i-do-not-exist-${Math.random()}`))
     }
@@ -157,6 +204,9 @@ describe('files', function () {
   })
 
   it('returns an error when writing deeply nested files and the parents do not exist', () => {
+    /**
+     * @param {Controller} daemon
+     */
     const writeNonExistentFile = (daemon) => {
       return daemon.api.files.write(`/foo-${Math.random()}/bar-${Math.random()}/baz-${Math.random()}/i-do-not-exist-${Math.random()}`, Uint8Array.from([0, 1, 2, 3]))
     }
@@ -174,8 +224,12 @@ describe('files', function () {
   // https://github.com/ipfs/js-ipfs-http-client/blob/d7eb0e8ffb15e207a8a6062e292a3b5babf35a9e/src/lib/error-handler.js#L12-L23
   it.skip('uses raw nodes for leaf data', () => {
     const data = randomBytes(1024 * 300)
+    /**
+     * @param {Controller} daemon
+     */
     const testLeavesAreRaw = async (daemon) => {
       const file = await addFile(daemon, data)
+      // @ts-expect-error types do not have sufficient overlap
       await checkNodeTypes(daemon, file)
     }
 
@@ -187,6 +241,9 @@ describe('files', function () {
 
   it('errors when creating the same directory twice', () => {
     const path = `/test-dir-${Math.random()}`
+    /**
+     * @param {Controller} daemon
+     */
     const createSameDirectory = async (daemon) => {
       await createDirectory(daemon, path)
       await createDirectory(daemon, path)
@@ -201,6 +258,9 @@ describe('files', function () {
 
   it('does not error when creating the same directory twice and parents option is passed', () => {
     const path = `/test-dir-${Math.random()}`
+    /**
+     * @param {Controller} daemon
+     */
     const createSameDirectory = async (daemon) => {
       await createDirectory(daemon, path)
       await createDirectory(daemon, path, { parents: true })
@@ -214,6 +274,9 @@ describe('files', function () {
 
   it('errors when creating the root directory', () => {
     const path = '/'
+    /**
+     * @param {Controller} daemon
+     */
     const createSameDirectory = async (daemon) => {
       await createDirectory(daemon, path)
       await createDirectory(daemon, path)
@@ -227,33 +290,66 @@ describe('files', function () {
   })
 
   describe('has the same hashes for', () => {
+    /**
+     * @param {Controller} daemon
+     * @param {Parameters<Controller["api"]["add"]>[0]} data
+     * @param {Parameters<Controller["api"]["add"]>[1]} options
+     */
     const testHashesAreEqual = async (daemon, data, options = {}) => {
       const { cid } = await daemon.api.add(data, options)
 
       return cid
     }
 
+    /**
+     * @param {Controller} daemon
+     * @param {Parameters<Controller["api"]["addAll"]>[0]} data
+     * @param {Parameters<Controller["api"]["addAll"]>[1]} options
+     */
     const testDirectoryHashesAreEqual = async (daemon, data, options = {}) => {
-      const { cid } = await last(daemon.api.addAll(data, options))
+      const res = await last(daemon.api.addAll(data, options))
+
+      if (res == null) {
+        throw new Error('Nothing added')
+      }
+
+      const { cid } = res
 
       return cid
     }
 
-    const _writeData = async (daemon, initialData, newData, options) => {
+    /**
+     * @param {Controller} daemon
+     * @param {Parameters<Controller["api"]["files"]["write"]>[1]} initialData
+     * @param {Parameters<Controller["api"]["files"]["write"]>[1]} newData
+     * @param {Parameters<Controller["api"]["files"]["write"]>[2]} options
+     */
+    const _writeData = async (daemon, initialData, newData, options = {}) => {
       const fileName = `file-${Math.random()}.txt`
 
       await daemon.api.files.write(`/${fileName}`, initialData, { create: true })
-      const files = await all(daemon.api.files.ls('/'))
+      await daemon.api.files.write(`/${fileName}`, newData, options)
+      const { cid } = await daemon.api.files.stat(`/${fileName}`)
 
-      return files.filter(file => file.name === fileName).pop().cid
+      return cid.toString()
     }
 
+    /**
+     * @param {Controller} daemon
+     * @param {Uint8Array} initialData
+     * @param {Uint8Array} appendedData
+     */
     const appendData = (daemon, initialData, appendedData) => {
       return _writeData(daemon, initialData, appendedData, {
         offset: initialData.length
       })
     }
 
+    /**
+     * @param {Controller} daemon
+     * @param {Uint8Array} initialData
+     * @param {Uint8Array} newData
+     */
     const overwriteData = (daemon, initialData, newData) => {
       return _writeData(daemon, initialData, newData, {
         offset: 0
@@ -287,7 +383,7 @@ describe('files', function () {
       )
     })
 
-    it('files that have had data appended', () => {
+    it.skip('files that have had data appended', () => {
       const initialData = randomBytes(1024 * 300)
       const appendedData = randomBytes(1024 * 300)
 
@@ -310,6 +406,7 @@ describe('files', function () {
 
     it('small files with CIDv1', () => {
       const data = Uint8Array.from([0x00, 0x01, 0x02])
+      /** @type {Parameters<Controller["api"]["add"]>[1]} */
       const options = {
         cidVersion: 1
       }
@@ -322,6 +419,7 @@ describe('files', function () {
 
     it('big files with CIDv1', () => {
       const data = randomBytes(1024 * 3000)
+      /** @type {Parameters<Controller["api"]["add"]>[1]} */
       const options = {
         cidVersion: 1
       }
@@ -333,6 +431,7 @@ describe('files', function () {
     })
 
     it('trickle DAGs', () => {
+      /** @type {Parameters<Controller["api"]["add"]>[1]} */
       const options = {
         cidVersion: 0,
         trickle: true,
@@ -423,13 +522,29 @@ describe('files', function () {
         })
       }
 
-      // will operate on sub-shard three levels deep
+      /**
+       * will operate on sub-shard three levels deep
+       *
+       * @param {Controller} daemon
+       * @param {Parameters<Controller["api"]["addAll"]>[0]} data
+       */
       const testHamtShardHashesAreEqual = async (daemon, data) => {
-        const { cid } = await last(daemon.api.addAll(data))
+        const res = await last(daemon.api.addAll(data))
+
+        if (res == null) {
+          throw new Error('Nothing added')
+        }
+
+        const { cid } = res
 
         await daemon.api.files.cp(`/ipfs/${cid}`, dir)
 
         const node = await daemon.api.object.get(cid)
+
+        if (node.Data == null) {
+          throw new Error('No data found on pb node')
+        }
+
         const meta = UnixFS.unmarshal(node.Data)
 
         expect(meta.type).to.equal('hamt-sharded-directory')
@@ -452,6 +567,11 @@ describe('files', function () {
 
         const stats = await daemon.api.files.stat(dir)
         const nodeAfterUpdates = await daemon.api.object.get(stats.cid)
+
+        if (nodeAfterUpdates.Data == null) {
+          throw new Error('No data found on pb node')
+        }
+
         const metaAfterUpdates = UnixFS.unmarshal(nodeAfterUpdates.Data)
 
         expect(metaAfterUpdates.type).to.equal('hamt-sharded-directory')

test/circuit/v1/browser.js

@@ -1,142 +1,157 @@
 /* eslint-env mocha */
 
-import PeerID from 'peer-id'
-import { base58btc } from 'multiformats/bases/base58'
-import { getIdKeys } from 'ipns'
-import last from 'it-last'
-import pRetry from 'p-retry'
-import { waitFor } from './utils/wait-for.js'
-import { expect } from 'aegir/utils/chai.js'
+import { peerIdToRoutingKey } from 'ipns'
+import { expect } from 'aegir/chai'
 import { daemonFactory } from './utils/daemon-factory.js'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import last from 'it-last'
+import { peerIdFromString } from '@libp2p/peer-id'
+import defer from 'p-defer'
+
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
 
 const daemonsOptions = {
   args: ['--enable-namesys-pubsub'] // enable ipns over pubsub
 }
 
-const retryOptions = {
-  retries: 5
-}
-
 const namespace = '/record/'
 
 const ipfsRef = '/ipfs/QmPFVLPmp9zv5Z5KUqLhe2EivAGccQW2r7M7jhVJGLZoZU'
 
 describe('ipns-pubsub', function () {
-  let nodes = []
+  /** @type {Controller} */
+  let goNode0
+
+  /** @type {Controller} */
+  let goNode1
+
+  /** @type {Controller} */
+  let jsNode0
+
+  /** @type {Controller} */
+  let jsNode1
+
+  /** @type {Factory} */
   let factory
 
-  before(async () => {
+  beforeEach(async () => {
     factory = await daemonFactory()
   })
 
   // Spawn daemons
-  before('create the nodes', async function () {
-    this.timeout(20e3)
-    nodes = await Promise.all([
-      factory.spawn({
-        type: 'go',
-        test: true,
-        ...daemonsOptions
-      }),
-      factory.spawn({
-        type: 'js',
-        test: true,
-        ...daemonsOptions
-      }),
-      // TODO: go-ipfs needs two nodes in the DHT to be able to publish a record
-      // Remove this when js-ipfs has a DHT
-      factory.spawn({
-        type: 'go',
-        test: true,
-        ...daemonsOptions
-      })
-    ])
+  beforeEach('create the nodes', async function () {
+    this.timeout(120e3)
+
+    goNode0 = await factory.spawn({
+      type: 'go',
+      test: true,
+      ...daemonsOptions
+    })
+    goNode1 = await factory.spawn({
+      type: 'go',
+      test: true,
+      ...daemonsOptions
+    })
+
+    jsNode0 = await factory.spawn({
+      type: 'js',
+      test: true,
+      ...daemonsOptions
+    })
+    jsNode1 = await factory.spawn({
+      type: 'js',
+      test: true,
+      ...daemonsOptions
+    })
   })
 
   // Connect nodes and wait for republish
-  before('connect the nodes', async function () {
-    this.timeout(10e3)
-    // TODO: go-ipfs needs two nodes in the DHT to be able to publish a record
-    // Remove the second connect when js-ipfs runs a DHT server
-    await Promise.all([
-      nodes[0].api.swarm.connect(nodes[1].api.peerId.addresses[0]),
-      nodes[0].api.swarm.connect(nodes[2].api.peerId.addresses[0])
-    ])
+  beforeEach('connect the nodes', async function () {
+    this.timeout(60e3)
+    await goNode0.api.swarm.connect(goNode1.peer.addresses[0])
+    await goNode0.api.swarm.connect(jsNode0.peer.addresses[0])
+    await goNode0.api.swarm.connect(jsNode1.peer.addresses[0])
+
+    await jsNode0.api.swarm.connect(jsNode1.peer.addresses[0])
+    await jsNode0.api.swarm.connect(goNode1.peer.addresses[0])
   })
 
-  after(() => factory.clean())
+  afterEach(() => factory.clean())
 
   it('should get enabled state of pubsub', async function () {
-    for (const node of nodes) {
-      const state = await node.api.name.pubsub.state()
-      expect(state).to.exist()
-      expect(state.enabled).to.equal(true)
+    for (const node of [goNode0, goNode1, jsNode0, jsNode1]) {
+      await expect(node.api.name.pubsub.state()).to.eventually.have.property('enabled', true)
     }
   })
 
   it('should publish the received record to a go node and a js subscriber should receive it', async function () {
-    // TODO find out why JS doesn't resolve, might be just missing a DHT
-    await Promise.all([
-      subscribeToReceiveByPubsub(nodes[0], nodes[1], nodes[0].api.peerId.id, nodes[1].api.peerId.id),
-      expect(last(nodes[1].api.name.resolve(nodes[0].api.peerId.id, { stream: false }))).to.eventually.be.rejected.with(/was not found in the network/)
-    ])
+    await resolveByPubSub(goNode0, jsNode0)
   })
 
   it('should publish the received record to a js node and a go subscriber should receive it', async function () {
-    await Promise.all([
-      subscribeToReceiveByPubsub(nodes[1], nodes[0], nodes[1].api.peerId.id, nodes[0].api.peerId.id),
-      last(nodes[0].api.name.resolve(nodes[1].api.peerId.id, { stream: false }))
-    ])
+    await resolveByPubSub(goNode0, jsNode0)
+  })
+
+  it('should publish the received record to a go node and a go subscriber should receive it', async function () {
+    await resolveByPubSub(goNode0, goNode1)
+  })
+
+  it('should publish the received record to a js node and a js subscriber should receive it', async function () {
+    await resolveByPubSub(jsNode0, jsNode1)
   })
 })
 
 //  * IPNS resolve subscription test
-//  * 1) name.resolve() , which subscribes the topic
-//  * 2) wait to guarantee the subscription
-//  * 3) subscribe again just to know until when to wait (inside the scope of the test)
-//  * 4) wait for the other peer to get notified of the subscription
-//  * 5) publish new ipns record
-//  * 6) wait until the record is received in the test scope subscribe
+//  * 1) name.resolve(), which subscribes the topic
+//  * 2) check we are subscribed via name.subs
+//  * 3) subscribe to the actual pubsub topic
+//  * 4) publish new ipns record
+//  * 6) ensure we have received an update via pubsub
 //  * 7) resolve ipns record
-const subscribeToReceiveByPubsub = async (nodeA, nodeB, idA, idB) => {
-  let subscribed = false
-  function checkMessage (msg) {
-    subscribed = true
-  }
-
-  const keys = getIdKeys(base58btc.decode(`z${idA}`))
-  const topic = `${namespace}${uint8ArrayToString(keys.routingKey.uint8Array(), 'base64url')}`
-
-  await waitForPeerToSubscribe(nodeB.api, topic)
-  await nodeB.api.pubsub.subscribe(topic, checkMessage)
-  await waitForNotificationOfSubscription(nodeA.api, topic, idB)
-  const res1 = await nodeA.api.name.publish(ipfsRef, { resolve: false })
-  await waitFor(() => subscribed === true, (50 * 1000))
-  const res2 = await last(nodeB.api.name.resolve(idA))
-
-  expect(PeerID.parse(res1.name).toString()).to.equal(PeerID.parse(idA).toString()) // Published to Node A ID
-  expect(res2).to.equal(ipfsRef)
-}
-
-// wait until a peer know about other peer to subscribe a topic
-const waitForNotificationOfSubscription = (daemon, topic, peerId) => pRetry(async () => {
-  const res = await daemon.pubsub.peers(topic)
+/**
+ * @param {Controller} publisher
+ * @param {Controller} subscriber
+ */
+const resolveByPubSub = async (publisher, subscriber) => {
+  const routingKey = peerIdToRoutingKey(publisher.peer.id)
+  const topic = `${namespace}${uint8ArrayToString(routingKey, 'base64url')}`
+
+  // should not be subscribed to anything
+  await expect(subscriber.api.name.pubsub.subs()).to.eventually.have.lengthOf(0)
+
+  try {
+    // attempt to resolve the peer id - n.b js throws here, go does not because streaming API errors don't work over http
+    await last(subscriber.api.name.resolve(publisher.peer.id, {
+      timeout: 1000
+    }))
+  } catch {}
+
+  // should now be subscribed to updates for the publisher's peer id
+  const subs = await subscriber.api.name.pubsub.subs()
+  expect(subs).to.have.lengthOf(1)
+  const subbed = peerIdFromString(subs[0].split('/ipns/').pop() || '')
+  expect(subbed.equals(publisher.peer.id)).to.be.true()
+
+  // set up a listener for the pubsub topic for the IPNS key
+  const deferred = defer()
+  await subscriber.api.pubsub.subscribe(topic, () => {
+    deferred.resolve()
+  })
 
-  if (!res || !res.length || !res.includes(peerId)) {
-    throw new Error('Could not find peer subscribing')
-  }
-}, retryOptions)
+  // publish an update
+  const res1 = await publisher.api.name.publish(ipfsRef, { resolve: false })
 
-// Wait until a peer subscribes a topic
-const waitForPeerToSubscribe = async (daemon, topic) => {
-  await pRetry(async () => {
-    const res = await daemon.pubsub.ls()
+  // should receive a message on the topic for the IPNS key
+  await deferred.promise
 
-    if (!res || !res.length || !res.includes(topic)) {
-      throw new Error(`Could not find subscription to ${topic} in "${JSON.stringify(res)}"`)
-    }
+  // should succeed and be fast
+  const res2 = await last(subscriber.api.name.resolve(publisher.peer.id, {
+    timeout: 1000
+  }))
 
-    return res[0]
-  }, retryOptions)
+  expect(peerIdFromString(res1.name).toString()).to.equal(publisher.peer.id.toString()) // Published to Node A ID
+  expect(res2).to.equal(ipfsRef)
 }

test/circuit/v2/all.js

@@ -5,9 +5,14 @@ import path from 'path'
 import { nanoid } from 'nanoid'
 import delay from 'delay'
 import last from 'it-last'
-import { expect } from 'aegir/utils/chai.js'
+import { expect } from 'aegir/chai'
 import { daemonFactory } from './utils/daemon-factory.js'
 
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
+
 const dir = path.join(os.tmpdir(), nanoid())
 
 const daemonOptions = {
@@ -20,6 +25,10 @@ const daemonOptions = {
 
 const ipfsRef = '/ipfs/QmPFVLPmp9zv5Z5KUqLhe2EivAGccQW2r7M7jhVJGLZoZU'
 
+/**
+ * @param {Controller} publisherDaemon
+ * @param {Controller} [resolverDaemon]
+ */
 const publishAndResolve = async (publisherDaemon, resolverDaemon) => {
   let sameDaemon = false
 
@@ -31,13 +40,16 @@ const publishAndResolve = async (publisherDaemon, resolverDaemon) => {
   const stopPublisherAndStartResolverDaemon = async () => {
     await publisherDaemon.stop()
     await delay(2000)
-    await resolverDaemon.start()
+
+    if (resolverDaemon != null) {
+      await resolverDaemon.start()
+    }
   }
 
   await publisherDaemon.init()
   await publisherDaemon.start()
 
-  const nodeId = publisherDaemon.api.peerId.id
+  const nodeId = publisherDaemon.peer.id
 
   await publisherDaemon.api.name.publish(ipfsRef, {
     resolve: false,
@@ -46,7 +58,7 @@ const publishAndResolve = async (publisherDaemon, resolverDaemon) => {
 
   !sameDaemon && await stopPublisherAndStartResolverDaemon()
 
-  const res = await last(resolverDaemon.api.name.resolve(nodeId, { local: true }))
+  const res = await last(resolverDaemon.api.name.resolve(nodeId))
   expect(res).to.equal(ipfsRef)
 
   await resolverDaemon.stop()
@@ -56,8 +68,9 @@ const publishAndResolve = async (publisherDaemon, resolverDaemon) => {
 }
 
 describe('ipns locally using the same repo across implementations', function () {
-  this.timeout(160 * 1000)
+  this.timeout(160e3)
 
+  /** @type {Factory} */
   let factory
 
   before(async () => {

test/exchange-files.js

@@ -5,13 +5,19 @@ import all from 'it-all'
 import last from 'it-last'
 import drain from 'it-drain'
 import { tmpPath, removeAllPins } from './utils/pin-utils.js'
-import { expect } from 'aegir/utils/chai.js'
+import { expect } from 'aegir/chai'
 import { daemonFactory } from './utils/daemon-factory.js'
 
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
+
 describe('pin', function () {
-  this.timeout(60 * 1000)
-  this.slow(30 * 1000)
+  this.timeout(60e3)
+  this.slow(30e3)
 
+  /** @type {Factory} */
   let factory
 
   before(async () => {
@@ -25,6 +31,10 @@ describe('pin', function () {
   }]
 
   let daemons = []
+  /**
+   * @param {'go' | 'js'} type
+   * @param {string} [repoPath]
+   */
   async function spawnAndStart (type, repoPath = tmpPath()) {
     const daemonOptions = {
       ipfsOptions: {
@@ -50,6 +60,11 @@ describe('pin', function () {
     return daemon
   }
 
+  /**
+   * @template T
+   * @param {(controller: Controller) => Promise<T>} pipeline
+   * @returns {Promise<[T, T]>}
+   */
   async function withDaemons (pipeline) {
     const goDaemon = await spawnAndStart('go')
     await removeAllPins(goDaemon)
@@ -61,16 +76,26 @@ describe('pin', function () {
   }
 
   afterEach(async function () {
-    this.timeout(25 * 1000)
+    this.timeout(25e3)
     await factory.clean()
     daemons = []
   })
 
   describe('pin add', function () {
     // Pinning a large file recursively results in the same pins
     it('pin recursively', async function () {
+      /**
+       * @param {Controller} daemon
+       */
       async function pipeline (daemon) {
-        const { cid } = await last(daemon.api.addAll(jupiter, { pin: false }))
+        const res = await last(daemon.api.addAll(jupiter, { pin: false }))
+
+        if (!res) {
+          throw new Error('Nothing added')
+        }
+
+        const { cid } = res
+
         await daemon.api.pin.add(cid)
 
         return all(daemon.api.pin.ls())
@@ -85,8 +110,18 @@ describe('pin', function () {
 
     // Pinning a large file with recursive=false results in the same direct pin
     it('pin directly', async function () {
+      /**
+       * @param {Controller} daemon
+       */
       async function pipeline (daemon) {
-        const { cid } = await last(daemon.api.addAll(jupiter, { pin: false }))
+        const res = await last(daemon.api.addAll(jupiter, { pin: false }))
+
+        if (!res) {
+          throw new Error('Nothing added')
+        }
+
+        const { cid } = res
+
         await daemon.api.pin.add(cid, { recursive: false })
 
         return all(daemon.api.pin.ls())
@@ -104,8 +139,18 @@ describe('pin', function () {
     // removing a root pin removes children as long as they're
     // not part of another pin's dag
     it('pin recursively, remove the root pin', async function () {
+      /**
+       * @param {Controller} daemon
+       */
       async function pipeline (daemon) {
-        const { cid } = await last(daemon.api.addAll(jupiter))
+        const res = await last(daemon.api.addAll(jupiter))
+
+        if (!res) {
+          throw new Error('Nothing added')
+        }
+
+        const { cid } = res
+
         await daemon.api.pin.rm(cid)
 
         return all(daemon.api.pin.ls())
@@ -120,9 +165,21 @@ describe('pin', function () {
     // When a pin contains the root of another pin and we remove it, it is
     // instead kept but its type is changed to 'indirect'
     it('remove a child shared by multiple pins', async function () {
+      /** @type {Awaited<ReturnType<Controller["api"]["files"]["stat"]>>} */
       let jupiterDir
+
+      /**
+       * @param {Controller} daemon
+       */
       async function pipeline (daemon) {
-        const { cid } = await last(daemon.api.addAll(jupiter, { pin: false, wrapWithDirectory: true }))
+        const res = await last(daemon.api.addAll(jupiter, { pin: false, wrapWithDirectory: true }))
+
+        if (!res) {
+          throw new Error('Nothing added')
+        }
+
+        const { cid } = res
+
         jupiterDir = jupiterDir || await daemon.api.files.stat(`/ipfs/${cid}/test/fixtures/planets`)
 
         // by separately pinning all the DAG nodes created when adding,
@@ -149,12 +206,15 @@ describe('pin', function () {
       expect(jsPins).to.deep.include.members(goPins)
 
       const dirPin = goPins.find(pin => pin.cid.equals(jupiterDir.cid))
-      expect(dirPin.type).to.eql('indirect')
+      expect(dirPin).to.have.property('type', 'indirect')
     })
   })
 
   describe('ls', function () {
     it('print same pins', async function () {
+      /**
+       * @param {Controller} daemon
+       */
       async function pipeline (daemon) {
         await drain(daemon.api.addAll(jupiter))
 

test/files.js

@@ -2,20 +2,32 @@
 /* eslint-env mocha */
 
 import pRetry from 'p-retry'
-import { expect } from 'aegir/utils/chai.js'
+import { expect } from 'aegir/chai'
 import { daemonFactory } from './utils/daemon-factory.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { isPeerId } from '@libp2p/interface-peer-id'
+import pTimeout from 'p-timeout'
+
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
 
 const retryOptions = {
   retries: 5
 }
 
+/**
+ * @param {string} topic
+ * @param {Controller["peer"]} peer
+ * @param {Controller} daemon
+ */
 const waitForTopicPeer = (topic, peer, daemon) => {
   return pRetry(async () => {
     const peers = await daemon.api.pubsub.peers(topic)
 
-    if (!peers.includes(peer.id)) {
+    if (!peers.map(p => p.toString()).includes(peer.id.toString())) {
       throw new Error(`Could not find peer ${peer.id}`)
     }
   }, retryOptions)
@@ -28,8 +40,9 @@ const daemonOptions = {
 const timeout = 20e3
 
 describe('pubsub', function () {
-  this.timeout(60 * 1000)
+  this.timeout(60e3)
 
+  /** @type {Record<string, ((fac: Factory) => Promise<Controller>)[]>} */
   const tests = {
     'publish from Go, subscribe on Go': [(factory) => factory.spawn({ ...daemonOptions, type: 'go' }), (factory) => factory.spawn({ ...daemonOptions, type: 'go' })],
     'publish from JS, subscribe on JS': [(factory) => factory.spawn({ type: 'js' }), (factory) => factory.spawn({ type: 'js' })],
@@ -39,9 +52,11 @@ describe('pubsub', function () {
 
   Object.keys(tests).forEach((name) => {
     describe(name, function () {
+      /** @type {Controller} */
       let daemon1
+      /** @type {Controller} */
       let daemon2
-
+      /** @type {Factory} */
       let factory
 
       before(async () => {
@@ -51,23 +66,20 @@ describe('pubsub', function () {
       after(() => factory.clean())
 
       before('spawn nodes', async function () {
-        this.timeout(timeout)
         ;[daemon1, daemon2] = await Promise.all(tests[name].map(fn => fn(factory)))
       })
 
       before('connect', async function () {
-        this.timeout(timeout)
-
-        await daemon1.api.swarm.connect(daemon2.api.peerId.addresses[0])
-        await daemon2.api.swarm.connect(daemon1.api.peerId.addresses[0])
+        await daemon1.api.swarm.connect(daemon2.peer.addresses[0])
+        await daemon2.api.swarm.connect(daemon1.peer.addresses[0])
 
         const peers = await Promise.all([
           daemon1.api.swarm.peers(),
           daemon2.api.swarm.peers()
         ])
 
-        expect(peers[0].map((p) => p.peer.toString())).to.include(daemon2.api.peerId.id)
-        expect(peers[1].map((p) => p.peer.toString())).to.include(daemon1.api.peerId.id)
+        expect(peers[0].map((p) => p.peer.toString())).to.include(daemon2.peer.id.toString())
+        expect(peers[1].map((p) => p.peer.toString())).to.include(daemon1.peer.id.toString())
       })
 
       after(() => factory.clean())
@@ -76,103 +88,167 @@ describe('pubsub', function () {
         const data = uint8ArrayFromString('hello world')
         const topic = 'pubsub-ascii'
 
-        const subscriber = () => new Promise((resolve) => {
+        /** @type {() => Promise<void>} */
+        const subscriber = () => new Promise((resolve, reject) => {
           daemon2.api.pubsub.subscribe(topic, (msg) => {
-            expect(uint8ArrayEquals(data, msg.data)).to.be.true()
-            expect(msg).to.have.property('seqno')
-            expect(msg.seqno).to.be.an.instanceof(Uint8Array)
-            expect(msg).to.have.property('topicIDs').and.to.include(topic)
-            expect(msg).to.have.property('from', daemon1.api.peerId.id)
-            resolve()
+            try {
+              if (msg.type !== 'signed') {
+                throw new Error('Message was unsigned')
+              }
+
+              expect(uint8ArrayEquals(data, msg.data)).to.be.true()
+              expect(msg).to.have.property('sequenceNumber')
+              expect(msg.sequenceNumber).to.be.a('bigint')
+              expect(msg).to.have.property('topic', topic)
+              expect(isPeerId(msg.from)).to.be.true()
+              expect(msg.from.toString()).to.equal(daemon1.peer.id.toString())
+              resolve()
+            } catch (err) {
+              reject(err)
+            }
           })
         })
 
         const publisher = async () => {
-          await waitForTopicPeer(topic, daemon2.api.peerId, daemon1)
+          await waitForTopicPeer(topic, daemon2.peer, daemon1)
           await daemon1.api.pubsub.publish(topic, data)
         }
 
         return Promise.all([
-          subscriber(),
-          publisher()
+          pTimeout(subscriber(), {
+            milliseconds: timeout,
+            message: 'subscriber timed out'
+          }),
+          pTimeout(publisher(), {
+            milliseconds: timeout,
+            message: 'publisher timed out'
+          })
         ])
       })
 
       it('should exchange non ascii data', function () {
         const data = uint8ArrayFromString('你好世界 zażółć gęślą jaźń')
         const topic = 'pubsub-non-ascii'
 
-        const subscriber = () => new Promise((resolve) => {
+        /** @type {() => Promise<void>} */
+        const subscriber = () => new Promise((resolve, reject) => {
           daemon2.api.pubsub.subscribe(topic, (msg) => {
-            expect(uint8ArrayEquals(data, msg.data)).to.be.true()
-            expect(msg).to.have.property('seqno')
-            expect(msg.seqno).to.be.an.instanceof(Uint8Array)
-            expect(msg).to.have.property('topicIDs').and.to.include(topic)
-            expect(msg).to.have.property('from', daemon1.api.peerId.id)
-            resolve()
+            try {
+              if (msg.type !== 'signed') {
+                throw new Error('Message was unsigned')
+              }
+
+              expect(uint8ArrayEquals(data, msg.data)).to.be.true()
+              expect(msg).to.have.property('sequenceNumber')
+              expect(msg.sequenceNumber).to.be.a('bigint')
+              expect(msg).to.have.property('topic', topic)
+              expect(isPeerId(msg.from)).to.be.true()
+              expect(msg.from.toString()).to.equal(daemon1.peer.id.toString())
+              resolve()
+            } catch (err) {
+              reject(err)
+            }
           })
         })
 
         const publisher = async () => {
-          await waitForTopicPeer(topic, daemon2.api.peerId, daemon1)
+          await waitForTopicPeer(topic, daemon2.peer, daemon1)
           await daemon1.api.pubsub.publish(topic, data)
         }
 
         return Promise.all([
-          subscriber(),
-          publisher()
+          pTimeout(subscriber(), {
+            milliseconds: timeout,
+            message: 'subscriber timed out'
+          }),
+          pTimeout(publisher(), {
+            milliseconds: timeout,
+            message: 'publisher timed out'
+          })
         ])
       })
 
       it('should exchange binary data', function () {
         const data = uint8ArrayFromString('a36161636179656162830103056164a16466666666f400010203040506070809', 'base16')
         const topic = 'pubsub-binary'
 
-        const subscriber = () => new Promise((resolve) => {
+        /** @type {() => Promise<void>} */
+        const subscriber = () => new Promise((resolve, reject) => {
           daemon2.api.pubsub.subscribe(topic, (msg) => {
-            expect(uint8ArrayEquals(data, msg.data)).to.be.true()
-            expect(msg).to.have.property('seqno')
-            expect(msg.seqno).to.be.an.instanceof(Uint8Array)
-            expect(msg).to.have.property('topicIDs').and.to.include(topic)
-            expect(msg).to.have.property('from', daemon1.api.peerId.id)
-            resolve()
+            try {
+              if (msg.type !== 'signed') {
+                throw new Error('Message was unsigned')
+              }
+
+              expect(uint8ArrayEquals(data, msg.data)).to.be.true()
+              expect(msg).to.have.property('sequenceNumber')
+              expect(msg.sequenceNumber).to.be.a('bigint')
+              expect(msg).to.have.property('topic', topic)
+              expect(isPeerId(msg.from)).to.be.true()
+              expect(msg.from.toString()).to.equal(daemon1.peer.id.toString())
+              resolve()
+            } catch (err) {
+              reject(err)
+            }
           })
         })
 
         const publisher = async () => {
-          await waitForTopicPeer(topic, daemon2.api.peerId, daemon1)
+          await waitForTopicPeer(topic, daemon2.peer, daemon1)
           await daemon1.api.pubsub.publish(topic, data)
         }
 
         return Promise.all([
-          subscriber(),
-          publisher()
+          pTimeout(subscriber(), {
+            milliseconds: timeout,
+            message: 'subscriber timed out'
+          }),
+          pTimeout(publisher(), {
+            milliseconds: timeout,
+            message: 'publisher timed out'
+          })
         ])
       })
 
       it('should exchange data over a topic with unicode and newlines', function () {
         const data = uint8ArrayFromString('你好世界\nzażółć\r\ngęślą\njaźń')
         const topic = 'pubsub\n你好世界\r\njaźń'
 
-        const subscriber = () => new Promise((resolve) => {
+        /** @type {() => Promise<void>} */
+        const subscriber = () => new Promise((resolve, reject) => {
           daemon2.api.pubsub.subscribe(topic, (msg) => {
-            expect(uint8ArrayEquals(data, msg.data)).to.be.true()
-            expect(msg).to.have.property('seqno')
-            expect(msg.seqno).to.be.an.instanceof(Uint8Array)
-            expect(msg).to.have.property('topicIDs').and.to.include(topic)
-            expect(msg).to.have.property('from', daemon1.api.peerId.id)
-            resolve()
+            try {
+              if (msg.type !== 'signed') {
+                throw new Error('Message was unsigned')
+              }
+
+              expect(uint8ArrayEquals(data, msg.data)).to.be.true()
+              expect(msg).to.have.property('sequenceNumber')
+              expect(msg.sequenceNumber).to.be.a('bigint')
+              expect(msg).to.have.property('topic', topic)
+              expect(isPeerId(msg.from)).to.be.true()
+              expect(msg.from.toString()).to.equal(daemon1.peer.id.toString())
+              resolve()
+            } catch (err) {
+              reject(err)
+            }
           })
         })
 
         const publisher = async () => {
-          await waitForTopicPeer(topic, daemon2.api.peerId, daemon1)
+          await waitForTopicPeer(topic, daemon2.peer, daemon1)
           await daemon1.api.pubsub.publish(topic, data)
         }
 
         return Promise.all([
-          subscriber(),
-          publisher()
+          pTimeout(subscriber(), {
+            milliseconds: timeout,
+            message: 'subscriber timed out'
+          }),
+          pTimeout(publisher(), {
+            milliseconds: timeout,
+            message: 'publisher timed out'
+          })
         ])
       })
     })

test/ipns-pubsub.js

@@ -2,15 +2,24 @@
 import delay from 'delay'
 import randomBytes from 'iso-random-stream/src/random.js'
 import concat from 'it-concat'
-import WS from 'libp2p-websockets'
+import { WebSockets } from '@libp2p/websockets'
 import pRetry from 'p-retry'
-import filters from 'libp2p-websockets/src/filters.js'
-import { expect } from 'aegir/utils/chai.js'
+import * as filters from '@libp2p/websockets/filters'
+import { expect } from 'aegir/chai'
+import { Multiaddr } from '@multiformats/multiaddr'
 
-const transportKey = WS.prototype[Symbol.toStringTag]
+/**
+ * @typedef {import('ipfsd-ctl').Controller} Controller
+ * @typedef {import('ipfsd-ctl').Factory} Factory
+ */
 
 export const randomWsAddr = '/ip4/127.0.0.1/tcp/0/ws'
 
+/**
+ * @param {string[]} addrs
+ * @param {Factory} factory
+ * @param {Controller} [relay]
+ */
 export function createProc (addrs, factory, relay) {
   if (relay) {
     throw new Error('createProc missing support for static relay v2')
@@ -33,21 +42,21 @@ export function createProc (addrs, factory, relay) {
         }
       },
       libp2p: {
-        config: {
-          transport: {
-            [transportKey]: {
-              filter: filters.all
-            }
-          },
-          dht: {
-            enabled: false
-          }
-        }
+        transports: [
+          new WebSockets({
+            filter: filters.all
+          })
+        ]
       }
     }
   })
 }
 
+/**
+ * @param {string[]} addrs
+ * @param {Factory} factory
+ * @param {Controller} [relay]
+ */
 export function createJs (addrs, factory, relay) {
   if (relay) {
     throw new Error('createJs missing support for static relay v2')
@@ -67,20 +76,19 @@ export function createJs (addrs, factory, relay) {
           hop: {
             enabled: true
           }
-        },
-        libp2p: {
-          config: {
-            dht: {
-              enabled: false
-            }
-          }
         }
       }
     }
   })
 }
 
-// creates "private" go-ipfs node which is uses static relay if specified
+/**
+ * creates "private" go-ipfs node which is uses static relay if specified
+ *
+ * @param {string[]} addrs
+ * @param {Factory} factory
+ * @param {Controller} [relay]
+ */
 export async function createGo (addrs, factory, relay) {
   let StaticRelays
   if (relay) {
@@ -121,7 +129,12 @@ export async function createGo (addrs, factory, relay) {
   })
 }
 
-// creates "publicly diallable" go-ipfs running a relay service
+/**
+ * creates "publicly diallable" go-ipfs running a relay service
+ *
+ * @param {string[]} addrs
+ * @param {Factory} factory
+ */
 export function createGoRelay (addrs, factory) {
   return factory.spawn({
     type: 'go',
@@ -157,19 +170,29 @@ export function createGoRelay (addrs, factory) {
   })
 }
 
+/**
+ * @param {Factory} factory
+ */
 export function clean (factory) {
   return factory.clean()
 }
 
 const data = randomBytes(128)
 
+/**
+ * @param {Controller} nodeA
+ * @param {Controller} nodeB
+ */
 export async function send (nodeA, nodeB) {
   const { cid } = await nodeA.api.add(data)
   const buffer = await concat(nodeB.api.cat(cid))
 
   expect(buffer.slice()).to.deep.equal(data)
 }
 
+/**
+ * @param {Controller["api"]} api
+ */
 export async function getWsAddr (api) {
   return await pRetry(async () => {
     const id = await api.id()
@@ -184,10 +207,13 @@ export async function getWsAddr (api) {
       throw new Error(`No ws address found in ${id.addresses}`)
     }
 
-    return result
+    return new Multiaddr(result)
   })
 }
 
+/**
+ * @param {Controller["api"]} api
+ */
 export async function getWsStarAddr (api) {
   return await pRetry(async () => {
     const id = await api.id()
@@ -200,10 +226,13 @@ export async function getWsStarAddr (api) {
       throw new Error(`No wsstar address found in ${id.addresses}`)
     }
 
-    return result
+    return new Multiaddr(result)
   })
 }
 
+/**
+ * @param {Controller["api"]} api
+ */
 export async function getWrtcStarAddr (api) {
   return await pRetry(async () => {
     const id = await api.id()
@@ -216,10 +245,13 @@ export async function getWrtcStarAddr (api) {
       throw new Error(`No webrtcstar address found in ${id.addresses}`)
     }
 
-    return result
+    return new Multiaddr(result)
   })
 }
 
+/**
+ * @param {Controller["api"]} api
+ */
 export async function getTcpAddr (api) {
   return await pRetry(async () => {
     const id = await api.id()
@@ -232,40 +264,62 @@ export async function getTcpAddr (api) {
       throw new Error(`No TCP address found in ${id.addresses}`)
     }
 
-    return result
+    return new Multiaddr(result)
   })
 }
 
+/**
+ * @param {Controller} nodeA
+ * @param {Controller} nodeB
+ * @param {Controller} relay
+ * @param {number} timeout
+ */
 export async function connect (nodeA, nodeB, relay, timeout = 1000) {
   const relayWsAddr = await getWsAddr(relay.api)
-  const nodeAId = nodeA.api.peerId.id
-  const nodeBId = nodeB.api.peerId.id
+  const nodeAId = (await nodeA.api.id()).id
+  const nodeBId = (await nodeB.api.id()).id
 
-  if (process.env.DEBUG) console.log(`connect A (${nodeAId}) to relay at`, relayWsAddr)
+  if (process.env.DEBUG) console.log(`connect A (${nodeAId.toString()}) to relay at`, relayWsAddr.toString())
   await nodeA.api.swarm.connect(relayWsAddr)
 
-  if (process.env.DEBUG) console.log(`connect B (${nodeBId}) to relay at`, relayWsAddr)
+  if (process.env.DEBUG) console.log(`connect B (${nodeBId.toString()}) to relay at`, relayWsAddr.toString())
   await nodeB.api.swarm.connect(relayWsAddr)
 
   // TODO: needed until https://github.com/ipfs/interop/issues/17 is resolved
   await delay(timeout)
-  const nodeBCircuitAddr = `${relayWsAddr}/p2p-circuit/p2p/${nodeB.api.peerId.id}`
-  if (process.env.DEBUG) console.log('connect A to B over circuit', nodeBCircuitAddr)
+  const nodeBCircuitAddr = new Multiaddr(`${relayWsAddr}/p2p-circuit/p2p/${nodeBId.toString()}`)
+  if (process.env.DEBUG) console.log('connect A to B over circuit', nodeBCircuitAddr.toString())
   await nodeA.api.swarm.connect(nodeBCircuitAddr)
 
   if (process.env.DEBUG) {
     console.log('done!')
+
+    /**
+     * @param {string} name
+     * @param {Controller} node
+     */
     const listConnections = async (name, node) => {
       const peers = await node.api.swarm.peers()
-      console.log(`${name} has connections`, peers.map(p => `${p.addr.toString()}/p2p/${p.peer}`))
+      console.log(`${name} has connections`, peers.map(p => p.addr.toString()))
     }
     await listConnections('nodeA', nodeA)
     await listConnections('nodeB', nodeB)
   }
 }
 
+/**
+ * @param {number} timeout
+ * @returns
+ */
 export function connWithTimeout (timeout) {
-  return (nodeA, nodeB, relay) => {
+  /**
+   * @param {Controller} nodeA
+   * @param {Controller} nodeB
+   * @param {Controller} relay
+   */
+  const connectControllers = (nodeA, nodeB, relay) => {
     return connect(nodeA, nodeB, relay, timeout)
   }
+
+  return connectControllers
 }

test/ipns.js

@@ -1,18 +1,19 @@
-
 import { createFactory } from 'ipfsd-ctl'
-import isNode from 'detect-node'
+import { isNode, isElectronMain } from 'wherearewe'
 
 export async function daemonFactory () {
   let ipfsHttpModule
   let ipfsModule
 
   try {
+    // @ts-expect-error env var could be undefined
     ipfsHttpModule = await import(process.env.IPFS_JS_HTTP_MODULE)
   } catch {
     ipfsHttpModule = await import('ipfs-http-client')
   }
 
   try {
+    // @ts-expect-error env var could be undefined
     ipfsModule = await import(process.env.IPFS_JS_MODULE)
   } catch {
     ipfsModule = await import('ipfs')
@@ -41,7 +42,7 @@ export async function daemonFactory () {
  * @param {{ path: () => string }} [module]
  */
 async function findBin (envVar, moduleName, module) {
-  if (!isNode) {
+  if (!isNode && !isElectronMain) {
     return
   }
 

test/kad-dht.js

@@ -0,0 +1 @@
+export default false

test/pin.js

@@ -0,0 +1,3 @@
+import os from 'os'
+
+export default os.platform() === 'win32'

test/pubsub.js

@@ -4,11 +4,14 @@ import { nanoid } from 'nanoid'
 import all from 'it-all'
 import drain from 'it-drain'
 
+/**
+ * @param {import('ipfsd-ctl').Controller} daemon
+ */
 export async function removeAllPins (daemon) {
   const pins = await all(daemon.api.pin.ls())
   const rootPins = pins.filter(pin => pin.type === 'recursive' || pin.type === 'direct')
 
-  await drain(daemon.api.pin.rmAll(rootPins.map(pin => pin.cid)))
+  await drain(daemon.api.pin.rmAll(rootPins.map(pin => ({ cid: pin.cid }))))
 
   return daemon
 }

test/utils/circuit.js

@@ -1,7 +1,11 @@
-import isNode from 'detect-node'
+import { isNode, isElectronMain } from 'wherearewe'
 import fs from 'fs'
 import path from 'path'
-import { command } from 'execa'
+import { execaCommand } from 'execa'
+import pTimeout from 'p-timeout'
+import { download, LIBP2P_RELAY_DAEMON_VERSION } from '../../scripts/download-relay-daemon.js'
+import os from 'os'
+// @ts-expect-error no types
 import goenv from 'go-platform'
 const platform = process.env.TARGET_OS || goenv.GOOS
 
@@ -10,25 +14,91 @@ const platform = process.env.TARGET_OS || goenv.GOOS
 // per circuit relay version.
 const relays = new Map()
 
-export async function getRelayV (version, factory) {
-  if (!isNode) return
-  if (relays.has(version)) return relays.get(version)
-  if (process.env.DEBUG) console.log(`Starting relayd_v${version}..`) // eslint-disable-line no-console
-  if (version < 1 || version > 2) throw new Error('Unsupported circuit relay version')
+const RELAY_STARTUP_TIMEOUT = Number(process.env.RELAY_STARTUP_TIMEOUT || 30000)
+
+/**
+ * @param {number} version
+ */
+export async function getRelayV (version) {
+  if (!isNode && !isElectronMain) {
+    return
+  }
+
+  if (relays.has(version)) {
+    return relays.get(version)
+  }
+
+  if (process.env.DEBUG) {
+    console.log(`Starting relayd_v${version}..`) // eslint-disable-line no-console
+  }
+
+  if (version < 1 || version > 2) {
+    throw new Error('Unsupported circuit relay version')
+  }
+
   const binaryPath = path.join('scripts', `libp2p-relay-daemon${platform === 'windows' ? '.exe' : ''}`)
   const configPath = path.join('scripts', `relayd_v${version}.config.json`)
-  const identityPath = path.join('scripts', `relayd_v${version}.identity`)
-  const relayd = command(`${binaryPath} -config ${configPath} -id ${identityPath}`)
-  let id
-  for await (const line of relayd.stdout) {
-    const text = line.toString()
-    if (process.env.DEBUG) console.log(text) // eslint-disable-line no-console
-    if (text.includes(`RelayV${version} is running!`)) break
-    if (text.includes('I am')) {
-      id = text.split('I am')[1].split('\n')[0].trim()
+  const identityPath = path.join(os.tmpdir(), `relayd_v${version}-${Math.random()}.identity`)
+
+  if (!fs.existsSync(binaryPath)) {
+    console.info('libp2p-relay-daemon binary not found at', binaryPath) // eslint-disable-line no-console
+    await download({
+      version: LIBP2P_RELAY_DAEMON_VERSION,
+      platform: process.env.TARGET_OS || goenv.GOOS || os.platform(),
+      arch: process.env.TARGET_ARCH || goenv.GOARCH || os.arch(),
+      distUrl: process.env.GO_IPFS_DIST_URL || 'https://dist.ipfs.io',
+      installPath: path.resolve('scripts')
+    })
+  }
+
+  if (process.env.DEBUG) {
+    console.info(`${binaryPath} -config ${configPath} -id ${identityPath}`) // eslint-disable-line no-console
+  }
+
+  const relayd = execaCommand(`${binaryPath} -config ${configPath} -id ${identityPath}`, {
+    all: true
+  })
+
+  const all = relayd.all
+
+  if (all == null) {
+    throw new Error('No stdout/stderr on execa return value')
+  }
+
+  const waitForStartup = async () => {
+    let id = ''
+
+    for await (const line of all) {
+      const text = line.toString()
+
+      if (process.env.DEBUG) {
+        console.log(text) // eslint-disable-line no-console
+      }
+
+      if (text.includes(`RelayV${version} is running!`)) {
+        return id
+      }
+
+      if (text.includes('I am')) {
+        id = text.split('I am')[1].split('\n')[0].trim()
+      }
     }
   }
-  const config = JSON.parse(fs.readFileSync(configPath))
+
+  const promise = waitForStartup()
+  // @ts-ignore
+  promise.cancel = () => {
+    console.error(`Timed out waiting for ${binaryPath} to start after ${RELAY_STARTUP_TIMEOUT}ms, killing process`) // eslint-disable-line no-console
+    relayd.kill()
+  }
+
+  const id = await pTimeout(promise, {
+    milliseconds: RELAY_STARTUP_TIMEOUT
+  })
+
+  const config = JSON.parse(fs.readFileSync(configPath, {
+    encoding: 'utf-8'
+  }))
   const result = {
     relayd,
     // Mock: make it look like other things returned by ipfsd-ctl to reuse existing code.

test/utils/daemon-factory.js

@@ -1,7 +1,11 @@
 import delay from 'delay'
 
-/*
- * Wait for a condition to become true.
+/**
+ * Wait for a condition to become true
+ *
+ * @param {() => boolean} predicate
+ * @param {number} ttl
+ * @param {number} checkInterval
  */
 export async function waitFor (predicate, ttl = 10e3, checkInterval = 50) {
   const timeout = Date.now() + ttl

test/utils/is-windows.browser.js

@@ -1,10 +1,12 @@
 {
   "extends": "aegir/src/config/tsconfig.aegir.json",
   "compilerOptions": {
-    "outDir": "types"
+    "outDir": "dist",
+    "emitDeclarationOnly": true
   },
   "include": [
     "src",
+    "scripts",
     "test"
   ]
 }