@helia/http 0.9.0 → 1.0.0

package/dist/src/index.d.ts

@@ -3,6 +3,8 @@
  *
  * Exports a `createHeliaHTTP` function that returns an object that implements a lightweight version of the {@link Helia} API that functions only over HTTP.
  *
+ * By default, content and peer routing are requests are resolved using the [Delegated HTTP Routing API](https://specs.ipfs.tech/routing/http-routing-v1/) and blocks are fetched from [Trustless Gateways](https://specs.ipfs.tech/http-gateways/trustless-gateway/).
+ *
  * Pass it to other modules like {@link https://www.npmjs.com/package/@helia/unixfs | @helia/unixfs} to fetch files from the distributed web.
  *
  * @example
@@ -17,84 +19,41 @@
  * const fs = unixfs(helia)
  * fs.cat(CID.parse('bafyFoo'))
  * ```
+ * @example with custom gateways and delegated routing endpoints
+ * ```typescript
+ * import { createHeliaHTTP } from '@helia/http'
+ * import { trustlessGateway } from '@helia/block-brokers'
+ * import { delegatedHTTPRouting } from '@helia/routers'
+ * import { unixfs } from '@helia/unixfs'
+ * import { CID } from 'multiformats/cid'
+ *
+ * const helia = await createHeliaHTTP({
+ *   blockBrokers: [
+ *     trustlessGateway({
+ *       gateways: ['https://cloudflare-ipfs.com', 'https://ipfs.io'],
+ *     }),
+ *   ],
+ *   routers: [
+ *     delegatedHTTPRouting('https://delegated-ipfs.dev')
+ *   ]
+ * })
+ *
+ * const fs = unixfs(helia)
+ * fs.cat(CID.parse('bafyFoo'))
+ * ```
  */
-import type { DAGWalker, Helia } from '@helia/interface';
-import type { BlockBroker } from '@helia/interface/blocks';
-import type { ComponentLogger, Libp2p } from '@libp2p/interface';
-import type { Blockstore } from 'interface-blockstore';
-import type { Datastore } from 'interface-datastore';
-import type { Libp2pOptions } from 'libp2p';
-import type { MultihashHasher } from 'multiformats/hashes/interface';
+import { type HeliaInit } from '@helia/utils';
+import type { Helia } from '@helia/interface';
 export * from '@helia/interface';
-export * from '@helia/interface/blocks';
-export * from '@helia/interface/pins';
-/**
- * Options used to create a Helia node.
- */
-export interface HeliaHTTPInit<T extends Libp2p = Libp2p> {
+export interface HeliaHTTPInit extends HeliaInit {
     /**
-     * A libp2p node is required to perform network operations. Either a
-     * preconfigured node or options to configure a node can be passed
-     * here.
-     *
-     * If node options are passed, they will be merged with the default
-     * config for the current platform. In this case all passed config
-     * keys will replace those from the default config.
-     */
-    libp2p?: T | Libp2pOptions;
-    /**
-     * The blockstore is where blocks are stored
-     */
-    blockstore?: Blockstore;
-    /**
-     * The datastore is where data is stored
-     */
-    datastore?: Datastore;
-    /**
-     * By default sha256, sha512 and identity hashes are supported for
-     * bitswap operations. To bitswap blocks with CIDs using other hashes
-     * pass appropriate MultihashHashers here.
-     */
-    hashers?: MultihashHasher[];
-    /**
-     * In order to pin CIDs that correspond to a DAG, it's necessary to know
-     * how to traverse that DAG.  DAGWalkers take a block and yield any CIDs
-     * encoded within that block.
-     */
-    dagWalkers?: DAGWalker[];
-    /**
-     * A list of strategies used to fetch blocks when they are not present in
-     * the local blockstore
-     */
-    blockBrokers?: Array<(components: any) => BlockBroker>;
-    /**
-     * Pass `false` to not start the Helia node
+     * Whether to start the Helia node
      */
     start?: boolean;
-    /**
-     * Garbage collection requires preventing blockstore writes during searches
-     * for unpinned blocks as DAGs are typically pinned after they've been
-     * imported - without locking this could lead to the deletion of blocks while
-     * they are being added to the blockstore.
-     *
-     * By default this lock is held on the main process (e.g. node cluster's
-     * primary process, the renderer thread in browsers) and other processes will
-     * contact the main process for access (worker processes in node cluster,
-     * webworkers in the browser).
-     *
-     * If Helia is being run wholly in a non-primary process, with no other process
-     * expected to access the blockstore (e.g. being run in the background in a
-     * webworker), pass true here to hold the gc lock in this process.
-     */
-    holdGcLock?: boolean;
-    /**
-     * An optional logging component to pass to libp2p. If not specified the
-     * default implementation from libp2p will be used.
-     */
-    logger?: ComponentLogger;
 }
+/**
 /**
  * Create and return a Helia node
  */
-export declare function createHeliaHTTP(init?: HeliaHTTPInit): Promise<Helia>;
+export declare function createHeliaHTTP(init?: Partial<HeliaHTTPInit>): Promise<Helia>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAQH,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAIpE,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,uBAAuB,CAAA;AAErC;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACtD;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,aAAa,CAAA;IAE1B;;OAEG;IACH,UAAU,CAAC,EAAE,UAAU,CAAA;IAEvB;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IAErB;;;;OAIG;IACH,OAAO,CAAC,EAAE,eAAe,EAAE,CAAA;IAE3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,EAAE,CAAA;IAExB;;;OAGG;IACH,YAAY,CAAC,EAAE,KAAK,CAAC,CAAC,UAAU,EAAE,GAAG,KAAK,WAAW,CAAC,CAAA;IAEtD;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IAEf;;;;;;;;;;;;;;OAcG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IAEpB;;;OAGG;IACH,MAAM,CAAC,EAAE,eAAe,CAAA;CACzB;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAE,IAAI,GAAE,aAAkB,GAAG,OAAO,CAAC,KAAK,CAAC,CA+B/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAIH,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAGlE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAI7C,cAAc,kBAAkB,CAAA;AAEhC,MAAM,WAAW,aAAc,SAAQ,SAAS;IAC9C;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAE,IAAI,GAAE,OAAO,CAAC,aAAa,CAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAqBxF"}

package/dist/src/index.js

@@ -3,6 +3,8 @@
  *
  * Exports a `createHeliaHTTP` function that returns an object that implements a lightweight version of the {@link Helia} API that functions only over HTTP.
  *
+ * By default, content and peer routing are requests are resolved using the [Delegated HTTP Routing API](https://specs.ipfs.tech/routing/http-routing-v1/) and blocks are fetched from [Trustless Gateways](https://specs.ipfs.tech/http-gateways/trustless-gateway/).
+ *
  * Pass it to other modules like {@link https://www.npmjs.com/package/@helia/unixfs | @helia/unixfs} to fetch files from the distributed web.
  *
  * @example
@@ -17,41 +19,53 @@
  * const fs = unixfs(helia)
  * fs.cat(CID.parse('bafyFoo'))
  * ```
+ * @example with custom gateways and delegated routing endpoints
+ * ```typescript
+ * import { createHeliaHTTP } from '@helia/http'
+ * import { trustlessGateway } from '@helia/block-brokers'
+ * import { delegatedHTTPRouting } from '@helia/routers'
+ * import { unixfs } from '@helia/unixfs'
+ * import { CID } from 'multiformats/cid'
+ *
+ * const helia = await createHeliaHTTP({
+ *   blockBrokers: [
+ *     trustlessGateway({
+ *       gateways: ['https://cloudflare-ipfs.com', 'https://ipfs.io'],
+ *     }),
+ *   ],
+ *   routers: [
+ *     delegatedHTTPRouting('https://delegated-ipfs.dev')
+ *   ]
+ * })
+ *
+ * const fs = unixfs(helia)
+ * fs.cat(CID.parse('bafyFoo'))
+ * ```
  */
 import { trustlessGateway } from '@helia/block-brokers';
-import { Helia as HeliaClass } from '@helia/core';
+import { delegatedHTTPRouting } from '@helia/routers';
+import { Helia as HeliaClass } from '@helia/utils';
 import { MemoryBlockstore } from 'blockstore-core';
 import { MemoryDatastore } from 'datastore-core';
-import { createLibp2p } from './utils/libp2p.js';
 // re-export interface types so people don't have to depend on @helia/interface
 // if they don't want to
 export * from '@helia/interface';
-export * from '@helia/interface/blocks';
-export * from '@helia/interface/pins';
+/**
 /**
  * Create and return a Helia node
  */
 export async function createHeliaHTTP(init = {}) {
     const datastore = init.datastore ?? new MemoryDatastore();
     const blockstore = init.blockstore ?? new MemoryBlockstore();
-    let libp2p;
-    if (isLibp2p(init.libp2p)) {
-        libp2p = init.libp2p;
-    }
-    else {
-        libp2p = await createLibp2p({
-            ...init,
-            libp2p: init.libp2p,
-            datastore
-        });
-    }
     const helia = new HeliaClass({
         ...init,
-        libp2p,
         datastore,
         blockstore,
         blockBrokers: init.blockBrokers ?? [
             trustlessGateway()
+        ],
+        routers: init.routers ?? [
+            delegatedHTTPRouting('https://delegated-ipfs.dev')
         ]
     });
     if (init.start !== false) {
@@ -59,13 +73,4 @@ export async function createHeliaHTTP(init = {}) {
     }
     return helia;
 }
-function isLibp2p(obj) {
-    if (obj == null) {
-        return false;
-    }
-    // a non-exhaustive list of methods found on the libp2p object
-    const funcs = ['dial', 'dialProtocol', 'hangUp', 'handle', 'unhandle', 'getMultiaddrs', 'getProtocols'];
-    // if these are all functions it's probably a libp2p object
-    return funcs.every(m => typeof obj[m] === 'function');
-}
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,KAAK,IAAI,UAAU,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAUhD,+EAA+E;AAC/E,wBAAwB;AACxB,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,uBAAuB,CAAA;AA4ErC;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAE,OAAsB,EAAE;IAC7D,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,eAAe,EAAE,CAAA;IACzD,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,gBAAgB,EAAE,CAAA;IAE5D,IAAI,MAAqC,CAAA;IAEzC,IAAI,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1B,MAAM,GAAG,IAAI,CAAC,MAAa,CAAA;IAC7B,CAAC;SAAM,CAAC;QACN,MAAM,GAAG,MAAM,YAAY,CAAwB;YACjD,GAAG,IAAI;YACP,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,SAAS;SACV,CAAC,CAAA;IACJ,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC;QAC3B,GAAG,IAAI;QACP,MAAM;QACN,SAAS;QACT,UAAU;QACV,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI;YACjC,gBAAgB,EAAE;SACnB;KACF,CAAC,CAAA;IAEF,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED,SAAS,QAAQ,CAAE,GAAQ;IACzB,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAChB,OAAO,KAAK,CAAA;IACd,CAAC;IAED,8DAA8D;IAC9D,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe,EAAE,cAAc,CAAC,CAAA;IAEvG,2DAA2D;IAC3D,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAA;AACvD,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,KAAK,IAAI,UAAU,EAAkB,MAAM,cAAc,CAAA;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAGhD,+EAA+E;AAC/E,wBAAwB;AACxB,cAAc,kBAAkB,CAAA;AAShC;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAE,OAA+B,EAAE;IACtE,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,eAAe,EAAE,CAAA;IACzD,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,gBAAgB,EAAE,CAAA;IAE5D,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC;QAC3B,GAAG,IAAI;QACP,SAAS;QACT,UAAU;QACV,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI;YACjC,gBAAgB,EAAE;SACnB;QACD,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI;YACvB,oBAAoB,CAAC,4BAA4B,CAAC;SACnD;KACF,CAAC,CAAA;IAEF,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helia/http",
-  "version": "0.9.0",
+  "version": "1.0.0",
   "description": "A lightweight implementation of IPFS over HTTP in JavaScript",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia/tree/main/packages/http#readme",
@@ -11,6 +11,10 @@
   "bugs": {
     "url": "https://github.com/ipfs/helia/issues"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "keywords": [
     "IPFS"
   ],
@@ -49,19 +53,19 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@helia/block-brokers": "~0.0.0",
-    "@helia/core": "~0.0.0",
-    "@helia/delegated-routing-v1-http-api-client": "^1.1.2",
-    "@helia/interface": "^3.0.0",
-    "@libp2p/interface": "^1.1.1",
+    "@helia/block-brokers": "^2.0.0",
+    "@helia/interface": "^4.0.0",
+    "@helia/routers": "^1.0.0",
+    "@helia/utils": "^0.0.1",
     "blockstore-core": "^4.3.8",
-    "datastore-core": "^9.2.6",
-    "interface-blockstore": "^5.2.7",
-    "interface-datastore": "^8.2.9",
-    "libp2p": "^1.1.1",
-    "multiformats": "^13.0.0"
+    "datastore-core": "^9.2.6"
   },
   "devDependencies": {
-    "aegir": "^42.1.0"
+    "@libp2p/interface": "^1.1.1",
+    "aegir": "^42.1.0",
+    "interface-datastore": "^8.2.10",
+    "multiformats": "^13.0.1",
+    "sinon": "^17.0.1",
+    "sinon-ts": "^2.0.0"
   }
 }

package/src/index.ts

@@ -3,6 +3,8 @@
  *
  * Exports a `createHeliaHTTP` function that returns an object that implements a lightweight version of the {@link Helia} API that functions only over HTTP.
  *
+ * By default, content and peer routing are requests are resolved using the [Delegated HTTP Routing API](https://specs.ipfs.tech/routing/http-routing-v1/) and blocks are fetched from [Trustless Gateways](https://specs.ipfs.tech/http-gateways/trustless-gateway/).
+ *
  * Pass it to other modules like {@link https://www.npmjs.com/package/@helia/unixfs | @helia/unixfs} to fetch files from the distributed web.
  *
  * @example
@@ -17,128 +19,65 @@
  * const fs = unixfs(helia)
  * fs.cat(CID.parse('bafyFoo'))
  * ```
+ * @example with custom gateways and delegated routing endpoints
+ * ```typescript
+ * import { createHeliaHTTP } from '@helia/http'
+ * import { trustlessGateway } from '@helia/block-brokers'
+ * import { delegatedHTTPRouting } from '@helia/routers'
+ * import { unixfs } from '@helia/unixfs'
+ * import { CID } from 'multiformats/cid'
+ *
+ * const helia = await createHeliaHTTP({
+ *   blockBrokers: [
+ *     trustlessGateway({
+ *       gateways: ['https://cloudflare-ipfs.com', 'https://ipfs.io'],
+ *     }),
+ *   ],
+ *   routers: [
+ *     delegatedHTTPRouting('https://delegated-ipfs.dev')
+ *   ]
+ * })
+ *
+ * const fs = unixfs(helia)
+ * fs.cat(CID.parse('bafyFoo'))
+ * ```
  */
 
 import { trustlessGateway } from '@helia/block-brokers'
-import { Helia as HeliaClass } from '@helia/core'
+import { delegatedHTTPRouting } from '@helia/routers'
+import { Helia as HeliaClass, type HeliaInit } from '@helia/utils'
 import { MemoryBlockstore } from 'blockstore-core'
 import { MemoryDatastore } from 'datastore-core'
-import { createLibp2p } from './utils/libp2p.js'
-import type { DefaultLibp2pServices } from './utils/libp2p-defaults.js'
-import type { DAGWalker, Helia } from '@helia/interface'
-import type { BlockBroker } from '@helia/interface/blocks'
-import type { ComponentLogger, Libp2p } from '@libp2p/interface'
-import type { Blockstore } from 'interface-blockstore'
-import type { Datastore } from 'interface-datastore'
-import type { Libp2pOptions } from 'libp2p'
-import type { MultihashHasher } from 'multiformats/hashes/interface'
+import type { Helia } from '@helia/interface'
 
 // re-export interface types so people don't have to depend on @helia/interface
 // if they don't want to
 export * from '@helia/interface'
-export * from '@helia/interface/blocks'
-export * from '@helia/interface/pins'
 
-/**
- * Options used to create a Helia node.
- */
-export interface HeliaHTTPInit<T extends Libp2p = Libp2p> {
+export interface HeliaHTTPInit extends HeliaInit {
   /**
-   * A libp2p node is required to perform network operations. Either a
-   * preconfigured node or options to configure a node can be passed
-   * here.
-   *
-   * If node options are passed, they will be merged with the default
-   * config for the current platform. In this case all passed config
-   * keys will replace those from the default config.
-   */
-  libp2p?: T | Libp2pOptions
-
-  /**
-   * The blockstore is where blocks are stored
-   */
-  blockstore?: Blockstore
-
-  /**
-   * The datastore is where data is stored
-   */
-  datastore?: Datastore
-
-  /**
-   * By default sha256, sha512 and identity hashes are supported for
-   * bitswap operations. To bitswap blocks with CIDs using other hashes
-   * pass appropriate MultihashHashers here.
-   */
-  hashers?: MultihashHasher[]
-
-  /**
-   * In order to pin CIDs that correspond to a DAG, it's necessary to know
-   * how to traverse that DAG.  DAGWalkers take a block and yield any CIDs
-   * encoded within that block.
-   */
-  dagWalkers?: DAGWalker[]
-
-  /**
-   * A list of strategies used to fetch blocks when they are not present in
-   * the local blockstore
-   */
-  blockBrokers?: Array<(components: any) => BlockBroker>
-
-  /**
-   * Pass `false` to not start the Helia node
+   * Whether to start the Helia node
    */
   start?: boolean
-
-  /**
-   * Garbage collection requires preventing blockstore writes during searches
-   * for unpinned blocks as DAGs are typically pinned after they've been
-   * imported - without locking this could lead to the deletion of blocks while
-   * they are being added to the blockstore.
-   *
-   * By default this lock is held on the main process (e.g. node cluster's
-   * primary process, the renderer thread in browsers) and other processes will
-   * contact the main process for access (worker processes in node cluster,
-   * webworkers in the browser).
-   *
-   * If Helia is being run wholly in a non-primary process, with no other process
-   * expected to access the blockstore (e.g. being run in the background in a
-   * webworker), pass true here to hold the gc lock in this process.
-   */
-  holdGcLock?: boolean
-
-  /**
-   * An optional logging component to pass to libp2p. If not specified the
-   * default implementation from libp2p will be used.
-   */
-  logger?: ComponentLogger
 }
 
+/**
 /**
  * Create and return a Helia node
  */
-export async function createHeliaHTTP (init: HeliaHTTPInit = {}): Promise<Helia> {
+export async function createHeliaHTTP (init: Partial<HeliaHTTPInit> = {}): Promise<Helia> {
   const datastore = init.datastore ?? new MemoryDatastore()
   const blockstore = init.blockstore ?? new MemoryBlockstore()
 
-  let libp2p: Libp2p<DefaultLibp2pServices>
-
-  if (isLibp2p(init.libp2p)) {
-    libp2p = init.libp2p as any
-  } else {
-    libp2p = await createLibp2p<DefaultLibp2pServices>({
-      ...init,
-      libp2p: init.libp2p,
-      datastore
-    })
-  }
-
   const helia = new HeliaClass({
     ...init,
-    libp2p,
     datastore,
     blockstore,
     blockBrokers: init.blockBrokers ?? [
       trustlessGateway()
+    ],
+    routers: init.routers ?? [
+      delegatedHTTPRouting('https://delegated-ipfs.dev')
     ]
   })
 
@@ -148,15 +87,3 @@ export async function createHeliaHTTP (init: HeliaHTTPInit = {}): Promise<Helia>
 
   return helia
 }
-
-function isLibp2p (obj: any): obj is Libp2p {
-  if (obj == null) {
-    return false
-  }
-
-  // a non-exhaustive list of methods found on the libp2p object
-  const funcs = ['dial', 'dialProtocol', 'hangUp', 'handle', 'unhandle', 'getMultiaddrs', 'getProtocols']
-
-  // if these are all functions it's probably a libp2p object
-  return funcs.every(m => typeof obj[m] === 'function')
-}

package/dist/src/utils/libp2p-defaults.d.ts

@@ -1,7 +0,0 @@
-import type { Libp2pDefaultsOptions } from './libp2p.js';
-import type { Libp2pOptions } from 'libp2p';
-export interface DefaultLibp2pServices extends Record<string, unknown> {
-    delegatedRouting: unknown;
-}
-export declare function libp2pDefaults(options?: Libp2pDefaultsOptions): Libp2pOptions<DefaultLibp2pServices>;
-//# sourceMappingURL=libp2p-defaults.d.ts.map

package/dist/src/utils/libp2p-defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"libp2p-defaults.d.ts","sourceRoot":"","sources":["../../../src/utils/libp2p-defaults.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAE3C,MAAM,WAAW,qBAAsB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACpE,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED,wBAAgB,cAAc,CAAE,OAAO,GAAE,qBAA0B,GAAG,aAAa,CAAC,qBAAqB,CAAC,CAUzG"}

package/dist/src/utils/libp2p-defaults.js

@@ -1,13 +0,0 @@
-import { createDelegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client';
-export function libp2pDefaults(options = {}) {
-    return {
-        services: {
-            delegatedRouting: () => createDelegatedRoutingV1HttpApiClient('https://delegated-ipfs.dev')
-        },
-        connectionManager: {
-            minConnections: 0
-        },
-        ...options
-    };
-}
-//# sourceMappingURL=libp2p-defaults.js.map

package/dist/src/utils/libp2p-defaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"libp2p-defaults.js","sourceRoot":"","sources":["../../../src/utils/libp2p-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qCAAqC,EAAE,MAAM,6CAA6C,CAAA;AAQnG,MAAM,UAAU,cAAc,CAAE,UAAiC,EAAE;IACjE,OAAO;QACL,QAAQ,EAAE;YACR,gBAAgB,EAAE,GAAG,EAAE,CAAC,qCAAqC,CAAC,4BAA4B,CAAC;SAC5F;QACD,iBAAiB,EAAE;YACjB,cAAc,EAAE,CAAC;SAClB;QACD,GAAG,OAAO;KACX,CAAA;AACH,CAAC"}

package/dist/src/utils/libp2p.d.ts

@@ -1,15 +0,0 @@
-import type { DefaultLibp2pServices } from './libp2p-defaults.js';
-import type { ComponentLogger, Libp2p, PeerId } from '@libp2p/interface';
-import type { Datastore } from 'interface-datastore';
-import type { Libp2pOptions } from 'libp2p';
-export interface CreateLibp2pOptions<T extends Record<string, unknown>> {
-    datastore: Datastore;
-    libp2p?: Libp2pOptions<T>;
-    logger?: ComponentLogger;
-    start?: boolean;
-}
-export interface Libp2pDefaultsOptions {
-    peerId?: PeerId;
-}
-export declare function createLibp2p<T extends Record<string, unknown> = DefaultLibp2pServices>(options: CreateLibp2pOptions<T>): Promise<Libp2p<T>>;
-//# sourceMappingURL=libp2p.d.ts.map

package/dist/src/utils/libp2p.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"libp2p.d.ts","sourceRoot":"","sources":["../../../src/utils/libp2p.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAE3C,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACpE,SAAS,EAAE,SAAS,CAAA;IACpB,MAAM,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;IACzB,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,wBAAsB,YAAY,CAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,qBAAqB,EAAG,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAUnJ"}

package/dist/src/utils/libp2p.js

@@ -1,13 +0,0 @@
-import { createLibp2p as create } from 'libp2p';
-import { libp2pDefaults } from './libp2p-defaults.js';
-export async function createLibp2p(options) {
-    const defaults = libp2pDefaults();
-    options = options ?? {};
-    // @ts-expect-error derived ServiceMap is not compatible with ServiceFactoryMap
-    return create({
-        ...defaults,
-        ...options.libp2p,
-        start: false
-    });
-}
-//# sourceMappingURL=libp2p.js.map

package/dist/src/utils/libp2p.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"libp2p.js","sourceRoot":"","sources":["../../../src/utils/libp2p.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,IAAI,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAiBrD,MAAM,CAAC,KAAK,UAAU,YAAY,CAA8D,OAA+B;IAC7H,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAA;IACjC,OAAO,GAAG,OAAO,IAAI,EAAE,CAAA;IAEvB,+EAA+E;IAC/E,OAAO,MAAM,CAAC;QACZ,GAAG,QAAQ;QACX,GAAG,OAAO,CAAC,MAAM;QACjB,KAAK,EAAE,KAAK;KACb,CAAC,CAAA;AACJ,CAAC"}

package/src/utils/libp2p-defaults.ts

@@ -1,19 +0,0 @@
-import { createDelegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
-import type { Libp2pDefaultsOptions } from './libp2p.js'
-import type { Libp2pOptions } from 'libp2p'
-
-export interface DefaultLibp2pServices extends Record<string, unknown> {
-  delegatedRouting: unknown
-}
-
-export function libp2pDefaults (options: Libp2pDefaultsOptions = {}): Libp2pOptions<DefaultLibp2pServices> {
-  return {
-    services: {
-      delegatedRouting: () => createDelegatedRoutingV1HttpApiClient('https://delegated-ipfs.dev')
-    },
-    connectionManager: {
-      minConnections: 0
-    },
-    ...options
-  }
-}

package/src/utils/libp2p.ts

@@ -1,29 +0,0 @@
-import { createLibp2p as create } from 'libp2p'
-import { libp2pDefaults } from './libp2p-defaults.js'
-import type { DefaultLibp2pServices } from './libp2p-defaults.js'
-import type { ComponentLogger, Libp2p, PeerId } from '@libp2p/interface'
-import type { Datastore } from 'interface-datastore'
-import type { Libp2pOptions } from 'libp2p'
-
-export interface CreateLibp2pOptions<T extends Record<string, unknown>> {
-  datastore: Datastore
-  libp2p?: Libp2pOptions<T>
-  logger?: ComponentLogger
-  start?: boolean
-}
-
-export interface Libp2pDefaultsOptions {
-  peerId?: PeerId
-}
-
-export async function createLibp2p <T extends Record<string, unknown> = DefaultLibp2pServices> (options: CreateLibp2pOptions<T>): Promise<Libp2p<T>> {
-  const defaults = libp2pDefaults()
-  options = options ?? {}
-
-  // @ts-expect-error derived ServiceMap is not compatible with ServiceFactoryMap
-  return create({
-    ...defaults,
-    ...options.libp2p,
-    start: false
-  })
-}