diff --git a/packages/blockstore-core/src/memory.ts b/packages/blockstore-core/src/memory.ts
index 68a0372b..72686d89 100644
--- a/packages/blockstore-core/src/memory.ts
+++ b/packages/blockstore-core/src/memory.ts
@@ -1,11 +1,11 @@
-import { BaseBlockstore } from './base.js'
 import { base32 } from 'multiformats/bases/base32'
-import * as raw from 'multiformats/codecs/raw'
 import { CID } from 'multiformats/cid'
+import * as raw from 'multiformats/codecs/raw'
 import * as Digest from 'multiformats/hashes/digest'
+import { BaseBlockstore } from './base.js'
 import * as Errors from './errors.js'
-import type { Await, AwaitIterable } from 'interface-store'
 import type { Pair } from 'interface-blockstore'
+import type { Await, AwaitIterable } from 'interface-store'
 
 export class MemoryBlockstore extends BaseBlockstore {
   private readonly data: Map<string, Uint8Array>
diff --git a/packages/blockstore-fs/benchmarks/encoding/src/index.ts b/packages/blockstore-fs/benchmarks/encoding/src/index.ts
index 6bb13797..40fc0905 100644
--- a/packages/blockstore-fs/benchmarks/encoding/src/index.ts
+++ b/packages/blockstore-fs/benchmarks/encoding/src/index.ts
@@ -1,11 +1,11 @@
-import { Bench } from 'tinybench'
-import { CID } from 'multiformats/cid'
-import { base8 } from 'multiformats/bases/base8'
 import { base10 } from 'multiformats/bases/base10'
 import { base16upper } from 'multiformats/bases/base16'
+import { base256emoji } from 'multiformats/bases/base256emoji'
 import { base32, base32upper, base32hexupper, base32z } from 'multiformats/bases/base32'
 import { base36, base36upper } from 'multiformats/bases/base36'
-import { base256emoji } from 'multiformats/bases/base256emoji'
+import { base8 } from 'multiformats/bases/base8'
+import { CID } from 'multiformats/cid'
+import { Bench } from 'tinybench'
 
 const RESULT_PRECISION = 2
 
diff --git a/packages/blockstore-fs/src/index.ts b/packages/blockstore-fs/src/index.ts
index ff02d92e..81b9e739 100644
--- a/packages/blockstore-fs/src/index.ts
+++ b/packages/blockstore-fs/src/index.ts
@@ -1,18 +1,18 @@
 import fs from 'node:fs/promises'
-import glob from 'it-glob'
 import path from 'node:path'
 import { promisify } from 'node:util'
 import {
   Errors
 } from 'blockstore-core'
-import map from 'it-map'
-import parallelBatch from 'it-parallel-batch'
 // @ts-expect-error no types
 import fwa from 'fast-write-atomic'
-import type { CID } from 'multiformats/cid'
+import glob from 'it-glob'
+import map from 'it-map'
+import parallelBatch from 'it-parallel-batch'
+import { NextToLast, type ShardingStrategy } from './sharding.js'
 import type { Blockstore, Pair } from 'interface-blockstore'
 import type { AwaitIterable } from 'interface-store'
-import { NextToLast, ShardingStrategy } from './sharding.js'
+import type { CID } from 'multiformats/cid'
 
 const writeAtomic = promisify(fwa)
 
diff --git a/packages/blockstore-fs/src/sharding.ts b/packages/blockstore-fs/src/sharding.ts
index 5742390f..10d65169 100644
--- a/packages/blockstore-fs/src/sharding.ts
+++ b/packages/blockstore-fs/src/sharding.ts
@@ -1,6 +1,6 @@
 import path from 'node:path'
-import { CID } from 'multiformats/cid'
 import { base32upper } from 'multiformats/bases/base32'
+import { CID } from 'multiformats/cid'
 import type { MultibaseCodec } from 'multiformats/bases/interface'
 
 export interface ShardingStrategy {
diff --git a/packages/blockstore-fs/test/index.spec.ts b/packages/blockstore-fs/test/index.spec.ts
index d2dfe45d..25e0ebc3 100644
--- a/packages/blockstore-fs/test/index.spec.ts
+++ b/packages/blockstore-fs/test/index.spec.ts
@@ -1,13 +1,13 @@
 /* eslint-env mocha */
-import { expect } from 'aegir/chai'
-import path from 'node:path'
-import os from 'node:os'
 import fs from 'node:fs/promises'
-import { CID } from 'multiformats/cid'
+import os from 'node:os'
+import path from 'node:path'
+import { expect } from 'aegir/chai'
 import { interfaceBlockstoreTests } from 'interface-blockstore-tests'
+import { base256emoji } from 'multiformats/bases/base256emoji'
+import { CID } from 'multiformats/cid'
 import { FsBlockstore } from '../src/index.js'
 import { FlatDirectory, NextToLast } from '../src/sharding.js'
-import { base256emoji } from 'multiformats/bases/base256emoji'
 
 const utf8Encoder = new TextEncoder()
 
diff --git a/packages/blockstore-fs/test/sharding.spec.ts b/packages/blockstore-fs/test/sharding.spec.ts
index 99253b3b..3c896570 100644
--- a/packages/blockstore-fs/test/sharding.spec.ts
+++ b/packages/blockstore-fs/test/sharding.spec.ts
@@ -1,8 +1,8 @@
 /* eslint-env mocha */
 import { expect } from 'aegir/chai'
+import { base32upper } from 'multiformats/bases/base32'
 import { CID } from 'multiformats/cid'
 import { FlatDirectory, NextToLast } from '../src/sharding.js'
-import { base32upper } from 'multiformats/bases/base32'
 
 describe('flat', () => {
   it('should encode', () => {
diff --git a/packages/blockstore-idb/src/index.ts b/packages/blockstore-idb/src/index.ts
index 82316624..8adbe0eb 100644
--- a/packages/blockstore-idb/src/index.ts
+++ b/packages/blockstore-idb/src/index.ts
@@ -1,15 +1,15 @@
-import { openDB, IDBPDatabase, deleteDB } from 'idb'
 import {
   BaseBlockstore,
   Errors
 } from 'blockstore-core'
-import { CID } from 'multiformats/cid'
-import type { MultibaseCodec } from 'multiformats/bases/interface'
+import { openDB, type IDBPDatabase, deleteDB } from 'idb'
 import { base32upper } from 'multiformats/bases/base32'
+import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
 import * as Digest from 'multiformats/hashes/digest'
 import type { Pair } from 'interface-blockstore'
 import type { AbortOptions, AwaitIterable } from 'interface-store'
+import type { MultibaseCodec } from 'multiformats/bases/interface'
 
 export interface IDBDatastoreInit {
   /**
diff --git a/packages/blockstore-idb/test/index.spec.ts b/packages/blockstore-idb/test/index.spec.ts
index 51697205..e4b9434a 100644
--- a/packages/blockstore-idb/test/index.spec.ts
+++ b/packages/blockstore-idb/test/index.spec.ts
@@ -1,9 +1,9 @@
 /* eslint-env mocha */
 
 import { expect } from 'aegir/chai'
-import { IDBBlockstore } from '../src/index.js'
-import { CID } from 'multiformats/cid'
 import { interfaceBlockstoreTests } from 'interface-blockstore-tests'
+import { CID } from 'multiformats/cid'
+import { IDBBlockstore } from '../src/index.js'
 
 describe('IndexedDB Blockstore', function () {
   describe('interface-blockstore (idb)', () => {
diff --git a/packages/blockstore-level/src/index.ts b/packages/blockstore-level/src/index.ts
index 747f9574..4748dda1 100644
--- a/packages/blockstore-level/src/index.ts
+++ b/packages/blockstore-level/src/index.ts
@@ -1,13 +1,13 @@
-import type { Pair } from 'interface-blockstore'
 import { BaseBlockstore, Errors } from 'blockstore-core'
 import { Level } from 'level'
-import { CID } from 'multiformats/cid'
-import type { DatabaseOptions, OpenOptions, IteratorOptions } from 'level'
-import type { MultibaseCodec } from 'multiformats/bases/interface'
 import { base32upper } from 'multiformats/bases/base32'
+import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
 import * as Digest from 'multiformats/hashes/digest'
+import type { Pair } from 'interface-blockstore'
 import type { AbortOptions, AwaitIterable } from 'interface-store'
+import type { DatabaseOptions, OpenOptions, IteratorOptions } from 'level'
+import type { MultibaseCodec } from 'multiformats/bases/interface'
 
 export interface LevelBlockstoreInit extends DatabaseOptions<string, Uint8Array>, OpenOptions {
   /**
diff --git a/packages/blockstore-level/test/fixtures/test-level-iterator-destroy.ts b/packages/blockstore-level/test/fixtures/test-level-iterator-destroy.ts
index 4183fbf0..3a6f492b 100644
--- a/packages/blockstore-level/test/fixtures/test-level-iterator-destroy.ts
+++ b/packages/blockstore-level/test/fixtures/test-level-iterator-destroy.ts
@@ -1,6 +1,6 @@
-import { LevelBlockstore } from '../../src/index.js'
 import tempdir from 'ipfs-utils/src/temp-dir.js'
 import { CID } from 'multiformats/cid'
+import { LevelBlockstore } from '../../src/index.js'
 
 async function testLevelIteratorDestroy (): Promise<void> {
   const store = new LevelBlockstore(tempdir())
diff --git a/packages/blockstore-level/test/index.spec.ts b/packages/blockstore-level/test/index.spec.ts
index 877c6811..087b519c 100644
--- a/packages/blockstore-level/test/index.spec.ts
+++ b/packages/blockstore-level/test/index.spec.ts
@@ -1,11 +1,11 @@
 /* eslint-env mocha */
 
 import { expect } from 'aegir/chai'
-import { MemoryLevel } from 'memory-level'
+import { interfaceBlockstoreTests } from 'interface-blockstore-tests'
+import tempdir from 'ipfs-utils/src/temp-dir.js'
 import { Level } from 'level'
+import { MemoryLevel } from 'memory-level'
 import { LevelBlockstore } from '../src/index.js'
-import tempdir from 'ipfs-utils/src/temp-dir.js'
-import { interfaceBlockstoreTests } from 'interface-blockstore-tests'
 
 describe('LevelBlockstore', () => {
   describe('initialization', () => {
diff --git a/packages/blockstore-level/test/node.ts b/packages/blockstore-level/test/node.ts
index 230ba594..db104ccc 100644
--- a/packages/blockstore-level/test/node.ts
+++ b/packages/blockstore-level/test/node.ts
@@ -1,11 +1,11 @@
 /* eslint-env mocha */
 
-import { expect } from 'aegir/chai'
-import path from 'path'
 import childProcess from 'child_process'
+import path from 'path'
+import { expect } from 'aegir/chai'
 import { interfaceBlockstoreTests } from 'interface-blockstore-tests'
-import { LevelBlockstore } from '../src/index.js'
 import tempdir from 'ipfs-utils/src/temp-dir.js'
+import { LevelBlockstore } from '../src/index.js'
 
 describe('LevelDatastore', () => {
   describe('interface-blockstore (leveldown)', () => {
diff --git a/packages/blockstore-s3/src/index.ts b/packages/blockstore-s3/src/index.ts
index 0e6c90a9..0444d4d3 100644
--- a/packages/blockstore-s3/src/index.ts
+++ b/packages/blockstore-s3/src/index.ts
@@ -1,10 +1,3 @@
-import type { Pair } from 'interface-blockstore'
-import { BaseBlockstore } from 'blockstore-core/base'
-import * as Errors from 'blockstore-core/errors'
-import { fromString as unint8arrayFromString } from 'uint8arrays'
-import toBuffer from 'it-to-buffer'
-import type { S3 } from '@aws-sdk/client-s3'
-import type { AbortOptions } from 'interface-store'
 import {
   PutObjectCommand,
   CreateBucketCommand,
@@ -13,8 +6,15 @@ import {
   DeleteObjectCommand,
   ListObjectsV2Command
 } from '@aws-sdk/client-s3'
+import { BaseBlockstore } from 'blockstore-core/base'
+import * as Errors from 'blockstore-core/errors'
+import toBuffer from 'it-to-buffer'
+import { fromString as unint8arrayFromString } from 'uint8arrays'
+import { NextToLast, type ShardingStrategy } from './sharding.js'
+import type { S3 } from '@aws-sdk/client-s3'
+import type { Pair } from 'interface-blockstore'
+import type { AbortOptions } from 'interface-store'
 import type { CID } from 'multiformats/cid'
-import { NextToLast, ShardingStrategy } from './sharding.js'
 
 export interface S3BlockstoreInit {
   /**
diff --git a/packages/blockstore-s3/src/sharding.ts b/packages/blockstore-s3/src/sharding.ts
index 28f66cee..ef086143 100644
--- a/packages/blockstore-s3/src/sharding.ts
+++ b/packages/blockstore-s3/src/sharding.ts
@@ -1,5 +1,5 @@
-import { CID } from 'multiformats/cid'
 import { base32upper } from 'multiformats/bases/base32'
+import { CID } from 'multiformats/cid'
 import type { MultibaseCodec } from 'multiformats/bases/interface'
 
 export interface ShardingStrategy {
diff --git a/packages/blockstore-s3/test/index.spec.ts b/packages/blockstore-s3/test/index.spec.ts
index bb9a59fd..10ac4b9d 100644
--- a/packages/blockstore-s3/test/index.spec.ts
+++ b/packages/blockstore-s3/test/index.spec.ts
@@ -1,14 +1,13 @@
 /* eslint-env mocha */
 
+import { type CreateBucketCommand, type HeadObjectCommand, S3 } from '@aws-sdk/client-s3'
 import { expect } from 'aegir/chai'
-import sinon from 'sinon'
-import { CreateBucketCommand, HeadObjectCommand, S3 } from '@aws-sdk/client-s3'
-import defer from 'p-defer'
 import { interfaceBlockstoreTests } from 'interface-blockstore-tests'
 import { CID } from 'multiformats/cid'
-
-import { s3Resolve, s3Reject, S3Error, s3Mock } from './utils/s3-mock.js'
+import defer from 'p-defer'
+import sinon from 'sinon'
 import { S3Blockstore } from '../src/index.js'
+import { s3Resolve, s3Reject, S3Error, s3Mock } from './utils/s3-mock.js'
 
 const cid = CID.parse('QmeimKZyjcBnuXmAD9zMnSjM9JodTbgGT3gutofkTqz9rE')
 
diff --git a/packages/blockstore-s3/test/utils/s3-mock.ts b/packages/blockstore-s3/test/utils/s3-mock.ts
index 6c4bf01f..ac100f40 100644
--- a/packages/blockstore-s3/test/utils/s3-mock.ts
+++ b/packages/blockstore-s3/test/utils/s3-mock.ts
@@ -30,9 +30,9 @@ export const s3Reject = <T> (err: T): any => {
  */
 export function s3Mock (s3: S3): S3 {
   const mocks: any = {}
-  const storage: Map<string, any> = new Map()
+  const storage = new Map<string, any>()
 
-  mocks.send = sinon.replace(s3, 'send', (command) => {
+  mocks.send = sinon.replace(s3, 'send', (command: Parameters<S3['send']>[0]) => {
     const commandName = command.constructor.name
     const input: any = command.input
 
diff --git a/packages/datastore-core/src/base.ts b/packages/datastore-core/src/base.ts
index 821112eb..841d9858 100644
--- a/packages/datastore-core/src/base.ts
+++ b/packages/datastore-core/src/base.ts
@@ -1,6 +1,6 @@
-import sort from 'it-sort'
 import drain from 'it-drain'
 import filter from 'it-filter'
+import sort from 'it-sort'
 import take from 'it-take'
 import type { Batch, Datastore, Key, KeyQuery, Pair, Query } from 'interface-datastore'
 import type { AbortOptions, Await, AwaitIterable } from 'interface-store'
@@ -50,16 +50,22 @@ export class BaseDatastore implements Datastore {
     let dels: Key[] = []
 
     return {
-      put (key, value) {
+      put (key: Key, value) {
         puts.push({ key, value })
       },
 
       delete (key) {
         dels.push(key)
       },
+
       commit: async (options) => {
+        // @see https://github.com/ipfs/js-stores/issues/221
+        // eslint-disable-next-line @typescript-eslint/await-thenable, @typescript-eslint/no-confusing-void-expression
         await drain(this.putMany(puts, options))
         puts = []
+
+        // @see https://github.com/ipfs/js-stores/issues/221
+        // eslint-disable-next-line @typescript-eslint/await-thenable, @typescript-eslint/no-confusing-void-expression
         await drain(this.deleteMany(dels, options))
         dels = []
       }
diff --git a/packages/datastore-core/src/index.ts b/packages/datastore-core/src/index.ts
index 04f205c6..5982fa02 100644
--- a/packages/datastore-core/src/index.ts
+++ b/packages/datastore-core/src/index.ts
@@ -1,7 +1,7 @@
-import type { Key } from 'interface-datastore'
 
 import * as Errors from './errors.js'
 import * as shard from './shard.js'
+import type { Key } from 'interface-datastore'
 
 export { BaseDatastore } from './base.js'
 export { MemoryDatastore } from './memory.js'
diff --git a/packages/datastore-core/src/keytransform.ts b/packages/datastore-core/src/keytransform.ts
index a9d2c9f6..7f00d17e 100644
--- a/packages/datastore-core/src/keytransform.ts
+++ b/packages/datastore-core/src/keytransform.ts
@@ -1,6 +1,6 @@
-import { BaseDatastore } from './base.js'
 import map from 'it-map'
 import { pipe } from 'it-pipe'
+import { BaseDatastore } from './base.js'
 import type { KeyTransform } from './index.js'
 import type { Batch, Datastore, Key, KeyQuery, Pair, Query } from 'interface-datastore'
 import type { AbortOptions, AwaitIterable } from 'interface-store'
@@ -22,17 +22,15 @@ export class KeyTransformDatastore extends BaseDatastore {
   }
 
   async put (key: Key, val: Uint8Array, options?: AbortOptions): Promise<Key> {
-    await this.child.put(this.transform.convert(key), val, options)
-
-    return key
+    return this.child.put(this.transform.convert(key), val, options)
   }
 
   async get (key: Key, options?: AbortOptions): Promise<Uint8Array> {
-    return await this.child.get(this.transform.convert(key), options)
+    return this.child.get(this.transform.convert(key), options)
   }
 
   async has (key: Key, options?: AbortOptions): Promise<boolean> {
-    return await this.child.has(this.transform.convert(key), options)
+    return this.child.has(this.transform.convert(key), options)
   }
 
   async delete (key: Key, options?: AbortOptions): Promise<void> {
diff --git a/packages/datastore-core/src/memory.ts b/packages/datastore-core/src/memory.ts
index ad5cce4b..df87fd4b 100644
--- a/packages/datastore-core/src/memory.ts
+++ b/packages/datastore-core/src/memory.ts
@@ -1,5 +1,5 @@
-import { BaseDatastore } from './base.js'
 import { Key } from 'interface-datastore/key'
+import { BaseDatastore } from './base.js'
 import * as Errors from './errors.js'
 import type { Pair } from 'interface-datastore'
 import type { Await, AwaitIterable } from 'interface-store'
diff --git a/packages/datastore-core/src/mount.ts b/packages/datastore-core/src/mount.ts
index 80e7b8c6..b2660a42 100644
--- a/packages/datastore-core/src/mount.ts
+++ b/packages/datastore-core/src/mount.ts
@@ -1,9 +1,9 @@
 import filter from 'it-filter'
-import take from 'it-take'
 import merge from 'it-merge'
+import sort from 'it-sort'
+import take from 'it-take'
 import { BaseDatastore } from './base.js'
 import * as Errors from './errors.js'
-import sort from 'it-sort'
 import type { Batch, Datastore, Key, KeyQuery, Pair, Query } from 'interface-datastore'
 import type { AbortOptions } from 'interface-store'
 
@@ -49,20 +49,20 @@ export class MountDatastore extends BaseDatastore {
    * @param {Key} key
    * @param {Options} [options]
    */
-  async get (key: Key, options: AbortOptions = {}): Promise<Uint8Array> {
+  async get (key: Key, options?: AbortOptions): Promise<Uint8Array> {
     const match = this._lookup(key)
     if (match == null) {
       throw Errors.notFoundError(new Error('No datastore mounted for this key'))
     }
-    return await match.datastore.get(key, options)
+    return match.datastore.get(key, options)
   }
 
   async has (key: Key, options?: AbortOptions): Promise<boolean> {
     const match = this._lookup(key)
     if (match == null) {
-      return await Promise.resolve(false)
+      return Promise.resolve(false)
     }
-    return await match.datastore.has(key, options)
+    return match.datastore.has(key, options)
   }
 
   async delete (key: Key, options?: AbortOptions): Promise<void> {
diff --git a/packages/datastore-core/src/namespace.ts b/packages/datastore-core/src/namespace.ts
index 08f0dcd6..02c20601 100644
--- a/packages/datastore-core/src/namespace.ts
+++ b/packages/datastore-core/src/namespace.ts
@@ -1,6 +1,6 @@
 import { Key } from 'interface-datastore'
-import type { Datastore } from 'interface-datastore'
 import { KeyTransformDatastore } from './keytransform.js'
+import type { Datastore } from 'interface-datastore'
 
 /**
  * Wraps a given datastore into a keytransform which
diff --git a/packages/datastore-core/src/shard.ts b/packages/datastore-core/src/shard.ts
index 4005f1c5..5e3a8663 100644
--- a/packages/datastore-core/src/shard.ts
+++ b/packages/datastore-core/src/shard.ts
@@ -1,6 +1,6 @@
-import type { Datastore } from 'interface-datastore'
 import { Key } from 'interface-datastore/key'
 import type { Shard } from './index.js'
+import type { Datastore } from 'interface-datastore'
 
 export const PREFIX = '/repo/flatfs/shard/'
 export const SHARDING_FN = 'SHARDING'
@@ -108,8 +108,6 @@ export function parseShardFun (str: string): Shard {
 
 export const readShardFun = async (path: string | Uint8Array, store: Datastore): Promise<Shard> => {
   const key = new Key(path).child(new Key(SHARDING_FN))
-  // @ts-expect-error
-  const get = typeof store.getRaw === 'function' ? store.getRaw.bind(store) : store.get.bind(store)
-  const res = await get(key)
+  const res = await store.get(key)
   return parseShardFun(new TextDecoder().decode(res ?? '').trim())
 }
diff --git a/packages/datastore-core/src/sharding.ts b/packages/datastore-core/src/sharding.ts
index 06e191dc..6244bb2b 100644
--- a/packages/datastore-core/src/sharding.ts
+++ b/packages/datastore-core/src/sharding.ts
@@ -1,13 +1,12 @@
-import { Batch, Key, KeyQuery, KeyQueryFilter, Pair, Query, QueryFilter } from 'interface-datastore'
+import { type Batch, Key, type KeyQuery, type KeyQueryFilter, type Pair, type Query, type QueryFilter, type Datastore } from 'interface-datastore'
+import { BaseDatastore } from './base.js'
+import * as Errors from './errors.js'
+import { KeyTransformDatastore } from './keytransform.js'
 import {
   readShardFun,
   SHARDING_FN
 } from './shard.js'
-import { BaseDatastore } from './base.js'
-import { KeyTransformDatastore } from './keytransform.js'
-import * as Errors from './errors.js'
 import type { Shard } from './index.js'
-import type { Datastore } from 'interface-datastore'
 import type { AbortOptions, AwaitIterable } from 'interface-store'
 
 const shardKey = new Key(SHARDING_FN)
@@ -88,11 +87,11 @@ export class ShardingDatastore extends BaseDatastore {
   }
 
   async get (key: Key, options?: AbortOptions): Promise<Uint8Array> {
-    return await this.child.get(key, options)
+    return this.child.get(key, options)
   }
 
   async has (key: Key, options?: AbortOptions): Promise<boolean> {
-    return await this.child.has(key, options)
+    return this.child.has(key, options)
   }
 
   async delete (key: Key, options?: AbortOptions): Promise<void> {
diff --git a/packages/datastore-core/src/tiered.ts b/packages/datastore-core/src/tiered.ts
index c42084d8..dd668687 100644
--- a/packages/datastore-core/src/tiered.ts
+++ b/packages/datastore-core/src/tiered.ts
@@ -1,8 +1,8 @@
-import { BaseDatastore } from './base.js'
-import * as Errors from './errors.js'
 import { logger } from '@libp2p/logger'
-import { pushable } from 'it-pushable'
 import drain from 'it-drain'
+import { pushable } from 'it-pushable'
+import { BaseDatastore } from './base.js'
+import * as Errors from './errors.js'
 import type { Batch, Datastore, Key, KeyQuery, Pair, Query } from 'interface-datastore'
 import type { AbortOptions, AwaitIterable } from 'interface-store'
 
@@ -71,8 +71,7 @@ export class TieredDatastore extends BaseDatastore {
       })
 
       drain(store.putMany(source, options))
-        .catch(err => {
-          // store threw while putting, make sure we bubble the error up
+        .catch((err) => {
           error = err
         })
 
@@ -102,8 +101,7 @@ export class TieredDatastore extends BaseDatastore {
       })
 
       drain(store.deleteMany(source, options))
-        .catch(err => {
-          // store threw while deleting, make sure we bubble the error up
+        .catch((err) => {
           error = err
         })
 
diff --git a/packages/datastore-core/test/keytransform.spec.ts b/packages/datastore-core/test/keytransform.spec.ts
index 265266b2..ce474da6 100644
--- a/packages/datastore-core/test/keytransform.spec.ts
+++ b/packages/datastore-core/test/keytransform.spec.ts
@@ -1,10 +1,10 @@
 /* eslint-env mocha */
 
 import { expect } from 'aegir/chai'
-import all from 'it-all'
 import { Key } from 'interface-datastore/key'
-import { MemoryDatastore } from '../src/memory.js'
+import all from 'it-all'
 import { KeyTransformDatastore } from '../src/keytransform.js'
+import { MemoryDatastore } from '../src/memory.js'
 
 describe('KeyTransformDatastore', () => {
   it('basic', async () => {
@@ -33,12 +33,12 @@ describe('KeyTransformDatastore', () => {
       'foo/bar/baz/barb'
     ].map((s) => new Key(s))
     await Promise.all(keys.map(async (key) => { await kStore.put(key, key.uint8Array()) }))
-    const kResults = Promise.all(keys.map(async (key) => await kStore.get(key)))
-    const mResults = Promise.all(keys.map(async (key) => await mStore.get(new Key('abc').child(key))))
+    const kResults = Promise.all(keys.map(async (key) => kStore.get(key)))
+    const mResults = Promise.all(keys.map(async (key) => mStore.get(new Key('abc').child(key))))
     const results = await Promise.all([kResults, mResults])
     expect(results[0]).to.eql(results[1])
 
-    const mRes = await all(mStore.query({}))
+    const mRes = await Promise.resolve(all(mStore.query({})))
     const kRes = await all(kStore.query({}))
     expect(kRes).to.have.length(mRes.length)
 
diff --git a/packages/datastore-core/test/memory.spec.ts b/packages/datastore-core/test/memory.spec.ts
index 8011d6b0..3db10706 100644
--- a/packages/datastore-core/test/memory.spec.ts
+++ b/packages/datastore-core/test/memory.spec.ts
@@ -1,7 +1,7 @@
 /* eslint-env mocha */
 
-import { MemoryDatastore } from '../src/memory.js'
 import { interfaceDatastoreTests } from 'interface-datastore-tests'
+import { MemoryDatastore } from '../src/memory.js'
 
 describe('Memory', () => {
   describe('interface-datastore', () => {
diff --git a/packages/datastore-core/test/mount.spec.ts b/packages/datastore-core/test/mount.spec.ts
index a30e101c..da42feaa 100644
--- a/packages/datastore-core/test/mount.spec.ts
+++ b/packages/datastore-core/test/mount.spec.ts
@@ -2,13 +2,13 @@
 /* eslint max-nested-callbacks: ["error", 8] */
 
 import { expect, assert } from 'aegir/chai'
-import all from 'it-all'
 import { Key } from 'interface-datastore/key'
-import { MemoryDatastore } from '../src/memory.js'
-import { MountDatastore } from '../src/mount.js'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { interfaceDatastoreTests } from 'interface-datastore-tests'
+import all from 'it-all'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { KeyTransformDatastore } from '../src/keytransform.js'
+import { MemoryDatastore } from '../src/memory.js'
+import { MountDatastore } from '../src/mount.js'
 import type { Datastore } from 'interface-datastore'
 
 const stripPrefixDatastore = (datastore: Datastore, prefix: Key): Datastore => {
diff --git a/packages/datastore-core/test/namespace.spec.ts b/packages/datastore-core/test/namespace.spec.ts
index a81c677c..d82c9edd 100644
--- a/packages/datastore-core/test/namespace.spec.ts
+++ b/packages/datastore-core/test/namespace.spec.ts
@@ -1,12 +1,12 @@
 /* eslint-env mocha */
 
 import { expect } from 'aegir/chai'
-import all from 'it-all'
 import { Key } from 'interface-datastore/key'
-import { MemoryDatastore } from '../src/memory.js'
+import { interfaceDatastoreTests } from 'interface-datastore-tests'
+import all from 'it-all'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { MemoryDatastore } from '../src/memory.js'
 import { NamespaceDatastore } from '../src/namespace.js'
-import { interfaceDatastoreTests } from 'interface-datastore-tests'
 
 describe('NamespaceDatastore', () => {
   const prefixes = [
@@ -27,10 +27,10 @@ describe('NamespaceDatastore', () => {
     ].map((s) => new Key(s))
 
     await Promise.all(keys.map(async key => { await store.put(key, uint8ArrayFromString(key.toString())) }))
-    const nResults = Promise.all(keys.map(async (key) => await store.get(key)))
-    const mResults = Promise.all(keys.map(async (key) => await mStore.get(new Key(prefix).child(key))))
+    const nResults = Promise.all(keys.map(async (key) => store.get(key)))
+    const mResults = Promise.all(keys.map(async (key) => mStore.get(new Key(prefix).child(key))))
     const results = await Promise.all([nResults, mResults])
-    const mRes = await all(mStore.query({}))
+    const mRes = await Promise.resolve(all(mStore.query({})))
     const nRes = await all(store.query({}))
 
     expect(nRes).to.have.length(mRes.length)
diff --git a/packages/datastore-core/test/sharding.spec.ts b/packages/datastore-core/test/sharding.spec.ts
index 4266019b..21183b14 100644
--- a/packages/datastore-core/test/sharding.spec.ts
+++ b/packages/datastore-core/test/sharding.spec.ts
@@ -2,9 +2,10 @@
 
 import { expect } from 'aegir/chai'
 import { Key } from 'interface-datastore/key'
-import { MemoryDatastore } from '../src/memory.js'
+import { interfaceDatastoreTests } from 'interface-datastore-tests'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { MemoryDatastore } from '../src/memory.js'
 import {
   NextToLast,
   SHARDING_FN
@@ -12,7 +13,6 @@ import {
 import {
   ShardingDatastore
 } from '../src/sharding.js'
-import { interfaceDatastoreTests } from 'interface-datastore-tests'
 
 describe('ShardingDatastore', () => {
   it('create', async () => {
@@ -28,7 +28,7 @@ describe('ShardingDatastore', () => {
 
   it('open - empty', () => {
     const ms = new MemoryDatastore()
-    // @ts-expect-error
+    // @ts-expect-error No shard is given on purpose to generate an error.
     const store = new ShardingDatastore(ms)
     return expect(store.open())
       .to.eventually.be.rejected()
diff --git a/packages/datastore-core/test/tiered.spec.ts b/packages/datastore-core/test/tiered.spec.ts
index 9dade7d9..f2dc73c7 100644
--- a/packages/datastore-core/test/tiered.spec.ts
+++ b/packages/datastore-core/test/tiered.spec.ts
@@ -2,10 +2,10 @@
 
 import { expect } from 'aegir/chai'
 import { Key } from 'interface-datastore/key'
+import { interfaceDatastoreTests } from 'interface-datastore-tests'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { MemoryDatastore } from '../src/memory.js'
 import { TieredDatastore } from '../src/tiered.js'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { interfaceDatastoreTests } from 'interface-datastore-tests'
 import type { Datastore } from 'interface-datastore'
 
 /**
diff --git a/packages/datastore-fs/src/index.ts b/packages/datastore-fs/src/index.ts
index a5a54236..6843419f 100644
--- a/packages/datastore-fs/src/index.ts
+++ b/packages/datastore-fs/src/index.ts
@@ -1,17 +1,17 @@
 import fs from 'node:fs/promises'
-import glob from 'it-glob'
 import path from 'node:path'
 import { promisify } from 'util'
-import {
-  Key, KeyQuery, Pair, Query
-} from 'interface-datastore'
 import {
   BaseDatastore, Errors
 } from 'datastore-core'
-import map from 'it-map'
-import parallel from 'it-parallel-batch'
 // @ts-expect-error no types
 import fwa from 'fast-write-atomic'
+import {
+  Key, type KeyQuery, type Pair, type Query
+} from 'interface-datastore'
+import glob from 'it-glob'
+import map from 'it-map'
+import parallel from 'it-parallel-batch'
 import type { AwaitIterable } from 'interface-store'
 
 const writeAtomic = promisify(fwa)
diff --git a/packages/datastore-fs/test/index.spec.ts b/packages/datastore-fs/test/index.spec.ts
index 96d09637..69173b89 100644
--- a/packages/datastore-fs/test/index.spec.ts
+++ b/packages/datastore-fs/test/index.spec.ts
@@ -1,12 +1,12 @@
 /* eslint-env mocha */
-import { expect } from 'aegir/chai'
-import path from 'node:path'
 import fs from 'node:fs/promises'
-import { Key } from 'interface-datastore'
+import path from 'node:path'
+import { expect } from 'aegir/chai'
 import { ShardingDatastore, shard } from 'datastore-core'
+import { Key } from 'interface-datastore'
 import { interfaceDatastoreTests } from 'interface-datastore-tests'
-import { FsDatastore } from '../src/index.js'
 import tempdir from 'ipfs-utils/src/temp-dir.js'
+import { FsDatastore } from '../src/index.js'
 
 const utf8Encoder = new TextEncoder()
 
@@ -115,7 +115,7 @@ describe('FsDatastore', () => {
     await fstore.open()
     await ShardingDatastore.create(fstore, new shard.NextToLast(2))
 
-    const file = await fs.readFile(path.join(dir, shard.SHARDING_FN + '.data'))
+    const file = await fs.readFile(path.join(dir, `${shard.SHARDING_FN}.data`))
     expect(file.toString()).to.be.eql('/repo/flatfs/shard/v1/next-to-last/2\n')
 
     await fs.rm(dir, {
diff --git a/packages/datastore-idb/src/index.ts b/packages/datastore-idb/src/index.ts
index 3548b829..8a582f79 100644
--- a/packages/datastore-idb/src/index.ts
+++ b/packages/datastore-idb/src/index.ts
@@ -1,6 +1,6 @@
-import { openDB, deleteDB, IDBPDatabase } from 'idb'
-import { Batch, Key, KeyQuery, Pair, Query } from 'interface-datastore'
 import { Errors, BaseDatastore } from 'datastore-core'
+import { openDB, deleteDB, type IDBPDatabase } from 'idb'
+import { type Batch, Key, type KeyQuery, type Pair, type Query } from 'interface-datastore'
 import filter from 'it-filter'
 import sort from 'it-sort'
 
diff --git a/packages/datastore-idb/test/index.spec.ts b/packages/datastore-idb/test/index.spec.ts
index 04146e90..ecf3e381 100644
--- a/packages/datastore-idb/test/index.spec.ts
+++ b/packages/datastore-idb/test/index.spec.ts
@@ -1,10 +1,10 @@
 /* eslint-env mocha */
 
+import { expect } from 'aegir/chai'
 import { MountDatastore } from 'datastore-core'
 import { Key } from 'interface-datastore'
-import { IDBDatastore } from '../src/index.js'
-import { expect } from 'aegir/chai'
 import { interfaceDatastoreTests } from 'interface-datastore-tests'
+import { IDBDatastore } from '../src/index.js'
 
 describe('IndexedDB Datastore', function () {
   describe('interface-datastore (idb)', () => {
diff --git a/packages/datastore-level/src/index.ts b/packages/datastore-level/src/index.ts
index 405e85ef..25e9418e 100644
--- a/packages/datastore-level/src/index.ts
+++ b/packages/datastore-level/src/index.ts
@@ -1,9 +1,9 @@
-import { Batch, Key, KeyQuery, Pair, Query } from 'interface-datastore'
 import { BaseDatastore, Errors } from 'datastore-core'
+import { type Batch, Key, type KeyQuery, type Pair, type Query } from 'interface-datastore'
 import filter from 'it-filter'
 import map from 'it-map'
-import take from 'it-take'
 import sort from 'it-sort'
+import take from 'it-take'
 import { Level } from 'level'
 import type { DatabaseOptions, OpenOptions, IteratorOptions } from 'level'
 
@@ -232,7 +232,7 @@ function oldLevelIteratorToIterator (li: OldLevelIterator): AsyncIterable<Pair>
   return {
     [Symbol.asyncIterator] () {
       return {
-        next: async () => await new Promise((resolve, reject) => {
+        next: async () => new Promise((resolve, reject) => {
           li.next((err, key, value) => {
             if (err != null) {
               reject(err); return
@@ -249,7 +249,7 @@ function oldLevelIteratorToIterator (li: OldLevelIterator): AsyncIterable<Pair>
             resolve({ done: false, value: { key: new Key(key, false), value } })
           })
         }),
-        return: async () => await new Promise((resolve, reject) => {
+        return: async () => new Promise((resolve, reject) => {
           li.end(err => {
             if (err != null) {
               reject(err); return
diff --git a/packages/datastore-level/test/browser.ts b/packages/datastore-level/test/browser.ts
index e86adacd..481c5c6e 100644
--- a/packages/datastore-level/test/browser.ts
+++ b/packages/datastore-level/test/browser.ts
@@ -2,8 +2,8 @@
 
 import { MountDatastore } from 'datastore-core'
 import { Key } from 'interface-datastore/key'
-import { LevelDatastore } from '../src/index.js'
 import { interfaceDatastoreTests } from 'interface-datastore-tests'
+import { LevelDatastore } from '../src/index.js'
 
 describe('LevelDatastore', () => {
   describe('interface-datastore (leveljs)', () => {
diff --git a/packages/datastore-level/test/fixtures/test-level-iterator-destroy.ts b/packages/datastore-level/test/fixtures/test-level-iterator-destroy.ts
index ac945639..3be86b02 100644
--- a/packages/datastore-level/test/fixtures/test-level-iterator-destroy.ts
+++ b/packages/datastore-level/test/fixtures/test-level-iterator-destroy.ts
@@ -1,6 +1,6 @@
 import { Key } from 'interface-datastore/key'
-import { LevelDatastore } from '../../src/index.js'
 import tempdir from 'ipfs-utils/src/temp-dir.js'
+import { LevelDatastore } from '../../src/index.js'
 
 async function testLevelIteratorDestroy (): Promise<void> {
   const store = new LevelDatastore(tempdir())
diff --git a/packages/datastore-level/test/index.spec.ts b/packages/datastore-level/test/index.spec.ts
index b4f58e7f..522fbe7a 100644
--- a/packages/datastore-level/test/index.spec.ts
+++ b/packages/datastore-level/test/index.spec.ts
@@ -1,11 +1,11 @@
 /* eslint-env mocha */
 
 import { expect } from 'aegir/chai'
-import { MemoryLevel } from 'memory-level'
+import { interfaceDatastoreTests } from 'interface-datastore-tests'
+import tempdir from 'ipfs-utils/src/temp-dir.js'
 import { Level } from 'level'
+import { MemoryLevel } from 'memory-level'
 import { LevelDatastore } from '../src/index.js'
-import tempdir from 'ipfs-utils/src/temp-dir.js'
-import { interfaceDatastoreTests } from 'interface-datastore-tests'
 
 describe('LevelDatastore', () => {
   describe('initialization', () => {
diff --git a/packages/datastore-level/test/node.ts b/packages/datastore-level/test/node.ts
index 075af85f..37ee8cd8 100644
--- a/packages/datastore-level/test/node.ts
+++ b/packages/datastore-level/test/node.ts
@@ -1,13 +1,13 @@
 /* eslint-env mocha */
 
-import { expect } from 'aegir/chai'
+import childProcess from 'child_process'
 import path from 'path'
-import { Key } from 'interface-datastore/key'
+import { expect } from 'aegir/chai'
 import { MountDatastore } from 'datastore-core'
-import childProcess from 'child_process'
+import { Key } from 'interface-datastore/key'
 import { interfaceDatastoreTests } from 'interface-datastore-tests'
-import { LevelDatastore } from '../src/index.js'
 import tempdir from 'ipfs-utils/src/temp-dir.js'
+import { LevelDatastore } from '../src/index.js'
 
 describe('LevelDatastore', () => {
   describe('interface-datastore (leveldown)', () => {
diff --git a/packages/datastore-s3/src/index.ts b/packages/datastore-s3/src/index.ts
index 89a87588..4087cd6d 100644
--- a/packages/datastore-s3/src/index.ts
+++ b/packages/datastore-s3/src/index.ts
@@ -1,11 +1,3 @@
-import filter from 'it-filter'
-import { Key, KeyQuery, Pair, Query } from 'interface-datastore'
-import { BaseDatastore } from 'datastore-core/base'
-import * as Errors from 'datastore-core/errors'
-import { fromString as unint8arrayFromString } from 'uint8arrays'
-import toBuffer from 'it-to-buffer'
-import type { S3 } from '@aws-sdk/client-s3'
-import type { AbortOptions } from 'interface-store'
 import {
   PutObjectCommand,
   CreateBucketCommand,
@@ -14,6 +6,13 @@ import {
   DeleteObjectCommand,
   ListObjectsV2Command
 } from '@aws-sdk/client-s3'
+import { BaseDatastore, Errors } from 'datastore-core'
+import { Key, type KeyQuery, type Pair, type Query } from 'interface-datastore'
+import filter from 'it-filter'
+import toBuffer from 'it-to-buffer'
+import { fromString as unint8arrayFromString } from 'uint8arrays'
+import type { S3 } from '@aws-sdk/client-s3'
+import type { AbortOptions } from 'interface-store'
 
 export interface S3DatastoreInit {
   /**
diff --git a/packages/datastore-s3/test/index.spec.ts b/packages/datastore-s3/test/index.spec.ts
index 007850cc..28aaf2fd 100644
--- a/packages/datastore-s3/test/index.spec.ts
+++ b/packages/datastore-s3/test/index.spec.ts
@@ -1,14 +1,13 @@
 /* eslint-env mocha */
 
+import { type CreateBucketCommand, type PutObjectCommand, type HeadObjectCommand, S3, type GetObjectCommand } from '@aws-sdk/client-s3'
 import { expect } from 'aegir/chai'
-import sinon from 'sinon'
 import { Key } from 'interface-datastore'
-import { CreateBucketCommand, PutObjectCommand, HeadObjectCommand, S3, GetObjectCommand } from '@aws-sdk/client-s3'
-import defer from 'p-defer'
 import { interfaceDatastoreTests } from 'interface-datastore-tests'
-
-import { s3Resolve, s3Reject, S3Error, s3Mock } from './utils/s3-mock.js'
+import defer from 'p-defer'
+import sinon from 'sinon'
 import { S3Datastore } from '../src/index.js'
+import { s3Resolve, s3Reject, S3Error, s3Mock } from './utils/s3-mock.js'
 
 describe('S3Datastore', () => {
   describe('construction', () => {
diff --git a/packages/datastore-s3/test/utils/s3-mock.ts b/packages/datastore-s3/test/utils/s3-mock.ts
index 6c4bf01f..ac100f40 100644
--- a/packages/datastore-s3/test/utils/s3-mock.ts
+++ b/packages/datastore-s3/test/utils/s3-mock.ts
@@ -30,9 +30,9 @@ export const s3Reject = <T> (err: T): any => {
  */
 export function s3Mock (s3: S3): S3 {
   const mocks: any = {}
-  const storage: Map<string, any> = new Map()
+  const storage = new Map<string, any>()
 
-  mocks.send = sinon.replace(s3, 'send', (command) => {
+  mocks.send = sinon.replace(s3, 'send', (command: Parameters<S3['send']>[0]) => {
     const commandName = command.constructor.name
     const input: any = command.input
 
diff --git a/packages/interface-blockstore-tests/src/index.ts b/packages/interface-blockstore-tests/src/index.ts
index d3a7faa6..313c94cb 100644
--- a/packages/interface-blockstore-tests/src/index.ts
+++ b/packages/interface-blockstore-tests/src/index.ts
@@ -3,12 +3,12 @@
 import { expect } from 'aegir/chai'
 import all from 'it-all'
 import drain from 'it-drain'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { sha256 } from 'multiformats/hashes/sha2'
-import type { Blockstore, Pair } from 'interface-blockstore'
 import { base32 } from 'multiformats/bases/base32'
 import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
+import { sha256 } from 'multiformats/hashes/sha2'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import type { Blockstore, Pair } from 'interface-blockstore'
 
 async function getKeyValuePair (data?: string): Promise<Pair> {
   const block = uint8ArrayFromString(data ?? `data-${Math.random()}`)
@@ -19,8 +19,8 @@ async function getKeyValuePair (data?: string): Promise<Pair> {
 }
 
 async function getKeyValuePairs (count: number): Promise<Pair[]> {
-  return await Promise.all(
-    new Array(count).fill(0).map(async (_, i) => await getKeyValuePair())
+  return Promise.all(
+    new Array(count).fill(0).map(async (_, i) => getKeyValuePair())
   )
 }
 
@@ -66,7 +66,7 @@ export function interfaceBlockstoreTests <B extends Blockstore = Blockstore> (te
 
       await Promise.all(data.map(async d => { await store.put(d.cid, d.block) }))
 
-      const res = await all(store.getMany(data.map(d => d.cid)))
+      const res = await Promise.resolve(all(store.getMany(data.map(d => d.cid))))
       expect(res).to.deep.equal(data)
     })
   })
@@ -94,7 +94,7 @@ export function interfaceBlockstoreTests <B extends Blockstore = Blockstore> (te
 
       expect(index).to.equal(data.length)
 
-      const res = await all(store.getMany(data.map(d => d.cid)))
+      const res = await Promise.resolve(all(store.getMany(data.map(d => d.cid))))
       expect(res).to.deep.equal(data)
     })
   })
@@ -156,7 +156,7 @@ export function interfaceBlockstoreTests <B extends Blockstore = Blockstore> (te
       await store.put(cid, block)
       const source = [cid]
 
-      const res = await all(store.getMany(source))
+      const res = await Promise.resolve(all(store.getMany(source)))
       expect(res).to.have.lengthOf(1)
       expect(res[0].cid).to.deep.equal(cid)
       expect(res[0].block).to.equalBytes(block)
@@ -168,7 +168,8 @@ export function interfaceBlockstoreTests <B extends Blockstore = Blockstore> (te
       } = await getKeyValuePair()
 
       try {
-        await drain(store.getMany([cid]))
+        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+        await Promise.resolve(drain(store.getMany([cid])))
       } catch (err) {
         expect(err).to.have.property('code', 'ERR_NOT_FOUND')
         return
@@ -192,9 +193,10 @@ export function interfaceBlockstoreTests <B extends Blockstore = Blockstore> (te
     it('returns all blocks', async () => {
       const data = await getKeyValuePairs(100)
 
-      await drain(store.putMany(data))
+      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+      await Promise.resolve(drain(store.putMany(data)))
 
-      const allBlocks = await all(store.getAll())
+      const allBlocks = await Promise.resolve(all(store.getAll()))
 
       expect(allBlocks).of.have.lengthOf(data.length)
 
@@ -243,12 +245,12 @@ export function interfaceBlockstoreTests <B extends Blockstore = Blockstore> (te
 
       await Promise.all(data.map(async d => { await store.put(d.cid, d.block) }))
 
-      const res0 = await Promise.all(data.map(async d => await store.has(d.cid)))
+      const res0 = await Promise.all(data.map(async d => store.has(d.cid)))
       res0.forEach(res => expect(res).to.be.eql(true))
 
       await Promise.all(data.map(async d => { await store.delete(d.cid) }))
 
-      const res1 = await Promise.all(data.map(async d => await store.has(d.cid)))
+      const res1 = await Promise.all(data.map(async d => store.has(d.cid)))
       res1.forEach(res => expect(res).to.be.eql(false))
     })
   })
@@ -267,9 +269,10 @@ export function interfaceBlockstoreTests <B extends Blockstore = Blockstore> (te
     it('streaming', async () => {
       const data = await getKeyValuePairs(100)
 
-      await drain(store.putMany(data))
+      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+      await Promise.resolve(drain(store.putMany(data)))
 
-      const res0 = await Promise.all(data.map(async d => await store.has(d.cid)))
+      const res0 = await Promise.all(data.map(async d => store.has(d.cid)))
       res0.forEach(res => expect(res).to.be.eql(true))
 
       let index = 0
@@ -281,7 +284,7 @@ export function interfaceBlockstoreTests <B extends Blockstore = Blockstore> (te
 
       expect(index).to.equal(data.length)
 
-      const res1 = await Promise.all(data.map(async d => await store.has(d.cid)))
+      const res1 = await Promise.all(data.map(async d => store.has(d.cid)))
       res1.forEach(res => expect(res).to.be.eql(false))
     })
   })
diff --git a/packages/interface-blockstore/src/index.ts b/packages/interface-blockstore/src/index.ts
index b19875e8..eedf1e84 100644
--- a/packages/interface-blockstore/src/index.ts
+++ b/packages/interface-blockstore/src/index.ts
@@ -10,10 +10,10 @@ export interface Pair {
   block: Uint8Array
 }
 
-export interface Blockstore <HasOptionsExtension = {},
-PutOptionsExtension = {}, PutManyOptionsExtension = {},
-GetOptionsExtension = {}, GetManyOptionsExtension = {}, GetAllOptionsExtension = {},
-DeleteOptionsExtension = {}, DeleteManyOptionsExtension = {}> extends Store<CID, Uint8Array, Pair, HasOptionsExtension,
+export interface Blockstore <HasOptionsExtension = unknown,
+PutOptionsExtension = unknown, PutManyOptionsExtension = unknown,
+GetOptionsExtension = unknown, GetManyOptionsExtension = unknown, GetAllOptionsExtension = unknown,
+DeleteOptionsExtension = unknown, DeleteManyOptionsExtension = unknown> extends Store<CID, Uint8Array, Pair, HasOptionsExtension,
   PutOptionsExtension, PutManyOptionsExtension,
   GetOptionsExtension, GetManyOptionsExtension,
   DeleteOptionsExtension, DeleteManyOptionsExtension> {
diff --git a/packages/interface-datastore-tests/src/index.ts b/packages/interface-datastore-tests/src/index.ts
index 7143cc13..cce19519 100644
--- a/packages/interface-datastore-tests/src/index.ts
+++ b/packages/interface-datastore-tests/src/index.ts
@@ -1,12 +1,12 @@
 /* eslint-env mocha */
 
-import { randomBytes } from 'iso-random-stream'
 import { expect } from 'aegir/chai'
+import { type Datastore, Key, type KeyQueryFilter, type KeyQueryOrder, type Pair, type QueryFilter, type QueryOrder } from 'interface-datastore'
+import { randomBytes } from 'iso-random-stream'
 import all from 'it-all'
 import drain from 'it-drain'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { Datastore, Key, KeyQueryFilter, KeyQueryOrder, Pair, QueryFilter, QueryOrder } from 'interface-datastore'
 import length from 'it-length'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 
 export interface InterfacDatastoreTest<D extends Datastore = Datastore> {
   setup: () => D | Promise<D>
@@ -19,7 +19,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
   }
 
   const createStore = async (): Promise<D> => {
-    return await test.setup()
+    return test.setup()
   }
 
   describe('put', () => {
@@ -44,7 +44,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
 
       await Promise.all(data.map(async d => { await store.put(d.key, d.value) }))
 
-      const res = await all(store.getMany(data.map(d => d.key)))
+      const res = await Promise.resolve(all(store.getMany(data.map(d => d.key))))
       expect(res).to.deep.equal(data)
     })
   })
@@ -73,7 +73,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
 
       expect(index).to.equal(data.length)
 
-      const res = await all(store.getMany(data.map(d => d.key)))
+      const res = await Promise.resolve(all(store.getMany(data.map(d => d.key))))
       expect(res).to.deep.equal(data)
     })
   })
@@ -122,7 +122,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
       await store.put(k, uint8ArrayFromString('hello'))
       const source = [k]
 
-      const res = await all(store.getMany(source))
+      const res = await Promise.resolve(all(store.getMany(source)))
       expect(res).to.have.lengthOf(1)
       expect(res[0].key).to.be.eql(k)
       expect(res[0].value).to.be.eql(uint8ArrayFromString('hello'))
@@ -132,7 +132,8 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
       const k = new Key('/does/not/exist')
 
       try {
-        await drain(store.getMany([k]))
+        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+        await Promise.resolve(drain(store.getMany([k])))
       } catch (err) {
         expect(err).to.have.property('code', 'ERR_NOT_FOUND')
         return
@@ -168,12 +169,12 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
 
       await Promise.all(data.map(async d => { await store.put(d[0], d[1]) }))
 
-      const res0 = await Promise.all(data.map(async d => await store.has(d[0])))
+      const res0 = await Promise.all(data.map(async d => store.has(d[0])))
       res0.forEach(res => expect(res).to.be.eql(true))
 
       await Promise.all(data.map(async d => { await store.delete(d[0]) }))
 
-      const res1 = await Promise.all(data.map(async d => await store.has(d[0])))
+      const res1 = await Promise.all(data.map(async d => store.has(d[0])))
       res1.forEach(res => expect(res).to.be.eql(false))
     })
   })
@@ -193,9 +194,10 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
         data.push({ key: new Key(`/a/key${i}`), value: uint8ArrayFromString(`data${i}`) })
       }
 
-      await drain(store.putMany(data))
+      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+      await Promise.resolve(drain(store.putMany(data)))
 
-      const res0 = await Promise.all(data.map(async d => await store.has(d.key)))
+      const res0 = await Promise.all(data.map(async d => store.has(d.key)))
       res0.forEach(res => expect(res).to.be.eql(true))
 
       let index = 0
@@ -207,7 +209,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
 
       expect(index).to.equal(data.length)
 
-      const res1 = await Promise.all(data.map(async d => await store.has(d.key)))
+      const res1 = await Promise.all(data.map(async d => store.has(d.key)))
       res1.forEach(res => expect(res).to.be.eql(false))
     })
   })
@@ -233,7 +235,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
       await b.commit()
 
       const keys = ['/a/one', '/q/two', '/q/three', '/z/old']
-      const res = await Promise.all(keys.map(async k => await store.has(new Key(k))))
+      const res = await Promise.all(keys.map(async k => store.has(new Key(k))))
 
       expect(res).to.be.eql([true, true, true, false])
     })
@@ -250,9 +252,13 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
 
       await b.commit()
 
-      expect(await length(store.query({ prefix: '/a' }))).to.equal(count)
-      expect(await length(store.query({ prefix: '/z' }))).to.equal(count)
-      expect(await length(store.query({ prefix: '/q' }))).to.equal(count)
+      const length1 = await Promise.resolve(length(store.query({ prefix: '/a' })))
+      const length2 = await Promise.resolve(length(store.query({ prefix: '/z' })))
+      const length3 = await Promise.resolve(length(store.query({ prefix: '/q' })))
+
+      expect(length1).to.equal(count)
+      expect(length2).to.equal(count)
+      expect(length3).to.equal(count)
     })
   })
 
@@ -307,7 +313,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
     after(async () => { await cleanup(store) })
 
     tests.forEach(([name, query, expected]) => it(name, async () => {
-      let res = await all(store.query(query))
+      let res = await Promise.resolve(all(store.query(query)))
 
       if (Array.isArray(expected)) {
         if (query.orders == null) {
@@ -355,7 +361,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
         }
       }
 
-      const results = await all(store.query({}))
+      const results = await Promise.resolve(all(store.query({})))
 
       expect(firstIteration).to.be.false('Query did not return anything')
       expect(results.map(result => result.key)).to.have.deep.members([
@@ -367,7 +373,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
 
     it('queries while the datastore is being mutated', async () => {
       const writePromise = store.put(new Key(`/z/key-${Math.random()}`), uint8ArrayFromString('0'))
-      const results = await all(store.query({}))
+      const results = await Promise.resolve(all(store.query({})))
       expect(results.length).to.be.greaterThan(0)
       await writePromise
     })
@@ -425,7 +431,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
     after(async () => { await cleanup(store) })
 
     tests.forEach(([name, query, expected]) => it(name, async () => {
-      let res = await all(store.queryKeys(query))
+      let res = await Promise.resolve(all(store.queryKeys(query)))
 
       if (Array.isArray(expected)) {
         if (query.orders == null) {
@@ -467,7 +473,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
         }
       }
 
-      const results = await all(store.queryKeys({}))
+      const results = await Promise.resolve(all(store.queryKeys({})))
 
       expect(firstIteration).to.be.false('Query did not return anything')
       expect(results).to.have.deep.members([
@@ -479,7 +485,7 @@ export function interfaceDatastoreTests <D extends Datastore = Datastore> (test:
 
     it('queries while the datastore is being mutated', async () => {
       const writePromise = store.put(new Key(`/z/key-${Math.random()}`), uint8ArrayFromString('0'))
-      const results = await all(store.queryKeys({}))
+      const results = await Promise.resolve(all(store.queryKeys({})))
       expect(results.length).to.be.greaterThan(0)
       await writePromise
     })
diff --git a/packages/interface-datastore/src/index.ts b/packages/interface-datastore/src/index.ts
index c6360bf7..4a2affaf 100644
--- a/packages/interface-datastore/src/index.ts
+++ b/packages/interface-datastore/src/index.ts
@@ -1,28 +1,28 @@
+import { Key } from './key.js'
 import type {
   Await,
   AwaitIterable,
   Store,
   AbortOptions
 } from 'interface-store'
-import { Key } from './key.js'
 
 export interface Pair {
   key: Key
   value: Uint8Array
 }
 
-export interface Batch<BatchOptionsExtension = {}> {
+export interface Batch<BatchOptionsExtension = unknown> {
   put: (key: Key, value: Uint8Array) => void
   delete: (key: Key) => void
   commit: (options?: AbortOptions & BatchOptionsExtension) => Await<void>
 }
 
-export interface Datastore <HasOptionsExtension = {},
-PutOptionsExtension = {}, PutManyOptionsExtension = {},
-GetOptionsExtension = {}, GetManyOptionsExtension = {},
-DeleteOptionsExtension = {}, DeleteManyOptionsExtension = {},
-QueryOptionsExtension = {}, QueryKeysOptionsExtension = {},
-BatchOptionsExtension = {}
+export interface Datastore <HasOptionsExtension = unknown,
+PutOptionsExtension = unknown, PutManyOptionsExtension = unknown,
+GetOptionsExtension = unknown, GetManyOptionsExtension = unknown,
+DeleteOptionsExtension = unknown, DeleteManyOptionsExtension = unknown,
+QueryOptionsExtension = unknown, QueryKeysOptionsExtension = unknown,
+BatchOptionsExtension = unknown,
 > extends Store<Key, Uint8Array, Pair, HasOptionsExtension,
   PutOptionsExtension, PutManyOptionsExtension,
   GetOptionsExtension, GetManyOptionsExtension,
diff --git a/packages/interface-datastore/src/key.ts b/packages/interface-datastore/src/key.ts
index aed1d7b6..e12d9b29 100644
--- a/packages/interface-datastore/src/key.ts
+++ b/packages/interface-datastore/src/key.ts
@@ -1,7 +1,7 @@
 
 import { nanoid } from 'nanoid'
-import { SupportedEncodings, toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { type SupportedEncodings, toString as uint8ArrayToString } from 'uint8arrays/to-string'
 
 const pathSepS = '/'
 const pathSepB = new TextEncoder().encode(pathSepS)
@@ -385,7 +385,6 @@ export class Key {
    * Checks if this key has only one namespace.
    *
    * @returns {boolean}
-   *
    */
   isTopLevel (): boolean {
     return this.list().length === 1
diff --git a/packages/interface-datastore/test/key.spec.ts b/packages/interface-datastore/test/key.spec.ts
index 5a1fb159..07dfa61d 100644
--- a/packages/interface-datastore/test/key.spec.ts
+++ b/packages/interface-datastore/test/key.spec.ts
@@ -1,8 +1,8 @@
 /* eslint-env mocha */
 
 import { expect } from 'aegir/chai'
-import { Key } from '../src/key.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays'
+import { Key } from '../src/key.js'
 
 const pathSep = '/'
 
diff --git a/packages/interface-store/src/index.ts b/packages/interface-store/src/index.ts
index cc3c805c..8e25f2b5 100644
--- a/packages/interface-store/src/index.ts
+++ b/packages/interface-store/src/index.ts
@@ -16,10 +16,10 @@ export interface AbortOptions {
   signal?: AbortSignal
 }
 
-export interface Store<Key, Value, Pair, HasOptionsExtension = {},
-  PutOptionsExtension = {}, PutManyOptionsExtension = {},
-  GetOptionsExtension = {}, GetManyOptionsExtension = {},
-  DeleteOptionsExtension = {}, DeleteManyOptionsExtension = {}> {
+export interface Store<Key, Value, Pair, HasOptionsExtension = unknown,
+  PutOptionsExtension = unknown, PutManyOptionsExtension = unknown,
+  GetOptionsExtension = unknown, GetManyOptionsExtension = unknown,
+  DeleteOptionsExtension = unknown, DeleteManyOptionsExtension = unknown> {
   /**
    * Check for the existence of a value for the passed key
    *