@libp2p/interop 0.0.0

package/dist/src/resources/keys/go.secp256k1.key

@@ -0,0 +1 @@
+ {��ܥg�oT+.�\�L�Y��Jb���G�q7�

package/dist/src/resources/keys/index.d.ts

@@ -0,0 +1,5 @@
+import type { NodeType, PeerIdType } from '../..';
+declare type KeyCollection = Record<PeerIdType, string>;
+export declare const keys: Record<NodeType, KeyCollection>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/resources/keys/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/resources/keys/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAIjD,aAAK,aAAa,GAAG,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;AAc/C,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,aAAa,CAGhD,CAAA"}

package/dist/src/resources/keys/index.js

@@ -0,0 +1,18 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url)); // eslint-disable-line @typescript-eslint/naming-convention
+const goKeys = {
+    ed25519: path.join(__dirname, 'go.ed25519.key'),
+    rsa: path.join(__dirname, 'go.rsa.key'),
+    secp256k1: path.join(__dirname, 'go.secp256k1.key')
+};
+const jsKeys = {
+    ed25519: path.join(__dirname, 'js.ed25519.key'),
+    rsa: path.join(__dirname, 'js.rsa.key'),
+    secp256k1: path.join(__dirname, 'js.secp256k1.key')
+};
+export const keys = {
+    go: goKeys,
+    js: jsKeys
+};
+//# sourceMappingURL=index.js.map

package/dist/src/resources/keys/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/resources/keys/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAA;AAGnC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAA,CAAC,2DAA2D;AAI1H,MAAM,MAAM,GAAkB;IAC5B,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,gBAAgB,CAAC;IAC/C,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC;IACvC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,kBAAkB,CAAC;CACpD,CAAA;AAED,MAAM,MAAM,GAAkB;IAC5B,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,gBAAgB,CAAC;IAC/C,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC;IACvC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,kBAAkB,CAAC;CACpD,CAAA;AAED,MAAM,CAAC,MAAM,IAAI,GAAoC;IACnD,EAAE,EAAE,MAAM;IACV,EAAE,EAAE,MAAM;CACX,CAAA"}

package/dist/src/resources/keys/js.ed25519.key

@@ -0,0 +1 @@
+
`F́o��.ux��7f�v71��{�z���9*x7Ӟ�g��Q�g,�FhŒ�0������]3�7Ӟ�g��Q�g,�FhŒ�0������]3�

package/dist/src/resources/keys/js.secp256k1.key

@@ -0,0 +1 @@
+ �z�m�/�kPa�ࡓ$�Z���p"�>v��

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

@@ -0,0 +1,6 @@
+declare const _default: {
+    key: Uint8Array;
+    value: Uint8Array;
+};
+export default _default;
+//# sourceMappingURL=dht-record.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dht-record.d.ts","sourceRoot":"","sources":["../../../src/utils/dht-record.ts"],"names":[],"mappings":";;;;AAGA,wBAMC"}

package/dist/src/utils/dht-record.js

@@ -0,0 +1,10 @@
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
+import { concat as uint8ArrayConcat } from 'uint8arrays/concat';
+export default {
+    key: uint8ArrayConcat([
+        uint8ArrayFromString('/pk/'),
+        uint8ArrayFromString('muft89xjpybos8eas1vaq2xrbsx2vkll7is4ocy7pia5fsjlt3c2', 'base36')
+    ]),
+    value: uint8ArrayFromString('080012a60230820122300d06092a864886f70d01010105000382010f003082010a0282010100c2588f998971dac9e3eef76a311bf9159505aff69ea3b664c55a36aa28ee08de1127228a4d431bb9c0840240c75f6e98a0843a78d945491a3ea5e1f7cee2bc71383510db5290702383975b7bffae9fb40c84cc1220fb4a7db862fffb0de42f8fd8fb33a17deb20f30e2d0f194791fe69355a392f77df35f101e08a2fc95b2c018768938814fcb52482f899f5e90a1905e8abbcdbb1647ad80a5b0417e1ce8320d64197a6ba3848926375c63adebabdf6eb82109bcadfee13b62bf922bbb6f74c1a26c9bc6122d1436787e0e6de3c152b1959701092abef84599f73eaedb2fcef9f87293e1bbe8e0fef3f1a7fd2e8b94c7e633f88473644a63cb948e4d25c54490203010001', 'hex')
+};
+//# sourceMappingURL=dht-record.js.map

package/dist/src/utils/dht-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dht-record.js","sourceRoot":"","sources":["../../../src/utils/dht-record.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAC5E,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE/D,eAAe;IACb,GAAG,EAAE,gBAAgB,CAAC;QACpB,oBAAoB,CAAC,MAAM,CAAC;QAC5B,oBAAoB,CAAC,sDAAsD,EAAE,QAAQ,CAAC;KACvF,CAAC;IACF,KAAK,EAAE,oBAAoB,CAAC,wlBAAwlB,EAAE,KAAK,CAAC;CAC7nB,CAAA"}

package/package.json

@@ -0,0 +1,151 @@
+{
+  "name": "@libp2p/interop",
+  "version": "0.0.0",
+  "description": "Interoperability Tests for libp2p",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/interop#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/interop.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/interop/issues"
+  },
+  "keywords": [
+    "libp2p"
+  ],
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=7.0.0"
+  },
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist/src",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "sourceType": "module"
+    }
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  },
+  "scripts": {
+    "lint": "aegir lint",
+    "dep-check": "aegir dep-check dist/src/**/*.js dist/test/**/*.js",
+    "build": "tsc",
+    "postbuild": "cp src/resources/keys/*.key dist/src/resources/keys",
+    "pretest": "npm run build",
+    "test": "aegir test -f \"./dist/test/**/*.spec.js\"",
+    "test:node": "npm run test -- -t node -f ./dist/test/node.js",
+    "test:chrome": "npm run test -- -t browser -f ./dist/test/browser.js ",
+    "test:firefox": "npm run test -- -t browser -- --browser firefox -f ./dist/test/browser.js",
+    "release": "semantic-release"
+  },
+  "dependencies": {
+    "@libp2p/daemon-client": "^0.0.2",
+    "@libp2p/interfaces": "^1.3.17",
+    "@libp2p/logger": "^1.1.2",
+    "@libp2p/peer-id": "^1.1.8",
+    "@multiformats/multiaddr": "^10.1.8",
+    "it-all": "^1.0.6",
+    "it-first": "^1.0.7",
+    "multiformats": "^9.4.5",
+    "p-retry": "^5.1.0",
+    "uint8arrays": "^3.0.0"
+  },
+  "peerDependencies": {
+    "aegir": "^36.0.0"
+  },
+  "devDependencies": {
+    "aegir": "^36.0.0"
+  }
+}

package/src/connect.ts

@@ -0,0 +1,75 @@
+import { expect } from 'aegir/utils/chai.js'
+import type { Daemon, NodeType, SpawnOptions, DaemonFactory, PeerIdType } from './index.js'
+import { keys } from './resources/keys/index.js'
+
+export function connectTests (factory: DaemonFactory) {
+  const keyTypes: PeerIdType[] = ['ed25519', 'rsa', 'secp256k1']
+  const impls: NodeType[] = ['js', 'go']
+
+  for (const keyType of keyTypes) {
+    for (const implA of impls) {
+      for (const implB of impls) {
+        runConnectTests(
+          `noise/${keyType}`,
+          factory,
+          { type: implA, noise: true, key: keys.go[keyType] },
+          { type: implB, noise: true, key: keys.js[keyType] }
+        )
+      }
+    }
+  }
+}
+
+function runConnectTests (name: string, factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+  describe(`connect using ${name}`, () => {
+    let daemons: Daemon[]
+
+    // Start Daemons
+    before(async function () {
+      this.timeout(20 * 1000)
+
+      daemons = await Promise.all([
+        factory.spawn(optionsA),
+        factory.spawn(optionsB)
+      ])
+    })
+
+    // Stop daemons
+    after(async function () {
+      if (daemons != null) {
+        await Promise.all(
+          daemons.map(async (daemon) => await daemon.stop())
+        )
+      }
+    })
+
+    it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
+      this.timeout(10 * 1000)
+
+      const identify1 = await daemons[0].client.identify()
+      const identify2 = await daemons[1].client.identify()
+
+      // verify connected peers
+      const knownPeersBeforeConnect1 = await daemons[0].client.listPeers()
+      expect(knownPeersBeforeConnect1).to.have.lengthOf(0)
+
+      const knownPeersBeforeConnect2 = await daemons[1].client.listPeers()
+      expect(knownPeersBeforeConnect2).to.have.lengthOf(0)
+
+      // connect peers
+      await daemons[0].client.connect(identify2.peerId, identify2.addrs)
+
+      // daemons[0] will take some time to get the peers
+      await new Promise(resolve => setTimeout(resolve, 1000))
+
+      // verify connected peers
+      const knownPeersAfterConnect1 = await daemons[0].client.listPeers()
+      expect(knownPeersAfterConnect1).to.have.lengthOf(1)
+      expect(knownPeersAfterConnect1[0].toString()).to.equal(identify2.peerId.toString())
+
+      const knownPeersAfterConnect2 = await daemons[1].client.listPeers()
+      expect(knownPeersAfterConnect2).to.have.lengthOf(1)
+      expect(knownPeersAfterConnect2[0].toString()).to.equal(identify1.peerId.toString())
+    })
+  })
+}

package/src/dht/content-fetching.ts

@@ -0,0 +1,70 @@
+/* eslint-env mocha */
+
+import { expect } from 'aegir/utils/chai.js'
+import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
+
+const record = {
+  key: uint8ArrayConcat([
+    uint8ArrayFromString('/pk/'),
+    uint8ArrayFromString('muft89xjpybos8eas1vaq2xrbsx2vkll7is4ocy7pia5fsjlt3c2', 'base36')
+  ]),
+  value: uint8ArrayFromString('080012a60230820122300d06092a864886f70d01010105000382010f003082010a0282010100c2588f998971dac9e3eef76a311bf9159505aff69ea3b664c55a36aa28ee08de1127228a4d431bb9c0840240c75f6e98a0843a78d945491a3ea5e1f7cee2bc71383510db5290702383975b7bffae9fb40c84cc1220fb4a7db862fffb0de42f8fd8fb33a17deb20f30e2d0f194791fe69355a392f77df35f101e08a2fc95b2c018768938814fcb52482f899f5e90a1905e8abbcdbb1647ad80a5b0417e1ce8320d64197a6ba3848926375c63adebabdf6eb82109bcadfee13b62bf922bbb6f74c1a26c9bc6122d1436787e0e6de3c152b1959701092abef84599f73eaedb2fcef9f87293e1bbe8e0fef3f1a7fd2e8b94c7e633f88473644a63cb948e4d25c54490203010001', 'hex')
+}
+
+export function contentFetchingTests (factory: DaemonFactory) {
+  const nodeTypes: NodeType[] = ['js', 'go']
+
+  for (const typeA of nodeTypes) {
+    for (const typeB of nodeTypes) {
+      runContentFetchingTests(
+        factory,
+        { type: typeA, dht: true },
+        { type: typeB, dht: true }
+      )
+    }
+  }
+}
+
+function runContentFetchingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+  describe('dht.contentFetching', () => {
+    let daemons: Daemon[]
+
+    // Start Daemons
+    before(async function () {
+      this.timeout(20 * 1000)
+
+      daemons = await Promise.all([
+        factory.spawn(optionsA),
+        factory.spawn(optionsB)
+      ])
+
+      // connect them
+      const identify0 = await daemons[0].client.identify()
+
+      await daemons[1].client.connect(identify0.peerId, identify0.addrs)
+
+      // jsDaemon1 will take some time to get the peers
+      await new Promise(resolve => setTimeout(resolve, 1000))
+    })
+
+    // Stop daemons
+    after(async function () {
+      if (daemons != null) {
+        await Promise.all(
+          daemons.map(async (daemon) => await daemon.stop())
+        )
+      }
+    })
+
+    it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
+      this.timeout(10 * 1000)
+
+      await daemons[0].client.dht.put(record.key, record.value)
+
+      const data = await daemons[1].client.dht.get(record.key)
+      expect(data).to.equalBytes(record.value)
+    })
+  })
+}

package/src/dht/content-routing.ts

@@ -0,0 +1,74 @@
+/* eslint-env mocha */
+
+import { expect } from 'aegir/utils/chai.js'
+import { CID } from 'multiformats/cid'
+import all from 'it-all'
+import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
+import type { IdentifyResult } from '@libp2p/daemon-client'
+
+export function contentRoutingTests (factory: DaemonFactory) {
+  const nodeTypes: NodeType[] = ['js', 'go']
+
+  for (const typeA of nodeTypes) {
+    for (const typeB of nodeTypes) {
+      if (typeA === 'go' && typeB === 'go') {
+        // skip go<->go as it never seems to populate the routing tables
+        continue
+      }
+
+      runContentRoutingTests(
+        factory,
+        { type: typeA, dht: true },
+        { type: typeB, dht: true }
+      )
+    }
+  }
+}
+
+function runContentRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+  describe('dht.contentRouting', () => {
+    let daemons: Daemon[]
+    let identify: IdentifyResult[]
+
+    // Start Daemons
+    before(async function () {
+      this.timeout(20 * 1000)
+
+      daemons = await Promise.all([
+        factory.spawn(optionsA),
+        factory.spawn(optionsB),
+        factory.spawn(optionsB)
+      ])
+
+      identify = await Promise.all(
+        daemons.map(async d => await d.client.identify())
+      )
+
+      await daemons[0].client.connect(identify[1].peerId, identify[1].addrs)
+      await daemons[0].client.connect(identify[2].peerId, identify[2].addrs)
+
+      // get the peers in the table
+      await new Promise(resolve => setTimeout(resolve, 1000))
+    })
+
+    // Stop daemons
+    after(async function () {
+      if (daemons != null) {
+        await Promise.all(
+          daemons.map(async (daemon) => await daemon.stop())
+        )
+      }
+    })
+
+    it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
+      const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp39')
+
+      await daemons[0].client.dht.provide(cid)
+
+      const providers = await all(daemons[1].client.dht.findProviders(cid, 1))
+
+      expect(providers).to.exist()
+      expect(providers.length).to.be.greaterThan(0)
+    })
+  })
+}

package/src/dht/index.ts

@@ -0,0 +1,10 @@
+import type { DaemonFactory } from '../index.js'
+import { contentFetchingTests } from './content-fetching.js'
+import { contentRoutingTests } from './content-routing.js'
+import { peerRoutingTests } from './peer-routing.js'
+
+export async function dhtTests (factory: DaemonFactory) {
+  await contentFetchingTests(factory)
+  await contentRoutingTests(factory)
+  await peerRoutingTests(factory)
+}

package/src/dht/peer-routing.ts

@@ -0,0 +1,63 @@
+/* eslint-env mocha */
+
+import { expect } from 'aegir/utils/chai.js'
+import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
+import pRetry from 'p-retry'
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+
+export function peerRoutingTests (factory: DaemonFactory) {
+  const nodeTypes: NodeType[] = ['js', 'go']
+
+  for (const typeA of nodeTypes) {
+    for (const typeB of nodeTypes) {
+      runPeerRoutingTests(
+        factory,
+        { type: typeA, dht: true },
+        { type: typeB, dht: true }
+      )
+    }
+  }
+}
+
+function runPeerRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+  describe('dht.peerRouting', () => {
+    let daemons: Daemon[]
+
+    // Start Daemons
+    before(async function () {
+      this.timeout(20 * 1000)
+
+      daemons = await Promise.all([
+        factory.spawn(optionsA),
+        factory.spawn(optionsB),
+        factory.spawn(optionsB)
+      ])
+    })
+
+    // Stop daemons
+    after(async function () {
+      if (daemons != null) {
+        await Promise.all(
+          daemons.map(async (daemon) => await daemon.stop())
+        )
+      }
+    })
+
+    it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
+      const identify1 = await daemons[1].client.identify()
+      const identify2 = await daemons[2].client.identify()
+
+      // peers need at least one peer in their routing table or they fail with:
+      // connect 0 => 1
+      await daemons[0].client.connect(identify1.peerId, identify1.addrs)
+
+      // connect 0 => 2
+      await daemons[0].client.connect(identify2.peerId, identify2.addrs)
+
+      // peer 1 find peer 2, retry up to 10 times to allow the routing table to refresh
+      const peerData: PeerInfo = await pRetry(async () => await daemons[1].client.dht.findPeer(identify2.peerId), { retries: 10 })
+
+      expect(identify2.addrs.map(ma => ma.toString())).to.include.deep.members(peerData.multiaddrs.map(ma => ma.toString()))
+    })
+  })
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+import { connectTests } from './connect.js'
+import { dhtTests } from './dht/index.js'
+import { pubsubTests } from './pubsub/index.js'
+import type { DaemonClient } from '@libp2p/daemon-client'
+
+export interface Daemon {
+  stop: () => Promise<void>
+  client: DaemonClient
+}
+
+export type NodeType = 'js' | 'go'
+export type PeerIdType = 'rsa' | 'ed25519' | 'secp256k1'
+
+export interface SpawnOptions {
+  type: NodeType
+  key?: string
+  noise?: true
+  dht?: boolean
+  pubsub?: boolean
+  pubsubRouter?: 'gossipsub' | 'floodsub'
+}
+
+export interface DaemonFactory {
+  spawn: (options: SpawnOptions) => Promise<Daemon>
+}
+
+export default async function interopTests (factory: DaemonFactory) {
+  await connectTests(factory)
+  await dhtTests(factory)
+  await pubsubTests(factory)
+}

package/src/pubsub/floodsub.ts

@@ -0,0 +1,70 @@
+/* eslint-env mocha */
+
+import { expect } from 'aegir/utils/chai.js'
+import type { Daemon, DaemonFactory, NodeType, SpawnOptions } from '../index.js'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import first from 'it-first'
+
+export function floodsubTests (factory: DaemonFactory) {
+  const nodeTypes: NodeType[] = ['js', 'go']
+
+  for (const typeA of nodeTypes) {
+    for (const typeB of nodeTypes) {
+      runFloodsubTests(
+        factory,
+        { type: typeA, pubsub: true, pubsubRouter: 'floodsub' },
+        { type: typeB, pubsub: true, pubsubRouter: 'floodsub' }
+      )
+    }
+  }
+}
+
+function runFloodsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions) {
+  describe('pubsub.floodSub', () => {
+    let daemons: Daemon[]
+
+    // Start Daemons
+    before(async function () {
+      this.timeout(20 * 1000)
+
+      daemons = await Promise.all([
+        factory.spawn(optionsA),
+        factory.spawn(optionsB),
+        factory.spawn(optionsB)
+      ])
+    })
+
+    // Stop daemons
+    after(async function () {
+      if (daemons != null) {
+        await Promise.all(
+          daemons.map(async (daemon) => await daemon.stop())
+        )
+      }
+    })
+
+    it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
+      const topic = 'test-topic'
+      const data = uint8ArrayFromString('test-data')
+
+      const subscribeIterator = await daemons[1].client.pubsub.subscribe(topic)
+      const subscriber = async () => {
+        const message = await first(subscribeIterator)
+
+        expect(message).to.exist()
+        expect(message).to.have.property('data').that.equalBytes(data)
+      }
+
+      const publisher = async () => {
+        // wait for subscription stream
+        await new Promise(resolve => setTimeout(resolve, 800))
+        await daemons[0].client.pubsub.publish(topic, data)
+      }
+
+      return await Promise.all([
+        subscriber(),
+        publisher()
+      ])
+    })
+  })
+}