@helia/http 0.9.0

package/dist/src/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @packageDocumentation
+ *
+ * Exports a `createHeliaHTTP` function that returns an object that implements a lightweight version of the {@link Helia} API that functions only over HTTP.
+ *
+ * Pass it to other modules like {@link https://www.npmjs.com/package/@helia/unixfs | @helia/unixfs} to fetch files from the distributed web.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createHeliaHTTP } from '@helia/http'
+ * import { unixfs } from '@helia/unixfs'
+ * import { CID } from 'multiformats/cid'
+ *
+ * const helia = await createHeliaHTTP()
+ *
+ * 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';
+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> {
+    /**
+     * 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
+     */
+    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>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/src/index.js

@@ -0,0 +1,71 @@
+/**
+ * @packageDocumentation
+ *
+ * Exports a `createHeliaHTTP` function that returns an object that implements a lightweight version of the {@link Helia} API that functions only over HTTP.
+ *
+ * Pass it to other modules like {@link https://www.npmjs.com/package/@helia/unixfs | @helia/unixfs} to fetch files from the distributed web.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createHeliaHTTP } from '@helia/http'
+ * import { unixfs } from '@helia/unixfs'
+ * import { CID } from 'multiformats/cid'
+ *
+ * const helia = await createHeliaHTTP()
+ *
+ * const fs = unixfs(helia)
+ * fs.cat(CID.parse('bafyFoo'))
+ * ```
+ */
+import { trustlessGateway } from '@helia/block-brokers';
+import { Helia as HeliaClass } from '@helia/core';
+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()
+        ]
+    });
+    if (init.start !== false) {
+        await helia.start();
+    }
+    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

@@ -0,0 +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"}

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1 @@
+{"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/dist/typedoc-urls.json

@@ -0,0 +1,6 @@
+{
+  "HeliaHTTPInit": "https://ipfs.github.io/helia/interfaces/_helia_http.HeliaHTTPInit.html",
+  ".:HeliaHTTPInit": "https://ipfs.github.io/helia/interfaces/_helia_http.HeliaHTTPInit.html",
+  "createHeliaHTTP": "https://ipfs.github.io/helia/functions/_helia_http.createHeliaHTTP.html",
+  ".:createHeliaHTTP": "https://ipfs.github.io/helia/functions/_helia_http.createHeliaHTTP.html"
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@helia/http",
+  "version": "0.9.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",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ipfs/helia.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ipfs/helia/issues"
+  },
+  "keywords": [
+    "IPFS"
+  ],
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "project": true,
+      "sourceType": "module"
+    }
+  },
+  "scripts": {
+    "clean": "aegir clean",
+    "lint": "aegir lint",
+    "dep-check": "aegir dep-check",
+    "build": "aegir build",
+    "test": "aegir test",
+    "test:chrome": "aegir test -t browser --cov",
+    "test:chrome-webworker": "aegir test -t webworker",
+    "test:firefox": "aegir test -t browser -- --browser firefox",
+    "test:firefox-webworker": "aegir test -t webworker -- --browser firefox",
+    "test:node": "aegir test -t node --cov",
+    "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",
+    "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"
+  },
+  "devDependencies": {
+    "aegir": "^42.1.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,162 @@
+/**
+ * @packageDocumentation
+ *
+ * Exports a `createHeliaHTTP` function that returns an object that implements a lightweight version of the {@link Helia} API that functions only over HTTP.
+ *
+ * Pass it to other modules like {@link https://www.npmjs.com/package/@helia/unixfs | @helia/unixfs} to fetch files from the distributed web.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createHeliaHTTP } from '@helia/http'
+ * import { unixfs } from '@helia/unixfs'
+ * import { CID } from 'multiformats/cid'
+ *
+ * const helia = await createHeliaHTTP()
+ *
+ * const fs = unixfs(helia)
+ * fs.cat(CID.parse('bafyFoo'))
+ * ```
+ */
+
+import { trustlessGateway } from '@helia/block-brokers'
+import { Helia as HeliaClass } from '@helia/core'
+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'
+
+// 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> {
+  /**
+   * 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
+   */
+  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> {
+  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()
+    ]
+  })
+
+  if (init.start !== false) {
+    await helia.start()
+  }
+
+  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/src/utils/libp2p-defaults.ts

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,29 @@
+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
+  })
+}