@helia/utils 2.5.2-ae98a4f4 → 2.5.2-ed6c3b79

package/src/errors.ts

@@ -32,3 +32,8 @@ export class BlockNotFoundWhileOfflineError extends Error {
   static name = 'BlockNotFoundWhileOfflineError'
   name = 'BlockNotFoundWhileOfflineError'
 }
+
+export class DecryptionFailedError extends Error {
+  static name = 'DecryptionFailedError'
+  name = 'DecryptionFailedError'
+}

package/src/index.ts

@@ -5,8 +5,12 @@
  * modules such as `helia`, `@helia/http`, etc.
  */
 
-import { contentRoutingSymbol, peerRoutingSymbol, start, stop, TypedEventEmitter } from '@libp2p/interface'
+import { keychain } from '@ipshipyard/keychain'
+import { start, stop, TypedEventEmitter } from '@libp2p/interface'
 import { dns } from '@multiformats/dns'
+import { defaultLogger } from 'birnam'
+import { MemoryBlockstore } from 'blockstore-core'
+import { MemoryDatastore } from 'datastore-core'
 import drain from 'it-drain'
 import { CustomProgressEvent } from 'progress-events'
 import { PinsImpl } from './pins.ts'
@@ -14,18 +18,18 @@ import { Routing as RoutingClass } from './routing.ts'
 import { BlockStorage } from './storage.ts'
 import { assertDatastoreVersionIsCurrent } from './utils/datastore-version.ts'
 import { getCodec } from './utils/get-codec.ts'
+import { getCrypto } from './utils/get-crypto.ts'
 import { getHasher } from './utils/get-hasher.ts'
 import { NetworkedStorage } from './utils/networked-storage.ts'
 import type { BlockStorageInit } from './storage.ts'
-import type { Await, CodecLoader, GCOptions, HasherLoader, Helia as HeliaInterface, HeliaEvents, Routing } from '@helia/interface'
+import type { CodecLoader, GCOptions, HasherLoader, Helia as HeliaInterface, HeliaEvents, Routing, CryptoLoader, Crypto, NodeInfo, Router, HeliaMixin } from '@helia/interface'
 import type { BlockBroker } from '@helia/interface/blocks'
 import type { Pins } from '@helia/interface/pins'
-import type { ComponentLogger, ContentRouting, Libp2p, Logger, Metrics, PeerRouting } from '@libp2p/interface'
-import type { KeychainInit } from '@libp2p/keychain'
+import type { Keychain, KeychainInit } from '@ipshipyard/keychain'
+import type { ComponentLogger, Logger, Metrics } from '@libp2p/interface'
 import type { DNS } from '@multiformats/dns'
 import type { Blockstore } from 'interface-blockstore'
 import type { Datastore } from 'interface-datastore'
-import type { Libp2pOptions } from 'libp2p'
 import type { BlockCodec } from 'multiformats'
 import type { CID } from 'multiformats/cid'
 import type { MultihashHasher } from 'multiformats/hashes/interface'
@@ -33,6 +37,8 @@ import type { MultihashHasher } from 'multiformats/hashes/interface'
 export { AbstractSession } from './abstract-session.ts'
 export type { AbstractCreateSessionOptions, BlockstoreSessionEvents, AbstractSessionComponents } from './abstract-session.ts'
 
+export { isCID } from './utils/is-cid.ts'
+
 export type { BlockStorage, BlockStorageInit }
 
 export { breadthFirstWalker, depthFirstWalker, naturalOrderWalker } from './graph-walker.ts'
@@ -41,26 +47,7 @@ export type { GraphWalkerComponents, GraphWalkerInit, GraphNode, GraphWalker } f
 /**
  * Options used to create a Helia node.
  */
-export interface HeliaInit<T extends Libp2p = Libp2p> {
-  /**
-   * A libp2p node is required to perform network operations. Either a
-   * pre-configured node or options to configure a node can be passed
-   * here.
-   *
-   * If node options are passed, they will be merged with the default
-   * config for the current platform. In this case all passed config
-   * keys will replace those from the default config.
-   *
-   * The libp2p `start` option is not supported, instead please pass `start` in
-   * the root of the HeliaInit object.
-   */
-  libp2p: T | Omit<Libp2pOptions<any>, 'start'>
-
-  /**
-   * Pass `false` to not start the Helia node
-   */
-  start?: boolean
-
+export interface HeliaInit {
   /**
    * By default Helia stores the node's PeerId in an encrypted form in a
    * libp2p keystore. These options control how that keystore is configured.
@@ -70,12 +57,12 @@ export interface HeliaInit<T extends Libp2p = Libp2p> {
   /**
    * The blockstore is where blocks are stored
    */
-  blockstore: Blockstore
+  blockstore?: Blockstore
 
   /**
    * The datastore is where data is stored
    */
-  datastore: Datastore
+  datastore?: Datastore
 
   /**
    * By default sha256, sha512 and identity hashes are supported for
@@ -88,7 +75,7 @@ export interface HeliaInit<T extends Libp2p = Libp2p> {
    * An optional function that can load a MultihashHasher on demand. May return
    * a promise.
    */
-  loadHasher?(code: number): Await<MultihashHasher>
+  loadHasher?(code: number): MultihashHasher | Promise<MultihashHasher>
 
   /**
    * In order to pin CIDs that correspond to a DAG, it's necessary to know
@@ -101,13 +88,17 @@ export interface HeliaInit<T extends Libp2p = Libp2p> {
    * An optional function that can load a BlockCodec on demand. May return a
    * promise.
    */
-  loadCodec?(code: number): Await<BlockCodec<any, any>>
+  loadCodec?(code: number): BlockCodec<any, any> | Promise<BlockCodec<any, any>>
 
   /**
-   * A list of strategies used to fetch blocks when they are not present in
-   * the local blockstore
+   * A list of pre-supported public/private key implementations
    */
-  blockBrokers: Array<(components: any) => BlockBroker>
+  cryptos?: Array<Crypto>
+
+  /**
+   * Dynamically load a cryptography implementation
+   */
+  loadCrypto?: CryptoLoader
 
   /**
    * Garbage collection requires preventing blockstore writes during searches
@@ -131,11 +122,17 @@ export interface HeliaInit<T extends Libp2p = Libp2p> {
    */
   logger?: ComponentLogger
 
+  /**
+   * A list of strategies used to fetch blocks when they are not present in
+   * the local blockstore
+   */
+  blockBrokers?: Array<BlockBroker | ((components: any) => BlockBroker)>
+
   /**
    * Routers perform operations such as looking up content providers,
    * information about network peers or getting/putting records.
    */
-  routers?: Array<Partial<Routing> | ((components: any) => Partial<Routing>)>
+  routers?: Array<Router | ((components: any) => Router)>
 
   /**
    * During provider lookups, peers can be returned from routing implementations
@@ -180,58 +177,72 @@ export interface HeliaInit<T extends Libp2p = Libp2p> {
 }
 
 interface Components {
-  libp2p: Libp2p
   blockstore: Blockstore
   datastore: Datastore
   logger: ComponentLogger
   blockBrokers: BlockBroker[]
   routing: Routing
   dns: DNS
+  keychain: Keychain
   metrics?: Metrics
   getCodec: CodecLoader
   getHasher: HasherLoader
+  getCrypto: CryptoLoader
 }
 
-export class Helia<T extends Libp2p> implements HeliaInterface<T> {
-  public libp2p: T
+export class Helia implements HeliaInterface {
+  public info: NodeInfo
   public blockstore: BlockStorage
   public datastore: Datastore
-  public events: TypedEventEmitter<HeliaEvents<T>>
+  public events: TypedEventEmitter<HeliaEvents<this>>
   public pins: Pins
   public logger: ComponentLogger
-  public routing: Routing
+  public routing: RoutingClass
   public getCodec: CodecLoader
   public getHasher: HasherLoader
+  public getCrypto: CryptoLoader
   public dns: DNS
+  public keychain: Keychain
   public metrics?: Metrics
+  public status: 'stopped' | 'stopping' | 'starting' | 'started'
   private readonly log: Logger
+  private readonly blockBrokers: BlockBroker[]
+  private readonly mixins: HeliaMixin[]
 
-  constructor (init: Omit<HeliaInit, 'start' | 'libp2p'> & { libp2p: T }) {
-    this.logger = init.logger ?? init.libp2p.logger
+  constructor (init: HeliaInit & { name: string, version: string }) {
+    this.info = {
+      name: init.name,
+      version: init.version
+    }
+    this.logger = init.logger ?? defaultLogger()
     this.log = this.logger.forComponent('helia')
     this.getHasher = getHasher(init.hashers, init.loadHasher)
     this.getCodec = getCodec(init.codecs, init.loadCodec)
+    this.getCrypto = getCrypto(init.cryptos, init.loadCrypto)
     this.dns = init.dns ?? dns()
     this.metrics = init.metrics
-    this.libp2p = init.libp2p
-    this.events = new TypedEventEmitter<HeliaEvents<T>>()
+    this.events = new TypedEventEmitter<HeliaEvents<typeof this>>()
+    this.status = 'stopped'
+    this.mixins = []
 
-    // @ts-expect-error routing is not set
+    // @ts-expect-error routing and keychain are not set
     const components: Components = {
-      blockstore: init.blockstore,
-      datastore: init.datastore,
+      blockstore: init.blockstore ?? new MemoryBlockstore(),
+      datastore: init.datastore ?? new MemoryDatastore(),
       logger: this.logger,
-      libp2p: this.libp2p,
       blockBrokers: [],
       getHasher: this.getHasher,
       getCodec: this.getCodec,
+      getCrypto: this.getCrypto,
       dns: this.dns,
       metrics: this.metrics,
       ...(init.components ?? {})
     }
 
+    this.keychain = components.keychain = keychain()(components)
+
     this.routing = components.routing = new RoutingClass(components, {
-      routers: (init.routers ?? []).flatMap((router: Partial<Routing> | ((components: any) => Partial<Routing>)) => {
+      routers: (init.routers ?? []).flatMap((router: Router | ((components: any) => Router)) => {
         if (typeof router === 'function') {
           router = router(components)
         }
@@ -241,54 +252,86 @@ export class Helia<T extends Libp2p> implements HeliaInterface<T> {
           router
         ]
 
-        // if the router provides a libp2p-style ContentRouter
-        const contentRouting = asContentRouting(router)
-        if (contentRouting != null) {
-          routers.push(contentRouting)
-        }
-
-        // if the router provides a libp2p-style PeerRouter
-        const peerRouting = asPeerRouting(router)
-        if (peerRouting != null) {
-          routers.push(peerRouting)
-        }
-
         return routers
       }),
       providerLookupConcurrency: init.providerLookupConcurrency
     })
 
-    components.blockBrokers = init.blockBrokers.map((fn) => {
-      return fn(components)
+    this.blockBrokers = components.blockBrokers = (init.blockBrokers ?? []).map((broker) => {
+      if (typeof broker === 'function') {
+        broker = broker(components)
+      }
+
+      return broker
     })
 
     const networkedStorage = new NetworkedStorage(components, init)
-    this.pins = new PinsImpl(init.datastore, networkedStorage, this.getCodec)
+    this.pins = new PinsImpl(components.datastore, networkedStorage, this.getCodec)
     this.blockstore = new BlockStorage(networkedStorage, this.pins, this.routing, {
       holdGcLock: init.holdGcLock ?? true
     })
-    this.datastore = init.datastore
+    this.datastore = components.datastore
+  }
+
+  hasRouter (name: string): boolean {
+    return this.routing.hasRouter(name)
   }
 
-  async start (): Promise<void> {
+  addRouter (router: Router): void {
+    this.routing.addRouter(router)
+  }
+
+  hasBlockBroker (name: string): boolean {
+    return this.blockBrokers.findIndex(b => b.name === name) !== -1
+  }
+
+  addBlockBroker (blockBroker: BlockBroker): void {
+    this.blockBrokers.push(blockBroker)
+  }
+
+  addMixin (mixin: HeliaMixin): void {
+    this.mixins.push(mixin)
+  }
+
+  async start (): Promise<this> {
+    this.status = 'starting'
+
     await assertDatastoreVersionIsCurrent(this.datastore)
     await start(
       this.blockstore,
       this.datastore,
       this.routing,
-      this.libp2p
+      ...this.blockBrokers
     )
+
+    for (const mixin of this.mixins) {
+      await mixin.start?.(this)
+    }
+
+    this.status = 'started'
     this.events.dispatchEvent(new CustomEvent('start', { detail: this }))
+
+    return this
   }
 
-  async stop (): Promise<void> {
+  async stop (): Promise<this> {
+    this.status = 'stopping'
+
+    for (const mixin of this.mixins) {
+      await mixin.stop?.(this)
+    }
+
     await stop(
       this.blockstore,
       this.datastore,
       this.routing,
-      this.libp2p
+      ...this.blockBrokers
     )
+
+    this.status = 'stopped'
     this.events.dispatchEvent(new CustomEvent('stop', { detail: this }))
+
+    return this
   }
 
   async gc (options: GCOptions = {}): Promise<void> {
@@ -323,11 +366,3 @@ export class Helia<T extends Libp2p> implements HeliaInterface<T> {
     this.log('gc finished')
   }
 }
-
-function asContentRouting (obj?: any): ContentRouting | undefined {
-  return obj?.[contentRoutingSymbol]
-}
-
-function asPeerRouting (obj?: any): PeerRouting | undefined {
-  return obj?.[peerRoutingSymbol]
-}

package/src/routing.ts

@@ -1,18 +1,19 @@
 import { NoRoutersAvailableError } from '@helia/interface'
 import { NotFoundError, start, stop } from '@libp2p/interface'
-import { PeerQueue } from '@libp2p/utils'
+import { Queue } from '@libp2p/utils'
 import merge from 'it-merge'
 import { CustomProgressEvent } from 'progress-events'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { GetFailedError } from './errors.ts'
-import type { Routing as RoutingInterface, Provider, RoutingOptions, RoutingFindProvidersProgressEvents, RoutingProvideProgressEvents, RoutingPutProgressEvents, RoutingGetProgressEvents, RoutingFindPeerProgressEvents, RoutingGetClosestPeersProgressEvents, RoutingCancelReprovideProgressEvents } from '@helia/interface'
-import type { ComponentLogger, Logger, Metrics, PeerId, PeerInfo, Startable } from '@libp2p/interface'
+import type { Routing as RoutingInterface, Provider, RoutingOptions, RoutingFindProvidersProgressEvents, RoutingProvideProgressEvents, RoutingPutProgressEvents, RoutingGetProgressEvents, RoutingFindPeerProgressEvents, RoutingGetClosestPeersProgressEvents, RoutingCancelReprovideProgressEvents, Router, Peer } from '@helia/interface'
+import type { ComponentLogger, Logger, Metrics, Startable } from '@libp2p/interface'
+import type { AbortOptions } from 'abort-error'
 import type { CID } from 'multiformats/cid'
 
 const DEFAULT_PROVIDER_LOOKUP_CONCURRENCY = 5
 
 export interface RoutingInit {
-  routers: Array<Partial<RoutingInterface>>
+  routers: Router[]
   providerLookupConcurrency?: number
 }
 
@@ -21,11 +22,15 @@ export interface RoutingComponents {
   metrics?: Metrics
 }
 
+interface PeerQueueOptions extends AbortOptions {
+  peer: CID
+}
+
 export class Routing implements RoutingInterface, Startable {
   public name: string
 
   private readonly log: Logger
-  private readonly routers: Array<Partial<RoutingInterface>>
+  private readonly routers: Router[]
   private readonly providerLookupConcurrency: number
 
   constructor (components: RoutingComponents, init: RoutingInit) {
@@ -65,6 +70,14 @@ export class Routing implements RoutingInterface, Startable {
     await stop(...this.routers)
   }
 
+  hasRouter (name: string): boolean {
+    return this.routers.findIndex(r => r.name === name) !== -1
+  }
+
+  addRouter (router: Router): void {
+    this.routers.push(router)
+  }
+
   /**
    * Iterates over all content routers in parallel to find providers of the
    * given key
@@ -78,7 +91,7 @@ export class Routing implements RoutingInterface, Startable {
     // back as an empty array - when this happens we have to do a FIND_PEER
     // query to get updated addresses, but we shouldn't block on this so use a
     // separate bounded queue to perform this lookup
-    const queue = new PeerQueue<Provider | null>({
+    const queue = new Queue<Provider | null, PeerQueueOptions>({
       concurrency: this.providerLookupConcurrency
     })
 
@@ -145,7 +158,7 @@ export class Routing implements RoutingInterface, Startable {
       // have to refresh peer info for this peer to get updated multiaddrs
       if (peer.multiaddrs.length === 0) {
         // already looking this peer up
-        if (queue.find(peer.id) != null) {
+        if (queue.queue.find(job => job.options.peer.equals(peer.id)) != null) {
           continue
         }
 
@@ -167,7 +180,7 @@ export class Routing implements RoutingInterface, Startable {
             return null
           }
         }, {
-          peerId: peer.id,
+          peer: peer.id,
           signal: options.signal
         })
           .catch(err => {
@@ -298,7 +311,7 @@ export class Routing implements RoutingInterface, Startable {
   /**
    * Iterates over all peer routers in parallel to find the given peer
    */
-  async findPeer (id: PeerId, options?: RoutingOptions<RoutingFindPeerProgressEvents>): Promise<PeerInfo> {
+  async findPeer (id: CID, options?: RoutingOptions<RoutingFindPeerProgressEvents>): Promise<Peer> {
     if (this.routers.length === 0) {
       throw new NoRoutersAvailableError('No peer routers available')
     }
@@ -339,7 +352,7 @@ export class Routing implements RoutingInterface, Startable {
   /**
    * Attempt to find the closest peers on the network to the given key
    */
-  async * getClosestPeers (key: Uint8Array, options: RoutingOptions<RoutingGetClosestPeersProgressEvents> = {}): AsyncIterable<PeerInfo> {
+  async * getClosestPeers (key: Uint8Array, options: RoutingOptions<RoutingGetClosestPeersProgressEvents> = {}): AsyncIterable<Peer> {
     if (this.routers.length === 0) {
       throw new NoRoutersAvailableError('No peer routers available')
     }

package/src/storage.ts

@@ -6,7 +6,6 @@ import type { Blocks, Pair, DeleteManyBlocksProgressEvents, DeleteBlockProgressE
 import type { Pins } from '@helia/interface/pins'
 import type { AbortOptions, Startable } from '@libp2p/interface'
 import type { Blockstore, InputPair } from 'interface-blockstore'
-import type { AwaitIterable } from 'interface-store'
 import type { Mortice } from 'mortice'
 import type { CID } from 'multiformats/cid'
 import type { ProgressOptions } from 'progress-events'
@@ -79,7 +78,7 @@ export class BlockStorage implements Blocks, Startable {
   /**
    * Put a multiple blocks to the underlying datastore
    */
-  async * putMany (blocks: AwaitIterable<InputPair>, options: AbortOptions & ProgressOptions<PutManyBlocksProgressEvents> = {}): AsyncGenerator<CID> {
+  async * putMany (blocks: Iterable<InputPair> | AsyncIterable<InputPair>, options: AbortOptions & ProgressOptions<PutManyBlocksProgressEvents> = {}): AsyncGenerator<CID> {
     options?.signal?.throwIfAborted()
     const releaseLock = await this.lock.readLock()
 
@@ -107,7 +106,7 @@ export class BlockStorage implements Blocks, Startable {
   /**
    * Get multiple blocks back from an (async) iterable of cids
    */
-  async * getMany (cids: AwaitIterable<CID>, options: GetOfflineOptions & AbortOptions & ProgressOptions<GetManyBlocksProgressEvents> = {}): AsyncGenerator<Pair> {
+  async * getMany (cids: Iterable<CID> | AsyncIterable<CID>, options: GetOfflineOptions & AbortOptions & ProgressOptions<GetManyBlocksProgressEvents> = {}): AsyncGenerator<Pair> {
     options?.signal?.throwIfAborted()
     const releaseLock = await this.lock.readLock()
 
@@ -142,7 +141,7 @@ export class BlockStorage implements Blocks, Startable {
   /**
    * Delete multiple blocks from the blockstore
    */
-  async * deleteMany (cids: AwaitIterable<CID>, options: AbortOptions & ProgressOptions<DeleteManyBlocksProgressEvents> = {}): AsyncGenerator<CID> {
+  async * deleteMany (cids: Iterable<CID> | AsyncIterable<CID>, options: AbortOptions & ProgressOptions<DeleteManyBlocksProgressEvents> = {}): AsyncGenerator<CID> {
     options?.signal?.throwIfAborted()
     const releaseLock = await this.lock.writeLock()
 

package/src/utils/constants.ts

@@ -0,0 +1,3 @@
+export const SALT_LENGTH = 16
+export const KEY_SIZE = 32
+export const ITERATIONS = 10000

package/src/utils/get-codec.ts

@@ -1,5 +1,3 @@
-/* eslint max-depth: ["error", 7] */
-
 import { UnknownCodecError } from '@helia/interface'
 import * as dagCbor from '@ipld/dag-cbor'
 import * as dagJson from '@ipld/dag-json'
@@ -7,10 +5,10 @@ import * as dagPb from '@ipld/dag-pb'
 import * as json from 'multiformats/codecs/json'
 import * as raw from 'multiformats/codecs/raw'
 import { isPromise } from './is-promise.ts'
-import type { Await } from '@helia/interface'
+import type { CodecLoader } from '@helia/interface'
 import type { BlockCodec } from 'multiformats/codecs/interface'
 
-export function getCodec <T = any, Code extends number = any> (initialCodecs: Array<BlockCodec<any, any>> = [], loadCodec?: (code: number) => Await<BlockCodec<any, any>>): (code: Code) => Await<BlockCodec<Code, T>> {
+export function getCodec (initialCodecs: Array<BlockCodec<any, any>> = [], loadCodec?: CodecLoader): CodecLoader {
   const codecs: Record<number, BlockCodec<any, any>> = {
     [dagPb.code]: dagPb,
     [raw.code]: raw,

package/src/utils/get-crypto.ts

@@ -0,0 +1,44 @@
+import { UnknownCryptoError } from '@helia/interface'
+import { ecdsaCrypto, ed25519Crypto, rsaCrypto } from '@ipshipyard/crypto'
+import { isPromise } from './is-promise.ts'
+import type { CryptoLoader } from '@helia/interface'
+import type { Crypto } from '@ipshipyard/crypto'
+
+export function getCrypto (initialCryptos: Array<Crypto> = [], loadCrypto?: CryptoLoader): CryptoLoader {
+  const cryptos: Record<string | number, Crypto> = {}
+
+  initialCryptos = [
+    ecdsaCrypto(),
+    ed25519Crypto(),
+    rsaCrypto(),
+    ...initialCryptos
+  ]
+
+  initialCryptos.forEach(crypto => {
+    cryptos[crypto.type] = crypto
+    cryptos[crypto.code] = crypto
+  })
+
+  return async (nameOrCode) => {
+    let crypto = cryptos[nameOrCode]
+
+    if (crypto == null && loadCrypto != null) {
+      const res = loadCrypto(nameOrCode)
+
+      if (isPromise(res)) {
+        crypto = await res
+      } else {
+        crypto = res
+      }
+
+      cryptos[crypto.type] = crypto
+      cryptos[crypto.code] = crypto
+    }
+
+    if (crypto != null) {
+      return crypto
+    }
+
+    throw new UnknownCryptoError(`Could not load crypto for ${crypto}`)
+  }
+}

package/src/utils/get-hasher.ts

@@ -2,10 +2,10 @@ import { UnknownHashAlgorithmError } from '@helia/interface'
 import { identity } from 'multiformats/hashes/identity'
 import { sha256, sha512 } from 'multiformats/hashes/sha2'
 import { isPromise } from './is-promise.ts'
-import type { Await } from '@helia/interface'
+import type { HasherLoader } from '@helia/interface'
 import type { MultihashHasher } from 'multiformats/hashes/interface'
 
-export function getHasher (initialHashers: MultihashHasher[] = [], loadHasher?: (code: number) => Await<MultihashHasher>): (code: number) => Await<MultihashHasher> {
+export function getHasher (initialHashers: MultihashHasher[] = [], loadHasher?: HasherLoader): HasherLoader {
   const hashers: Record<number, MultihashHasher> = {
     [sha256.code]: sha256,
     [sha512.code]: sha512,

package/src/utils/is-cid.ts

@@ -0,0 +1,9 @@
+import { CID } from 'multiformats/cid'
+
+export function isCID (obj?: any): obj is CID {
+  if (obj == null) {
+    return false
+  }
+
+  return CID.asCID(obj) != null
+}

package/src/utils/networked-storage.ts

@@ -4,7 +4,8 @@ import { SessionStorage } from './session-storage.ts'
 import { Storage } from './storage.ts'
 import type { StorageComponents, StorageInit } from './storage.ts'
 import type { BlockBroker, Blocks, CreateSessionOptions, SessionBlockstore } from '@helia/interface/blocks'
-import type { AbortOptions, Startable } from '@libp2p/interface'
+import type { Startable } from '@libp2p/interface'
+import type { AbortOptions } from 'abort-error'
 import type { Blockstore } from 'interface-blockstore'
 import type { CID } from 'multiformats/cid'
 

package/src/utils/session-storage.ts

@@ -3,10 +3,9 @@ import { anySignal } from 'any-signal'
 import { Storage } from './storage.ts'
 import type { StorageComponents } from './storage.ts'
 import type { Pair, DeleteManyBlocksProgressEvents, DeleteBlockProgressEvents, GetBlockProgressEvents, GetManyBlocksProgressEvents, PutManyBlocksProgressEvents, PutBlockProgressEvents, GetAllBlocksProgressEvents, GetOfflineOptions, SessionBlockstore, SessionBlockBroker } from '@helia/interface/blocks'
-import type { AbortOptions, PeerId } from '@libp2p/interface'
+import type { AbortOptions } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { InputPair } from 'interface-blockstore'
-import type { AwaitIterable } from 'interface-store'
 import type { CID } from 'multiformats/cid'
 import type { ProgressOptions } from 'progress-events'
 
@@ -36,7 +35,7 @@ export class SessionStorage extends Storage<SessionBlockBroker> implements Sessi
     this.closeController.abort()
   }
 
-  async addPeer (peer: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions): Promise<void> {
+  async addPeer (peer: CID | Multiaddr | Multiaddr[], options?: AbortOptions): Promise<void> {
     await Promise.all(
       this.blockBrokers
         .map(broker => broker.addPeer(peer, options))
@@ -63,7 +62,7 @@ export class SessionStorage extends Storage<SessionBlockBroker> implements Sessi
   /**
    * Put a multiple blocks to the underlying datastore
    */
-  async * putMany (blocks: AwaitIterable<InputPair>, options: AbortOptions & ProgressOptions<PutManyBlocksProgressEvents> = {}): AsyncGenerator<CID> {
+  async * putMany (blocks: Iterable<InputPair> | AsyncIterable<InputPair>, options: AbortOptions & ProgressOptions<PutManyBlocksProgressEvents> = {}): AsyncGenerator<CID> {
     const signal = anySignal([this.closeController.signal, options.signal])
     setMaxListeners(Infinity, signal)
 
@@ -97,7 +96,7 @@ export class SessionStorage extends Storage<SessionBlockBroker> implements Sessi
   /**
    * Get multiple blocks back from an (async) iterable of cids
    */
-  async * getMany (cids: AwaitIterable<CID>, options: GetOfflineOptions & AbortOptions & ProgressOptions<GetManyBlocksProgressEvents> = {}): AsyncGenerator<Pair> {
+  async * getMany (cids: Iterable<CID> | AsyncIterable<CID>, options: GetOfflineOptions & AbortOptions & ProgressOptions<GetManyBlocksProgressEvents> = {}): AsyncGenerator<Pair> {
     const signal = anySignal([this.closeController.signal, options.signal])
     setMaxListeners(Infinity, signal)
 
@@ -131,7 +130,7 @@ export class SessionStorage extends Storage<SessionBlockBroker> implements Sessi
   /**
    * Delete multiple blocks from the blockstore
    */
-  async * deleteMany (cids: AwaitIterable<CID>, options: AbortOptions & ProgressOptions<DeleteManyBlocksProgressEvents> = {}): AsyncGenerator<CID> {
+  async * deleteMany (cids: Iterable<CID> | AsyncIterable<CID>, options: AbortOptions & ProgressOptions<DeleteManyBlocksProgressEvents> = {}): AsyncGenerator<CID> {
     const signal = anySignal([this.closeController.signal, options.signal])
     setMaxListeners(Infinity, signal)