@helia/interop 10.2.4 → 10.2.5-1361bfa5

package/src/fixtures/create-helia.ts

@@ -1,15 +1,13 @@
-import { bitswap } from '@helia/block-brokers'
-import { ipnsValidator, ipnsSelector } from '@helia/ipns'
+import { withBitswap } from '@helia/bitswap'
+import { withLibp2p, libp2pDefaults } from '@helia/libp2p'
 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 { createHelia } from 'helia'
+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 +18,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 +34,16 @@ 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()
-    ],
-    libp2p: defaults,
+  return withBitswap(withLibp2p(createHelia({
     hashers: [
       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,7 +63,12 @@ describe('@helia/ipns - http', () => {
     })
 
     const key = peerIdFromCID(CID.parse(res.name))
-    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,7 +170,7 @@ keyTypes.filter(keyType => keyType !== 'RSA').forEach(keyType => {
       // we should get an update eventually
       await waitFor(async () => {
         try {
-          resolveResult = await name.resolve(peerId.toMultihash())
+          resolveResult = await last(name.resolve(peerId.toMultihash()))
 
           return true
         } catch {
@@ -188,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,17 +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')
 
-        const routingKey = multihashToIPNSRoutingKey(key.publicKey?.toMultihash())
+        const routingKey = multihashToIPNSRoutingKey(key.publicKey.toMultihash())
 
         const [closest] = await sortClosestPeers(routingKey, [
           helia.libp2p.peerId,
@@ -119,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()))
@@ -155,7 +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()
-      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()
@@ -166,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, {
@@ -173,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/providers.spec.ts

@@ -13,7 +13,6 @@ import { multiaddr } from 'kubo-rpc-client'
 import { CID } from 'multiformats/cid'
 import { createHeliaNode } from './fixtures/create-helia.ts'
 import { createKuboNode } from './fixtures/create-kubo.ts'
-import type { PeerId } from '@libp2p/interface'
 import type { Helia } from 'helia'
 import type { FileCandidate } from 'ipfs-unixfs-importer'
 import type { KuboInfo, KuboNode } from 'ipfsd-ctl'
@@ -68,7 +67,7 @@ describe('providers', () => {
   })
 
   it('should fetch raw using a provider', async () => {
-    let sender: PeerId | undefined
+    let sender: CID | undefined
 
     const buf = await toBuffer(helia.blockstore.get(cid, {
       providers: [
@@ -82,11 +81,11 @@ describe('providers', () => {
     }))
 
     expect(buf).to.have.lengthOf(1930)
-    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? '').toCID())
   })
 
   it('should fetch dag-cbor using a provider', async () => {
-    let sender: PeerId | undefined
+    let sender: CID | undefined
     const obj = { hello: 'world' }
     const cid = await kubo.api.dag.put(obj, {
       storeCodec: 'dag-cbor'
@@ -104,11 +103,11 @@ describe('providers', () => {
         }
       }
     })).to.eventually.deep.equal(obj)
-    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? '').toCID())
   })
 
   it('should fetch dag-json using a provider', async () => {
-    let sender: PeerId | undefined
+    let sender: CID | undefined
     const obj = { hello: 'world' }
     const cid = await kubo.api.dag.put(obj, {
       storeCodec: 'dag-json'
@@ -126,11 +125,11 @@ describe('providers', () => {
         }
       }
     })).to.eventually.deep.equal(obj)
-    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? '').toCID())
   })
 
   it('should fetch string using a provider', async () => {
-    let sender: PeerId | undefined
+    let sender: CID | undefined
     const obj = 'hello world'
     const cid = await kubo.api.dag.put(obj, {
       storeCodec: 'dag-json'
@@ -148,11 +147,11 @@ describe('providers', () => {
         }
       }
     })).to.eventually.equal(JSON.stringify(obj))
-    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? '').toCID())
   })
 
   it('should fetch via unixfs using a provider', async () => {
-    let sender: PeerId | undefined
+    let sender: CID | undefined
     const fs = unixfs(helia)
 
     const bytes = await toBuffer(fs.cat(cid, {
@@ -167,11 +166,11 @@ describe('providers', () => {
     }))
 
     expect(bytes).to.equalBytes(toBuffer(input))
-    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? '').toCID())
   })
 
   it('should fetch via mfs using a provider', async () => {
-    let sender: PeerId | undefined
+    let sender: CID | undefined
     const fs = mfs(helia)
 
     await fs.cp(cid, '/file.txt', {
@@ -188,11 +187,11 @@ describe('providers', () => {
     const bytes = await toBuffer(fs.cat('/file.txt'))
 
     expect(bytes).to.equalBytes(toBuffer(input))
-    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? '').toCID())
   })
 
   it('should fetch via car using a provider', async () => {
-    let sender: PeerId | undefined
+    let sender: CID | undefined
     const c = car(helia)
 
     expect(await toBuffer(
@@ -210,6 +209,6 @@ describe('providers', () => {
     ).to.equalBytes(await toBuffer(
       kubo.api.dag.export(cid)
     ))
-    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? '').toCID())
   })
 })

package/src/strings.spec.ts

@@ -5,13 +5,13 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { createHeliaNode } from './fixtures/create-helia.ts'
 import { createKuboNode } from './fixtures/create-kubo.ts'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { Strings, AddOptions } from '@helia/strings'
-import type { Helia } from 'helia'
 import type { KuboNode } from 'ipfsd-ctl'
 import type { BlockPutOptions as KuboAddOptions } from 'kubo-rpc-client'
 
 describe('@helia/strings', () => {
-  let helia: Helia
+  let helia: HeliaWithLibp2p
   let str: Strings
   let kubo: KuboNode
 

package/src/unixfs-bitswap.spec.ts

@@ -4,13 +4,13 @@ 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 { HeliaWithLibp2p } from '@helia/libp2p'
 import type { UnixFS } from '@helia/unixfs'
-import type { Helia } from 'helia'
 import type { ByteStream, FileCandidate } from 'ipfs-unixfs-importer'
 import type { KuboNode } from 'ipfsd-ctl'
 
 describe('@helia/unixfs - bitswap', () => {
-  let helia: Helia
+  let helia: HeliaWithLibp2p
   let unixFs: UnixFS
   let kubo: KuboNode
 

package/src/unixfs-files.spec.ts

@@ -11,14 +11,14 @@ import { CID } from 'multiformats/cid'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { createHeliaNode } from './fixtures/create-helia.ts'
 import { createKuboNode } from './fixtures/create-kubo.ts'
+import type { HeliaWithLibp2p } from '@helia/libp2p'
 import type { AddOptions, UnixFS } from '@helia/unixfs'
-import type { Helia } from 'helia'
 import type { ByteStream, ImportCandidateStream } from 'ipfs-unixfs-importer'
 import type { KuboNode } from 'ipfsd-ctl'
 import type { AddOptions as KuboAddOptions } from 'kubo-rpc-client'
 
 describe('@helia/unixfs - files', () => {
-  let helia: Helia
+  let helia: HeliaWithLibp2p
   let unixFs: UnixFS
   let kubo: KuboNode
 

package/.aegir.js

@@ -1,49 +0,0 @@
-import getPort from 'aegir/get-port'
-import { createServer } from 'ipfsd-ctl'
-import { create } from 'kubo-rpc-client'
-import { path } from 'kubo'
-
-/** @type {import('aegir').PartialOptions} */
-export default {
-  test: {
-    files: './dist/src/*.spec.js',
-    before: async (options) => {
-      if (options.runner !== 'node') {
-        const ipfsdPort = await getPort()
-        const ipfsdServer = await createServer({
-          host: '127.0.0.1',
-          port: ipfsdPort
-        }, {
-          type: 'kubo',
-          bin: path(),
-          rpc: create,
-          test: true,
-          init: {
-            config: {
-              Addresses: {
-                Swarm: [
-                  "/ip4/0.0.0.0/tcp/0",
-                  "/ip4/0.0.0.0/tcp/0/ws"
-                ]
-              }
-            }
-          }
-        }).start()
-
-        return {
-          env: {
-            IPFSD_SERVER: `http://127.0.0.1:${ipfsdPort}`
-          },
-          ipfsdServer
-        }
-      }
-
-      return {}
-    },
-    after: async (options, beforeResult) => {
-      if (options.runner !== 'node') {
-        await beforeResult.ipfsdServer.stop()
-      }
-    }
-  }
-}