diff --git a/packages/block-brokers/README.md b/packages/block-brokers/README.md
index f64ff74a..fd49ee6e 100644
--- a/packages/block-brokers/README.md
+++ b/packages/block-brokers/README.md
@@ -19,7 +19,7 @@ $ npm i @helia/block-brokers
 
 <!-- ### Browser `<script>` tag
 
-Loading this module through a script tag will make it's exports available as `bitswap` and `trustlessGateway` in the global namespace.
+Loading this module through a script tag will make it's exports available as `bitswap` and `trustlessGateway` and `NetworkedStorage` in the global namespace.
 
 ```html
 <script src="https://unpkg.com/@helia/block-brokers/dist/index.min.js"></script>
diff --git a/packages/block-brokers/src/index.ts b/packages/block-brokers/src/index.ts
index e7f503c9..004e98f0 100644
--- a/packages/block-brokers/src/index.ts
+++ b/packages/block-brokers/src/index.ts
@@ -1,2 +1,3 @@
 export { bitswap } from './bitswap.js'
 export { trustlessGateway } from './trustless-gateway/index.js'
+export { NetworkedStorage } from './utils/networked-storage.js'
diff --git a/packages/helia/src/helia.ts b/packages/helia/src/helia.ts
index c1a1f2d6..010cb7e9 100644
--- a/packages/helia/src/helia.ts
+++ b/packages/helia/src/helia.ts
@@ -1,4 +1,4 @@
-import { bitswap, trustlessGateway } from '@helia/block-brokers'
+import { bitswap, trustlessGateway, NetworkedStorage } from '@helia/block-brokers'
 import { start, stop } from '@libp2p/interface'
 import drain from 'it-drain'
 import { CustomProgressEvent } from 'progress-events'
@@ -6,7 +6,6 @@ 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'
diff --git a/packages/helia/src/utils/networked-storage.ts b/packages/helia/src/utils/networked-storage.ts
deleted file mode 100644
index f8e78b4b..00000000
--- a/packages/helia/src/utils/networked-storage.ts
+++ /dev/null
@@ -1,266 +0,0 @@
-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 { 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 { CID } from 'multiformats/cid'
-import type { MultihashHasher } from 'multiformats/hashes/interface'
-
-export interface NetworkedStorageStorageInit {
-  blockBrokers?: BlockBroker[]
-  hashers?: MultihashHasher[]
-}
-
-export interface GetOptions extends AbortOptions {
-  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, Startable {
-  private readonly child: Blockstore
-  private readonly blockRetrievers: BlockRetriever[]
-  private readonly blockAnnouncers: BlockAnnouncer[]
-  private readonly hashers: MultihashHasher[]
-  private started: boolean
-  private readonly log: Logger
-
-  /**
-   * Create a new BlockStorage
-   */
-  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 {
-    return this.child
-  }
-
-  /**
-   * Put a block to the underlying datastore
-   */
-  async put (cid: CID, block: Uint8Array, options: AbortOptions & ProgressOptions<PutBlockProgressEvents> = {}): Promise<CID> {
-    if (await this.child.has(cid)) {
-      options.onProgress?.(new CustomProgressEvent<CID>('blocks:put:duplicate', cid))
-      return cid
-    }
-
-    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))
-
-    return this.child.put(cid, block, options)
-  }
-
-  /**
-   * Put a multiple blocks to the underlying datastore
-   */
-  async * putMany (blocks: AwaitIterable<{ cid: CID, block: Uint8Array }>, options: AbortOptions & ProgressOptions<PutManyBlocksProgressEvents> = {}): AsyncIterable<CID> {
-    const missingBlocks = filter(blocks, async ({ cid }): Promise<boolean> => {
-      const has = await this.child.has(cid)
-
-      if (has) {
-        options.onProgress?.(new CustomProgressEvent<CID>('blocks:put-many:duplicate', cid))
-      }
-
-      return !has
-    })
-
-    const notifyEach = forEach(missingBlocks, ({ cid, block }): void => {
-      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'))
-    yield * this.child.putMany(notifyEach, options)
-  }
-
-  /**
-   * Get a block by cid
-   */
-  async get (cid: CID, options: GetOfflineOptions & AbortOptions & ProgressOptions<GetBlockProgressEvents> = {}): Promise<Uint8Array> {
-    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
-    }
-
-    options.onProgress?.(new CustomProgressEvent<CID>('blocks:get:blockstore:get', cid))
-
-    return this.child.get(cid, options)
-  }
-
-  /**
-   * Get multiple blocks back from an (async) iterable of cids
-   */
-  async * getMany (cids: AwaitIterable<CID>, options: GetOfflineOptions & AbortOptions & ProgressOptions<GetManyBlocksProgressEvents> = {}): AsyncIterable<Pair> {
-    options.onProgress?.(new CustomProgressEvent('blocks:get-many:blockstore:get-many'))
-
-    yield * this.child.getMany(forEach(cids, async (cid): Promise<void> => {
-      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)
-        })
-      }
-    }))
-  }
-
-  /**
-   * Delete a block from the blockstore
-   */
-  async delete (cid: CID, options: AbortOptions & ProgressOptions<DeleteBlockProgressEvents> = {}): Promise<void> {
-    options.onProgress?.(new CustomProgressEvent<CID>('blocks:delete:blockstore:delete', cid))
-
-    await this.child.delete(cid, options)
-  }
-
-  /**
-   * Delete multiple blocks from the blockstore
-   */
-  async * deleteMany (cids: AwaitIterable<CID>, options: AbortOptions & ProgressOptions<DeleteManyBlocksProgressEvents> = {}): AsyncIterable<CID> {
-    options.onProgress?.(new CustomProgressEvent('blocks:delete-many:blockstore:delete-many'))
-    yield * this.child.deleteMany((async function * (): AsyncGenerator<CID> {
-      for await (const cid of cids) {
-        yield cid
-      }
-    }()), options)
-  }
-
-  async has (cid: CID, options: AbortOptions = {}): Promise<boolean> {
-    return this.child.has(cid, options)
-  }
-
-  async * getAll (options: AbortOptions & ProgressOptions<GetAllBlocksProgressEvents> = {}): AsyncIterable<Pair> {
-    options.onProgress?.(new CustomProgressEvent('blocks:get-all:blockstore:get-many'))
-    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/utils/networked-storage.spec.ts b/packages/helia/test/utils/networked-storage.spec.ts
deleted file mode 100644
index b4072738..00000000
--- a/packages/helia/test/utils/networked-storage.spec.ts
+++ /dev/null
@@ -1,189 +0,0 @@
-/* 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 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 { CID } from 'multiformats/cid'
-
-describe('networked-storage', () => {
-  let storage: NetworkedStorage
-  let blockstore: Blockstore
-  let bitswap: StubbedInstance<Required<BlockRetriever & BlockAnnouncer>>
-  let blocks: Array<{ cid: CID, block: Uint8Array }>
-
-  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()
-    bitswap = stubInterface()
-    storage = new NetworkedStorage({
-      blockstore,
-      logger: defaultLogger()
-    }, {
-      blockBrokers: [
-        bitswap
-      ],
-      hashers: defaultHashers()
-    })
-  })
-
-  it('gets a block from the blockstore', async () => {
-    const { cid, block } = blocks[0]
-    await blockstore.put(cid, block)
-
-    const retrieved = await storage.get(cid)
-    expect(retrieved).to.equalBytes(block)
-  })
-
-  it('gets a block from the blockstore offline', async () => {
-    const { cid } = blocks[0]
-
-    await expect(storage.get(cid, {
-      offline: true
-    })).to.eventually.be.rejected.with.property('code', 'ERR_NOT_FOUND')
-  })
-
-  it('gets a block from the blockstore with progress', async () => {
-    const { cid, block } = blocks[0]
-    await blockstore.put(cid, block)
-
-    const onProgress = Sinon.stub()
-
-    await storage.get(cid, {
-      onProgress
-    })
-    expect(onProgress.called).to.be.true()
-  })
-
-  it('gets many blocks from the blockstore', async () => {
-    const count = 5
-
-    for (let i = 0; i < count; i++) {
-      const { cid, block } = blocks[i]
-      await blockstore.put(cid, 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]))
-  })
-
-  it('gets many blocks from the blockstore offline', async () => {
-    const { cid } = blocks[0]
-
-    await expect(drain(storage.getMany([cid], {
-      offline: true
-    }))).to.eventually.be.rejected.with.property('code', 'ERR_NOT_FOUND')
-  })
-
-  it('puts a block into the blockstore', async () => {
-    const { cid, block } = blocks[0]
-    await storage.put(cid, block)
-
-    const retrieved = await blockstore.get(cid)
-    expect(retrieved).to.equalBytes(block)
-  })
-
-  it('puts many blocks into the blockstore', async () => {
-    const count = 5
-
-    await drain(storage.putMany(async function * () {
-      for (let i = 0; i < count; i++) {
-        yield { cid: blocks[i].cid, block: blocks[i].block }
-        await delay(10)
-      }
-    }()))
-
-    const retrieved = await all(blockstore.getMany(new Array(count).fill(0).map((_, i) => blocks[i].cid)))
-    expect(retrieved).to.deep.equal(retrieved)
-  })
-
-  it('gets a block from bitswap when it is not in the blockstore', async () => {
-    const { cid, block } = blocks[0]
-
-    bitswap.retrieve.withArgs(cid).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(bitswap.retrieve.called).to.be.true()
-  })
-
-  it('gets many blocks from bitswap when they are not in the blockstore', async () => {
-    const count = 5
-
-    for (let i = 0; i < count; i++) {
-      const { cid, block } = blocks[i]
-      bitswap.retrieve.withArgs(cid).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(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 () => {
-    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 bitswap but slowly
-    bitswap.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()
-    }
-  })
-})