@helia/interop 8.1.2 → 8.2.0-5a911c69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helia/interop",
-  "version": "8.1.2",
+  "version": "8.2.0-5a911c69",
   "description": "Interop tests for Helia",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia/tree/main/packages/interop#readme",
@@ -59,18 +59,18 @@
   },
   "dependencies": {
     "@chainsafe/libp2p-gossipsub": "^14.1.0",
-    "@helia/block-brokers": "^4.2.2",
-    "@helia/car": "^4.1.2",
-    "@helia/dag-cbor": "^4.0.6",
-    "@helia/dag-json": "^4.0.6",
-    "@helia/http": "^2.1.2",
-    "@helia/interface": "^5.3.2",
-    "@helia/ipns": "^8.2.3",
-    "@helia/json": "^4.0.6",
-    "@helia/mfs": "^5.0.3",
-    "@helia/routers": "^3.1.2",
-    "@helia/strings": "^4.0.6",
-    "@helia/unixfs": "^5.0.3",
+    "@helia/block-brokers": "4.2.3-5a911c69",
+    "@helia/car": "4.1.3-5a911c69",
+    "@helia/dag-cbor": "4.0.7-5a911c69",
+    "@helia/dag-json": "4.0.7-5a911c69",
+    "@helia/http": "2.2.0-5a911c69",
+    "@helia/interface": "5.4.0-5a911c69",
+    "@helia/ipns": "8.2.4-5a911c69",
+    "@helia/json": "4.0.7-5a911c69",
+    "@helia/mfs": "5.0.4-5a911c69",
+    "@helia/routers": "3.1.3-5a911c69",
+    "@helia/strings": "4.0.7-5a911c69",
+    "@helia/unixfs": "5.0.4-5a911c69",
     "@ipld/car": "^5.3.3",
     "@ipld/dag-cbor": "^9.2.2",
     "@ipld/dag-pb": "^4.1.3",
@@ -79,11 +79,12 @@
     "@libp2p/kad-dht": "^15.0.2",
     "@libp2p/keychain": "^5.0.10",
     "@libp2p/peer-id": "^5.0.8",
+    "@libp2p/utils": "^6.7.1",
     "@libp2p/websockets": "^9.0.13",
     "@multiformats/multiaddr": "^12.4.0",
     "@multiformats/sha3": "^3.0.2",
     "aegir": "^47.0.7",
-    "helia": "^5.4.2",
+    "helia": "5.5.0-5a911c69",
     "ipfs-unixfs-importer": "^15.3.1",
     "ipfsd-ctl": "^15.0.2",
     "ipns": "^10.0.0",
@@ -92,9 +93,9 @@
     "it-last": "^3.0.6",
     "it-map": "^3.1.1",
     "it-to-buffer": "^4.0.7",
-    "kubo": "^0.34.1",
+    "kubo": "^0.35.0",
     "kubo-rpc-client": "^5.0.2",
-    "libp2p": "^2.3.1",
+    "libp2p": "^2.9.0",
     "multiformats": "^13.3.1",
     "p-defer": "^4.0.1",
     "uint8arrays": "^5.1.0",

package/src/car.spec.ts

@@ -12,12 +12,12 @@ import { createKuboNode } from './fixtures/create-kubo.js'
 import { memoryCarWriter } from './fixtures/memory-car.js'
 import type { Car } from '@helia/car'
 import type { UnixFS } from '@helia/unixfs'
-import type { HeliaLibp2p } from 'helia'
+import type { Helia } from 'helia'
 import type { ByteStream, FileCandidate } from 'ipfs-unixfs-importer'
 import type { KuboNode } from 'ipfsd-ctl'
 
 describe('@helia/car', () => {
-  let helia: HeliaLibp2p
+  let helia: Helia
   let c: Car
   let u: UnixFS
   let kubo: KuboNode

package/src/dag-cbor.spec.ts

@@ -7,12 +7,12 @@ import { CID } from 'multiformats/cid'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
 import type { DAGCBOR, AddOptions } from '@helia/dag-cbor'
-import type { HeliaLibp2p } from 'helia'
+import type { Helia } from 'helia'
 import type { KuboNode } from 'ipfsd-ctl'
 import type { AddOptions as KuboAddOptions } from 'kubo-rpc-client'
 
 describe('@helia/dag-cbor', () => {
-  let helia: HeliaLibp2p
+  let helia: Helia
   let d: DAGCBOR
   let kubo: KuboNode
 

package/src/dag-json.spec.ts

@@ -7,12 +7,12 @@ import * as codec from 'multiformats/codecs/json'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
 import type { DAGJSON, AddOptions } from '@helia/dag-json'
-import type { HeliaLibp2p } from 'helia'
+import type { Helia } from 'helia'
 import type { KuboNode } from 'ipfsd-ctl'
 import type { BlockPutOptions as KuboAddOptions } from 'kubo-rpc-client'
 
 describe('@helia/dag-json', () => {
-  let helia: HeliaLibp2p
+  let helia: Helia
   let d: DAGJSON
   let kubo: KuboNode
 

package/src/fixtures/connect.ts

@@ -1,11 +1,11 @@
 import { expect } from 'aegir/chai'
-import type { HeliaLibp2p } from 'helia'
+import type { Helia } from 'helia'
 import type { KuboNode } from 'ipfsd-ctl'
 
 /**
  * Connect the two nodes by dialing a protocol stream
  */
-export async function connect (helia: HeliaLibp2p<any>, kubo: KuboNode, protocol: string): Promise<void> {
+export async function connect (helia: Helia<any>, kubo: KuboNode, protocol: string): Promise<void> {
   let connected = false
   const id = await kubo.api.id()
 

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

@@ -6,12 +6,12 @@ import { all } from '@libp2p/websockets/filters'
 import { sha3512 } from '@multiformats/sha3'
 import { createHelia, libp2pDefaults } from 'helia'
 import type { Libp2p } from '@libp2p/interface'
-import type { DefaultLibp2pServices, HeliaLibp2p } from 'helia'
+import type { DefaultLibp2pServices, Helia } from 'helia'
 import type { Libp2pOptions } from 'libp2p'
 
-export async function createHeliaNode (): Promise<HeliaLibp2p<Libp2p<DefaultLibp2pServices>>>
-export async function createHeliaNode <Services extends Record<string, unknown>> (libp2pOptions: Libp2pOptions<Services>): Promise<HeliaLibp2p<Libp2p<Services & DefaultLibp2pServices>>>
-export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<HeliaLibp2p<Libp2p<DefaultLibp2pServices>>> {
+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>>> {
   const defaults = libp2pDefaults()
 
   // allow dialing insecure WebSockets

package/src/fixtures/create-helia.ts

@@ -4,12 +4,12 @@ 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, HeliaLibp2p } from 'helia'
+import type { DefaultLibp2pServices, Helia } from 'helia'
 import type { Libp2pOptions } from 'libp2p'
 
-export async function createHeliaNode (): Promise<HeliaLibp2p<Libp2p<DefaultLibp2pServices>>>
-export async function createHeliaNode <Services extends Record<string, unknown>> (libp2pOptions: Libp2pOptions<Services>): Promise<HeliaLibp2p<Libp2p<Services & DefaultLibp2pServices>>>
-export async function createHeliaNode (libp2pOptions?: Libp2pOptions): Promise<HeliaLibp2p<Libp2p<DefaultLibp2pServices>>> {
+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>>> {
   const defaults = libp2pDefaults()
   defaults.addresses = {
     listen: [

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

@@ -5,11 +5,11 @@ import { expect } from 'aegir/chai'
 import { CID } from 'multiformats/cid'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
-import type { HeliaLibp2p } from 'helia'
+import type { Helia } from 'helia'
 import type { KuboInfo, KuboNode } from 'ipfsd-ctl'
 
 describe('helia - blockstore sessions', () => {
-  let helia: HeliaLibp2p
+  let helia: Helia
   let kubo: KuboNode
   let kuboInfo: KuboInfo
 

package/src/helia-blockstore.spec.ts

@@ -8,11 +8,11 @@ import * as raw from 'multiformats/codecs/raw'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
-import type { HeliaLibp2p } from 'helia'
+import type { Helia } from 'helia'
 import type { KuboInfo, KuboNode } from 'ipfsd-ctl'
 
 describe('helia - blockstore', () => {
-  let helia: HeliaLibp2p
+  let helia: Helia
   let kubo: KuboNode
   let kuboInfo: KuboInfo
 

package/src/helia-hashes.spec.ts

@@ -7,11 +7,11 @@ import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
-import type { HeliaLibp2p } from 'helia'
+import type { Helia } from 'helia'
 import type { KuboNode } from 'ipfsd-ctl'
 
 describe('helia - hashes', () => {
-  let helia: HeliaLibp2p
+  let helia: Helia
   let kubo: KuboNode
 
   beforeEach(async () => {

package/src/helia-pins.spec.ts

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

package/src/ipns-dnslink.spec.ts

@@ -4,7 +4,8 @@ import { ipns } from '@helia/ipns'
 import { expect } from 'aegir/chai'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import type { IPNS } from '@helia/ipns'
-import type { HeliaLibp2p } from 'helia'
+import type { DefaultLibp2pServices, Helia } from 'helia'
+import type { Libp2p } from 'libp2p'
 
 const TEST_DOMAINS: string[] = [
   'ipfs.tech',
@@ -13,7 +14,7 @@ const TEST_DOMAINS: string[] = [
 ]
 
 describe('@helia/ipns - dnslink', () => {
-  let helia: HeliaLibp2p
+  let helia: Helia<Libp2p<DefaultLibp2pServices>>
   let name: IPNS
 
   beforeEach(async () => {

package/src/ipns-http.spec.ts

@@ -1,19 +1,20 @@
 /* eslint-env mocha */
 
+import { createHeliaHTTP } from '@helia/http'
 import { ipns } from '@helia/ipns'
 import { delegatedHTTPRouting } from '@helia/routers'
 import { peerIdFromCID } from '@libp2p/peer-id'
 import { expect } from 'aegir/chai'
 import { CID } from 'multiformats/cid'
 import { isNode } from 'wherearewe'
-import { createHeliaHTTP } from './fixtures/create-helia-http.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
 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
+  let helia: Helia<Libp2p<any>>
   let kubo: KuboNode
   let name: IPNS
 

package/src/ipns-pubsub.spec.ts

@@ -25,7 +25,7 @@ import { waitFor } from './fixtures/wait-for.js'
 import type { IPNS, ResolveResult } from '@helia/ipns'
 import type { Libp2p, PubSub } from '@libp2p/interface'
 import type { Keychain } from '@libp2p/keychain'
-import type { HeliaLibp2p } from 'helia'
+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 +33,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: HeliaLibp2p<Libp2p<{ pubsub: PubSub, keychain: Keychain }>>
+    let helia: Helia<Libp2p<{ pubsub: PubSub, keychain: Keychain }>>
     let kubo: KuboNode
     let name: IPNS
 

package/src/ipns.spec.ts

@@ -17,13 +17,13 @@ import { sortClosestPeers } from './fixtures/create-peer-ids.js'
 import { keyTypes } from './fixtures/key-types.js'
 import { waitFor } from './fixtures/wait-for.js'
 import type { IPNS } from '@helia/ipns'
-import type { PrivateKey } from '@libp2p/interface'
-import type { HeliaLibp2p } from 'helia'
+import type { Libp2p, PrivateKey } from '@libp2p/interface'
+import type { DefaultLibp2pServices, Helia } from 'helia'
 import type { KuboNode } from 'ipfsd-ctl'
 
 keyTypes.forEach(type => {
   describe(`@helia/ipns - default routing with ${type} keys`, () => {
-    let helia: HeliaLibp2p
+    let helia: Helia<Libp2p<DefaultLibp2pServices>>
     let kubo: KuboNode
     let name: IPNS
 

package/src/json.spec.ts

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

package/src/mfs.spec.ts

@@ -5,11 +5,11 @@ import { expect } from 'aegir/chai'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
 import type { MFS } from '@helia/mfs'
-import type { HeliaLibp2p } from 'helia'
+import type { Helia } from 'helia'
 import type { KuboNode } from 'ipfsd-ctl'
 
 describe('@helia/mfs', () => {
-  let helia: HeliaLibp2p
+  let helia: Helia
   let fs: MFS
   let kubo: KuboNode
 

package/src/providers.spec.ts

@@ -0,0 +1,230 @@
+/* eslint-env mocha */
+
+import { car } from '@helia/car'
+import { dagCbor } from '@helia/dag-cbor'
+import { dagJson } from '@helia/dag-json'
+import { mfs } from '@helia/mfs'
+import { strings } from '@helia/strings'
+import { unixfs } from '@helia/unixfs'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { createScalableCuckooFilter } from '@libp2p/utils/filters'
+import { expect } from 'aegir/chai'
+import toBuffer from 'it-to-buffer'
+import { multiaddr } from 'kubo-rpc-client'
+import { CID } from 'multiformats/cid'
+import { createHeliaNode } from './fixtures/create-helia.js'
+import { createKuboNode } from './fixtures/create-kubo.js'
+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'
+
+describe('providers', () => {
+  let helia: Helia
+  let kubo: KuboNode
+  let cid: CID
+  let kuboInfo: KuboInfo
+  let input: Uint8Array[]
+
+  beforeEach(async () => {
+    // helia and kubo are not connected together before the test
+    helia = await createHeliaNode()
+    kubo = await createKuboNode()
+
+    const chunkSize = 1024 * 1024
+    const size = chunkSize * 10
+    input = []
+
+    const candidate: FileCandidate = {
+      content: (async function * () {
+        for (let i = 0; i < size; i += chunkSize) {
+          const buf = new Uint8Array(chunkSize)
+          input.push(buf)
+
+          yield buf
+        }
+      }())
+    }
+
+    const importResult = await kubo.api.add(candidate.content)
+    cid = CID.parse(importResult.cid.toString())
+    kuboInfo = await kubo.info()
+  })
+
+  afterEach(async () => {
+    if (helia != null) {
+      await helia.stop()
+    }
+
+    if (kubo != null) {
+      await kubo.stop()
+    }
+  })
+
+  it('should fail to fetch without using a provider', async () => {
+    await expect(helia.blockstore.get(cid, {
+      signal: AbortSignal.timeout(100)
+    })).to.eventually.be.rejected()
+      .with.nested.property('errors[0].name', 'AbortError')
+  })
+
+  it('should fetch raw using a provider', async () => {
+    let sender: PeerId | undefined
+
+    const buf = await helia.blockstore.get(cid, {
+      providers: [
+        kuboInfo.multiaddrs.map(ma => multiaddr(ma))
+      ],
+      onProgress (evt) {
+        // @ts-expect-error cannot derive config-based progress event types
+        if (evt.type === 'bitswap:want-block:received') {
+          // @ts-expect-error cannot derive config-based progress event types
+          sender = evt.detail.sender
+        }
+      }
+    })
+
+    expect(buf).to.have.lengthOf(1930)
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+  })
+
+  it('should fetch dag-cbor using a provider', async () => {
+    let sender: PeerId | undefined
+    const obj = { hello: 'world' }
+    const cid = await kubo.api.dag.put(obj, {
+      storeCodec: 'dag-cbor'
+    })
+
+    const d = dagCbor(helia)
+
+    await expect(d.get(cid, {
+      providers: [
+        kuboInfo.multiaddrs.map(ma => multiaddr(ma))
+      ],
+      onProgress (evt) {
+        // @ts-expect-error cannot derive config-based progress event types
+        if (evt.type === 'bitswap:want-block:received') {
+          // @ts-expect-error cannot derive config-based progress event types
+          sender = evt.detail.sender
+        }
+      }
+    })).to.eventually.deep.equal(obj)
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+  })
+
+  it('should fetch dag-json using a provider', async () => {
+    let sender: PeerId | undefined
+    const obj = { hello: 'world' }
+    const cid = await kubo.api.dag.put(obj, {
+      storeCodec: 'dag-json'
+    })
+
+    const d = dagJson(helia)
+
+    await expect(d.get(cid, {
+      providers: [
+        kuboInfo.multiaddrs.map(ma => multiaddr(ma))
+      ],
+      onProgress (evt) {
+        // @ts-expect-error cannot derive config-based progress event types
+        if (evt.type === 'bitswap:want-block:received') {
+          // @ts-expect-error cannot derive config-based progress event types
+          sender = evt.detail.sender
+        }
+      }
+    })).to.eventually.deep.equal(obj)
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+  })
+
+  it('should fetch string using a provider', async () => {
+    let sender: PeerId | undefined
+    const obj = 'hello world'
+    const cid = await kubo.api.dag.put(obj, {
+      storeCodec: 'dag-json'
+    })
+
+    const s = strings(helia)
+
+    await expect(s.get(cid, {
+      providers: [
+        kuboInfo.multiaddrs.map(ma => multiaddr(ma))
+      ],
+      onProgress (evt) {
+        // @ts-expect-error cannot derive config-based progress event types
+        if (evt.type === 'bitswap:want-block:received') {
+          // @ts-expect-error cannot derive config-based progress event types
+          sender = evt.detail.sender
+        }
+      }
+    })).to.eventually.equal(JSON.stringify(obj))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+  })
+
+  it('should fetch via unixfs using a provider', async () => {
+    let sender: PeerId | undefined
+    const fs = unixfs(helia)
+
+    const bytes = await toBuffer(fs.cat(cid, {
+      providers: [
+        kuboInfo.multiaddrs.map(ma => multiaddr(ma))
+      ],
+      onProgress (evt) {
+        // @ts-expect-error cannot derive config-based progress event types
+        if (evt.type === 'bitswap:want-block:received') {
+          // @ts-expect-error cannot derive config-based progress event types
+          sender = evt.detail.sender
+        }
+      }
+    }))
+
+    expect(bytes).to.equalBytes(toBuffer(input))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+  })
+
+  it('should fetch via mfs using a provider', async () => {
+    let sender: PeerId | undefined
+    const fs = mfs(helia)
+
+    await fs.cp(cid, '/file.txt', {
+      providers: [
+        kuboInfo.multiaddrs.map(ma => multiaddr(ma))
+      ],
+      onProgress (evt) {
+        // @ts-expect-error cannot derive config-based progress event types
+        if (evt.type === 'bitswap:want-block:received') {
+          // @ts-expect-error cannot derive config-based progress event types
+          sender = evt.detail.sender
+        }
+      }
+    })
+
+    const bytes = await toBuffer(fs.cat('/file.txt'))
+
+    expect(bytes).to.equalBytes(toBuffer(input))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+  })
+
+  it('should fetch via car using a provider', async () => {
+    let sender: PeerId | undefined
+    const c = car(helia)
+
+    expect(await toBuffer(
+      c.stream(cid, {
+        providers: [
+          kuboInfo.multiaddrs.map(ma => multiaddr(ma))
+        ],
+        blockFilter: createScalableCuckooFilter(10),
+        onProgress (evt) {
+          // @ts-expect-error cannot derive config-based progress event types
+          if (evt.type === 'bitswap:want-block:received') {
+            // @ts-expect-error cannot derive config-based progress event types
+            sender = evt.detail.sender
+          }
+        }
+      }))
+    ).to.equalBytes(await toBuffer(
+      kubo.api.dag.export(cid)
+    ))
+    expect(sender).to.deep.equal(peerIdFromString(kuboInfo.peerId?.toString() ?? ''))
+  })
+})

package/src/strings.spec.ts

@@ -8,12 +8,12 @@ import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
 import type { Strings, AddOptions } from '@helia/strings'
-import type { HeliaLibp2p } from 'helia'
+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: HeliaLibp2p
+  let helia: Helia
   let str: Strings
   let kubo: KuboNode
 

package/src/unixfs-bitswap.spec.ts

@@ -7,12 +7,12 @@ import { CID } from 'multiformats/cid'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
 import type { UnixFS } from '@helia/unixfs'
-import type { HeliaLibp2p } from 'helia'
+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: HeliaLibp2p
+  let helia: Helia
   let unixFs: UnixFS
   let kubo: KuboNode
 

package/src/unixfs-files.spec.ts

@@ -13,13 +13,13 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { createHeliaNode } from './fixtures/create-helia.js'
 import { createKuboNode } from './fixtures/create-kubo.js'
 import type { AddOptions, UnixFS } from '@helia/unixfs'
-import type { HeliaLibp2p } from 'helia'
+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: HeliaLibp2p
+  let helia: Helia
   let unixFs: UnixFS
   let kubo: KuboNode
 

package/dist/src/fixtures/create-helia-http.d.ts

@@ -1,4 +0,0 @@
-import type { HeliaHTTPInit } from '@helia/http';
-import type { Helia } from '@helia/interface';
-export declare function createHeliaHTTP(init?: Partial<HeliaHTTPInit>): Promise<Helia>;
-//# sourceMappingURL=create-helia-http.d.ts.map

package/dist/src/fixtures/create-helia-http.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-helia-http.d.ts","sourceRoot":"","sources":["../../../src/fixtures/create-helia-http.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAE7C,wBAAsB,eAAe,CAAE,IAAI,GAAE,OAAO,CAAC,aAAa,CAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAIxF"}

package/dist/src/fixtures/create-helia-http.js

@@ -1,7 +0,0 @@
-import { createHeliaHTTP as createHelia } from '@helia/http';
-export async function createHeliaHTTP(init = {}) {
-    return createHelia({
-        ...init
-    });
-}
-//# sourceMappingURL=create-helia-http.js.map

package/dist/src/fixtures/create-helia-http.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-helia-http.js","sourceRoot":"","sources":["../../../src/fixtures/create-helia-http.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,IAAI,WAAW,EAAE,MAAM,aAAa,CAAA;AAI5D,MAAM,CAAC,KAAK,UAAU,eAAe,CAAE,OAA+B,EAAE;IACtE,OAAO,WAAW,CAAC;QACjB,GAAG,IAAI;KACR,CAAC,CAAA;AACJ,CAAC"}

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

@@ -1,9 +0,0 @@
-import { createHeliaHTTP as createHelia } from '@helia/http'
-import type { HeliaHTTPInit } from '@helia/http'
-import type { Helia } from '@helia/interface'
-
-export async function createHeliaHTTP (init: Partial<HeliaHTTPInit> = {}): Promise<Helia> {
-  return createHelia({
-    ...init
-  })
-}