deps!: bump multiformats from 13.4.2 to 14.0.0

packages/blockstore-core/package.json

@@ -187,18 +187,19 @@
   },
   "dependencies": {
     "@libp2p/logger": "^6.2.4",
+    "abort-error": "^1.0.2",
     "interface-blockstore": "^6.0.0",
     "interface-store": "^7.0.0",
     "it-all": "^3.0.9",
     "it-filter": "^3.1.4",
     "it-merge": "^3.0.12",
-    "multiformats": "^13.4.2"
+    "multiformats": "^14.0.0"
   },
   "devDependencies": {
     "aegir": "^48.0.4",
     "interface-blockstore-tests": "^8.0.0",
     "it-drain": "^3.0.10",
-    "it-to-buffer": "^4.0.10",
-    "uint8arrays": "^5.1.0"
+    "it-to-buffer": "^5.0.0",
+    "uint8arrays": "^6.1.1"
   }
 }

packages/blockstore-core/src/base.ts

@@ -1,28 +1,28 @@
+import type { AbortOptions } from 'abort-error'
 import type { Blockstore, InputPair, Pair } from 'interface-blockstore'
-import type { AbortOptions, Await, AwaitGenerator, AwaitIterable } from 'interface-store'
 import type { CID } from 'multiformats/cid'
 
 export class BaseBlockstore implements Blockstore {
-  has (key: CID, options?: AbortOptions): Await<boolean> {
+  has (key: CID, options?: AbortOptions): boolean | Promise<boolean> {
     return Promise.reject(new Error('.has is not implemented'))
   }
 
-  put (key: CID, val: Uint8Array | AwaitIterable<Uint8Array>, options?: AbortOptions): Await<CID> {
+  put (key: CID, val: Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array>, options?: AbortOptions): CID | Promise<CID> {
     return Promise.reject(new Error('.put is not implemented'))
   }
 
-  async * putMany (source: AwaitIterable<InputPair>, options?: AbortOptions): AwaitGenerator<CID> {
+  async * putMany (source: Iterable<InputPair> | AsyncIterable<InputPair>, options?: AbortOptions): Generator<CID> | AsyncGenerator<CID> {
     for await (const { cid, bytes } of source) {
       await this.put(cid, bytes, options)
       yield cid
     }
   }
 
-  get (key: CID, options?: AbortOptions): AwaitGenerator<Uint8Array> {
+  get (key: CID, options?: AbortOptions): Generator<Uint8Array> | AsyncGenerator<Uint8Array> {
     throw new Error('.get is not implemented')
   }
 
-  async * getMany (source: AwaitIterable<CID>, options?: AbortOptions): AwaitGenerator<Pair> {
+  async * getMany (source: Iterable<CID> | AsyncIterable<CID>, options?: AbortOptions): Generator<Pair> | AsyncGenerator<Pair> {
     for await (const key of source) {
       yield {
         cid: key,
@@ -31,11 +31,11 @@ export class BaseBlockstore implements Blockstore {
     }
   }
 
-  delete (key: CID, options?: AbortOptions): Await<void> {
+  delete (key: CID, options?: AbortOptions): void | Promise<void> {
     return Promise.reject(new Error('.delete is not implemented'))
   }
 
-  async * deleteMany (source: AwaitIterable<CID>, options?: AbortOptions): AwaitGenerator<CID> {
+  async * deleteMany (source: Iterable<CID> | AsyncIterable<CID>, options?: AbortOptions): Generator<CID> | AsyncGenerator<CID> {
     for await (const key of source) {
       await this.delete(key, options)
       yield key
@@ -45,7 +45,7 @@ export class BaseBlockstore implements Blockstore {
   /**
    * Extending classes should override `query` or implement this method
    */
-  async * getAll (options?: AbortOptions): AwaitGenerator<Pair> { // eslint-disable-line require-yield
+  async * getAll (options?: AbortOptions): Generator<Pair> | AsyncGenerator<Pair> { // eslint-disable-line require-yield
     throw new Error('.getAll is not implemented')
   }
 }

packages/blockstore-core/src/black-hole.ts

@@ -1,21 +1,21 @@
 import { NotFoundError } from 'interface-store'
 import { BaseBlockstore } from './base.ts'
+import type { AbortOptions } from 'abort-error'
 import type { Pair } from 'interface-blockstore'
-import type { AbortOptions, Await, AwaitGenerator, AwaitIterable } from 'interface-store'
 import type { CID } from 'multiformats/cid'
 
 export class BlackHoleBlockstore extends BaseBlockstore {
-  put (key: CID, value: Uint8Array | AwaitIterable<Uint8Array>, options?: AbortOptions): Await<CID> {
+  put (key: CID, value: Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array>, options?: AbortOptions): CID | Promise<CID> {
     options?.signal?.throwIfAborted()
     return key
   }
 
-  get (key: CID, options?: AbortOptions): AwaitGenerator<Uint8Array> {
+  get (key: CID, options?: AbortOptions): Generator<Uint8Array> | AsyncGenerator<Uint8Array> {
     options?.signal?.throwIfAborted()
     throw new NotFoundError()
   }
 
-  has (key: CID, options?: AbortOptions): Await<boolean> {
+  has (key: CID, options?: AbortOptions): boolean | Promise<boolean> {
     options?.signal?.throwIfAborted()
     return false
   }
@@ -25,7 +25,7 @@ export class BlackHoleBlockstore extends BaseBlockstore {
   }
 
   // eslint-disable-next-line require-yield
-  async * getAll (options?: AbortOptions): AwaitGenerator<Pair> {
+  async * getAll (options?: AbortOptions): Generator<Pair> | AsyncGenerator<Pair> {
     options?.signal?.throwIfAborted()
   }
 }

packages/blockstore-core/src/identity.ts

@@ -1,7 +1,7 @@
 import { NotFoundError } from 'interface-store'
 import { BaseBlockstore } from './base.ts'
+import type { AbortOptions } from 'abort-error'
 import type { Blockstore, Pair } from 'interface-blockstore'
-import type { AbortOptions, Await, AwaitIterable } from 'interface-store'
 import type { CID } from 'multiformats/cid'
 
 // https://github.com/multiformats/multicodec/blob/d06fc6194710e8909bac64273c43f16b56ca4c34/table.csv#L2
@@ -27,7 +27,7 @@ export class IdentityBlockstore extends BaseBlockstore {
     this.maxDigestLength = init?.maxDigestLength
   }
 
-  put (key: CID, block: Uint8Array | AwaitIterable<Uint8Array>, options?: AbortOptions): Await<CID> {
+  put (key: CID, block: Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array>, options?: AbortOptions): CID | Promise<CID> {
     if (key.multihash.code === IDENTITY_CODEC) {
       if (this.maxDigestLength != null && key.multihash.digest.byteLength > this.maxDigestLength) {
         throw new IdentityHashDigestTooLongError(`Identity digest too long - ${key.multihash.digest.byteLength} > this.maxDigestLength`)
@@ -64,7 +64,7 @@ export class IdentityBlockstore extends BaseBlockstore {
     yield * this.child.get(key, options)
   }
 
-  has (key: CID, options?: AbortOptions): Await<boolean> {
+  has (key: CID, options?: AbortOptions): boolean | Promise<boolean> {
     if (key.multihash.code === IDENTITY_CODEC) {
       if (this.maxDigestLength != null && key.multihash.digest.byteLength > this.maxDigestLength) {
         throw new IdentityHashDigestTooLongError(`Identity digest too long - ${key.multihash.digest.byteLength} > this.maxDigestLength`)
@@ -82,7 +82,7 @@ export class IdentityBlockstore extends BaseBlockstore {
     return this.child.has(key, options)
   }
 
-  delete (key: CID, options?: AbortOptions): Await<void> {
+  delete (key: CID, options?: AbortOptions): void | Promise<void> {
     if (key.code === IDENTITY_CODEC) {
       if (this.maxDigestLength != null && key.multihash.digest.byteLength > this.maxDigestLength) {
         throw new IdentityHashDigestTooLongError(`Identity digest too long - ${key.multihash.digest.byteLength} > this.maxDigestLength`)

packages/blockstore-core/src/memory.ts

@@ -5,8 +5,8 @@ import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
 import * as Digest from 'multiformats/hashes/digest'
 import { BaseBlockstore } from './base.ts'
+import type { AbortOptions } from 'abort-error'
 import type { Pair } from 'interface-blockstore'
-import type { AbortOptions, Await, AwaitGenerator, AwaitIterable } from 'interface-store'
 
 function isPromise <T> (p?: any): p is Promise<T> {
   return typeof p?.then === 'function'
@@ -21,7 +21,7 @@ export class MemoryBlockstore extends BaseBlockstore {
     this.data = new Map()
   }
 
-  put (key: CID, val: Uint8Array | AwaitIterable<Uint8Array>, options?: AbortOptions): Await<CID> {
+  put (key: CID, val: Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array>, options?: AbortOptions): CID | Promise<CID> {
     options?.signal?.throwIfAborted()
 
     let buf: Uint8Array[]
@@ -43,15 +43,15 @@ export class MemoryBlockstore extends BaseBlockstore {
     return this._put(key, buf, options)
   }
 
-  private _put (key: CID, val: Uint8Array[], options?: AbortOptions): Await<CID> {
+  private _put (key: CID, val: Uint8Array[], options?: AbortOptions): CID | Promise<CID> {
     options?.signal?.throwIfAborted()
 
     this.data.set(base32.encode(key.multihash.bytes), val)
 
     return key
   }
 
-  * get (key: CID, options?: AbortOptions): AwaitGenerator<Uint8Array> {
+  * get (key: CID, options?: AbortOptions): Generator<Uint8Array> | AsyncGenerator<Uint8Array> {
     options?.signal?.throwIfAborted()
     const buf = this.data.get(base32.encode(key.multihash.bytes))
 
@@ -62,7 +62,7 @@ export class MemoryBlockstore extends BaseBlockstore {
     yield * buf
   }
 
-  has (key: CID, options?: AbortOptions): Await<boolean> {
+  has (key: CID, options?: AbortOptions): boolean | Promise<boolean> {
     options?.signal?.throwIfAborted()
     return this.data.has(base32.encode(key.multihash.bytes))
   }
@@ -72,7 +72,7 @@ export class MemoryBlockstore extends BaseBlockstore {
     this.data.delete(base32.encode(key.multihash.bytes))
   }
 
-  * getAll (options?: AbortOptions): AwaitGenerator<Pair> {
+  * getAll (options?: AbortOptions): Generator<Pair> | AsyncGenerator<Pair> {
     options?.signal?.throwIfAborted()
 
     for (const [key, value] of this.data.entries()) {

packages/blockstore-core/src/tiered.ts

@@ -3,8 +3,8 @@ import { NotFoundError } from 'interface-store'
 import filter from 'it-filter'
 import merge from 'it-merge'
 import { BaseBlockstore } from './base.ts'
+import type { AbortOptions } from 'abort-error'
 import type { Blockstore, InputPair, Pair } from 'interface-blockstore'
-import type { AbortOptions, AwaitGenerator, AwaitIterable } from 'interface-store'
 import type { CID } from 'multiformats/cid'
 
 const log = logger('blockstore:core:tiered')
@@ -24,7 +24,7 @@ export class TieredBlockstore extends BaseBlockstore {
     this.stores = stores.slice()
   }
 
-  async put (key: CID, value: Uint8Array | AwaitIterable<Uint8Array>, options?: AbortOptions): Promise<CID> {
+  async put (key: CID, value: Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array>, options?: AbortOptions): Promise<CID> {
     await Promise.all(
       this.stores.map(async store => {
         await store.put(key, value, options)
@@ -34,7 +34,7 @@ export class TieredBlockstore extends BaseBlockstore {
     return key
   }
 
-  async * get (key: CID, options?: AbortOptions): AwaitGenerator<Uint8Array> {
+  async * get (key: CID, options?: AbortOptions): Generator<Uint8Array> | AsyncGenerator<Uint8Array> {
     let error: Error | undefined
 
     for (const store of this.stores) {
@@ -68,21 +68,21 @@ export class TieredBlockstore extends BaseBlockstore {
     )
   }
 
-  async * putMany (source: AwaitIterable<InputPair>, options: AbortOptions = {}): AwaitGenerator<CID> {
+  async * putMany (source: Iterable<InputPair> | AsyncIterable<InputPair>, options: AbortOptions = {}): Generator<CID> | AsyncGenerator<CID> {
     for await (const pair of source) {
       await this.put(pair.cid, pair.bytes, options)
       yield pair.cid
     }
   }
 
-  async * deleteMany (source: AwaitIterable<CID>, options: AbortOptions = {}): AwaitGenerator<CID> {
+  async * deleteMany (source: Iterable<CID> | AsyncIterable<CID>, options: AbortOptions = {}): Generator<CID> | AsyncGenerator<CID> {
     for await (const cid of source) {
       await this.delete(cid, options)
       yield cid
     }
   }
 
-  async * getAll (options?: AbortOptions): AwaitGenerator<Pair> {
+  async * getAll (options?: AbortOptions): Generator<Pair> | AsyncGenerator<Pair> {
     // deduplicate yielded pairs
     const seen = new Set<string>()
 

packages/blockstore-core/test/identity.spec.ts

@@ -8,8 +8,8 @@ import { identity } from 'multiformats/hashes/identity'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { IdentityBlockstore } from '../src/identity.ts'
 import { MemoryBlockstore } from '../src/memory.ts'
+import type { AbortOptions } from 'abort-error'
 import type { Blockstore } from 'interface-blockstore'
-import type { AbortOptions } from 'interface-store'
 
 describe('identity', () => {
   let blockstore: Blockstore

packages/blockstore-fs/package.json

@@ -162,12 +162,13 @@
     "release": "aegir release"
   },
   "dependencies": {
+    "abort-error": "^1.0.2",
     "interface-blockstore": "^6.0.0",
     "interface-store": "^7.0.0",
     "it-glob": "^3.0.4",
     "it-map": "^3.1.4",
     "it-parallel-batch": "^3.0.9",
-    "multiformats": "^13.4.2",
+    "multiformats": "^14.0.0",
     "race-signal": "^2.0.0",
     "steno": "^4.0.2"
   },

packages/blockstore-fs/src/index.ts

@@ -22,15 +22,15 @@ import { raceSignal } from 'race-signal'
 import { Writer } from 'steno'
 import { NextToLast } from './sharding.ts'
 import type { ShardingStrategy } from './sharding.ts'
+import type { AbortOptions } from 'abort-error'
 import type { Blockstore, Pair } from 'interface-blockstore'
-import type { AbortOptions, AwaitGenerator, AwaitIterable } from 'interface-store'
 import type { CID } from 'multiformats/cid'
 import type { FileHandle } from 'node:fs/promises'
 
 /**
  * Write a file atomically
  */
-async function writeFile (file: string, contents: Uint8Array | AwaitIterable<Uint8Array>, options?: AbortOptions): Promise<void> {
+async function writeFile (file: string, contents: Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array>, options?: AbortOptions): Promise<void> {
   try {
     options?.signal?.throwIfAborted()
     await raceSignal(fs.mkdir(path.dirname(file), {
@@ -147,7 +147,7 @@ export class FsBlockstore implements Blockstore {
     await Promise.resolve()
   }
 
-  async put (key: CID, val: Uint8Array | AwaitIterable<Uint8Array>, options?: AbortOptions): Promise<CID> {
+  async put (key: CID, val: Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array>, options?: AbortOptions): Promise<CID> {
     const { dir, file } = this.shardingStrategy.encode(key)
 
     try {
@@ -159,7 +159,7 @@ export class FsBlockstore implements Blockstore {
     }
   }
 
-  async * putMany (source: AwaitIterable<Pair>, options?: AbortOptions): AsyncGenerator<CID> {
+  async * putMany (source: Iterable<Pair> | AsyncIterable<Pair>, options?: AbortOptions): AsyncGenerator<CID> {
     yield * parallelBatch(
       map(source, ({ cid, bytes }) => {
         return async () => {
@@ -191,7 +191,7 @@ export class FsBlockstore implements Blockstore {
     }
   }
 
-  async * getMany (source: AwaitIterable<CID>, options?: AbortOptions): AsyncGenerator<Pair> {
+  async * getMany (source: Iterable<CID> | AsyncIterable<CID>, options?: AbortOptions): AsyncGenerator<Pair> {
     yield * parallelBatch(
       map(source, key => {
         return async () => {
@@ -220,7 +220,7 @@ export class FsBlockstore implements Blockstore {
     }
   }
 
-  async * deleteMany (source: AwaitIterable<CID>, options?: AbortOptions): AsyncGenerator<CID> {
+  async * deleteMany (source: Iterable<CID> | AsyncIterable<CID>, options?: AbortOptions): AsyncGenerator<CID> {
     yield * parallelBatch(
       map(source, key => {
         return async () => {
@@ -245,7 +245,7 @@ export class FsBlockstore implements Blockstore {
     return true
   }
 
-  async * getAll (options?: AbortOptions): AwaitGenerator<Pair> {
+  async * getAll (options?: AbortOptions): Generator<Pair> | AsyncGenerator<Pair> {
     const pattern = `**/*${this.shardingStrategy.extension}`
       .split(path.sep)
       .join('/')

packages/blockstore-idb/package.json

@@ -144,13 +144,14 @@
     "release": "aegir release"
   },
   "dependencies": {
+    "abort-error": "^1.0.2",
     "blockstore-core": "^6.0.0",
     "idb": "^8.0.3",
     "interface-blockstore": "^6.0.0",
     "interface-store": "^7.0.0",
     "it-all": "^3.0.9",
-    "it-to-buffer": "^4.0.10",
-    "multiformats": "^13.4.2",
+    "it-to-buffer": "^5.0.0",
+    "multiformats": "^14.0.0",
     "race-signal": "^2.0.0"
   },
   "devDependencies": {