@helia/interop 10.2.5-f6cc7640 → 11.0.0

package/src/fixtures/create-helia.browser.ts

@@ -1,16 +1,19 @@
-import { bitswap } from '@helia/block-brokers'
-import { ipnsValidator, ipnsSelector } from '@helia/ipns'
+import { withBitswap } from '@helia/bitswap'
+import { libp2pDefaults, withLibp2p } from '@helia/libp2p'
+import * as dagCbor from '@ipld/dag-cbor'
+import * as dagJson from '@ipld/dag-json'
 import { kadDHT, removePublicAddressesMapper } from '@libp2p/kad-dht'
 import { webSockets } from '@libp2p/websockets'
 import { sha3512 } from '@multiformats/sha3'
-import { createHelia, libp2pDefaults } from 'helia'
-import type { Libp2p } from '@libp2p/interface'
-import type { DefaultLibp2pServices, Helia } from 'helia'
+import { createHeliaLight } from 'helia'
+import * as json from 'multiformats/codecs/json'
+import { sha512 } from 'multiformats/hashes/sha2'
+import type { DefaultLibp2pServices, HeliaWithLibp2p } from '@helia/libp2p'
 import type { Libp2pOptions } from 'libp2p'
 
-export async function createHeliaNode (): Promise<Helia<Libp2p<DefaultLibp2pServices>>>
-export async function createHeliaNode <Services extends Record<string, unknown>> (libp2pOptions: Libp2pOptions<Services>): Promise<Helia<Libp2p<Services & DefaultLibp2pServices>>>
-export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<Helia<Libp2p<DefaultLibp2pServices>>> {
+export async function createHeliaNode (): Promise<HeliaWithLibp2p<DefaultLibp2pServices>>
+export async function createHeliaNode <Services extends Record<string, unknown>> (libp2pOptions: Libp2pOptions<Services>): Promise<HeliaWithLibp2p<Services & DefaultLibp2pServices>>
+export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<HeliaWithLibp2p<DefaultLibp2pServices>> {
   const defaults = libp2pDefaults()
 
   // allow dialing insecure WebSockets
@@ -30,15 +33,6 @@ export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<H
     ...(defaults.services ?? {}),
     ...(libp2pOptions?.services ?? {}),
     dht: kadDHT({
-      validators: {
-        ipns: ipnsValidator
-      },
-      selectors: {
-        ipns: ipnsSelector
-      },
-      // skips waiting for the initial self-query to find peers
-      allowQueryWithZeroPeers: true,
-
       protocol: '/ipfs/lan/kad/1.0.0',
       peerInfoMapper: removePublicAddressesMapper,
       clientMode: false
@@ -53,16 +47,20 @@ export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<H
   delete defaults.services.autoNAT
   // @ts-expect-error services.dcutr is not optional
   delete defaults.services.dcutr
-  // @ts-expect-error services.delegatedRouting is not optional
-  delete defaults.services.delegatedRouting
+  // @ts-expect-error services.delegatedContentRouting is not optional
+  delete defaults.services.delegatedContentRouting
+  // @ts-expect-error services.delegatedPeerRouting is not optional
+  delete defaults.services.delegatedPeerRouting
 
-  return createHelia<Libp2p<DefaultLibp2pServices>>({
-    blockBrokers: [
-      bitswap()
+  return withBitswap(withLibp2p(createHeliaLight({
+    codecs: [
+      dagCbor,
+      dagJson,
+      json
     ],
-    libp2p: defaults,
     hashers: [
+      sha512,
       sha3512
     ]
-  })
+  }), defaults)).start()
 }

package/src/fixtures/create-helia.ts

@@ -1,15 +1,17 @@
-import { bitswap } from '@helia/block-brokers'
-import { ipnsValidator, ipnsSelector } from '@helia/ipns'
+import { withBitswap } from '@helia/bitswap'
+import { withLibp2p, libp2pDefaults } from '@helia/libp2p'
+import * as dagCbor from '@ipld/dag-cbor'
+import * as dagJson from '@ipld/dag-json'
 import { kadDHT, removePublicAddressesMapper } from '@libp2p/kad-dht'
 import { sha3512 } from '@multiformats/sha3'
-import { createHelia, libp2pDefaults } from 'helia'
-import type { Libp2p } from '@libp2p/interface'
-import type { DefaultLibp2pServices, Helia } from 'helia'
-import type { Libp2pOptions } from 'libp2p'
+import { createHeliaLight } from 'helia'
+import * as json from 'multiformats/codecs/json'
+import { sha512 } from 'multiformats/hashes/sha2'
+import type { HeliaWithLibp2p, DefaultLibp2pServices, CreateLibp2pOptions } from '@helia/libp2p'
 
-export async function createHeliaNode (): Promise<Helia<Libp2p<DefaultLibp2pServices>>>
-export async function createHeliaNode <Services extends Record<string, unknown>> (libp2pOptions: Libp2pOptions<Services>): Promise<Helia<Libp2p<Services & DefaultLibp2pServices>>>
-export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<Helia<Libp2p<DefaultLibp2pServices>>> {
+export async function createHeliaNode (): Promise<HeliaWithLibp2p<DefaultLibp2pServices>>
+export async function createHeliaNode <Services extends Record<string, unknown>> (libp2pOptions: CreateLibp2pOptions<Services>): Promise<HeliaWithLibp2p<Services & DefaultLibp2pServices>>
+export async function createHeliaNode (libp2pOptions?: CreateLibp2pOptions<any>): Promise<HeliaWithLibp2p<DefaultLibp2pServices>> {
   const defaults = libp2pDefaults()
   defaults.addresses = {
     listen: [
@@ -20,12 +22,6 @@ export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<H
     ...(defaults.services ?? {}),
     ...(libp2pOptions?.services ?? {}),
     dht: kadDHT({
-      validators: {
-        ipns: ipnsValidator
-      },
-      selectors: {
-        ipns: ipnsSelector
-      },
       protocol: '/ipfs/lan/kad/1.0.0',
       peerInfoMapper: removePublicAddressesMapper,
       clientMode: false
@@ -42,18 +38,22 @@ export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<H
   delete defaults.services.upnp
   // @ts-expect-error services.dcutr is not optional
   delete defaults.services.dcutr
-  // @ts-expect-error services.delegatedRouting is not optional
-  delete defaults.services.delegatedRouting
+  // @ts-expect-error services.delegatedContentRouting is not optional
+  delete defaults.services.delegatedContentRouting
+  // @ts-expect-error services.delegatedPeerRouting is not optional
+  delete defaults.services.delegatedPeerRouting
   // @ts-expect-error services.autoTLS is not optional
   delete defaults.services.autoTLS
 
-  return createHelia<Libp2p<DefaultLibp2pServices>>({
-    blockBrokers: [
-      bitswap()
+  return withBitswap(withLibp2p(createHeliaLight({
+    codecs: [
+      dagCbor,
+      dagJson,
+      json
     ],
-    libp2p: defaults,
     hashers: [
+      sha512,
       sha3512
     ]
-  })
+  }), defaults)).start()
 }

package/src/fixtures/key-types.ts

@@ -2,6 +2,5 @@ import type { KeyType } from '@libp2p/interface'
 
 export const keyTypes: KeyType[] = [
   'Ed25519',
-  'secp256k1',
   'RSA'
 ]

package/src/helia-blockstore-sessions.spec.ts

@@ -6,12 +6,12 @@ import toBuffer from 'it-to-buffer'
 import { CID } from 'multiformats/cid'
 import { createHeliaNode } from './fixtures/create-helia.ts'
 import { createKuboNode } from './fixtures/create-kubo.ts'
-import type { BitswapProvider } from '@helia/block-brokers'
-import type { Helia } from 'helia'
+import type { BitswapProvider } from '@helia/bitswap'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { KuboInfo, KuboNode } from 'ipfsd-ctl'
 
 describe('helia - blockstore sessions', () => {
-  let helia: Helia
+  let helia: HeliaWithLibp2p
   let kubo: KuboNode
   let kuboInfo: KuboInfo
   let kubo2: KuboNode
@@ -111,6 +111,6 @@ describe('helia - blockstore sessions', () => {
     }))
 
     expect(output).to.equalBytes(input)
-    expect(foundProviders).to.have.deep.nested.property('[0].provider.id', peerIdFromString(kuboInfo.peerId ?? ''))
+    expect(foundProviders).to.have.deep.nested.property('[0].provider.id', peerIdFromString(kuboInfo.peerId ?? '').toCID())
   })
 })

package/src/helia-blockstore.spec.ts

@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { multiaddr } from '@multiformats/multiaddr'
 import { expect } from 'aegir/chai'
 import toBuffer from 'it-to-buffer'
@@ -7,11 +6,11 @@ import * as raw from 'multiformats/codecs/raw'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { createHeliaNode } from './fixtures/create-helia.ts'
 import { createKuboNode } from './fixtures/create-kubo.ts'
-import type { Helia } from 'helia'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { KuboInfo, KuboNode } from 'ipfsd-ctl'
 
 describe('helia - blockstore', () => {
-  let helia: Helia
+  let helia: HeliaWithLibp2p
   let kubo: KuboNode
   let kuboInfo: KuboInfo
 
@@ -35,7 +34,7 @@ describe('helia - blockstore', () => {
   })
 
   it('should be able to send a block', async () => {
-    const input = randomBytes(10)
+    const input = crypto.getRandomValues(new Uint8Array(10))
     const digest = await sha256.digest(input)
     const cid = CID.createV1(raw.code, digest)
     await helia.blockstore.put(cid, input)
@@ -45,7 +44,7 @@ describe('helia - blockstore', () => {
   })
 
   it('should be able to receive a block', async () => {
-    const input = randomBytes(10)
+    const input = crypto.getRandomValues(new Uint8Array(10))
     const { cid } = await kubo.api.add({ content: input }, {
       cidVersion: 1,
       rawLeaves: true

package/src/helia-hashes.spec.ts

@@ -6,11 +6,11 @@ import * as raw from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
 import { createHeliaNode } from './fixtures/create-helia.ts'
 import { createKuboNode } from './fixtures/create-kubo.ts'
-import type { Helia } from 'helia'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { KuboNode } from 'ipfsd-ctl'
 
 describe('helia - hashes', () => {
-  let helia: Helia
+  let helia: HeliaWithLibp2p
   let kubo: KuboNode
 
   beforeEach(async () => {

package/src/helia-pins.spec.ts

@@ -6,11 +6,11 @@ import * as raw from 'multiformats/codecs/raw'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { createHeliaNode } from './fixtures/create-helia.ts'
 import { createKuboNode } from './fixtures/create-kubo.ts'
-import type { Helia } from 'helia'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { KuboNode } from 'ipfsd-ctl'
 
 describe('helia - pins', () => {
-  let helia: Helia
+  let helia: HeliaWithLibp2p
   let kubo: KuboNode
 
   beforeEach(async () => {

package/src/helia-progress-events.spec.ts

@@ -1,4 +1,3 @@
-import { randomBytes } from '@libp2p/crypto'
 import { contentRoutingSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { CODE_P2P, multiaddr } from '@multiformats/multiaddr'
@@ -62,7 +61,7 @@ describe('helia - progress events', () => {
   })
 
   it('should yield routing events', async () => {
-    const input = randomBytes(10)
+    const input = crypto.getRandomValues(new Uint8Array(10))
     const { cid } = await kubo.api.add({ content: input }, {
       cidVersion: 1,
       rawLeaves: true
@@ -82,7 +81,7 @@ describe('helia - progress events', () => {
   })
 
   it('should yield block broker events', async () => {
-    const input = randomBytes(10)
+    const input = crypto.getRandomValues(new Uint8Array(10))
     const { cid } = await kubo.api.add({ content: input }, {
       cidVersion: 1,
       rawLeaves: true

package/src/ipns-http.spec.ts

@@ -1,18 +1,18 @@
-import { createHeliaHTTP } from '@helia/http'
+import { delegatedHTTPRouter } from '@helia/delegated-routing-client'
 import { ipns } from '@helia/ipns'
-import { delegatedHTTPRouting } from '@helia/routers'
 import { peerIdFromCID } from '@libp2p/peer-id'
 import { expect } from 'aegir/chai'
+import { createHelia } from 'helia'
+import last from 'it-last'
 import { CID } from 'multiformats/cid'
 import { isNode } from 'wherearewe'
 import { createKuboNode } from './fixtures/create-kubo.ts'
 import type { Helia } from '@helia/interface'
 import type { IPNS } from '@helia/ipns'
 import type { KuboNode } from 'ipfsd-ctl'
-import type { Libp2p } from 'libp2p'
 
 describe('@helia/ipns - http', () => {
-  let helia: Helia<Libp2p<any>>
+  let helia: Helia
   let kubo: KuboNode
   let name: IPNS
 
@@ -24,13 +24,14 @@ describe('@helia/ipns - http', () => {
   beforeEach(async () => {
     kubo = await createKuboNode()
     const kuboInfo = await kubo.info()
-    helia = await createHeliaHTTP({
+    helia = await createHelia({
       routers: [
-        delegatedHTTPRouting({
+        delegatedHTTPRouter({
           url: kuboInfo.gateway
         })
       ]
-    })
+    }).start()
+
     name = ipns(helia)
   })
 
@@ -62,8 +63,12 @@ describe('@helia/ipns - http', () => {
     })
 
     const key = peerIdFromCID(CID.parse(res.name))
-    // @ts-expect-error @libp2p/peer-id needs dep updates
-    const { cid: resolvedCid } = await name.resolve(key.toMultihash())
-    expect(resolvedCid.toString()).to.equal(cid.toString())
+    const result = await last(name.resolve(key.toMultihash()))
+
+    if (result == null) {
+      throw new Error('No results found')
+    }
+
+    expect(result.record.value).to.equal(`/ipfs/${cid}`)
   })
 })

package/src/ipns-pubsub.spec.ts

@@ -2,7 +2,6 @@
 
 import { ipns } from '@helia/ipns'
 import { pubsub } from '@helia/ipns/routing'
-import { generateKeyPair } from '@libp2p/crypto/keys'
 import { floodsub } from '@libp2p/floodsub'
 import { peerIdFromCID } from '@libp2p/peer-id'
 import { expect } from 'aegir/chai'
@@ -23,9 +22,8 @@ import { keyTypes } from './fixtures/key-types.ts'
 import { waitFor } from './fixtures/wait-for.ts'
 import type { IPNS, ResolveResult } from '@helia/ipns'
 import type { PubSub } from '@helia/ipns/routing'
-import type { Libp2p } from '@libp2p/interface'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { Keychain } from '@libp2p/keychain'
-import type { Helia } from 'helia'
 import type { KuboNode } from 'ipfsd-ctl'
 
 // skip RSA tests because we need the DHT enabled to find the public key
@@ -33,7 +31,7 @@ import type { KuboNode } from 'ipfsd-ctl'
 // resolution because Kubo will use the DHT as well
 keyTypes.filter(keyType => keyType !== 'RSA').forEach(keyType => {
   describe(`@helia/ipns - pubsub routing with ${keyType} keys`, () => {
-    let helia: Helia<Libp2p<{ pubsub: PubSub, keychain: Keychain }>>
+    let helia: HeliaWithLibp2p<{ pubsub: PubSub, keychain: Keychain }>
     let kubo: KuboNode
     let name: IPNS
 
@@ -70,13 +68,12 @@ keyTypes.filter(keyType => keyType !== 'RSA').forEach(keyType => {
       const digest = await sha256.digest(input)
       const cid = CID.createV1(raw.code, digest)
 
-      const privateKey = await generateKeyPair('Ed25519')
       const keyName = 'my-ipns-key'
-      await helia.libp2p.services.keychain.importKey(keyName, privateKey)
+      const privateKey = await helia.keychain.generateKey(keyName)
 
       // first call to pubsub resolver will fail but we should trigger
       // subscribing pubsub for updates
-      await expect(last(kubo.api.name.resolve(privateKey.publicKey.toString(), {
+      await expect(last(kubo.api.name.resolve(`${privateKey.publicKey}`, {
         timeout: 100
       }))).to.eventually.be.undefined()
 
@@ -137,7 +134,7 @@ keyTypes.filter(keyType => keyType !== 'RSA').forEach(keyType => {
       }
 
       // first call to pubsub resolver should fail but we should now be subscribed for updates
-      await expect(name.resolve(peerCid.multihash)).to.eventually.be.rejected()
+      await expect(last(name.resolve(peerCid.multihash))).to.eventually.be.rejected()
 
       // actual pubsub subscription name
       const subscriptionName = `/record/${uint8ArrayToString(uint8ArrayConcat([
@@ -173,8 +170,7 @@ keyTypes.filter(keyType => keyType !== 'RSA').forEach(keyType => {
       // we should get an update eventually
       await waitFor(async () => {
         try {
-          // @ts-expect-error @libp2p/peer-id needs dep updates
-          resolveResult = await name.resolve(peerId.toMultihash())
+          resolveResult = await last(name.resolve(peerId.toMultihash()))
 
           return true
         } catch {
@@ -189,7 +185,7 @@ keyTypes.filter(keyType => keyType !== 'RSA').forEach(keyType => {
         throw new Error('Failed to resolve CID')
       }
 
-      expect(resolveResult.cid.toString()).to.equal(cid.toString())
+      expect(resolveResult.record.value).to.equal(`/ipfs/${cid}`)
     })
   })
 })

package/src/ipns.spec.ts

@@ -1,12 +1,13 @@
 import { ipns } from '@helia/ipns'
-import { generateKeyPair, privateKeyToProtobuf } from '@libp2p/crypto/keys'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { expect } from 'aegir/chai'
-import { multihashToIPNSRoutingKey } from 'ipns'
 import last from 'it-last'
+import { base36 } from 'multiformats/bases/base36'
 import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
 import { sha256 } from 'multiformats/hashes/sha2'
+import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { isElectronMain } from 'wherearewe'
 import { connect } from './fixtures/connect.ts'
 import { createHeliaNode } from './fixtures/create-helia.ts'
@@ -14,21 +15,29 @@ import { createKuboNode } from './fixtures/create-kubo.ts'
 import { sortClosestPeers } from './fixtures/create-peer-ids.ts'
 import { keyTypes } from './fixtures/key-types.ts'
 import { waitFor } from './fixtures/wait-for.ts'
+import type { PrivateKey } from '@helia/interface'
 import type { IPNS } from '@helia/ipns'
-import type { Libp2p, PrivateKey } from '@libp2p/interface'
-import type { DefaultLibp2pServices, Helia } from 'helia'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { KuboNode } from 'ipfsd-ctl'
+import type { MultihashDigest } from 'multiformats/cid'
+
+function multihashToIPNSRoutingKey (digest: MultihashDigest): Uint8Array<ArrayBuffer> {
+  return uint8ArrayConcat([
+    uint8ArrayFromString('/ipns/'),
+    digest.bytes
+  ])
+}
 
 keyTypes.forEach(type => {
   describe(`@helia/ipns - default routing with ${type} keys`, () => {
-    let helia: Helia<Libp2p<DefaultLibp2pServices>>
+    let helia: HeliaWithLibp2p
     let kubo: KuboNode
     let name: IPNS
 
     // the CID we are going to publish
     let value: CID
 
-    // the public key we will use to publish the value
+    // the key we will use to publish the value
     let key: PrivateKey
 
     /**
@@ -44,18 +53,16 @@ keyTypes.forEach(type => {
       helia = await createHeliaNode()
       kubo = await createKuboNode()
 
-      // find a PeerId that is KAD-closer to the resolver than the publisher when used as an IPNS key
+      // find a key that is KAD-closer to the resolver than the publisher when
+      // used as an IPNS key
       while (true) {
-        if (type === 'Ed25519') {
-          key = await generateKeyPair('Ed25519')
-        } else if (type === 'secp256k1') {
-          key = await generateKeyPair('secp256k1')
-        } else {
-          key = await generateKeyPair('RSA', 2048)
-        }
+        await helia.keychain.removeKey('test-key')
+        key = await helia.keychain.generateKey('test-key', {
+          type
+        })
+        await helia.keychain.removeKey('test-key')
 
-        // @ts-expect-error @libp2p/crypto needs dep updates
-        const routingKey = multihashToIPNSRoutingKey(key.publicKey?.toMultihash())
+        const routingKey = multihashToIPNSRoutingKey(key.publicKey.toMultihash())
 
         const [closest] = await sortClosestPeers(routingKey, [
           helia.libp2p.peerId,
@@ -120,12 +127,11 @@ keyTypes.forEach(type => {
       }
     })
 
-    it(`should publish on helia and resolve on kubo using a ${type} key`, async () => {
+    it('should publish on helia and resolve on kubo', async () => {
       await createNodes('kubo')
 
-      const privateKey = await generateKeyPair('Ed25519')
       const keyName = 'my-ipns-key'
-      await helia.libp2p.services.keychain.importKey(keyName, privateKey)
+      const privateKey = await helia.keychain.generateKey(keyName)
       await name.publish(keyName, value)
 
       const resolved = await last(kubo.api.name.resolve(privateKey.publicKey.toString()))
@@ -156,8 +162,7 @@ keyTypes.forEach(type => {
 
       // ensure the key is in the kubo keychain so we can use it to publish the IPNS record
       const body = new FormData()
-      // @ts-expect-error @libp2p/crypto needs dep updates
-      body.append('key', new Blob([privateKeyToProtobuf(key)]))
+      body.append('key', new Blob([key.toProtobuf()]))
 
       // can't use the kubo-rpc-api for this call yet
       const config = kubo.api.getEndpointConfig()
@@ -168,6 +173,9 @@ keyTypes.forEach(type => {
 
       expect(response).to.have.property('status', 200)
 
+      const json = await response.json()
+      expect(json.Id).to.equal(key.publicKey.toCID().toString(base36), 'did not import key correctly')
+
       const oneHourNS = BigInt(60 * 60 * 1e+9)
 
       await kubo.api.name.publish(cid, {
@@ -175,9 +183,14 @@ keyTypes.forEach(type => {
         ttl: '1h'
       })
 
-      const { cid: resolvedCid, record } = await name.resolve(key.publicKey)
-      expect(resolvedCid.toString()).to.equal(cid.toString())
-      expect(record.ttl).to.equal(oneHourNS)
+      const result = await last(name.resolve(key.publicKey))
+
+      if (result == null) {
+        throw new Error('No result found')
+      }
+
+      expect(result.record.value).to.equal(`/ipfs/${cid}`)
+      expect(result.record.ttl).to.equal(oneHourNS)
     })
   })
 })

package/src/json.spec.ts

@@ -5,12 +5,12 @@ import * as jsonCodec from 'multiformats/codecs/json'
 import { createHeliaNode } from './fixtures/create-helia.ts'
 import { createKuboNode } from './fixtures/create-kubo.ts'
 import type { JSON, AddOptions } from '@helia/json'
-import type { Helia } from 'helia'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { KuboNode } from 'ipfsd-ctl'
 import type { BlockPutOptions as KuboAddOptions } from 'kubo-rpc-client'
 
 describe('@helia/json', () => {
-  let helia: Helia
+  let helia: HeliaWithLibp2p
   let j: JSON
   let kubo: KuboNode
 

package/src/libp2p.spec.ts

@@ -0,0 +1,107 @@
+import { withLibp2p } from '@helia/libp2p'
+import { identify } from '@libp2p/identify'
+import { webSockets } from '@libp2p/websockets'
+import { expect } from 'aegir/chai'
+import { createHeliaLight } from 'helia'
+import { createLibp2p, isLibp2p } from 'libp2p'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
+
+describe('@helia/libp2p', () => {
+  let helia: HeliaWithLibp2p<any>
+
+  beforeEach(() => {
+    helia = withLibp2p(createHeliaLight())
+  })
+
+  afterEach(async () => {
+    if (helia != null) {
+      await helia.stop()
+    }
+  })
+
+  it('should add a libp2p property', async () => {
+    await helia.start()
+    expect(isLibp2p(helia.libp2p)).to.be.true()
+  })
+
+  it('should start libp2p', async () => {
+    await helia.start()
+    await helia.stop()
+
+    expect(helia.libp2p.status).to.equal('stopped')
+
+    await helia.start()
+
+    expect(helia.libp2p.status).to.equal('started')
+  })
+
+  it('should stop libp2p', async () => {
+    await helia.start()
+
+    expect(helia.libp2p.status).to.equal('started')
+
+    await helia.stop()
+
+    expect(helia.libp2p.status).to.equal('stopped')
+  })
+
+  it('does not add helia details to the AgentVersion when it has been overridden', async () => {
+    helia = await withLibp2p(createHeliaLight(), await createLibp2p({
+      nodeInfo: {
+        userAgent: 'my custom user agent'
+      },
+      transports: [
+        webSockets()
+      ],
+      services: {
+        identify: identify()
+      }
+    })).start()
+
+    expect(helia).to.have.nested.property('libp2p.services.identify.host.agentVersion')
+      .that.does.not.include('helia/')
+
+    const peer = await helia.libp2p.peerStore.get(helia.libp2p.peerId)
+    const agentVersionBuf = peer.metadata.get('AgentVersion')
+
+    if (agentVersionBuf == null) {
+      throw new Error('AgentVersion not stored')
+    }
+
+    expect(agentVersionBuf).to.be.ok()
+    expect(uint8ArrayToString(agentVersionBuf)).to.not.include('helia/')
+  })
+
+  it('should have the same peer id after a restart', async () => {
+    await helia.start()
+
+    const datastore = helia.datastore
+    const peerId = helia.libp2p.peerId
+
+    await helia.stop()
+
+    helia = await withLibp2p(createHeliaLight({
+      datastore
+    }), {
+      datastore
+    }).start()
+
+    expect(helia.libp2p.peerId.toString()).to.equal(peerId.toString())
+  })
+
+  it('allows passing a libp2p node', async () => {
+    const libp2p = await createLibp2p()
+
+    helia = await withLibp2p(createHeliaLight(), libp2p).start()
+
+    expect(helia.libp2p).to.equal(libp2p)
+  })
+
+  it('adds helia details to the AgentVersion', async () => {
+    await helia.start()
+
+    expect(helia).to.have.nested.property('libp2p.services.identify.host.agentVersion')
+      .that.includes('helia/')
+  })
+})