diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 5162d586f..5c6dc2a9b 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -1,4 +1,4 @@
-name: ci
+name: CI
 on:
   push:
     branches:
@@ -12,8 +12,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-node@v3
+    - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
       with:
         node-version: lts/*
     - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -22,8 +22,8 @@ jobs:
     needs: build
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-node@v3
+    - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
       with:
         node-version: lts/*
     - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -40,8 +40,8 @@ jobs:
         node: [lts/*]
       fail-fast: true
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node }}
       - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -49,13 +49,14 @@ jobs:
       - uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3.1.4
         with:
           flags: node
+          files: .coverage/*,packages/*/.coverage/*
 
   test-chrome:
     needs: build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -63,13 +64,14 @@ jobs:
       - uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3.1.4
         with:
           flags: chrome
+          files: .coverage/*,packages/*/.coverage/*
 
   test-chrome-webworker:
     needs: build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -77,13 +79,14 @@ jobs:
       - uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3.1.4
         with:
           flags: chrome-webworker
+          files: .coverage/*,packages/*/.coverage/*
 
   test-firefox:
     needs: build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -91,13 +94,14 @@ jobs:
       - uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3.1.4
         with:
           flags: firefox
+          files: .coverage/*,packages/*/.coverage/*
 
   test-firefox-webworker:
     needs: build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -105,13 +109,14 @@ jobs:
       - uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3.1.4
         with:
           flags: firefox-webworker
+          files: .coverage/*,packages/*/.coverage/*
 
   test-webkit:
     needs: build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -119,13 +124,14 @@ jobs:
       - uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3.1.4
         with:
           flags: webkit
+          files: .coverage/*,packages/*/.coverage/*
 
   test-electron-main:
     needs: build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -133,13 +139,14 @@ jobs:
       - uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3.1.4
         with:
           flags: electron-main
+          files: .coverage/*,packages/*/.coverage/*
 
   test-electron-renderer:
     needs: build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - uses: ipfs/aegir/actions/cache-node-modules@master
@@ -147,6 +154,7 @@ jobs:
       - uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3.1.4
         with:
           flags: electron-renderer
+          files: .coverage/*,packages/*/.coverage/*
 
   release:
     runs-on: ubuntu-latest
@@ -160,11 +168,15 @@ jobs:
       test-electron-renderer
     ]
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    permissions:
+      contents: write
+      id-token: write
+      pull-requests: write
     steps:
-      - uses: GoogleCloudPlatform/release-please-action@v2
+      - uses: google-github-actions/release-please-action@v3
         id: release
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+          token: ${{ secrets.UCI_GITHUB_TOKEN || github.token }}
           command: manifest
           release-type: node
           manifest-file: .release-please-manifest.json
@@ -178,10 +190,10 @@ jobs:
               { "type": "deps", "section": "Dependencies", "hidden": false },
               { "type": "refactor", "section": "Refactors", "hidden": false }
             ]
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
           registry-url: 'https://registry.npmjs.org'
diff --git a/.github/workflows/semantic-pull-request.yml b/.github/workflows/semantic-pull-request.yml
new file mode 100644
index 000000000..bd00f090c
--- /dev/null
+++ b/.github/workflows/semantic-pull-request.yml
@@ -0,0 +1,12 @@
+name: Semantic PR
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+jobs:
+  main:
+    uses: pl-strflt/.github/.github/workflows/reusable-semantic-pull-request.yml@v0.3
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index e9167170d..0a23a8e19 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1 +1 @@
-{"packages/helia":"2.0.2","packages/interface":"2.0.0","packages/interop":"1.0.2"}
\ No newline at end of file
+{"packages/helia":"2.1.0","packages/interface":"2.1.0","packages/interop":"1.1.0"}
\ No newline at end of file
diff --git a/.release-please.json b/.release-please.json
index 8d7205414..35bf765b9 100644
--- a/.release-please.json
+++ b/.release-please.json
@@ -1,6 +1,5 @@
 {
   "plugins": ["node-workspace"],
-  "group-pull-request-title-pattern": "chore: release ${component}",
   "packages": {
     "packages/helia": {},
     "packages/interface": {},
diff --git a/README.md b/README.md
index 1a0ed7cb9..61e60f6d8 100644
--- a/README.md
+++ b/README.md
@@ -4,19 +4,21 @@
   </a>
 </p>
 
-# helia <!-- omit in toc -->
-
 [![ipfs.tech](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](https://ipfs.tech)
 [![Discuss](https://img.shields.io/discourse/https/discuss.ipfs.tech/posts.svg?style=flat-square)](https://discuss.ipfs.tech)
 [![codecov](https://img.shields.io/codecov/c/github/ipfs/helia.svg?style=flat-square)](https://codecov.io/gh/ipfs/helia)
 [![CI](https://img.shields.io/github/actions/workflow/status/ipfs/helia/main.yml?branch=main\&style=flat-square)](https://github.com/ipfs/helia/actions/workflows/main.yml?query=branch%3Amain)
 
-## 🌟 Usage
+[Helia](https://github.com/ipfs/helia) is a lean, modular, and modern TypeScript implementation of IPFS for the prolific JS and browser environments.
+
+See the [Manifesto](https://github.com/ipfs/helia/wiki/Manifesto), the [FAQ](https://github.com/ipfs/helia/wiki/FAQ), and the [State of IPFS in JS blog post from October 2022](https://blog.ipfs.tech/state-of-ipfs-in-js/) for more info.
+
+# 🌟 Usage
 
 A quick overview of how to get different types of data in and out of your Helia
 node.
 
-### 🪢 Strings
+## 🪢 Strings
 
 You can use the [@helia/strings](https://www.npmjs.com/package/@helia/strings)
 module to easily add and get strings from your Helia node:
@@ -34,7 +36,7 @@ console.log(await s.get(myImmutableAddress))
 // hello world
 ```
 
-### 🌃 JSON
+## 🌃 JSON
 
 The [@helia/json](https://www.npmjs.com/package/@helia/json) module lets you add
 or get plain JS objects:
@@ -52,7 +54,7 @@ console.log(await j.get(myImmutableAddress))
 // { hello: 'world' }
 ```
 
-### 🌠 DAG-JSON
+## 🌠 DAG-JSON
 
 The [@helia/dag-json](https://www.npmjs.com/package/@helia/dag-json) allows you
 to store references to linked objects as
@@ -79,7 +81,7 @@ console.log(await d.get(retrievedObject.link))
 // { hello: 'world' }
 ```
 
-### 🌌 DAG-CBOR
+## 🌌 DAG-CBOR
 
 [@helia/dag-cbor](https://www.npmjs.com/package/@helia/dag-cbor) works in a
 similar way to `@helia/dag-json` but stores objects using
@@ -106,52 +108,24 @@ console.log(await d.get(retrievedObject.link))
 // { hello: 'world' }
 ```
 
-### 🐾 Next steps
+# 🐾 Next steps
 
 Check out the [helia-examples](https://github.com/ipfs-examples/helia-examples)
 repo for how to do mostly anything with your Helia node.
 
-## Table of contents <!-- omit in toc -->
-
-- [🌟 Usage](#-usage)
-  - [🪢 Strings](#-strings)
-  - [🌃 JSON](#-json)
-  - [🌠 DAG-JSON](#-dag-json)
-  - [🌌 DAG-CBOR](#-dag-cbor)
-  - [🐾 Next steps](#-next-steps)
-- [🥅 Purpose and goals](#-purpose-and-goals)
-- [🏃‍♀️ Getting Started](#️-getting-started)
-- [📗 Project Docs](#-project-docs)
-- [📒 API Docs](#-api-docs)
-- [📐 System diagram](#-system-diagram)
-- [🏭 Code Structure](#-code-structure)
-- [📣 Project status](#-project-status)
-- [🛣️ Roadmap](#️-roadmap)
-- [👫 Get involved](#-get-involved)
-  - [🤲 Contribute](#-contribute)
-- [🛍️ Notable Consumers/Users](#️-notable-consumersusers)
-- [🌞 Branding](#-branding)
-- [🪪 License](#-license)
-
-## 🥅 Purpose and goals
-
-A lean, modular, and modern implementation of IPFS for the prolific JS and browser environments.
-
-See the [Manifesto](https://github.com/ipfs/helia/wiki/Manifesto), the [FAQ](https://github.com/ipfs/helia/wiki/FAQ), and the [State of IPFS in JS blog post from October 2022](https://blog.ipfs.tech/state-of-ipfs-in-js/) for more info.
-
-## 🏃‍♀️ Getting Started
+# 🏃‍♀️ Getting Started
 
 Check out the [Helia examples repo](https://github.com/ipfs-examples/helia-examples#examples), which covers a wide variety of use cases. If you feel something has been missed, follow the [contribution guide](https://github.com/ipfs-examples/helia-examples#contributing) and create a PR to the examples repo.
 
-## 📗 Project Docs
+# 📗 Project Docs
 
 - See the [project wiki](https://github.com/ipfs/helia/wiki).
 
-## 📒 API Docs
+# 📒 API Docs
 
 - https://ipfs.github.io/helia
 
-## 📐 System diagram
+# 📐 System diagram
 
 ```mermaid
 graph TD;
@@ -164,22 +138,26 @@ graph TD;
     IPNS-->Datastore;
     subgraph helia [Helia]
       Datastore
-      Blockstore-->Bitswap;
+      Blockstore-->BlockBrokers;
+      BlockBrokers-->Bitswap;
+      BlockBrokers-->TrustlessGateways;
       Libp2p-->DHT;
       Libp2p-->PubSub;
       Libp2p-->IPNI;
       Libp2p-->Reframe;
     end
-    Blockstore-->BlockStorage["File system/IDB/S3/etc"]
-    Datastore-->DataStorage["Level/S3/IDB/etc"]
+    Blockstore-->BlockStorage["File system/IDB/S3/etc"];
+    Datastore-->DataStorage["Level/S3/IDB/etc"];
     Bitswap-->Network;
+    TrustlessGateways-->Gateway1;
+    TrustlessGateways-->GatewayN;
     DHT-->Network;
     PubSub-->Network;
     IPNI-->Network;
     Reframe-->Network;
 ```
 
-## 🏭 Code Structure
+# 🏭 Code Structure
 Helia embraces a modular approach and encourages users to bring their own implementations of interfacing libraries to suit their needs. Helia also ships supplemental libraries and tools including:
 
 - [`@helia/UnixFS`](https://github.com/ipfs/helia-unixfs)
@@ -198,19 +176,20 @@ This repo itself is made up of these packages:
 - [`/packages/helia`](./packages/helia) An implementation of the Helia API
 - [`/packages/interop`](./packages/interop) Interop tests for Helia
 
-## 📣 Project status
+# 📣 Project status
 Helia v1 shipped in 202303 (see [releases](https://github.com/ipfs/helia/releases)), and development keeps on trucking as we work on initiatives in the [roadmap](#roadmap) and make performance improvements and bug fixes along the way.
 
-## 🛣️ Roadmap
+# 🛣️ Roadmap
 Please find and comment on [the Roadmap here](https://github.com/ipfs/helia/issues/5).
 
-## 👫 Get involved
-* Watch our Helia Demo Day presentations [here](https://www.youtube.com/playlist?list=PLuhRWgmPaHtQAnt8INOe5-kV9TLVaUJ9v)
-* We are sharing about the progress at periodic [Helia Demos](https://lu.ma/helia).  This is a good place to find out the latest and learn of ways to get involved.  We'd love to see you there!
-* Pick up one of the [issues](https://github.com/ipfs/helia/issues).
-* Come chat in Filecoin Slack #ip-js.  (Yes, we should bridge this to other chat enviornments.  Please comment [here](https://github.com/ipfs/helia/issues/33) if you'd like this.)
+# 👫 Get involved
+
+- Watch our Helia Demo Day presentations [here](https://www.youtube.com/playlist?list=PLuhRWgmPaHtQAnt8INOe5-kV9TLVaUJ9v)
+- We are sharing about the progress at periodic [Helia Demos](https://lu.ma/helia).  This is a good place to find out the latest and learn of ways to get involved.  We'd love to see you there!
+- Pick up one of the [issues](https://github.com/ipfs/helia/issues).
+- Come chat in Filecoin Slack #ip-js.  (Yes, we should bridge this to other chat enviornments.  Please comment [here](https://github.com/ipfs/helia/issues/33) if you'd like this.)
 
-### 🤲 Contribute
+# 🤲 Contribute
 
 Contributions welcome! Please check out [the issues](https://github.com/ipfs/helia/issues).
 
@@ -222,15 +201,15 @@ Unless you explicitly state otherwise, any contribution intentionally submitted
 
 [![](https://cdn.rawgit.com/jbenet/contribute-ipfs-gif/master/img/contribute.gif)](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md)
 
-## 🛍️ Notable Consumers/Users
+# 🛍️ Notable Consumers/Users
 
 - See [Projects using Helia](https://github.com/ipfs/helia/wiki/Projects-using-Helia).
 
-## 🌞 Branding
+# 🌞 Branding
 
 - See [Branding](https://github.com/ipfs/helia/wiki/Branding).
 
-## 🪪 License
+# 🪪 License
 
 Licensed under either of
 
diff --git a/package.json b/package.json
index e477a22c4..bf11c3223 100644
--- a/package.json
+++ b/package.json
@@ -33,11 +33,11 @@
     "release": "run-s build docs:no-publish npm:release docs",
     "npm:release": "aegir exec --bail false npm -- publish",
     "release:rc": "aegir release-rc",
-    "docs": "NODE_OPTIONS=--max_old_space_size=8192 aegir docs -- --exclude packages/interop --excludeExternals",
-    "docs:no-publish": "NODE_OPTIONS=--max_old_space_size=8192 aegir docs --publish false -- --exclude packages/interop"
+    "docs": "aegir docs",
+    "docs:no-publish": "aegir docs --publish false"
   },
   "devDependencies": {
-    "aegir": "^40.0.8",
+    "aegir": "^41.0.0",
     "npm-run-all": "^4.1.5",
     "typedoc-plugin-mdn-links": "^3.0.3"
   },
diff --git a/packages/helia/.aegir.js b/packages/helia/.aegir.js
index 6361cc84a..84e4b05d0 100644
--- a/packages/helia/.aegir.js
+++ b/packages/helia/.aegir.js
@@ -1,5 +1,5 @@
-import { circuitRelayServer } from 'libp2p/circuit-relay'
-import { identifyService } from 'libp2p/identify'
+import { circuitRelayServer } from '@libp2p/circuit-relay-v2'
+import { identify } from '@libp2p/identify'
 import { WebSockets } from '@multiformats/mafmt'
 import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
@@ -11,16 +11,23 @@ const options = {
     before: async () => {
       // use dynamic import otherwise the source may not have been built yet
       const { createHelia } = await import('./dist/src/index.js')
+      const { bitswap } = await import('./dist/src/block-brokers/index.js')
 
       const helia = await createHelia({
+        blockBrokers: [
+          bitswap()
+        ],
         libp2p: {
           addresses: {
             listen: [
               `/ip4/127.0.0.1/tcp/0/ws`
             ]
           },
+          connectionManager: {
+            inboundConnectionThreshold: Infinity
+          },
           services: {
-            identify: identifyService(),
+            identify: identify(),
             relay: circuitRelayServer({
               reservations: {
                 maxReservations: Infinity,
diff --git a/packages/helia/CHANGELOG.md b/packages/helia/CHANGELOG.md
index 621f97ebd..bdb0846ba 100644
--- a/packages/helia/CHANGELOG.md
+++ b/packages/helia/CHANGELOG.md
@@ -6,6 +6,38 @@
 * **dev:** bump aegir from 39.0.13 to 40.0.8 ([#198](https://github.com/ipfs/helia/issues/198)) ([4d75ecf](https://github.com/ipfs/helia/commit/4d75ecffb79e5177da35d3106e42dac7bc63153a))
 * update sibling dependencies ([beb10b5](https://github.com/ipfs/helia/commit/beb10b5590d66d1d5bef9b5e890b888263df2c92))
 
+## [2.1.0](https://www.github.com/ipfs/helia/compare/helia-v2.0.3...helia-v2.1.0) (2023-11-06)
+
+
+### Features
+
+* configurable block brokers ([#280](https://www.github.com/ipfs/helia/issues/280)) ([0749cbf](https://www.github.com/ipfs/helia/commit/0749cbf99745ea6ab4363f1b5d635634ca0ddcfa))
+* GatewayBlockBroker prioritizes & tries all gateways ([#281](https://www.github.com/ipfs/helia/issues/281)) ([9bad21b](https://www.github.com/ipfs/helia/commit/9bad21bd59fe6d1ba4a137db5a46bd2ead5238c3))
+* use trustless-gateway.link by default ([#299](https://www.github.com/ipfs/helia/issues/299)) ([bf11efa](https://www.github.com/ipfs/helia/commit/bf11efa4875f3b8f844511d70122983fc46b4f88))
+
+
+### Bug Fixes
+
+* listen on ip6 addresses ([#271](https://www.github.com/ipfs/helia/issues/271)) ([7ef5e79](https://www.github.com/ipfs/helia/commit/7ef5e79620f043522ff0dacc260af1fe83e5d77e))
+* remove trustless-gateway.link ([#301](https://www.github.com/ipfs/helia/issues/301)) ([0343725](https://www.github.com/ipfs/helia/commit/03437255213b14f5931aed91e8555d7fb7f92926))
+* replace IPNI gateway with delegated routing client ([#297](https://www.github.com/ipfs/helia/issues/297)) ([57d580d](https://www.github.com/ipfs/helia/commit/57d580da26c5e28852cc9fe4d0d80adb36699ece))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @helia/interface bumped from ^2.0.0 to ^2.1.0
+
+### [2.0.3](https://www.github.com/ipfs/helia/compare/helia-v2.0.2...helia-v2.0.3) (2023-09-18)
+
+
+### Bug Fixes
+
+* export libp2p service return type ([#263](https://www.github.com/ipfs/helia/issues/263)) ([76769cf](https://www.github.com/ipfs/helia/commit/76769cf33e06746f998b4f16b52d3e2a6a7a20a8))
+* try circuit relay transport first ([#267](https://www.github.com/ipfs/helia/issues/267)) ([d5e9c3c](https://www.github.com/ipfs/helia/commit/d5e9c3c45c8dc3e63969105b785f6a836820a1f8))
+* update attempt to add helia to identify agent version ([#268](https://www.github.com/ipfs/helia/issues/268)) ([6dc7d55](https://www.github.com/ipfs/helia/commit/6dc7d55cd3099785417a7a2c99db755e856bd59a))
+
 ### [2.0.2](https://www.github.com/ipfs/helia/compare/helia-v2.0.1...helia-v2.0.2) (2023-09-14)
 
 
@@ -329,4 +361,4 @@
 
 * The following workspace dependencies were updated
   * dependencies
-    * @helia/interface bumped from ~0.0.0 to ^0.1.0
+    * @helia/interface bumped from ~0.0.0 to ^0.1.0
\ No newline at end of file
diff --git a/packages/helia/README.md b/packages/helia/README.md
index b277a178c..39305c142 100644
--- a/packages/helia/README.md
+++ b/packages/helia/README.md
@@ -4,8 +4,6 @@
   </a>
 </p>
 
-# helia <!-- omit in toc -->
-
 [![ipfs.tech](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](https://ipfs.tech)
 [![Discuss](https://img.shields.io/discourse/https/discuss.ipfs.tech/posts.svg?style=flat-square)](https://discuss.ipfs.tech)
 [![codecov](https://img.shields.io/codecov/c/github/ipfs/helia.svg?style=flat-square)](https://codecov.io/gh/ipfs/helia)
@@ -13,13 +11,24 @@
 
 > An implementation of IPFS in JavaScript
 
-## Table of contents <!-- omit in toc -->
+## About
+
+Exports a `createHelia` function that returns an object that implements the Helia API.
+
+Pass it to other modules like @helia/unixfs to make files available on the distributed web.
+
+### Example
 
-- [Install](#install)
-  - [Browser `<script>` tag](#browser-script-tag)
-- [API Docs](#api-docs)
-- [License](#license)
-- [Contribute](#contribute)
+```typescript
+import { createHelia } from 'helia'
+import { unixfs } from '@helia/unixfs'
+import { CID } from 'multiformats/cid'
+
+const helia = await createHelia()
+
+const fs = unixfs(helia)
+fs.cat(CID.parse('bafyFoo'))
+```
 
 ## Install
 
diff --git a/packages/helia/package.json b/packages/helia/package.json
index 670efc79b..55cf9760d 100644
--- a/packages/helia/package.json
+++ b/packages/helia/package.json
@@ -1,6 +1,6 @@
 {
   "name": "helia",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "An implementation of IPFS in JavaScript",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia/tree/master/packages/helia#readme",
@@ -11,11 +11,31 @@
   "bugs": {
     "url": "https://github.com/ipfs/helia/issues"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "keywords": [
     "IPFS"
   ],
   "type": "module",
   "types": "./dist/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
+      ],
+      "src/*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
+      ]
+    }
+  },
   "files": [
     "src",
     "dist",
@@ -26,11 +46,20 @@
     ".": {
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
+    },
+    "./block-brokers": {
+      "types": "./dist/src/block-brokers/index.d.ts",
+      "import": "./dist/src/block-brokers/index.js"
+    },
+    "./hashers": {
+      "types": "./dist/src/utils/default-hashers.d.ts",
+      "import": "./dist/src/utils/default-hashers.js"
     }
   },
   "eslintConfig": {
     "extends": "ipfs",
     "parserOptions": {
+      "project": true,
       "sourceType": "module"
     }
   },
@@ -49,51 +78,59 @@
     "prepublishOnly": "node scripts/update-version.js && npm run build"
   },
   "dependencies": {
-    "@chainsafe/libp2p-gossipsub": "^10.0.0",
-    "@chainsafe/libp2p-noise": "^13.0.0",
-    "@chainsafe/libp2p-yamux": "^5.0.0",
-    "@helia/interface": "^2.0.0",
+    "@chainsafe/libp2p-gossipsub": "^11.0.0",
+    "@chainsafe/libp2p-noise": "^14.0.0",
+    "@chainsafe/libp2p-yamux": "^6.0.1",
+    "@helia/delegated-routing-v1-http-api-client": "^1.1.0",
+    "@helia/interface": "^2.1.0",
     "@ipld/dag-cbor": "^9.0.0",
     "@ipld/dag-json": "^10.0.1",
     "@ipld/dag-pb": "^4.0.3",
-    "@libp2p/bootstrap": "^9.0.2",
-    "@libp2p/interface": "^0.1.1",
-    "@libp2p/ipni-content-routing": "^2.0.0",
-    "@libp2p/kad-dht": "^10.0.2",
-    "@libp2p/logger": "^3.0.1",
-    "@libp2p/mdns": "^9.0.2",
-    "@libp2p/mplex": "^9.0.2",
-    "@libp2p/tcp": "^8.0.2",
-    "@libp2p/webrtc": "^3.1.3",
-    "@libp2p/websockets": "^7.0.2",
-    "@libp2p/webtransport": "^3.0.3",
+    "@libp2p/autonat": "^1.0.1",
+    "@libp2p/bootstrap": "^10.0.2",
+    "@libp2p/circuit-relay-v2": "^1.0.2",
+    "@libp2p/dcutr": "^1.0.1",
+    "@libp2p/identify": "^1.0.1",
+    "@libp2p/interface": "^1.0.1",
+    "@libp2p/kad-dht": "^11.0.2",
+    "@libp2p/keychain": "^4.0.2",
+    "@libp2p/mdns": "^10.0.2",
+    "@libp2p/mplex": "^10.0.2",
+    "@libp2p/ping": "^1.0.1",
+    "@libp2p/tcp": "^9.0.2",
+    "@libp2p/upnp-nat": "^1.0.1",
+    "@libp2p/webrtc": "^4.0.3",
+    "@libp2p/websockets": "^8.0.2",
+    "@libp2p/webtransport": "^4.0.3",
+    "any-signal": "^4.1.1",
     "blockstore-core": "^4.0.0",
     "cborg": "^4.0.1",
     "datastore-core": "^9.0.0",
     "interface-blockstore": "^5.0.0",
     "interface-datastore": "^8.0.0",
     "interface-store": "^5.0.1",
-    "ipfs-bitswap": "^19.0.0",
-    "ipns": "^6.0.0",
+    "ipfs-bitswap": "^20.0.0",
+    "ipns": "^7.0.1",
     "it-all": "^3.0.2",
     "it-drain": "^3.0.1",
     "it-filter": "^3.0.1",
     "it-foreach": "^2.0.2",
     "it-parallel": "^3.0.3",
-    "libp2p": "^0.46.6",
+    "libp2p": "^1.0.3",
     "mortice": "^3.0.1",
     "multiformats": "^12.0.1",
     "progress-events": "^1.0.0",
-    "uint8arrays": "^4.0.3"
+    "uint8arrays": "^5.0.0"
   },
   "devDependencies": {
+    "@libp2p/logger": "^4.0.1",
     "@multiformats/mafmt": "^12.1.5",
     "@multiformats/multiaddr": "^12.1.7",
-    "@types/sinon": "^10.0.14",
-    "aegir": "^40.0.8",
+    "@types/sinon": "^17.0.2",
+    "aegir": "^41.0.0",
     "delay": "^6.0.0",
-    "sinon": "^16.0.0",
-    "sinon-ts": "^1.0.0"
+    "sinon": "^17.0.0",
+    "sinon-ts": "^2.0.0"
   },
   "browser": {
     "./dist/src/utils/libp2p-defaults.js": "./dist/src/utils/libp2p-defaults.browser.js"
diff --git a/packages/helia/src/block-brokers/bitswap.ts b/packages/helia/src/block-brokers/bitswap.ts
new file mode 100644
index 000000000..d73331c7e
--- /dev/null
+++ b/packages/helia/src/block-brokers/bitswap.ts
@@ -0,0 +1,77 @@
+import { createBitswap } from 'ipfs-bitswap'
+import type { BlockAnnouncer, BlockBroker, BlockRetrievalOptions, BlockRetriever } from '@helia/interface/blocks'
+import type { Libp2p, Startable } from '@libp2p/interface'
+import type { Blockstore } from 'interface-blockstore'
+import type { Bitswap, BitswapNotifyProgressEvents, BitswapOptions, BitswapWantBlockProgressEvents } from 'ipfs-bitswap'
+import type { CID } from 'multiformats/cid'
+import type { MultihashHasher } from 'multiformats/hashes/interface'
+import type { ProgressOptions } from 'progress-events'
+
+interface BitswapComponents {
+  libp2p: Libp2p
+  blockstore: Blockstore
+  hashers: MultihashHasher[]
+}
+
+export interface BitswapInit extends BitswapOptions {
+
+}
+
+class BitswapBlockBroker implements BlockAnnouncer<ProgressOptions<BitswapNotifyProgressEvents>>, BlockRetriever<
+ProgressOptions<BitswapWantBlockProgressEvents>
+>, Startable {
+  private readonly bitswap: Bitswap
+  private started: boolean
+
+  constructor (components: BitswapComponents, init: BitswapInit = {}) {
+    const { libp2p, blockstore, hashers } = components
+
+    this.bitswap = createBitswap(libp2p, blockstore, {
+      hashLoader: {
+        getHasher: async (codecOrName: string | number): Promise<MultihashHasher<number>> => {
+          const hasher = hashers.find(hasher => {
+            return hasher.code === codecOrName || hasher.name === codecOrName
+          })
+
+          if (hasher != null) {
+            return hasher
+          }
+
+          throw new Error(`Could not load hasher for code/name "${codecOrName}"`)
+        }
+      },
+      ...init
+    })
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    await this.bitswap.start()
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    await this.bitswap.stop()
+    this.started = false
+  }
+
+  announce (cid: CID, block: Uint8Array, options?: ProgressOptions<BitswapNotifyProgressEvents>): void {
+    this.bitswap.notify(cid, block, options)
+  }
+
+  async retrieve (cid: CID, { validateFn, ...options }: BlockRetrievalOptions<ProgressOptions<BitswapWantBlockProgressEvents>> = {}): Promise<Uint8Array> {
+    return this.bitswap.want(cid, options)
+  }
+}
+
+/**
+ * A helper factory for users who want to override Helia `blockBrokers` but
+ * still want to use the default `BitswapBlockBroker`.
+ */
+export function bitswap (init: BitswapInit = {}): (components: BitswapComponents) => BlockBroker {
+  return (components) => new BitswapBlockBroker(components, init)
+}
diff --git a/packages/helia/src/block-brokers/index.ts b/packages/helia/src/block-brokers/index.ts
new file mode 100644
index 000000000..e7f503c97
--- /dev/null
+++ b/packages/helia/src/block-brokers/index.ts
@@ -0,0 +1,2 @@
+export { bitswap } from './bitswap.js'
+export { trustlessGateway } from './trustless-gateway/index.js'
diff --git a/packages/helia/src/block-brokers/trustless-gateway/broker.ts b/packages/helia/src/block-brokers/trustless-gateway/broker.ts
new file mode 100644
index 000000000..433a690d0
--- /dev/null
+++ b/packages/helia/src/block-brokers/trustless-gateway/broker.ts
@@ -0,0 +1,65 @@
+import { TrustlessGateway } from './trustless-gateway.js'
+import { DEFAULT_TRUSTLESS_GATEWAYS } from './index.js'
+import type { TrustlessGatewayBlockBrokerInit, TrustlessGatewayComponents, TrustlessGatewayGetBlockProgressEvents } from './index.js'
+import type { BlockRetrievalOptions, BlockRetriever } from '@helia/interface/blocks'
+import type { Logger } from '@libp2p/interface'
+import type { CID } from 'multiformats/cid'
+import type { ProgressOptions } from 'progress-events'
+
+/**
+ * A class that accepts a list of trustless gateways that are queried
+ * for blocks.
+ */
+export class TrustlessGatewayBlockBroker implements BlockRetriever<
+ProgressOptions<TrustlessGatewayGetBlockProgressEvents>
+> {
+  private readonly gateways: TrustlessGateway[]
+  private readonly log: Logger
+
+  constructor (components: TrustlessGatewayComponents, init: TrustlessGatewayBlockBrokerInit = {}) {
+    this.log = components.logger.forComponent('helia:trustless-gateway-block-broker')
+    this.gateways = (init.gateways ?? DEFAULT_TRUSTLESS_GATEWAYS)
+      .map((gatewayOrUrl) => {
+        return new TrustlessGateway(gatewayOrUrl)
+      })
+  }
+
+  async retrieve (cid: CID, options: BlockRetrievalOptions<ProgressOptions<TrustlessGatewayGetBlockProgressEvents>> = {}): Promise<Uint8Array> {
+    // Loop through the gateways until we get a block or run out of gateways
+    // TODO: switch to toSorted when support is better
+    const sortedGateways = this.gateways.sort((a, b) => b.reliability() - a.reliability())
+    const aggregateErrors: Error[] = []
+
+    for (const gateway of sortedGateways) {
+      this.log('getting block for %c from %s', cid, gateway.url)
+      try {
+        const block = await gateway.getRawBlock(cid, options.signal)
+        this.log.trace('got block for %c from %s', cid, gateway.url)
+        try {
+          await options.validateFn?.(block)
+        } catch (err) {
+          this.log.error('failed to validate block for %c from %s', cid, gateway.url, err)
+          gateway.incrementInvalidBlocks()
+
+          throw new Error(`unable to validate block for CID ${cid} from gateway ${gateway.url}`)
+        }
+
+        return block
+      } catch (err: unknown) {
+        this.log.error('failed to get block for %c from %s', cid, gateway.url, err)
+        if (err instanceof Error) {
+          aggregateErrors.push(err)
+        } else {
+          aggregateErrors.push(new Error(`unable to fetch raw block for CID ${cid} from gateway ${gateway.url}`))
+        }
+        // if signal was aborted, exit the loop
+        if (options.signal?.aborted === true) {
+          this.log.trace('request aborted while fetching raw block for CID %c from gateway %s', cid, gateway.url)
+          break
+        }
+      }
+    }
+
+    throw new AggregateError(aggregateErrors, `unable to fetch raw block for CID ${cid} from any gateway`)
+  }
+}
diff --git a/packages/helia/src/block-brokers/trustless-gateway/index.ts b/packages/helia/src/block-brokers/trustless-gateway/index.ts
new file mode 100644
index 000000000..2a97b463b
--- /dev/null
+++ b/packages/helia/src/block-brokers/trustless-gateway/index.ts
@@ -0,0 +1,33 @@
+import { TrustlessGatewayBlockBroker } from './broker.js'
+import type { BlockRetriever } from '@helia/interface/src/blocks.js'
+import type { ComponentLogger } from '@libp2p/interface'
+import type { ProgressEvent } from 'progress-events'
+
+export const DEFAULT_TRUSTLESS_GATEWAYS = [
+  // 2023-10-03: IPNS, Origin, and Block/CAR support from https://ipfs-public-gateway-checker.on.fleek.co/
+  'https://dweb.link',
+
+  // 2023-10-03: IPNS, Origin, and Block/CAR support from https://ipfs-public-gateway-checker.on.fleek.co/
+  'https://cf-ipfs.com',
+
+  // 2023-10-03: IPNS, Origin, and Block/CAR support from https://ipfs-public-gateway-checker.on.fleek.co/
+  'https://4everland.io',
+
+  // 2023-10-03: IPNS, Origin, and Block/CAR support from https://ipfs-public-gateway-checker.on.fleek.co/
+  'https://w3s.link'
+]
+
+export type TrustlessGatewayGetBlockProgressEvents =
+  ProgressEvent<'trustless-gateway:get-block:fetch', URL>
+
+export interface TrustlessGatewayBlockBrokerInit {
+  gateways?: Array<string | URL>
+}
+
+export interface TrustlessGatewayComponents {
+  logger: ComponentLogger
+}
+
+export function trustlessGateway (init: TrustlessGatewayBlockBrokerInit = {}): (components: TrustlessGatewayComponents) => BlockRetriever {
+  return (components) => new TrustlessGatewayBlockBroker(components, init)
+}
diff --git a/packages/helia/src/block-brokers/trustless-gateway/trustless-gateway.ts b/packages/helia/src/block-brokers/trustless-gateway/trustless-gateway.ts
new file mode 100644
index 000000000..352d6ea38
--- /dev/null
+++ b/packages/helia/src/block-brokers/trustless-gateway/trustless-gateway.ts
@@ -0,0 +1,126 @@
+import type { CID } from 'multiformats/cid'
+
+/**
+ * A `TrustlessGateway` keeps track of the number of attempts, errors, and
+ * successes for a given gateway url so that we can prioritize gateways that
+ * have been more reliable in the past, and ensure that requests are distributed
+ * across all gateways within a given `TrustlessGatewayBlockBroker` instance.
+ */
+export class TrustlessGateway {
+  public readonly url: URL
+  /**
+   * The number of times this gateway has been attempted to be used to fetch a
+   * block. This includes successful, errored, and aborted attempts. By counting
+   * even aborted attempts, slow gateways that are out-raced by others will be
+   * considered less reliable.
+   */
+  #attempts = 0
+
+  /**
+   * The number of times this gateway has errored while attempting to fetch a
+   * block. This includes `response.ok === false` and any other errors that
+   * throw while attempting to fetch a block. This does not include aborted
+   * attempts.
+   */
+  #errors = 0
+
+  /**
+   * The number of times this gateway has returned an invalid block. A gateway
+   * that returns the wrong blocks for a CID should be considered for removal
+   * from the list of gateways to fetch blocks from.
+   */
+  #invalidBlocks = 0
+
+  /**
+   * The number of times this gateway has successfully fetched a block.
+   */
+  #successes = 0
+
+  constructor (url: URL | string) {
+    this.url = url instanceof URL ? url : new URL(url)
+  }
+
+  /**
+   * Fetch a raw block from `this.url` following the specification defined at
+   * https://specs.ipfs.tech/http-gateways/trustless-gateway/
+   */
+  async getRawBlock (cid: CID, signal?: AbortSignal): Promise<Uint8Array> {
+    const gwUrl = this.url
+    gwUrl.pathname = `/ipfs/${cid.toString()}`
+
+    // necessary as not every gateway supports dag-cbor, but every should support
+    // sending raw block as-is
+    gwUrl.search = '?format=raw'
+
+    if (signal?.aborted === true) {
+      throw new Error(`Signal to fetch raw block for CID ${cid} from gateway ${this.url} was aborted prior to fetch`)
+    }
+
+    try {
+      this.#attempts++
+      const res = await fetch(gwUrl.toString(), {
+        signal,
+        headers: {
+        // also set header, just in case ?format= is filtered out by some
+        // reverse proxy
+          Accept: 'application/vnd.ipld.raw'
+        },
+        cache: 'force-cache'
+      })
+      if (!res.ok) {
+        this.#errors++
+        throw new Error(`unable to fetch raw block for CID ${cid} from gateway ${this.url}`)
+      }
+      this.#successes++
+      return new Uint8Array(await res.arrayBuffer())
+    } catch (cause) {
+      // @ts-expect-error - TS thinks signal?.aborted can only be false now
+      // because it was checked for true above.
+      if (signal?.aborted === true) {
+        throw new Error(`fetching raw block for CID ${cid} from gateway ${this.url} was aborted`)
+      }
+      this.#errors++
+      throw new Error(`unable to fetch raw block for CID ${cid}`)
+    }
+  }
+
+  /**
+   * Encapsulate the logic for determining whether a gateway is considered
+   * reliable, for prioritization. This is based on the number of successful attempts made
+   * and the number of errors encountered.
+   *
+   * Unused gateways have 100% reliability; They will be prioritized over
+   * gateways with a 100% success rate to ensure that we attempt all gateways.
+   */
+  reliability (): number {
+    /**
+     * if we have never tried to use this gateway, it is considered the most
+     * reliable until we determine otherwise (prioritize unused gateways)
+     */
+    if (this.#attempts === 0) {
+      return 1
+    }
+
+    if (this.#invalidBlocks > 0) {
+      // this gateway may not be trustworthy..
+      return -Infinity
+    }
+
+    /**
+     * We have attempted the gateway, so we need to calculate the reliability
+     * based on the number of attempts, errors, and successes. Gateways that
+     * return a single error should drop their reliability score more than a
+     * single success increases it.
+     *
+     * Play around with the below reliability function at https://www.desmos.com/calculator/d6hfhf5ukm
+     */
+    return this.#successes / (this.#attempts + (this.#errors * 3))
+  }
+
+  /**
+   * Increment the number of invalid blocks returned by this gateway.
+   */
+  incrementInvalidBlocks (): void {
+    this.#invalidBlocks++
+  }
+}
diff --git a/packages/helia/src/helia.ts b/packages/helia/src/helia.ts
index dd8ba172e..6e4ba230b 100644
--- a/packages/helia/src/helia.ts
+++ b/packages/helia/src/helia.ts
@@ -1,23 +1,19 @@
-import { logger } from '@libp2p/logger'
-import { type Bitswap, createBitswap } from 'ipfs-bitswap'
+import { start, stop } from '@libp2p/interface'
 import drain from 'it-drain'
-import { identity } from 'multiformats/hashes/identity'
-import { sha256, sha512 } from 'multiformats/hashes/sha2'
 import { CustomProgressEvent } from 'progress-events'
+import { bitswap, trustlessGateway } from './block-brokers/index.js'
 import { PinsImpl } from './pins.js'
 import { BlockStorage } from './storage.js'
 import { assertDatastoreVersionIsCurrent } from './utils/datastore-version.js'
+import { defaultHashers } from './utils/default-hashers.js'
 import { NetworkedStorage } from './utils/networked-storage.js'
 import type { HeliaInit } from '.'
 import type { GCOptions, Helia } from '@helia/interface'
 import type { Pins } from '@helia/interface/pins'
-import type { Libp2p } from '@libp2p/interface'
+import type { ComponentLogger, Libp2p, Logger } from '@libp2p/interface'
 import type { Blockstore } from 'interface-blockstore'
 import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats/cid'
-import type { MultihashHasher } from 'multiformats/hashes/interface'
-
-const log = logger('helia')
 
 interface HeliaImplInit<T extends Libp2p = Libp2p> extends HeliaInit<T> {
   libp2p: T
@@ -30,35 +26,32 @@ export class HeliaImpl implements Helia {
   public blockstore: BlockStorage
   public datastore: Datastore
   public pins: Pins
-
-  #bitswap?: Bitswap
+  public logger: ComponentLogger
+  private readonly log: Logger
 
   constructor (init: HeliaImplInit) {
-    const hashers: MultihashHasher[] = [
-      sha256,
-      sha512,
-      identity,
-      ...(init.hashers ?? [])
-    ]
-
-    this.#bitswap = createBitswap(init.libp2p, init.blockstore, {
-      hashLoader: {
-        getHasher: async (codecOrName: string | number): Promise<MultihashHasher<number>> => {
-          const hasher = hashers.find(hasher => {
-            return hasher.code === codecOrName || hasher.name === codecOrName
-          })
-
-          if (hasher != null) {
-            return hasher
-          }
+    this.logger = init.libp2p.logger
+    this.log = this.logger.forComponent('helia')
+    const hashers = defaultHashers(init.hashers)
+
+    const components = {
+      blockstore: init.blockstore,
+      datastore: init.datastore,
+      libp2p: init.libp2p,
+      hashers,
+      logger: init.libp2p.logger
+    }
 
-          throw new Error(`Could not load hasher for code/name "${codecOrName}"`)
-        }
-      }
-    })
+    const blockBrokers = init.blockBrokers?.map((fn) => {
+      return fn(components)
+    }) ?? [
+      bitswap()(components),
+      trustlessGateway()(components)
+    ]
 
-    const networkedStorage = new NetworkedStorage(init.blockstore, {
-      bitswap: this.#bitswap
+    const networkedStorage = new NetworkedStorage(components, {
+      blockBrokers,
+      hashers
     })
 
     this.pins = new PinsImpl(init.datastore, networkedStorage, init.dagWalkers ?? [])
@@ -72,14 +65,13 @@ export class HeliaImpl implements Helia {
 
   async start (): Promise<void> {
     await assertDatastoreVersionIsCurrent(this.datastore)
-
-    await this.#bitswap?.start()
+    await start(this.blockstore)
     await this.libp2p.start()
   }
 
   async stop (): Promise<void> {
     await this.libp2p.stop()
-    await this.#bitswap?.stop()
+    await stop(this.blockstore)
   }
 
   async gc (options: GCOptions = {}): Promise<void> {
@@ -89,7 +81,7 @@ export class HeliaImpl implements Helia {
       const helia = this
       const blockstore = this.blockstore.unwrap()
 
-      log('gc start')
+      this.log('gc start')
 
       await drain(blockstore.deleteMany((async function * (): AsyncGenerator<CID> {
         for await (const { cid } of blockstore.getAll()) {
@@ -102,7 +94,7 @@ export class HeliaImpl implements Helia {
 
             options.onProgress?.(new CustomProgressEvent<CID>('helia:gc:deleted', cid))
           } catch (err) {
-            log.error('Error during gc', err)
+            helia.log.error('Error during gc', err)
             options.onProgress?.(new CustomProgressEvent<Error>('helia:gc:error', err))
           }
         }
@@ -111,6 +103,6 @@ export class HeliaImpl implements Helia {
       releaseLock()
     }
 
-    log('gc finished')
+    this.log('gc finished')
   }
 }
diff --git a/packages/helia/src/index.ts b/packages/helia/src/index.ts
index 9f78b8317..ff41c238e 100644
--- a/packages/helia/src/index.ts
+++ b/packages/helia/src/index.ts
@@ -1,36 +1,33 @@
 /**
  * @packageDocumentation
  *
- * Create a Helia node.
+ * Exports a `createHelia` function that returns an object that implements the {@link Helia} API.
+ *
+ * Pass it to other modules like {@link https://www.npmjs.com/package/@helia/unixfs | @helia/unixfs} to make files available on the distributed web.
  *
  * @example
  *
  * ```typescript
- * import { MemoryDatastore } from 'datastore-core'
- * import { MemoryBlockstore } from 'blockstore-core'
  * import { createHelia } from 'helia'
  * import { unixfs } from '@helia/unixfs'
  * import { CID } from 'multiformats/cid'
  *
- * const node = await createHelia({
- *   blockstore: new MemoryBlockstore(),
- *   datastore: new MemoryDatastore()
- * })
- * const fs = unixfs(node)
+ * const helia = await createHelia()
+ *
+ * const fs = unixfs(helia)
  * fs.cat(CID.parse('bafyFoo'))
  * ```
  */
 
-import { logger } from '@libp2p/logger'
 import { MemoryBlockstore } from 'blockstore-core'
 import { MemoryDatastore } from 'datastore-core'
 import { HeliaImpl } from './helia.js'
 import { createLibp2p } from './utils/libp2p.js'
-import { name, version } from './version.js'
+import type { DefaultLibp2pServices } from './utils/libp2p-defaults.js'
 import type { Helia } from '@helia/interface'
-import type { Libp2p } from '@libp2p/interface'
-import type { PubSub } from '@libp2p/interface/pubsub'
-import type { DualKadDHT } from '@libp2p/kad-dht'
+import type { BlockBroker } from '@helia/interface/blocks'
+import type { ComponentLogger, Libp2p } from '@libp2p/interface'
+import type { KeychainInit } from '@libp2p/keychain'
 import type { Blockstore } from 'interface-blockstore'
 import type { Datastore } from 'interface-datastore'
 import type { Libp2pOptions } from 'libp2p'
@@ -43,14 +40,12 @@ export * from '@helia/interface'
 export * from '@helia/interface/blocks'
 export * from '@helia/interface/pins'
 
-const log = logger('helia')
-
 /**
  * DAGWalkers take a block and yield CIDs encoded in that block
  */
 export interface DAGWalker {
   codec: number
-  walk: (block: Uint8Array) => AsyncGenerator<CID, void, undefined>
+  walk(block: Uint8Array): AsyncGenerator<CID, void, undefined>
 }
 
 /**
@@ -92,6 +87,12 @@ export interface HeliaInit<T extends Libp2p = Libp2p> {
    */
   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
    */
@@ -113,13 +114,25 @@ export interface HeliaInit<T extends Libp2p = Libp2p> {
    * 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
+
+  /**
+   * By default Helia stores the node's PeerId in an encrypted form in a
+   * libp2p keystore. These options control how that keystore is configured.
+   */
+  keychain?: KeychainInit
 }
 
 /**
  * Create and return a Helia node
  */
 export async function createHelia <T extends Libp2p> (init: HeliaInit<T>): Promise<Helia<T>>
-export async function createHelia (init?: HeliaInit<Libp2p<{ dht: DualKadDHT, pubsub: PubSub }>>): Promise<Helia<Libp2p<{ dht: DualKadDHT, pubsub: PubSub }>>>
+export async function createHelia (init?: HeliaInit<Libp2p<DefaultLibp2pServices>>): Promise<Helia<Libp2p<DefaultLibp2pServices>>>
 export async function createHelia (init: HeliaInit = {}): Promise<Helia<unknown>> {
   const datastore = init.datastore ?? new MemoryDatastore()
   const blockstore = init.blockstore ?? new MemoryBlockstore()
@@ -129,32 +142,24 @@ export async function createHelia (init: HeliaInit = {}): Promise<Helia<unknown>
   if (isLibp2p(init.libp2p)) {
     libp2p = init.libp2p
   } else {
-    libp2p = await createLibp2p(datastore, init.libp2p)
+    libp2p = await createLibp2p({
+      ...init,
+      libp2p: init.libp2p,
+      datastore
+    })
   }
 
   const helia = new HeliaImpl({
     ...init,
+    libp2p,
     datastore,
-    blockstore,
-    libp2p
+    blockstore
   })
 
   if (init.start !== false) {
     await helia.start()
   }
 
-  // add helia to agent version
-  if (helia.libp2p.isStarted()) {
-    await addHeliaToAgentVersion(helia)
-  } else {
-    helia.libp2p.addEventListener('start', () => {
-      addHeliaToAgentVersion(helia)
-        .catch(err => {
-          log.error('could not add Helia to agent version', err)
-        })
-    })
-  }
-
   return helia
 }
 
@@ -169,35 +174,3 @@ function isLibp2p (obj: any): obj is Libp2p {
   // if these are all functions it's probably a libp2p object
   return funcs.every(m => typeof obj[m] === 'function')
 }
-
-async function addHeliaToAgentVersion (helia: Helia): Promise<void> {
-  // add helia to agent version
-  const peer = await helia.libp2p.peerStore.get(helia.libp2p.peerId)
-  const versionBuf = peer.metadata.get('AgentVersion')
-
-  if (versionBuf == null) {
-    // identify was not configured
-    return
-  }
-
-  let versionStr = new TextDecoder().decode(versionBuf)
-
-  if (versionStr.match(/js-libp2p\/\d+\.\d+\.\d+\sUserAgent=/) == null) {
-    // the user changed the agent version
-    return
-  }
-
-  if (versionStr.includes(name)) {
-    // update version name
-    versionStr = `${name}/${version} ${versionStr.split(' ').slice(1).join(' ')}`
-  } else {
-    // just prepend version name
-    versionStr = `${name}/${version} ${versionStr}`
-  }
-
-  await helia.libp2p.peerStore.merge(helia.libp2p.peerId, {
-    metadata: {
-      AgentVersion: new TextEncoder().encode(versionStr)
-    }
-  })
-}
diff --git a/packages/helia/src/storage.ts b/packages/helia/src/storage.ts
index 58a475749..909c2e89c 100644
--- a/packages/helia/src/storage.ts
+++ b/packages/helia/src/storage.ts
@@ -1,7 +1,8 @@
+import { start, stop } from '@libp2p/interface'
 import createMortice from 'mortice'
 import type { Blocks, Pair, DeleteManyBlocksProgressEvents, DeleteBlockProgressEvents, GetBlockProgressEvents, GetManyBlocksProgressEvents, PutManyBlocksProgressEvents, PutBlockProgressEvents, GetAllBlocksProgressEvents, GetOfflineOptions } from '@helia/interface/blocks'
 import type { Pins } from '@helia/interface/pins'
-import type { AbortOptions } from '@libp2p/interface'
+import type { AbortOptions, Startable } from '@libp2p/interface'
 import type { Blockstore } from 'interface-blockstore'
 import type { AwaitIterable } from 'interface-store'
 import type { Mortice } from 'mortice'
@@ -13,7 +14,7 @@ export interface BlockStorageInit {
 }
 
 export interface GetOptions extends AbortOptions {
-  progress?: (evt: Event) => void
+  progress?(evt: Event): void
 }
 
 /**
@@ -21,10 +22,11 @@ export interface GetOptions extends AbortOptions {
  * blockstore (that may be on disk, s3, or something else). If the blocks are
  * not present Bitswap will be used to fetch them from network peers.
  */
-export class BlockStorage implements Blocks {
+export class BlockStorage implements Blocks, Startable {
   public lock: Mortice
   private readonly child: Blockstore
   private readonly pins: Pins
+  private started: boolean
 
   /**
    * Create a new BlockStorage
@@ -35,6 +37,21 @@ export class BlockStorage implements Blocks {
     this.lock = createMortice({
       singleProcess: options.holdGcLock
     })
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    await start(this.child)
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    await stop(this.child)
+    this.started = false
   }
 
   unwrap (): Blockstore {
diff --git a/packages/helia/src/utils/default-hashers.ts b/packages/helia/src/utils/default-hashers.ts
new file mode 100644
index 000000000..9352e8703
--- /dev/null
+++ b/packages/helia/src/utils/default-hashers.ts
@@ -0,0 +1,12 @@
+import { identity } from 'multiformats/hashes/identity'
+import { sha256, sha512 } from 'multiformats/hashes/sha2'
+import type { MultihashHasher } from 'multiformats/hashes/interface'
+
+export function defaultHashers (hashers: MultihashHasher[] = []): MultihashHasher[] {
+  return [
+    sha256,
+    sha512,
+    identity,
+    ...hashers
+  ]
+}
diff --git a/packages/helia/src/utils/libp2p-defaults.browser.ts b/packages/helia/src/utils/libp2p-defaults.browser.ts
index 2802458e2..9dd2c7f0e 100644
--- a/packages/helia/src/utils/libp2p-defaults.browser.ts
+++ b/packages/helia/src/utils/libp2p-defaults.browser.ts
@@ -1,38 +1,55 @@
 import { gossipsub } from '@chainsafe/libp2p-gossipsub'
 import { noise } from '@chainsafe/libp2p-noise'
 import { yamux } from '@chainsafe/libp2p-yamux'
+import { createDelegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
+import { autoNAT } from '@libp2p/autonat'
 import { bootstrap } from '@libp2p/bootstrap'
-import { ipniContentRouting } from '@libp2p/ipni-content-routing'
+import { circuitRelayTransport } from '@libp2p/circuit-relay-v2'
+import { dcutr } from '@libp2p/dcutr'
+import { type Identify, identify } from '@libp2p/identify'
 import { type DualKadDHT, kadDHT } from '@libp2p/kad-dht'
+import { keychain, type Keychain } from '@libp2p/keychain'
 import { mplex } from '@libp2p/mplex'
+import { ping, type PingService } from '@libp2p/ping'
 import { webRTC, webRTCDirect } from '@libp2p/webrtc'
 import { webSockets } from '@libp2p/websockets'
 import { webTransport } from '@libp2p/webtransport'
 import { ipnsSelector } from 'ipns/selector'
 import { ipnsValidator } from 'ipns/validator'
-import { autoNATService } from 'libp2p/autonat'
-import { circuitRelayTransport } from 'libp2p/circuit-relay'
-import { dcutrService } from 'libp2p/dcutr'
-import { identifyService } from 'libp2p/identify'
+import * as libp2pInfo from 'libp2p/version'
+import { name, version } from '../version.js'
 import { bootstrapConfig } from './bootstrappers.js'
-import type { PubSub } from '@libp2p/interface/pubsub'
+import type { Libp2pDefaultsOptions } from './libp2p.js'
+import type { PubSub } from '@libp2p/interface'
 import type { Libp2pOptions } from 'libp2p'
 
-export function libp2pDefaults (): Libp2pOptions<{ dht: DualKadDHT, pubsub: PubSub, identify: unknown, autoNAT: unknown, dcutr: unknown }> {
+export interface DefaultLibp2pServices extends Record<string, unknown> {
+  autoNAT: unknown
+  dcutr: unknown
+  delegatedRouting: unknown
+  dht: DualKadDHT
+  identify: Identify
+  keychain: Keychain
+  ping: PingService
+  pubsub: PubSub
+}
+
+export function libp2pDefaults (options: Libp2pDefaultsOptions): Libp2pOptions<DefaultLibp2pServices> {
   return {
+    peerId: options.peerId,
     addresses: {
       listen: [
         '/webrtc'
       ]
     },
     transports: [
+      circuitRelayTransport({
+        discoverRelays: 1
+      }),
       webRTC(),
       webRTCDirect(),
       webTransport(),
-      webSockets(),
-      circuitRelayTransport({
-        discoverRelays: 1
-      })
+      webSockets()
     ],
     connectionEncryption: [
       noise()
@@ -44,14 +61,10 @@ export function libp2pDefaults (): Libp2pOptions<{ dht: DualKadDHT, pubsub: PubS
     peerDiscovery: [
       bootstrap(bootstrapConfig)
     ],
-    contentRouters: [
-      ipniContentRouting('https://cid.contact')
-    ],
     services: {
-      identify: identifyService(),
-      autoNAT: autoNATService(),
-      pubsub: gossipsub(),
-      dcutr: dcutrService(),
+      autoNAT: autoNAT(),
+      dcutr: dcutr(),
+      delegatedRouting: () => createDelegatedRoutingV1HttpApiClient('https://delegated-ipfs.dev'),
       dht: kadDHT({
         clientMode: true,
         validators: {
@@ -60,7 +73,13 @@ export function libp2pDefaults (): Libp2pOptions<{ dht: DualKadDHT, pubsub: PubS
         selectors: {
           ipns: ipnsSelector
         }
-      })
+      }),
+      identify: identify({
+        agentVersion: `${name}/${version} ${libp2pInfo.name}/${libp2pInfo.version} UserAgent=${globalThis.navigator.userAgent}`
+      }),
+      keychain: keychain(options.keychain),
+      ping: ping(),
+      pubsub: gossipsub()
     }
   }
 }
diff --git a/packages/helia/src/utils/libp2p-defaults.ts b/packages/helia/src/utils/libp2p-defaults.ts
index f70147c18..a71673078 100644
--- a/packages/helia/src/utils/libp2p-defaults.ts
+++ b/packages/helia/src/utils/libp2p-defaults.ts
@@ -1,37 +1,61 @@
 import { gossipsub } from '@chainsafe/libp2p-gossipsub'
 import { noise } from '@chainsafe/libp2p-noise'
 import { yamux } from '@chainsafe/libp2p-yamux'
+import { createDelegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
+import { autoNAT } from '@libp2p/autonat'
 import { bootstrap } from '@libp2p/bootstrap'
-import { ipniContentRouting } from '@libp2p/ipni-content-routing'
+import { circuitRelayTransport, circuitRelayServer, type CircuitRelayService } from '@libp2p/circuit-relay-v2'
+import { dcutr } from '@libp2p/dcutr'
+import { type Identify, identify } from '@libp2p/identify'
 import { type DualKadDHT, kadDHT } from '@libp2p/kad-dht'
+import { keychain, type Keychain } from '@libp2p/keychain'
 import { mdns } from '@libp2p/mdns'
 import { mplex } from '@libp2p/mplex'
+import { ping, type PingService } from '@libp2p/ping'
 import { tcp } from '@libp2p/tcp'
+import { uPnPNAT } from '@libp2p/upnp-nat'
+import { webRTC, webRTCDirect } from '@libp2p/webrtc'
 import { webSockets } from '@libp2p/websockets'
 import { ipnsSelector } from 'ipns/selector'
 import { ipnsValidator } from 'ipns/validator'
-import { autoNATService } from 'libp2p/autonat'
-import { circuitRelayTransport, circuitRelayServer, type CircuitRelayService } from 'libp2p/circuit-relay'
-import { dcutrService } from 'libp2p/dcutr'
-import { identifyService } from 'libp2p/identify'
-import { uPnPNATService } from 'libp2p/upnp-nat'
+import * as libp2pInfo from 'libp2p/version'
+import { name, version } from '../version.js'
 import { bootstrapConfig } from './bootstrappers.js'
-import type { PubSub } from '@libp2p/interface/pubsub'
+import type { Libp2pDefaultsOptions } from './libp2p.js'
+import type { PubSub } from '@libp2p/interface'
 import type { Libp2pOptions } from 'libp2p'
 
-export function libp2pDefaults (): Libp2pOptions<{ dht: DualKadDHT, pubsub: PubSub, relay: CircuitRelayService, identify: unknown, autoNAT: unknown, upnp: unknown, dcutr: unknown }> {
+export interface DefaultLibp2pServices extends Record<string, unknown> {
+  autoNAT: unknown
+  dcutr: unknown
+  delegatedRouting: unknown
+  dht: DualKadDHT
+  identify: Identify
+  keychain: Keychain
+  ping: PingService
+  pubsub: PubSub
+  relay: CircuitRelayService
+  upnp: unknown
+}
+
+export function libp2pDefaults (options: Libp2pDefaultsOptions): Libp2pOptions<DefaultLibp2pServices> {
   return {
+    peerId: options.peerId,
     addresses: {
       listen: [
-        '/ip4/0.0.0.0/tcp/0'
+        '/ip4/0.0.0.0/tcp/0',
+        '/ip6/::/tcp/0',
+        '/webrtc'
       ]
     },
     transports: [
-      tcp(),
-      webSockets(),
       circuitRelayTransport({
         discoverRelays: 1
-      })
+      }),
+      tcp(),
+      webRTC(),
+      webRTCDirect(),
+      webSockets()
     ],
     connectionEncryption: [
       noise()
@@ -44,15 +68,10 @@ export function libp2pDefaults (): Libp2pOptions<{ dht: DualKadDHT, pubsub: PubS
       mdns(),
       bootstrap(bootstrapConfig)
     ],
-    contentRouters: [
-      ipniContentRouting('https://cid.contact')
-    ],
     services: {
-      identify: identifyService(),
-      autoNAT: autoNATService(),
-      upnp: uPnPNATService(),
-      pubsub: gossipsub(),
-      dcutr: dcutrService(),
+      autoNAT: autoNAT(),
+      dcutr: dcutr(),
+      delegatedRouting: () => createDelegatedRoutingV1HttpApiClient('https://delegated-ipfs.dev'),
       dht: kadDHT({
         validators: {
           ipns: ipnsValidator
@@ -61,9 +80,16 @@ export function libp2pDefaults (): Libp2pOptions<{ dht: DualKadDHT, pubsub: PubS
           ipns: ipnsSelector
         }
       }),
+      identify: identify({
+        agentVersion: `${name}/${version} ${libp2pInfo.name}/${libp2pInfo.version} UserAgent=${globalThis.process.version}`
+      }),
+      keychain: keychain(options.keychain),
+      ping: ping(),
+      pubsub: gossipsub(),
       relay: circuitRelayServer({
         advertise: true
-      })
+      }),
+      upnp: uPnPNAT()
     }
   }
 }
diff --git a/packages/helia/src/utils/libp2p.ts b/packages/helia/src/utils/libp2p.ts
index 48ffbe844..e78a1f1fe 100644
--- a/packages/helia/src/utils/libp2p.ts
+++ b/packages/helia/src/utils/libp2p.ts
@@ -1,24 +1,53 @@
-import { createLibp2p as create, type Libp2pOptions } from 'libp2p'
+import { keychain } from '@libp2p/keychain'
+import { defaultLogger } from '@libp2p/logger'
+import { Key } from 'interface-datastore'
+import { createLibp2p as create } from 'libp2p'
 import { libp2pDefaults } from './libp2p-defaults.js'
-import type { Libp2p } from '@libp2p/interface'
-import type { PubSub } from '@libp2p/interface/pubsub'
-import type { DualKadDHT } from '@libp2p/kad-dht'
+import type { DefaultLibp2pServices } from './libp2p-defaults.js'
+import type { ComponentLogger, Libp2p, PeerId } from '@libp2p/interface'
+import type { KeychainInit } from '@libp2p/keychain'
 import type { Datastore } from 'interface-datastore'
-import type { CircuitRelayService } from 'libp2p/circuit-relay'
+import type { Libp2pOptions } from 'libp2p'
 
-export interface CreateLibp2pOptions {
+export interface CreateLibp2pOptions<T extends Record<string, unknown>> {
   datastore: Datastore
+  libp2p?: Libp2pOptions<T>
+  logger?: ComponentLogger
+  keychain?: KeychainInit
   start?: boolean
 }
 
-export async function createLibp2p (datastore: Datastore, options?: Libp2pOptions<any>): Promise<Libp2p<{ dht: DualKadDHT, pubsub: PubSub, relay: CircuitRelayService }>> {
-  const defaults = libp2pDefaults()
+export interface Libp2pDefaultsOptions {
+  peerId?: PeerId
+  keychain?: KeychainInit
+}
+
+export async function createLibp2p <T extends Record<string, unknown> = DefaultLibp2pServices> (options: CreateLibp2pOptions<T>): Promise<Libp2p<T>> {
+  let peerId = options.libp2p?.peerId
+  const logger = options.logger ?? defaultLogger()
+
+  // if no peer id was passed, try to load it from the keychain
+  if (peerId == null) {
+    const chain = keychain(options.keychain)({
+      datastore: options.datastore,
+      logger
+    })
+
+    const selfKey = new Key('/pkcs8/self')
+
+    if (await options.datastore.has(selfKey)) {
+      // load the peer id from the keychain
+      peerId = await chain.exportPeerId('self')
+    }
+  }
+
+  const defaults = libp2pDefaults(options)
   options = options ?? {}
 
+  // @ts-expect-error derived ServiceMap is not compatible with ServiceFactoryMap
   return create({
-    datastore,
     ...defaults,
-    ...options,
+    ...options.libp2p,
     start: false
   })
 }
diff --git a/packages/helia/src/utils/networked-storage.ts b/packages/helia/src/utils/networked-storage.ts
index c06c81c5d..f8e78b4bd 100644
--- a/packages/helia/src/utils/networked-storage.ts
+++ b/packages/helia/src/utils/networked-storage.ts
@@ -1,36 +1,74 @@
+import { CodeError, start, stop } from '@libp2p/interface'
+import { anySignal } from 'any-signal'
 import filter from 'it-filter'
 import forEach from 'it-foreach'
 import { CustomProgressEvent, type ProgressOptions } from 'progress-events'
-import type { Blocks, Pair, DeleteManyBlocksProgressEvents, DeleteBlockProgressEvents, GetBlockProgressEvents, GetManyBlocksProgressEvents, PutManyBlocksProgressEvents, PutBlockProgressEvents, GetAllBlocksProgressEvents, GetOfflineOptions } from '@helia/interface/blocks'
-import type { AbortOptions } from '@libp2p/interface'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import type { BlockBroker, Blocks, Pair, DeleteManyBlocksProgressEvents, DeleteBlockProgressEvents, GetBlockProgressEvents, GetManyBlocksProgressEvents, PutManyBlocksProgressEvents, PutBlockProgressEvents, GetAllBlocksProgressEvents, GetOfflineOptions, BlockRetriever, BlockAnnouncer, BlockRetrievalOptions } from '@helia/interface/blocks'
+import type { AbortOptions, ComponentLogger, Logger, LoggerOptions, Startable } from '@libp2p/interface'
 import type { Blockstore } from 'interface-blockstore'
 import type { AwaitIterable } from 'interface-store'
-import type { Bitswap } from 'ipfs-bitswap'
 import type { CID } from 'multiformats/cid'
+import type { MultihashHasher } from 'multiformats/hashes/interface'
 
-export interface BlockStorageInit {
-  holdGcLock?: boolean
-  bitswap?: Bitswap
+export interface NetworkedStorageStorageInit {
+  blockBrokers?: BlockBroker[]
+  hashers?: MultihashHasher[]
 }
 
 export interface GetOptions extends AbortOptions {
-  progress?: (evt: Event) => void
+  progress?(evt: Event): void
+}
+
+function isBlockRetriever (b: any): b is BlockRetriever {
+  return typeof b.retrieve === 'function'
+}
+
+function isBlockAnnouncer (b: any): b is BlockAnnouncer {
+  return typeof b.announce === 'function'
+}
+
+export interface NetworkedStorageComponents {
+  blockstore: Blockstore
+  logger: ComponentLogger
 }
 
 /**
  * Networked storage wraps a regular blockstore - when getting blocks if the
  * blocks are not present Bitswap will be used to fetch them from network peers.
  */
-export class NetworkedStorage implements Blocks {
+export class NetworkedStorage implements Blocks, Startable {
   private readonly child: Blockstore
-  private readonly bitswap?: Bitswap
+  private readonly blockRetrievers: BlockRetriever[]
+  private readonly blockAnnouncers: BlockAnnouncer[]
+  private readonly hashers: MultihashHasher[]
+  private started: boolean
+  private readonly log: Logger
 
   /**
    * Create a new BlockStorage
    */
-  constructor (blockstore: Blockstore, options: BlockStorageInit = {}) {
-    this.child = blockstore
-    this.bitswap = options.bitswap
+  constructor (components: NetworkedStorageComponents, init: NetworkedStorageStorageInit) {
+    this.log = components.logger.forComponent('helia:networked-storage')
+    this.child = components.blockstore
+    this.blockRetrievers = (init.blockBrokers ?? []).filter(isBlockRetriever)
+    this.blockAnnouncers = (init.blockBrokers ?? []).filter(isBlockAnnouncer)
+    this.hashers = init.hashers ?? []
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    await start(this.child, ...new Set([...this.blockRetrievers, ...this.blockAnnouncers]))
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    await stop(this.child, ...new Set([...this.blockRetrievers, ...this.blockAnnouncers]))
+    this.started = false
   }
 
   unwrap (): Blockstore {
@@ -46,10 +84,11 @@ export class NetworkedStorage implements Blocks {
       return cid
     }
 
-    if (this.bitswap?.isStarted() === true) {
-      options.onProgress?.(new CustomProgressEvent<CID>('blocks:put:bitswap:notify', cid))
-      this.bitswap.notify(cid, block, options)
-    }
+    options.onProgress?.(new CustomProgressEvent<CID>('blocks:put:providers:notify', cid))
+
+    this.blockAnnouncers.forEach(provider => {
+      provider.announce(cid, block, options)
+    })
 
     options.onProgress?.(new CustomProgressEvent<CID>('blocks:put:blockstore:put', cid))
 
@@ -71,8 +110,10 @@ export class NetworkedStorage implements Blocks {
     })
 
     const notifyEach = forEach(missingBlocks, ({ cid, block }): void => {
-      options.onProgress?.(new CustomProgressEvent<CID>('blocks:put-many:bitswap:notify', cid))
-      this.bitswap?.notify(cid, block, options)
+      options.onProgress?.(new CustomProgressEvent<CID>('blocks:put-many:providers:notify', cid))
+      this.blockAnnouncers.forEach(provider => {
+        provider.announce(cid, block, options)
+      })
     })
 
     options.onProgress?.(new CustomProgressEvent('blocks:put-many:blockstore:put-many'))
@@ -83,13 +124,22 @@ export class NetworkedStorage implements Blocks {
    * Get a block by cid
    */
   async get (cid: CID, options: GetOfflineOptions & AbortOptions & ProgressOptions<GetBlockProgressEvents> = {}): Promise<Uint8Array> {
-    if (options.offline !== true && this.bitswap?.isStarted() != null && !(await this.child.has(cid))) {
-      options.onProgress?.(new CustomProgressEvent<CID>('blocks:get:bitswap:get', cid))
-      const block = await this.bitswap.want(cid, options)
-
+    if (options.offline !== true && !(await this.child.has(cid))) {
+      // we do not have the block locally, get it from a block provider
+      options.onProgress?.(new CustomProgressEvent<CID>('blocks:get:providers:get', cid))
+      const block = await raceBlockRetrievers(cid, this.blockRetrievers, this.hashers, {
+        ...options,
+        log: this.log
+      })
       options.onProgress?.(new CustomProgressEvent<CID>('blocks:get:blockstore:put', cid))
       await this.child.put(cid, block, options)
 
+      // notify other block providers of the new block
+      options.onProgress?.(new CustomProgressEvent<CID>('blocks:get:providers:notify', cid))
+      this.blockAnnouncers.forEach(provider => {
+        provider.announce(cid, block, options)
+      })
+
       return block
     }
 
@@ -105,11 +155,21 @@ export class NetworkedStorage implements Blocks {
     options.onProgress?.(new CustomProgressEvent('blocks:get-many:blockstore:get-many'))
 
     yield * this.child.getMany(forEach(cids, async (cid): Promise<void> => {
-      if (options.offline !== true && this.bitswap?.isStarted() === true && !(await this.child.has(cid))) {
-        options.onProgress?.(new CustomProgressEvent<CID>('blocks:get-many:bitswap:get', cid))
-        const block = await this.bitswap.want(cid, options)
+      if (options.offline !== true && !(await this.child.has(cid))) {
+        // we do not have the block locally, get it from a block provider
+        options.onProgress?.(new CustomProgressEvent<CID>('blocks:get-many:providers:get', cid))
+        const block = await raceBlockRetrievers(cid, this.blockRetrievers, this.hashers, {
+          ...options,
+          log: this.log
+        })
         options.onProgress?.(new CustomProgressEvent<CID>('blocks:get-many:blockstore:put', cid))
         await this.child.put(cid, block, options)
+
+        // notify other block providers of the new block
+        options.onProgress?.(new CustomProgressEvent<CID>('blocks:get-many:providers:notify', cid))
+        this.blockAnnouncers.forEach(provider => {
+          provider.announce(cid, block, options)
+        })
       }
     }))
   }
@@ -144,3 +204,63 @@ export class NetworkedStorage implements Blocks {
     yield * this.child.getAll(options)
   }
 }
+
+export const getCidBlockVerifierFunction = (cid: CID, hashers: MultihashHasher[]): Required<BlockRetrievalOptions>['validateFn'] => {
+  const hasher = hashers.find(hasher => hasher.code === cid.multihash.code)
+
+  if (hasher == null) {
+    throw new CodeError(`No hasher configured for multihash code 0x${cid.multihash.code.toString(16)}, please configure one. You can look up which hash this is at https://github.com/multiformats/multicodec/blob/master/table.csv`, 'ERR_UNKNOWN_HASH_ALG')
+  }
+
+  return async (block: Uint8Array): Promise<void> => {
+    // verify block
+    const hash = await hasher.digest(block)
+
+    if (!uint8ArrayEquals(hash.digest, cid.multihash.digest)) {
+      // if a hash mismatch occurs for a TrustlessGatewayBlockBroker, we should try another gateway
+      throw new CodeError('Hash of downloaded block did not match multihash from passed CID', 'ERR_HASH_MISMATCH')
+    }
+  }
+}
+
+/**
+ * Race block providers cancelling any pending requests once the block has been
+ * found.
+ */
+async function raceBlockRetrievers (cid: CID, providers: BlockRetriever[], hashers: MultihashHasher[], options: AbortOptions & LoggerOptions): Promise<Uint8Array> {
+  const validateFn = getCidBlockVerifierFunction(cid, hashers)
+
+  const controller = new AbortController()
+  const signal = anySignal([controller.signal, options.signal])
+
+  try {
+    return await Promise.any(
+      providers.map(async provider => {
+        try {
+          let blocksWereValidated = false
+          const block = await provider.retrieve(cid, {
+            ...options,
+            signal,
+            validateFn: async (block: Uint8Array): Promise<void> => {
+              await validateFn(block)
+              blocksWereValidated = true
+            }
+          })
+
+          if (!blocksWereValidated) {
+            // the blockBroker either did not throw an error when attempting to validate the block
+            // or did not call the validateFn at all. We should validate the block ourselves
+            await validateFn(block)
+          }
+
+          return block
+        } catch (err) {
+          options.log.error('could not retrieve verified block for %c', cid, err)
+          throw err
+        }
+      })
+    )
+  } finally {
+    signal.clear()
+  }
+}
diff --git a/packages/helia/test/block-brokers/block-broker.spec.ts b/packages/helia/test/block-brokers/block-broker.spec.ts
new file mode 100644
index 000000000..e10eb7fcf
--- /dev/null
+++ b/packages/helia/test/block-brokers/block-broker.spec.ts
@@ -0,0 +1,143 @@
+/* eslint-env mocha */
+
+import { defaultLogger } from '@libp2p/logger'
+import { expect } from 'aegir/chai'
+import { MemoryBlockstore } from 'blockstore-core'
+import delay from 'delay'
+import all from 'it-all'
+import * as raw from 'multiformats/codecs/raw'
+import Sinon from 'sinon'
+import { type StubbedInstance, stubInterface } from 'sinon-ts'
+import { defaultHashers } from '../../src/utils/default-hashers.js'
+import { NetworkedStorage } from '../../src/utils/networked-storage.js'
+import { createBlock } from '../fixtures/create-block.js'
+import type { BlockBroker, BlockRetriever } from '@helia/interface/blocks'
+import type { Blockstore } from 'interface-blockstore'
+import type { CID } from 'multiformats/cid'
+
+describe('block-broker', () => {
+  let storage: NetworkedStorage
+  let blockstore: Blockstore
+  let bitswapBlockBroker: StubbedInstance<Required<BlockBroker>>
+  let blocks: Array<{ cid: CID, block: Uint8Array }>
+  let gatewayBlockBroker: StubbedInstance<Required<BlockRetriever>>
+
+  beforeEach(async () => {
+    blocks = []
+
+    for (let i = 0; i < 10; i++) {
+      blocks.push(await createBlock(raw.code, Uint8Array.from([0, 1, 2, i])))
+    }
+
+    blockstore = new MemoryBlockstore()
+    bitswapBlockBroker = stubInterface()
+    gatewayBlockBroker = stubInterface()
+    storage = new NetworkedStorage({
+      blockstore,
+      logger: defaultLogger()
+    }, {
+      blockBrokers: [
+        bitswapBlockBroker,
+        gatewayBlockBroker
+      ],
+      hashers: defaultHashers()
+    })
+  })
+
+  it('gets a block from the gatewayBlockBroker when it is not in the blockstore', async () => {
+    const { cid, block } = blocks[0]
+
+    gatewayBlockBroker.retrieve.withArgs(cid, Sinon.match.any).resolves(block)
+
+    expect(await blockstore.has(cid)).to.be.false()
+
+    const returned = await storage.get(cid)
+
+    expect(await blockstore.has(cid)).to.be.true()
+    expect(returned).to.equalBytes(block)
+    expect(gatewayBlockBroker.retrieve.calledWith(cid)).to.be.true()
+  })
+
+  it('gets many blocks from gatewayBlockBroker when they are not in the blockstore', async () => {
+    const count = 5
+
+    for (let i = 0; i < count; i++) {
+      const { cid, block } = blocks[i]
+      gatewayBlockBroker.retrieve.withArgs(cid, Sinon.match.any).resolves(block)
+
+      expect(await blockstore.has(cid)).to.be.false()
+    }
+
+    const retrieved = await all(storage.getMany(async function * () {
+      for (let i = 0; i < count; i++) {
+        yield blocks[i].cid
+        await delay(10)
+      }
+    }()))
+
+    expect(retrieved).to.deep.equal(new Array(count).fill(0).map((_, i) => blocks[i]))
+
+    for (let i = 0; i < count; i++) {
+      const { cid } = blocks[i]
+      expect(gatewayBlockBroker.retrieve.calledWith(cid)).to.be.true()
+      expect(await blockstore.has(cid)).to.be.true()
+    }
+  })
+
+  it('gets some blocks from gatewayBlockBroker when they are not in the blockstore', async () => {
+    const count = 5
+
+    // blocks 0,1,3,4 are in the blockstore
+    await blockstore.put(blocks[0].cid, blocks[0].block)
+    await blockstore.put(blocks[1].cid, blocks[1].block)
+    await blockstore.put(blocks[3].cid, blocks[3].block)
+    await blockstore.put(blocks[4].cid, blocks[4].block)
+
+    // block #2 comes from gatewayBlockBroker but slowly
+    gatewayBlockBroker.retrieve.withArgs(blocks[2].cid).callsFake(async () => {
+      await delay(100)
+      return blocks[2].block
+    })
+
+    const retrieved = await all(storage.getMany(async function * () {
+      for (let i = 0; i < count; i++) {
+        yield blocks[i].cid
+        await delay(10)
+      }
+    }()))
+
+    expect(retrieved).to.deep.equal(new Array(count).fill(0).map((_, i) => blocks[i]))
+
+    for (let i = 0; i < count; i++) {
+      expect(await blockstore.has(blocks[i].cid)).to.be.true()
+    }
+  })
+
+  it('handles incorrect bytes from a gateway', async () => {
+    const { cid } = blocks[0]
+    const block = blocks[1].block
+    storage = new NetworkedStorage({
+      blockstore,
+      logger: defaultLogger()
+    }, {
+      blockBrokers: [
+        gatewayBlockBroker
+      ],
+      hashers: defaultHashers()
+    })
+
+    gatewayBlockBroker.retrieve.withArgs(cid, Sinon.match.any).resolves(block)
+
+    expect(await blockstore.has(cid)).to.be.false()
+
+    try {
+      await storage.get(cid)
+      throw new Error('should have thrown')
+    } catch (err) {
+      const error = err as AggregateError & { errors: Error & { code: string } }
+      expect(error).to.be.an('error')
+      expect(error.errors).to.be.an('array').with.lengthOf(1)
+      expect(error.errors[0]).to.be.an('error').with.property('code', 'ERR_HASH_MISMATCH')
+    }
+  })
+})
diff --git a/packages/helia/test/block-brokers/trustless-gateway.spec.ts b/packages/helia/test/block-brokers/trustless-gateway.spec.ts
new file mode 100644
index 000000000..2b1af781e
--- /dev/null
+++ b/packages/helia/test/block-brokers/trustless-gateway.spec.ts
@@ -0,0 +1,153 @@
+/* eslint-env mocha */
+
+import { defaultLogger } from '@libp2p/logger'
+import { expect } from 'aegir/chai'
+import * as raw from 'multiformats/codecs/raw'
+import Sinon from 'sinon'
+import { type StubbedInstance, stubConstructor } from 'sinon-ts'
+import { TrustlessGatewayBlockBroker } from '../../src/block-brokers/trustless-gateway/broker.js'
+import { TrustlessGateway } from '../../src/block-brokers/trustless-gateway/trustless-gateway.js'
+import { createBlock } from '../fixtures/create-block.js'
+import type { BlockRetriever } from '@helia/interface/blocks'
+import type { CID } from 'multiformats/cid'
+
+describe('trustless-gateway-block-broker', () => {
+  let blocks: Array<{ cid: CID, block: Uint8Array }>
+  let gatewayBlockBroker: BlockRetriever
+  let gateways: Array<StubbedInstance<TrustlessGateway>>
+
+  // take a Record<gatewayIndex, (gateway: StubbedInstance<TrustlessGateway>) => void> and stub the gateways
+  // Record.default is the default handler
+  function stubGateways (handlers: Record<number, (gateway: StubbedInstance<TrustlessGateway>, index?: number) => void> & { default(gateway: StubbedInstance<TrustlessGateway>, index: number): void }): void {
+    for (let i = 0; i < gateways.length; i++) {
+      if (handlers[i] != null) {
+        handlers[i](gateways[i])
+        continue
+      }
+      handlers.default(gateways[i], i)
+    }
+  }
+
+  beforeEach(async () => {
+    blocks = []
+
+    for (let i = 0; i < 10; i++) {
+      blocks.push(await createBlock(raw.code, Uint8Array.from([0, 1, 2, i])))
+    }
+
+    gateways = [
+      stubConstructor(TrustlessGateway, 'http://localhost:8080'),
+      stubConstructor(TrustlessGateway, 'http://localhost:8081'),
+      stubConstructor(TrustlessGateway, 'http://localhost:8082'),
+      stubConstructor(TrustlessGateway, 'http://localhost:8083')
+    ]
+    gatewayBlockBroker = new TrustlessGatewayBlockBroker({
+      logger: defaultLogger()
+    })
+    // must copy the array because the broker calls .sort which mutates in-place
+    ;(gatewayBlockBroker as any).gateways = [...gateways]
+  })
+
+  it('tries all gateways before failing', async () => {
+    // stub all gateway responses to fail
+    for (const gateway of gateways) {
+      gateway.getRawBlock.rejects(new Error('failed'))
+    }
+
+    await expect(gatewayBlockBroker.retrieve(blocks[0].cid))
+      .to.eventually.be.rejected()
+      .with.property('errors')
+      .with.lengthOf(gateways.length)
+
+    for (const gateway of gateways) {
+      expect(gateway.getRawBlock.calledWith(blocks[0].cid)).to.be.true()
+    }
+  })
+
+  it('prioritizes gateways based on reliability', async () => {
+    const callOrder: number[] = []
+
+    // stub all gateway responses to fail, and set reliabilities to known values.
+    stubGateways({
+      default: (gateway, i) => {
+        gateway.getRawBlock.withArgs(blocks[1].cid, Sinon.match.any).callsFake(async () => {
+          callOrder.push(i)
+          throw new Error('failed')
+        })
+        gateway.reliability.returns(i) // known reliability of 0, 1, 2, 3
+      }
+    })
+
+    await expect(gatewayBlockBroker.retrieve(blocks[1].cid)).to.eventually.be.rejected()
+
+    // all gateways were called
+    expect(gateways[0].getRawBlock.calledWith(blocks[1].cid)).to.be.true()
+    expect(gateways[1].getRawBlock.calledWith(blocks[1].cid)).to.be.true()
+    expect(gateways[2].getRawBlock.calledWith(blocks[1].cid)).to.be.true()
+    expect(gateways[3].getRawBlock.calledWith(blocks[1].cid)).to.be.true()
+    // and in the correct order.
+    expect(callOrder).to.have.ordered.members([3, 2, 1, 0])
+  })
+
+  it('tries other gateways if it receives invalid blocks', async () => {
+    const { cid: cid1, block: block1 } = blocks[0]
+    const { block: block2 } = blocks[1]
+    stubGateways({
+      // return valid block for only one gateway
+      0: (gateway) => {
+        gateway.getRawBlock.withArgs(cid1, Sinon.match.any).resolves(block1)
+        gateway.reliability.returns(0) // make sure it's called last
+      },
+      // return invalid blocks for all other gateways
+      default: (gateway) => { // default stub function
+        gateway.getRawBlock.withArgs(cid1, Sinon.match.any).resolves(block2) // invalid block for the CID
+        gateway.reliability.returns(1) // make sure other gateways are called first
+      }
+    })
+
+    const block = await gatewayBlockBroker.retrieve(cid1, {
+      validateFn: async (block) => {
+        if (block !== block1) {
+          throw new Error('invalid block')
+        }
+      }
+    })
+    expect(block).to.equal(block1)
+
+    // expect that all gateways are called, because everyone returned invalid blocks except the last one
+    for (const gateway of gateways) {
+      expect(gateway.getRawBlock.calledWith(cid1, Sinon.match.any)).to.be.true()
+    }
+  })
+
+  it('does not call other gateways if the first gateway returns a valid block', async () => {
+    const { cid: cid1, block: block1 } = blocks[0]
+    const { block: block2 } = blocks[1]
+
+    stubGateways({
+      // return valid block for only one gateway
+      3: (gateway) => {
+        gateway.getRawBlock.withArgs(cid1, Sinon.match.any).resolves(block1)
+        gateway.reliability.returns(1) // make sure it's called first
+      },
+      // return invalid blocks for all other gateways
+      default: (gateway) => { // default stub function
+        gateway.getRawBlock.withArgs(cid1, Sinon.match.any).resolves(block2) // invalid block for the CID
+        gateway.reliability.returns(0) // make sure other gateways are called last
+      }
+    })
+    const block = await gatewayBlockBroker.retrieve(cid1, {
+      validateFn: async (block) => {
+        if (block !== block1) {
+          throw new Error('invalid block')
+        }
+      }
+    })
+    expect(block).to.equal(block1)
+    expect(gateways[3].getRawBlock.calledWith(cid1, Sinon.match.any)).to.be.true()
+    // expect that other gateways are not called, because the first gateway returned a valid block
+    expect(gateways[0].getRawBlock.calledWith(cid1, Sinon.match.any)).to.be.false()
+    expect(gateways[1].getRawBlock.calledWith(cid1, Sinon.match.any)).to.be.false()
+    expect(gateways[2].getRawBlock.calledWith(cid1, Sinon.match.any)).to.be.false()
+  })
+})
diff --git a/packages/helia/test/factory.spec.ts b/packages/helia/test/factory.spec.ts
index 4e86b65c0..a7de67403 100644
--- a/packages/helia/test/factory.spec.ts
+++ b/packages/helia/test/factory.spec.ts
@@ -1,10 +1,11 @@
 /* eslint-env mocha */
 
+import { identify } from '@libp2p/identify'
 import { webSockets } from '@libp2p/websockets'
 import { expect } from 'aegir/chai'
+import { MemoryDatastore } from 'datastore-core'
 import { Key } from 'interface-datastore'
 import { createLibp2p } from 'libp2p'
-import { identifyService } from 'libp2p/identify'
 import { CID } from 'multiformats/cid'
 import { createHelia } from '../src/index.js'
 import type { Helia } from '@helia/interface'
@@ -23,7 +24,7 @@ describe('helia factory', () => {
       start: false
     })
 
-    expect(helia.libp2p.isStarted()).to.be.false()
+    expect(helia.libp2p.status).to.equal('stopped')
   })
 
   it('does not require any constructor args', async () => {
@@ -42,11 +43,8 @@ describe('helia factory', () => {
   it('adds helia details to the AgentVersion', async () => {
     helia = await createHelia()
 
-    const peer = await helia.libp2p.peerStore.get(helia.libp2p.peerId)
-    const agentVersionBuf = peer.metadata.get('AgentVersion')
-    const agentVersion = new TextDecoder().decode(agentVersionBuf)
-
-    expect(agentVersion).to.include('helia/')
+    expect(helia).to.have.nested.property('libp2p.services.identify.host.agentVersion')
+      .that.includes('helia/')
   })
 
   it('does not add helia details to the AgentVersion when it has been overridden', async () => {
@@ -56,18 +54,15 @@ describe('helia factory', () => {
           webSockets()
         ],
         services: {
-          identity: identifyService({
+          identify: identify({
             agentVersion: 'my custom agent version'
           })
         }
       })
     })
 
-    const peer = await helia.libp2p.peerStore.get(helia.libp2p.peerId)
-    const agentVersionBuf = peer.metadata.get('AgentVersion')
-    const agentVersion = new TextDecoder().decode(agentVersionBuf)
-
-    expect(agentVersion).to.not.include('helia/')
+    expect(helia).to.have.nested.property('libp2p.services.identify.host.agentVersion')
+      .that.does.not.include('helia/')
   })
 
   it('does not add helia details to the AgentVersion when identify is not configured', async () => {
@@ -84,4 +79,26 @@ describe('helia factory', () => {
 
     expect(agentVersionBuf).to.be.undefined()
   })
+
+  it('reuses peer id if reusing datastore', async () => {
+    const datastore = new MemoryDatastore()
+
+    helia = await createHelia({
+      datastore,
+      start: false
+    })
+
+    const peerId = helia.libp2p.peerId
+
+    await helia.stop()
+
+    await createHelia({
+      datastore,
+      start: false
+    })
+
+    const otherPeerId = helia.libp2p.peerId
+
+    expect(peerId.toString()).to.equal(otherPeerId.toString())
+  })
 })
diff --git a/packages/helia/test/fixtures/create-helia.ts b/packages/helia/test/fixtures/create-helia.ts
index a8a0dd53f..1ac670e4c 100644
--- a/packages/helia/test/fixtures/create-helia.ts
+++ b/packages/helia/test/fixtures/create-helia.ts
@@ -1,12 +1,16 @@
+import { circuitRelayTransport } from '@libp2p/circuit-relay-v2'
+import { identify } from '@libp2p/identify'
 import { webSockets } from '@libp2p/websockets'
 import * as Filters from '@libp2p/websockets/filters'
-import { circuitRelayTransport } from 'libp2p/circuit-relay'
-import { identifyService } from 'libp2p/identify'
+import { bitswap } from '../../src/block-brokers/index.js'
 import { createHelia as createNode } from '../../src/index.js'
 import type { Helia } from '@helia/interface'
 
 export async function createHelia (): Promise<Helia> {
   return createNode({
+    blockBrokers: [
+      bitswap()
+    ],
     libp2p: {
       addresses: {
         listen: [
@@ -23,7 +27,7 @@ export async function createHelia (): Promise<Helia> {
         denyDialMultiaddr: async () => false
       },
       services: {
-        identify: identifyService()
+        identify: identify()
       }
     }
   })
diff --git a/packages/helia/test/index.spec.ts b/packages/helia/test/index.spec.ts
index d70d041b9..56dfd1901 100644
--- a/packages/helia/test/index.spec.ts
+++ b/packages/helia/test/index.spec.ts
@@ -37,11 +37,11 @@ describe('helia', () => {
   })
 
   it('stops and starts', async () => {
-    expect(helia.libp2p.isStarted()).to.be.true()
+    expect(helia.libp2p.status).to.equal('started')
 
     await helia.stop()
 
-    expect(helia.libp2p.isStarted()).to.be.false()
+    expect(helia.libp2p.status).to.equal('stopped')
   })
 
   it('should have a blockstore', async () => {
diff --git a/packages/helia/test/pins.depth-limited.spec.ts b/packages/helia/test/pins.depth-limited.spec.ts
index 96a766896..a74356452 100644
--- a/packages/helia/test/pins.depth-limited.spec.ts
+++ b/packages/helia/test/pins.depth-limited.spec.ts
@@ -29,6 +29,7 @@ describe('pins (depth limited)', () => {
     dag = await createDag(codec, blockstore, MAX_DEPTH, 3)
 
     helia = await createHelia({
+      blockBrokers: [],
       datastore: new MemoryDatastore(),
       blockstore,
       libp2p: await createLibp2p({
diff --git a/packages/helia/test/pins.recursive.spec.ts b/packages/helia/test/pins.recursive.spec.ts
index dfab79a3e..8d2858dcf 100644
--- a/packages/helia/test/pins.recursive.spec.ts
+++ b/packages/helia/test/pins.recursive.spec.ts
@@ -27,6 +27,7 @@ describe('pins (recursive)', () => {
     dag = await createDag(codec, blockstore, 2, 3)
 
     helia = await createHelia({
+      blockBrokers: [],
       datastore: new MemoryDatastore(),
       blockstore,
       libp2p: await createLibp2p({
diff --git a/packages/helia/test/utils/networked-storage.spec.ts b/packages/helia/test/utils/networked-storage.spec.ts
index 8ce33f648..b40727382 100644
--- a/packages/helia/test/utils/networked-storage.spec.ts
+++ b/packages/helia/test/utils/networked-storage.spec.ts
@@ -1,5 +1,6 @@
 /* eslint-env mocha */
 
+import { defaultLogger } from '@libp2p/logger'
 import { expect } from 'aegir/chai'
 import { MemoryBlockstore } from 'blockstore-core'
 import delay from 'delay'
@@ -8,16 +9,17 @@ import drain from 'it-drain'
 import * as raw from 'multiformats/codecs/raw'
 import Sinon from 'sinon'
 import { type StubbedInstance, stubInterface } from 'sinon-ts'
+import { defaultHashers } from '../../src/utils/default-hashers.js'
 import { NetworkedStorage } from '../../src/utils/networked-storage.js'
 import { createBlock } from '../fixtures/create-block.js'
+import type { BlockAnnouncer, BlockRetriever } from '@helia/interface/blocks'
 import type { Blockstore } from 'interface-blockstore'
-import type { Bitswap } from 'ipfs-bitswap'
 import type { CID } from 'multiformats/cid'
 
-describe('storage', () => {
+describe('networked-storage', () => {
   let storage: NetworkedStorage
   let blockstore: Blockstore
-  let bitswap: StubbedInstance<Bitswap>
+  let bitswap: StubbedInstance<Required<BlockRetriever & BlockAnnouncer>>
   let blocks: Array<{ cid: CID, block: Uint8Array }>
 
   beforeEach(async () => {
@@ -28,9 +30,15 @@ describe('storage', () => {
     }
 
     blockstore = new MemoryBlockstore()
-    bitswap = stubInterface<Bitswap>()
-    storage = new NetworkedStorage(blockstore, {
-      bitswap
+    bitswap = stubInterface()
+    storage = new NetworkedStorage({
+      blockstore,
+      logger: defaultLogger()
+    }, {
+      blockBrokers: [
+        bitswap
+      ],
+      hashers: defaultHashers()
     })
   })
 
@@ -113,8 +121,7 @@ describe('storage', () => {
   it('gets a block from bitswap when it is not in the blockstore', async () => {
     const { cid, block } = blocks[0]
 
-    bitswap.isStarted.returns(true)
-    bitswap.want.withArgs(cid).resolves(block)
+    bitswap.retrieve.withArgs(cid).resolves(block)
 
     expect(await blockstore.has(cid)).to.be.false()
 
@@ -122,17 +129,15 @@ describe('storage', () => {
 
     expect(await blockstore.has(cid)).to.be.true()
     expect(returned).to.equalBytes(block)
-    expect(bitswap.want.called).to.be.true()
+    expect(bitswap.retrieve.called).to.be.true()
   })
 
   it('gets many blocks from bitswap when they are not in the blockstore', async () => {
-    bitswap.isStarted.returns(true)
-
     const count = 5
 
     for (let i = 0; i < count; i++) {
       const { cid, block } = blocks[i]
-      bitswap.want.withArgs(cid).resolves(block)
+      bitswap.retrieve.withArgs(cid).resolves(block)
 
       expect(await blockstore.has(cid)).to.be.false()
     }
@@ -148,14 +153,12 @@ describe('storage', () => {
 
     for (let i = 0; i < count; i++) {
       const { cid } = blocks[i]
-      expect(bitswap.want.calledWith(cid)).to.be.true()
+      expect(bitswap.retrieve.calledWith(cid)).to.be.true()
       expect(await blockstore.has(cid)).to.be.true()
     }
   })
 
   it('gets some blocks from bitswap when they are not in the blockstore', async () => {
-    bitswap.isStarted.returns(true)
-
     const count = 5
 
     // blocks 0,1,3,4 are in the blockstore
@@ -165,7 +168,7 @@ describe('storage', () => {
     await blockstore.put(blocks[4].cid, blocks[4].block)
 
     // block #2 comes from bitswap but slowly
-    bitswap.want.withArgs(blocks[2].cid).callsFake(async () => {
+    bitswap.retrieve.withArgs(blocks[2].cid).callsFake(async () => {
       await delay(100)
       return blocks[2].block
     })
diff --git a/packages/helia/typedoc.json b/packages/helia/typedoc.json
index f599dc728..a2b60d386 100644
--- a/packages/helia/typedoc.json
+++ b/packages/helia/typedoc.json
@@ -1,5 +1,8 @@
 {
   "entryPoints": [
-    "./src/index.ts"
-  ]
+    "./src/index.ts",
+    "./src/block-brokers/index.ts",
+    "./src/utils/default-hashers.ts"
+  ],
+  "includeVersion": true
 }
diff --git a/packages/interface/CHANGELOG.md b/packages/interface/CHANGELOG.md
index deb26512b..92c57b0f8 100644
--- a/packages/interface/CHANGELOG.md
+++ b/packages/interface/CHANGELOG.md
@@ -10,6 +10,14 @@
 
 * **dev:** bump aegir from 39.0.13 to 40.0.8 ([#198](https://github.com/ipfs/helia/issues/198)) ([4d75ecf](https://github.com/ipfs/helia/commit/4d75ecffb79e5177da35d3106e42dac7bc63153a))
 
+## [2.1.0](https://www.github.com/ipfs/helia/compare/interface-v2.0.0...interface-v2.1.0) (2023-11-06)
+
+
+### Features
+
+* configurable block brokers ([#280](https://www.github.com/ipfs/helia/issues/280)) ([0749cbf](https://www.github.com/ipfs/helia/commit/0749cbf99745ea6ab4363f1b5d635634ca0ddcfa))
+* GatewayBlockBroker prioritizes & tries all gateways ([#281](https://www.github.com/ipfs/helia/issues/281)) ([9bad21b](https://www.github.com/ipfs/helia/commit/9bad21bd59fe6d1ba4a137db5a46bd2ead5238c3))
+
 ## [2.0.0](https://www.github.com/ipfs/helia/compare/interface-v1.2.2...interface-v2.0.0) (2023-08-16)
 
 
diff --git a/packages/interface/README.md b/packages/interface/README.md
index fc8bc4c10..a2bbbc287 100644
--- a/packages/interface/README.md
+++ b/packages/interface/README.md
@@ -4,8 +4,6 @@
   </a>
 </p>
 
-# @helia/interface <!-- omit in toc -->
-
 [![ipfs.tech](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](https://ipfs.tech)
 [![Discuss](https://img.shields.io/discourse/https/discuss.ipfs.tech/posts.svg?style=flat-square)](https://discuss.ipfs.tech)
 [![codecov](https://img.shields.io/codecov/c/github/ipfs/helia.svg?style=flat-square)](https://codecov.io/gh/ipfs/helia)
@@ -13,13 +11,6 @@
 
 > The Helia API
 
-## Table of contents <!-- omit in toc -->
-
-- [Install](#install)
-- [API Docs](#api-docs)
-- [License](#license)
-- [Contribute](#contribute)
-
 ## Install
 
 ```console
diff --git a/packages/interface/package.json b/packages/interface/package.json
index 264aed96e..0f95da5d3 100644
--- a/packages/interface/package.json
+++ b/packages/interface/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@helia/interface",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "The Helia API",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia/tree/master/packages/interface#readme",
@@ -11,6 +11,10 @@
   "bugs": {
     "url": "https://github.com/ipfs/helia/issues"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "keywords": [
     "IPFS"
   ],
@@ -55,6 +59,7 @@
   "eslintConfig": {
     "extends": "ipfs",
     "parserOptions": {
+      "project": true,
       "sourceType": "module"
     }
   },
@@ -65,15 +70,15 @@
     "build": "aegir build"
   },
   "dependencies": {
-    "@libp2p/interface": "^0.1.1",
+    "@libp2p/interface": "^1.0.1",
     "interface-blockstore": "^5.0.0",
     "interface-datastore": "^8.0.0",
     "interface-store": "^5.0.1",
-    "ipfs-bitswap": "^19.0.0",
+    "ipfs-bitswap": "^20.0.0",
     "multiformats": "^12.0.1",
     "progress-events": "^1.0.0"
   },
   "devDependencies": {
-    "aegir": "^40.0.8"
+    "aegir": "^41.0.0"
   }
 }
diff --git a/packages/interface/src/blocks.ts b/packages/interface/src/blocks.ts
index b0d494068..0b8356ea1 100644
--- a/packages/interface/src/blocks.ts
+++ b/packages/interface/src/blocks.ts
@@ -1,4 +1,5 @@
 import type { Blockstore } from 'interface-blockstore'
+import type { AbortOptions } from 'interface-store'
 import type { BitswapNotifyProgressEvents, BitswapWantProgressEvents } from 'ipfs-bitswap'
 import type { CID } from 'multiformats/cid'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
@@ -10,31 +11,31 @@ export interface Pair {
 
 export type HasBlockProgressEvents =
   ProgressEvent<'blocks:put:duplicate', CID> |
-  ProgressEvent<'blocks:put:bitswap:notify', CID> |
+  ProgressEvent<'blocks:put:providers:notify', CID> |
   ProgressEvent<'blocks:put:blockstore:put', CID> |
   BitswapNotifyProgressEvents
 
 export type PutBlockProgressEvents =
   ProgressEvent<'blocks:put:duplicate', CID> |
-  ProgressEvent<'blocks:put:bitswap:notify', CID> |
+  ProgressEvent<'blocks:put:providers:notify', CID> |
   ProgressEvent<'blocks:put:blockstore:put', CID> |
   BitswapNotifyProgressEvents
 
 export type PutManyBlocksProgressEvents =
   ProgressEvent<'blocks:put-many:duplicate', CID> |
-  ProgressEvent<'blocks:put-many:bitswap:notify', CID> |
+  ProgressEvent<'blocks:put-many:providers:notify', CID> |
   ProgressEvent<'blocks:put-many:blockstore:put-many'> |
   BitswapNotifyProgressEvents
 
 export type GetBlockProgressEvents =
-  ProgressEvent<'blocks:get:bitswap:want', CID> |
+  ProgressEvent<'blocks:get:providers:want', CID> |
   ProgressEvent<'blocks:get:blockstore:get', CID> |
   ProgressEvent<'blocks:get:blockstore:put', CID> |
   BitswapWantProgressEvents
 
 export type GetManyBlocksProgressEvents =
   ProgressEvent<'blocks:get-many:blockstore:get-many'> |
-  ProgressEvent<'blocks:get-many:bitswap:want', CID> |
+  ProgressEvent<'blocks:get-many:providers:want', CID> |
   ProgressEvent<'blocks:get-many:blockstore:put', CID> |
   BitswapWantProgressEvents
 
@@ -61,3 +62,29 @@ ProgressOptions<DeleteBlockProgressEvents>, ProgressOptions<DeleteManyBlocksProg
 > {
 
 }
+
+export type BlockRetrievalOptions<GetProgressOptions extends ProgressOptions = ProgressOptions> = AbortOptions & GetProgressOptions & {
+  /**
+   * A function that blockBrokers should call prior to returning a block to ensure it can maintain control
+   * of the block request flow. e.g. TrustedGatewayBlockBroker will use this to ensure that the block
+   * is valid from one of the gateways before assuming it's work is done. If the block is not valid, it should try another gateway
+   * and WILL consider the gateway that returned the invalid blocks completely unreliable.
+   */
+  validateFn?(block: Uint8Array): Promise<void>
+}
+
+export interface BlockRetriever<GetProgressOptions extends ProgressOptions = ProgressOptions> {
+  /**
+   * Retrieve a block from a source
+   */
+  retrieve(cid: CID, options?: BlockRetrievalOptions<GetProgressOptions>): Promise<Uint8Array>
+}
+
+export interface BlockAnnouncer<NotifyProgressOptions extends ProgressOptions = ProgressOptions> {
+  /**
+   * Make a new block available to peers
+   */
+  announce(cid: CID, block: Uint8Array, options?: NotifyProgressOptions): void
+}
+
+export type BlockBroker = BlockRetriever | BlockAnnouncer
diff --git a/packages/interface/src/index.ts b/packages/interface/src/index.ts
index 305e96474..1173ff06b 100644
--- a/packages/interface/src/index.ts
+++ b/packages/interface/src/index.ts
@@ -1,7 +1,7 @@
 /**
  * @packageDocumentation
  *
- * The API defined by a Helia node
+ * The API defined by a {@link Helia} node
  *
  * @example
  *
@@ -16,7 +16,7 @@
 
 import type { Blocks } from './blocks.js'
 import type { Pins } from './pins.js'
-import type { Libp2p, AbortOptions } from '@libp2p/interface'
+import type { Libp2p, AbortOptions, ComponentLogger } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats/cid'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
@@ -47,20 +47,25 @@ export interface Helia<T = Libp2p> {
    */
   pins: Pins
 
+  /**
+   * A logging component that can be reused by consumers
+   */
+  logger: ComponentLogger
+
   /**
    * Starts the Helia node
    */
-  start: () => Promise<void>
+  start(): Promise<void>
 
   /**
    * Stops the Helia node
    */
-  stop: () => Promise<void>
+  stop(): Promise<void>
 
   /**
    * Remove any unpinned blocks from the blockstore
    */
-  gc: (options?: GCOptions) => Promise<void>
+  gc(options?: GCOptions): Promise<void>
 }
 
 export type GcEvents =
diff --git a/packages/interface/src/pins.ts b/packages/interface/src/pins.ts
index e416e10a2..54fe22da7 100644
--- a/packages/interface/src/pins.ts
+++ b/packages/interface/src/pins.ts
@@ -43,21 +43,21 @@ export interface Pins {
    * Pin a block in the blockstore. It will not be deleted
    * when garbage collection is run.
    */
-  add: (cid: CID, options?: AddOptions) => AsyncGenerator<() => Promise<CID>, Pin>
+  add(cid: CID, options?: AddOptions): AsyncGenerator<() => Promise<CID>, Pin>
 
   /**
    * Unpin the block that corresponds to the passed CID. The block will
    * be deleted when garbage collection is run.
    */
-  rm: (cid: CID, options?: RmOptions) => AsyncGenerator<() => Promise<CID>, Pin>
+  rm(cid: CID, options?: RmOptions): AsyncGenerator<() => Promise<CID>, Pin>
 
   /**
    * List all blocks that have been pinned.
    */
-  ls: (options?: LsOptions) => AsyncGenerator<Pin, void, undefined>
+  ls(options?: LsOptions): AsyncGenerator<Pin, void, undefined>
 
   /**
    * Return true if the passed CID is pinned
    */
-  isPinned: (cid: CID, options?: IsPinnedOptions) => Promise<boolean>
+  isPinned(cid: CID, options?: IsPinnedOptions): Promise<boolean>
 }
diff --git a/packages/interface/typedoc.json b/packages/interface/typedoc.json
index 7969f9cdb..8e1641fce 100644
--- a/packages/interface/typedoc.json
+++ b/packages/interface/typedoc.json
@@ -3,5 +3,6 @@
     "./src/index.ts",
     "./src/blocks.ts",
     "./src/pins.ts"
-  ]
+  ],
+  "includeVersion": true
 }
diff --git a/packages/interop/CHANGELOG.md b/packages/interop/CHANGELOG.md
index 009adfc5a..96f7e4d6a 100644
--- a/packages/interop/CHANGELOG.md
+++ b/packages/interop/CHANGELOG.md
@@ -1,5 +1,29 @@
 # Changelog
 
+## [1.1.0](https://www.github.com/ipfs/helia/compare/interop-v1.0.3...interop-v1.1.0) (2023-11-06)
+
+
+### Features
+
+* GatewayBlockBroker prioritizes & tries all gateways ([#281](https://www.github.com/ipfs/helia/issues/281)) ([9bad21b](https://www.github.com/ipfs/helia/commit/9bad21bd59fe6d1ba4a137db5a46bd2ead5238c3))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * devDependencies
+    * @helia/interface bumped from ^2.0.0 to ^2.1.0
+    * helia bumped from ^2.0.3 to ^2.1.0
+
+### [1.0.3](https://www.github.com/ipfs/helia/compare/interop-v1.0.2...interop-v1.0.3) (2023-09-18)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * devDependencies
+    * helia bumped from ^2.0.2 to ^2.0.3
+
 ### [1.0.2](https://www.github.com/ipfs/helia/compare/interop-v1.0.1...interop-v1.0.2) (2023-09-14)
 
 
diff --git a/packages/interop/README.md b/packages/interop/README.md
index be04f0d54..d2b3bb29c 100644
--- a/packages/interop/README.md
+++ b/packages/interop/README.md
@@ -4,8 +4,6 @@
   </a>
 </p>
 
-# @helia/interop <!-- omit in toc -->
-
 [![ipfs.tech](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](https://ipfs.tech)
 [![Discuss](https://img.shields.io/discourse/https/discuss.ipfs.tech/posts.svg?style=flat-square)](https://discuss.ipfs.tech)
 [![codecov](https://img.shields.io/codecov/c/github/ipfs/helia.svg?style=flat-square)](https://codecov.io/gh/ipfs/helia)
@@ -13,14 +11,6 @@
 
 > Interop tests for Helia
 
-## Table of contents <!-- omit in toc -->
-
-- [Install](#install)
-  - [Browser `<script>` tag](#browser-script-tag)
-- [API Docs](#api-docs)
-- [License](#license)
-- [Contribute](#contribute)
-
 ## Install
 
 ```console
@@ -35,10 +25,6 @@ Loading this module through a script tag will make it's exports available as `He
 <script src="https://unpkg.com/@helia/interop/dist/index.min.js"></script>
 ```
 
-## API Docs
-
-- <https://ipfs.github.io/helia/modules/_helia_interop.html>
-
 ## License
 
 Licensed under either of
diff --git a/packages/interop/package.json b/packages/interop/package.json
index 1c3f85637..588b54075 100644
--- a/packages/interop/package.json
+++ b/packages/interop/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@helia/interop",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Interop tests for Helia",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia/tree/master/packages/interop#readme",
@@ -11,6 +11,10 @@
   "bugs": {
     "url": "https://github.com/ipfs/helia/issues"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "keywords": [
     "IPFS"
   ],
@@ -31,6 +35,7 @@
   "eslintConfig": {
     "extends": "ipfs",
     "parserOptions": {
+      "project": true,
       "sourceType": "module"
     }
   },
@@ -48,22 +53,23 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "devDependencies": {
-    "@chainsafe/libp2p-noise": "^13.0.0",
-    "@chainsafe/libp2p-yamux": "^5.0.0",
-    "@helia/interface": "^2.0.0",
-    "@libp2p/tcp": "^8.0.2",
-    "@libp2p/websockets": "^7.0.2",
+    "@chainsafe/libp2p-noise": "^14.0.0",
+    "@chainsafe/libp2p-yamux": "^6.0.1",
+    "@helia/interface": "^2.1.0",
+    "@libp2p/identify": "^1.0.1",
+    "@libp2p/tcp": "^9.0.1",
+    "@libp2p/websockets": "^8.0.1",
     "@multiformats/sha3": "^3.0.0",
-    "aegir": "^40.0.8",
+    "aegir": "^41.0.0",
     "blockstore-core": "^4.0.0",
     "datastore-core": "^9.0.0",
-    "helia": "^2.0.2",
+    "helia": "^2.1.0",
     "ipfsd-ctl": "^13.0.0",
     "it-all": "^3.0.2",
     "it-to-buffer": "^4.0.1",
-    "kubo": "^0.22.0",
+    "kubo": "^0.24.0",
     "kubo-rpc-client": "^3.0.1",
-    "libp2p": "^0.46.6",
+    "libp2p": "^1.0.1",
     "multiformats": "^12.0.1"
   },
   "browser": {
diff --git a/packages/interop/test/fixtures/create-helia.browser.ts b/packages/interop/test/fixtures/create-helia.browser.ts
index 38864c445..6f42ff962 100644
--- a/packages/interop/test/fixtures/create-helia.browser.ts
+++ b/packages/interop/test/fixtures/create-helia.browser.ts
@@ -1,12 +1,13 @@
 import { noise } from '@chainsafe/libp2p-noise'
 import { yamux } from '@chainsafe/libp2p-yamux'
+import { identify } from '@libp2p/identify'
 import { webSockets } from '@libp2p/websockets'
 import { all } from '@libp2p/websockets/filters'
 import { MemoryBlockstore } from 'blockstore-core'
 import { MemoryDatastore } from 'datastore-core'
 import { createHelia, type HeliaInit } from 'helia'
+import { bitswap } from 'helia/block-brokers'
 import { createLibp2p } from 'libp2p'
-import { identifyService } from 'libp2p/identify'
 import type { Helia } from '@helia/interface'
 
 export async function createHeliaNode (init?: Partial<HeliaInit>): Promise<Helia> {
@@ -28,7 +29,7 @@ export async function createHeliaNode (init?: Partial<HeliaInit>): Promise<Helia
     ],
     datastore,
     services: {
-      identify: identifyService()
+      identify: identify()
     },
     connectionGater: {
       // allow dialing loopback
@@ -38,6 +39,9 @@ export async function createHeliaNode (init?: Partial<HeliaInit>): Promise<Helia
 
   const helia = await createHelia({
     libp2p,
+    blockBrokers: [
+      bitswap()
+    ],
     blockstore,
     datastore,
     ...init
diff --git a/packages/interop/test/fixtures/create-helia.ts b/packages/interop/test/fixtures/create-helia.ts
index ed30023a3..c35504d34 100644
--- a/packages/interop/test/fixtures/create-helia.ts
+++ b/packages/interop/test/fixtures/create-helia.ts
@@ -1,11 +1,12 @@
 import { noise } from '@chainsafe/libp2p-noise'
 import { yamux } from '@chainsafe/libp2p-yamux'
+import { identify } from '@libp2p/identify'
 import { tcp } from '@libp2p/tcp'
 import { MemoryBlockstore } from 'blockstore-core'
 import { MemoryDatastore } from 'datastore-core'
 import { createHelia, type HeliaInit } from 'helia'
+import { bitswap } from 'helia/block-brokers'
 import { createLibp2p } from 'libp2p'
-import { identifyService } from 'libp2p/identify'
 import type { Helia } from '@helia/interface'
 
 export async function createHeliaNode (init?: Partial<HeliaInit>): Promise<Helia> {
@@ -29,12 +30,15 @@ export async function createHeliaNode (init?: Partial<HeliaInit>): Promise<Helia
     ],
     datastore,
     services: {
-      identify: identifyService()
+      identify: identify()
     }
   })
 
   const helia = await createHelia({
     libp2p,
+    blockBrokers: [
+      bitswap()
+    ],
     blockstore,
     datastore,
     ...init
diff --git a/typedoc.json b/typedoc.json
index b5cbc6721..ffab8cecf 100644
--- a/typedoc.json
+++ b/typedoc.json
@@ -1,4 +1,7 @@
 {
   "$schema": "https://typedoc.org/schema.json",
-  "name": "Helia"
+  "name": "Helia",
+  "exclude": [
+    "packages/interop"
+  ]
 }