@fireproof/core 0.20.0-dev-preview-39 → 0.20.0-dev-preview-41

package/tests/blockstore/keyed-crypto-indexeddb-file.test.ts

@@ -1,9 +1,8 @@
 import { bs, ensureSuperThis, PARAM, rt } from "@fireproof/core";
 import { runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
 import { base58btc } from "multiformats/bases/base58";
-import { mockSuperThis } from "../helpers.js";
+import { mockLoader, mockSuperThis } from "../helpers.js";
 import { KeyBagProviderIndexedDB } from "@fireproof/core/indexeddb";
-import { toKeyWithFingerPrint } from "../../src/runtime/key-bag.js";
 
 describe("KeyBag indexeddb and file", () => {
   let url: URI;
@@ -73,10 +72,10 @@ describe("KeyBag indexeddb and file", () => {
         return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeysItem;
       });
     }
-    expect((await toKeyWithFingerPrint(kb, Object.values(diskBag.keys)[0].key)).Ok().fingerPrint).toEqual(
+    expect((await rt.kb.toKeyWithFingerPrint(kb, Object.values(diskBag.keys)[0].key)).Ok().fingerPrint).toEqual(
       (await res.Ok().get())?.fingerPrint,
     );
-    expect((await toKeyWithFingerPrint(kb, Object.values(diskBag2.keys)[0].key)).Ok().fingerPrint).toEqual(
+    expect((await rt.kb.toKeyWithFingerPrint(kb, Object.values(diskBag2.keys)[0].key)).Ok().fingerPrint).toEqual(
       (await created.Ok().get())?.fingerPrint,
     );
     const algo = {
@@ -105,29 +104,20 @@ describe("KeyedCryptoStore", () => {
   beforeEach(async () => {
     await sthis.start();
     // logger = MockLogger().logger;
-    let kbUrl: URI;
+    // let kbUrl: URI;
     if (runtimeFn().isBrowser) {
-      kbUrl = URI.from("indexeddb://fp-keybag");
+      // kbUrl = URI.from("indexeddb://fp-keybag");
       baseUrl = URI.from("indexeddb://fp-keyed-crypto-store");
     } else {
-      kbUrl = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
+      // kbUrl = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
       baseUrl = URI.merge("file://./dist/tests/keyed-crypto-store", sthis.env.get("FP_STORAGE_URL"));
     }
     baseUrl = baseUrl.build().defParam(PARAM.NAME, "test").URI();
-    loader = {
-      sthis,
-      keyBag: () => rt.kb.getKeyBag(sthis, { url: kbUrl }),
-    } as bs.Loadable;
+    loader = mockLoader(sthis);
   });
   it("no crypto", async () => {
-    const strt = bs.toStoreRuntime(sthis);
     const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
-
-    for (const pstore of [
-      strt.makeDataStore({ url, loader }),
-      strt.makeMetaStore({ url, loader }),
-      strt.makeWALStore({ url, loader }),
-    ]) {
+    for (const pstore of (await bs.createAttachedStores(url, loader, "insecure")).stores.baseStores) {
       const store = await pstore;
       // await store.start();
       const kc = await store.keyedCrypto();

package/tests/blockstore/keyed-crypto.test.ts

@@ -4,7 +4,7 @@ import { base58btc } from "multiformats/bases/base58";
 import { sha256 as hasher } from "multiformats/hashes/sha2";
 import * as dagCodec from "@ipld/dag-cbor";
 import type { KeyBagProviderIndexedDB } from "@fireproof/core/indexeddb";
-import { MockSuperThis, mockSuperThis } from "../helpers.js";
+import { mockLoader, MockSuperThis, mockSuperThis } from "../helpers.js";
 import { KeyWithFingerPrint } from "../../src/blockstore/types.js";
 import { toKeyWithFingerPrint } from "../../src/runtime/key-bag.js";
 
@@ -230,11 +230,11 @@ describe("KeyBag", () => {
 });
 
 describe("KeyedCryptoStore", () => {
-  let loader: bs.Loadable;
   let kb: rt.kb.KeyBag;
   // let logger: Logger;
   let baseUrl: URI;
   const sthis = ensureSuperThis();
+  let loader: bs.Loadable;
   beforeEach(async () => {
     await sthis.start();
     // logger = MockLogger().logger;
@@ -256,20 +256,12 @@ describe("KeyedCryptoStore", () => {
     }
     baseUrl = baseUrl.build().setParam(PARAM.NAME, "test").URI();
     kb = await rt.kb.getKeyBag(sthis, {});
-    loader = {
-      sthis,
-      keyBag: async () => kb,
-    } as bs.Loadable;
+    loader = mockLoader(sthis);
   });
   it("no crypto", async () => {
-    const strt = bs.toStoreRuntime(sthis);
     const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
 
-    for (const pstore of [
-      strt.makeDataStore({ url, loader }),
-      strt.makeMetaStore({ url, loader }),
-      strt.makeWALStore({ url, loader }),
-    ]) {
+    for (const pstore of (await bs.createAttachedStores(url, loader, "insecure")).stores.baseStores) {
       const store = await pstore;
       // await store.start();
       const kc = await store.keyedCrypto();
@@ -281,12 +273,7 @@ describe("KeyedCryptoStore", () => {
   });
 
   it("create key", async () => {
-    const strt = bs.toStoreRuntime(sthis);
-    for (const pstore of [
-      strt.makeDataStore({ url: baseUrl, loader }),
-      strt.makeMetaStore({ url: baseUrl, loader }),
-      strt.makeWALStore({ url: baseUrl, loader }),
-    ]) {
+    for (const pstore of (await bs.createAttachedStores(baseUrl, loader, "insecure")).stores.baseStores) {
       const store = await pstore; // await bs.ensureStart(await pstore, logger);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("cryptoAction");
@@ -299,12 +286,7 @@ describe("KeyedCryptoStore", () => {
     const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
     const genKey = await kb.getNamedKey("@heute@", false, key);
     const url = baseUrl.build().setParam(PARAM.STORE_KEY, "@heute@").URI();
-    const strt = bs.toStoreRuntime(sthis);
-    for (const pstore of [
-      strt.makeDataStore({ url, loader }),
-      strt.makeMetaStore({ url, loader }),
-      strt.makeWALStore({ url, loader }),
-    ]) {
+    for (const pstore of (await bs.createAttachedStores(url, loader, "insecure")).stores.baseStores) {
       const store = await pstore;
       // await store.start();
       expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@heute@`);
@@ -324,13 +306,8 @@ describe("KeyedCryptoStore", () => {
 
   it("key", async () => {
     const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const strt = bs.toStoreRuntime(sthis);
     const url = baseUrl.build().setParam(PARAM.STORE_KEY, key).URI();
-    for (const pstore of [
-      strt.makeDataStore({ url, loader }),
-      strt.makeMetaStore({ url, loader }),
-      strt.makeWALStore({ url, loader }),
-    ]) {
+    for (const pstore of (await bs.createAttachedStores(url, loader, "insecure")).stores.baseStores) {
       // for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
       const store = await pstore;
       // await store.start();

package/tests/blockstore/loader.test.ts

@@ -54,12 +54,12 @@ describe("basic Loader simple", function () {
   let t: CarTransaction;
   const sthis = ensureSuperThis();
 
-  afterEach(async function () {
+  afterEach(async () => {
     await loader.close();
     await loader.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     const testDbName = "test-loader-commit";
     await sthis.start();
     const mockM = new MyMemoryBlockStore(sthis);
@@ -80,10 +80,10 @@ describe("basic Loader simple", function () {
   it("should have an empty car log", function () {
     expect(loader.carLog.length).toBe(0);
   });
-  it("should commit", async function () {
+  it("should commit", async () => {
     const carGroup = await loader.commit(t, { head: [block.cid] });
     expect(loader.carLog.length).toBe(1);
-    const reader = await loader.loadCar(carGroup[0]);
+    const reader = await loader.loadCar(carGroup[0], loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
@@ -105,7 +105,7 @@ describe("basic Loader with two commits", function () {
 
   const sthis = ensureSuperThis();
 
-  afterEach(async function () {
+  afterEach(async () => {
     await loader.close();
     await loader.destroy();
   });
@@ -118,6 +118,7 @@ describe("basic Loader with two commits", function () {
       ...simpleBlockOpts(sthis, "test-loader-two-commit"),
       public: true,
     });
+    await loader.ready();
 
     block = await rt.mf.block.encode({
       value: { hello: "world" },
@@ -157,8 +158,8 @@ describe("basic Loader with two commits", function () {
     expect(loader.carLog[1].toString()).toBe(carCid0.toString());
   });
 
-  it("should commit", async function () {
-    const reader = await loader.loadCar(carCid[0]);
+  it("should commit", async () => {
+    const reader = await loader.loadCar(carCid[0], loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
@@ -168,11 +169,11 @@ describe("basic Loader with two commits", function () {
     expect(parsed.meta.head).toBeTruthy();
   });
 
-  it("should compact", async function () {
+  it("should compact", async () => {
     const compactCid = await loader.commit(t, { head: [block2.cid] }, { compact: true });
     expect(loader.carLog.length).toBe(1);
 
-    const reader = await loader.loadCar(compactCid[0]);
+    const reader = await loader.loadCar(compactCid[0], loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
@@ -182,8 +183,8 @@ describe("basic Loader with two commits", function () {
     expect(parsed.meta.head).toBeTruthy();
   });
 
-  it("compact should erase old files", async function () {
-    const cs = await loader.carStore();
+  it("compact should erase old files", async () => {
+    const cs = await loader.attachedStores.local().active.car;
     await loader.commit(t, { head: [block2.cid] }, { compact: true });
     expect(loader.carLog.length).toBe(1);
     await loader.commit(t, { head: [block3.cid] }, { compact: false });
@@ -196,10 +197,10 @@ describe("basic Loader with two commits", function () {
     await loader.commit(t, { head: [block4.cid] }, { compact: false });
     expect(loader.carLog.length).toBe(2);
 
-    const e = await loader.loadCar(carCid[0]).catch((e) => e);
+    const e = await loader.loadCar(carCid[0], loader.attachedStores.local()).catch((e) => e);
     expect(e).toBeTruthy();
     expect(e instanceof Error).toBeTruthy();
-    expect(e.message).toMatch("missing car file");
+    expect(e.message).toMatch(/(missing car file)|(not found)/);
   }, 10000);
 });
 
@@ -211,16 +212,17 @@ describe("basic Loader with index commits", function () {
   // let indexMap: Map<string, CID>;
   const sthis = ensureSuperThis();
 
-  afterEach(async function () {
+  afterEach(async () => {
     await ib.close();
     await ib.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     const name = "test-loader-index" + Math.random();
     await sthis.start();
     // t = new CarTransaction()
     ib = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis, name));
+    await ib.ready();
     block = await rt.mf.block.encode({
       value: { hello: "world" },
       hasher,
@@ -248,7 +250,7 @@ describe("basic Loader with index commits", function () {
     expect(ib.loader.carLog.length).toBe(0);
   });
 
-  it("should commit the index metadata", async function () {
+  it("should commit the index metadata", async () => {
     const { cars: carCid } = await ib.transaction<IndexTransactionMeta>(
       async (t) => {
         await t.put(block.cid, block.bytes);
@@ -262,7 +264,7 @@ describe("basic Loader with index commits", function () {
 
     expect(carLog.length).toBe(1);
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const reader = await ib.loader.loadCar(carCid![0]);
+    const reader = await ib.loader.loadCar(carCid![0], ib.loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<IndexTransactionMeta>(reader, sthis.logger);
     expect(parsed.cars).toBeTruthy();

package/tests/blockstore/store.test.ts

@@ -1,30 +1,26 @@
 import { CID } from "multiformats";
-import { rt, bs, NotFoundError, SuperThis, PARAM, DbMeta, ensureSuperThis } from "@fireproof/core";
-import { noopUrl } from "../helpers.js";
+import { rt, bs, NotFoundError, PARAM, ensureSuperThis } from "@fireproof/core";
 import { Result } from "@adviser/cement";
-
-function runtime(sthis: SuperThis) {
-  return bs.toStoreRuntime(sthis);
-}
-
-async function mockLoader(sthis: SuperThis, name?: string): Promise<bs.StoreFactoryItem> {
-  const url = noopUrl(name);
-  return {
-    // sthis,
-    url: url,
-    loader: {
-      sthis,
-      keyBag: () => rt.kb.getKeyBag(sthis),
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      handleDbMetasFromStore: (metas: DbMeta[]): Promise<void> => Promise.resolve(),
-    } as bs.Loader,
-  };
-}
+import { createAttachedStores } from "../../src/blockstore/attachable-store.js";
+import { mockLoader, noopUrl } from "../helpers.js";
+
+// function runtime(sthis: SuperThis) {
+//   return bs.toStoreRuntime(sthis);
+// }
+
+// async function mockLoader(sthis: SuperThis, name?: string): Promise<bs.StoreFactoryItem> {
+//   const url = noopUrl(name);
+//   return {
+//     // sthis,
+//     url: url,
+//     loader:
+//   };
+// }
 
 describe("DataStore", function () {
   let store: bs.DataStore;
   const sthis = ensureSuperThis();
-  let loader: bs.StoreFactoryItem;
+  const loader = mockLoader(sthis);
 
   afterEach(async () => {
     await store.close();
@@ -33,22 +29,22 @@ describe("DataStore", function () {
 
   beforeEach(async () => {
     await sthis.start();
-    loader = await mockLoader(sthis);
-    store = await runtime(sthis).makeDataStore(loader);
-    await store.start();
+    const at = await createAttachedStores(noopUrl("test"), loader);
+    store = at.stores.car;
+    await store.start(at.stores);
   });
 
   it("should have a name", function () {
     expect(store.url().getParam(PARAM.NAME)).toEqual("test");
   });
 
-  it("should save a car", async function () {
+  it("should save a car", async () => {
     const car: bs.AnyBlock = {
       cid: "cidKey" as unknown as CID,
       bytes: new Uint8Array([55, 56, 57]),
     };
     await store.save(car);
-    const data = (await store.realGateway.getPlain(loader, store.url(), car.cid.toString())).Ok();
+    const data = (await store.realGateway.getPlain({ loader }, store.url(), car.cid.toString())).Ok();
     expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
   });
 });
@@ -56,20 +52,21 @@ describe("DataStore", function () {
 describe("DataStore with a saved car", function () {
   let store: bs.DataStore;
   let car: bs.AnyBlock;
-  let loader: bs.StoreFactoryItem;
 
   const sthis = ensureSuperThis();
+  const loader = mockLoader(sthis);
 
   afterEach(async () => {
     await store.close();
     await store.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
-    loader = await mockLoader(sthis, "test2");
-    store = await runtime(sthis).makeDataStore(loader);
-    await store.start();
+
+    const at = await createAttachedStores(noopUrl("test2"), loader);
+    store = at.stores.car;
+    await store.start(at.stores);
     car = {
       cid: "cid" as unknown as CID,
       bytes: new Uint8Array([55, 56, 57, 80]),
@@ -77,19 +74,19 @@ describe("DataStore with a saved car", function () {
     await store.save(car);
   });
 
-  it("should have a car", async function () {
-    const data = (await store.realGateway.getPlain(loader, store.url(), car.cid.toString())).Ok();
+  it("should have a car", async () => {
+    const data = (await store.realGateway.getPlain({ loader }, store.url(), car.cid.toString())).Ok();
     expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
   });
 
-  it("should load a car", async function () {
+  it("should load a car", async () => {
     const loaded = await store.load(car.cid);
     expect(loaded.cid).toEqual(car.cid);
     expect(loaded.bytes.constructor.name).toEqual("Uint8Array");
     expect(loaded.bytes.toString()).toEqual(car.bytes.toString());
   });
 
-  it("should remove a car", async function () {
+  it("should remove a car", async () => {
     await store.remove(car.cid);
     const { e: error } = (await store.load(car.cid).catch((e: Error) => ({ e }))) as { e: NotFoundError };
     expect(error).toBeTruthy();
@@ -99,32 +96,32 @@ describe("DataStore with a saved car", function () {
 describe("MetaStore", function () {
   let store: bs.MetaStore;
   const sthis = ensureSuperThis();
-  let loader: bs.StoreFactoryItem;
+  const loader = mockLoader(sthis);
 
   afterEach(async () => {
     await store.close();
     await store.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
-    loader = await mockLoader(sthis, "test");
-    store = await runtime(sthis).makeMetaStore(loader);
-    await store.start();
+    const at = await createAttachedStores(noopUrl("test"), loader);
+    store = at.stores.meta;
+    await store.start(at.stores);
   });
 
   it("should have a name", function () {
     expect(store.url().getParam(PARAM.NAME)).toEqual("test");
   });
 
-  it("should save a header", async function () {
+  it("should save a header", async () => {
     const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     const h: bs.DbMeta = {
       cars: [cid],
       // key: undefined,
     };
     await store.save(h);
-    const file = await store.realGateway.getPlain(loader, store.url(), "main");
+    const file = await store.realGateway.getPlain({ loader }, store.url(), "main");
     const blockMeta = (await rt.gw.fpDeserialize(sthis, store.url(), file)) as Result<bs.FPEnvelopeMeta>;
     expect(blockMeta.Ok()).toBeTruthy();
     expect(blockMeta.Ok().payload.length).toEqual(1);
@@ -139,30 +136,30 @@ describe("MetaStore with a saved header", function () {
   let store: bs.MetaStore;
   let cid: CID;
   const sthis = ensureSuperThis();
-  let loader: bs.StoreFactoryItem;
+  const loader = mockLoader(sthis);
 
   afterEach(async () => {
     await store.close();
     await store.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
-    loader = await mockLoader(sthis, "test-saved-header");
-    store = await runtime(sthis).makeMetaStore(loader);
-    await store.start();
+    const at = await createAttachedStores(noopUrl("test3-meta"), loader);
+    store = at.stores.meta;
+    await store.start(at.stores);
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     await store.save({ cars: [cid] /*, key: undefined */ });
   });
 
-  // it("should load", async function () {
+  // it("should load", async () =>{
   //   expect(onload).toBeTruthy();
   //   expect(onload?.length).toEqual(1);
   //   expect(onload?.[0].cars.toString()).toEqual(cid.toString());
   // });
 
-  it("should have a header", async function () {
-    const bytes = await store.realGateway.getPlain(loader, store.url(), "main");
+  it("should have a header", async () => {
+    const bytes = await store.realGateway.getPlain({ loader }, store.url(), "main");
     const data = sthis.txt.decode(bytes.Ok());
     expect(data).toMatch(/parents/);
     const header = JSON.parse(data)[0];
@@ -179,7 +176,7 @@ describe("MetaStore with a saved header", function () {
     expect(decodedHeader.cars[0].toString()).toEqual(cid.toString());
   });
 
-  it("should load a header", async function () {
+  it("should load a header", async () => {
     const loadeds = (await store.load()) as bs.DbMeta[];
     const loaded = loadeds[0];
     expect(loaded).toBeTruthy();

package/tests/blockstore/transaction.test.ts

@@ -5,8 +5,9 @@ import { simpleBlockOpts } from "../helpers.js";
 describe("Fresh TransactionBlockstore", function () {
   let blocks: BaseBlockstore;
   const sthis = ensureSuperThis();
-  beforeEach(function () {
+  beforeEach(async () => {
     blocks = new bs.BaseBlockstoreImpl(simpleBlockOpts(sthis));
+    await blocks.ready();
   });
   // it("should not have a name", function () {
   //   expect(blocks.name).toBeFalsy();
@@ -14,12 +15,12 @@ describe("Fresh TransactionBlockstore", function () {
   // it("should not have a loader", function () {
   //   expect(blocks.loader).toBeFalsy();
   // });
-  it("should not put", async function () {
+  it("should not put", async () => {
     const value = sthis.txt.encode("value");
     const e = await blocks.put("key" as unknown as bs.AnyLink, value).catch((e) => e);
     expect(e.message).toMatch(/transaction/g);
   });
-  it("should yield a transaction", async function () {
+  it("should yield a transaction", async () => {
     const txR = await blocks.transaction(async (tblocks) => {
       expect(tblocks).toBeTruthy();
       expect(tblocks instanceof bs.CarTransactionImpl).toBeTruthy();
@@ -34,8 +35,9 @@ describe("Fresh TransactionBlockstore", function () {
 describe("TransactionBlockstore with name", function () {
   let blocks: bs.EncryptedBlockstore;
   const sthis = ensureSuperThis();
-  beforeEach(function () {
+  beforeEach(async () => {
     blocks = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis));
+    await blocks.ready();
   });
   // it("should have a name", function () {
   //   expect(blocks.name).toEqual("test");
@@ -43,7 +45,7 @@ describe("TransactionBlockstore with name", function () {
   it("should have a loader", function () {
     expect(blocks.loader).toBeTruthy();
   });
-  it("should get from loader", async function () {
+  it("should get from loader", async () => {
     const bytes = sthis.txt.encode("bytes");
     expect(blocks.loader).toBeTruthy();
     blocks.loader.getBlock = async (cid) => {
@@ -58,12 +60,12 @@ describe("A transaction", function () {
   let tblocks: CarTransaction;
   let blocks: bs.EncryptedBlockstore;
   const sthis = ensureSuperThis();
-  beforeEach(async function () {
+  beforeEach(async () => {
     blocks = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis, "test"));
     tblocks = new bs.CarTransactionImpl(blocks);
     blocks.transactions.add(tblocks);
   });
-  it("should put and get", async function () {
+  it("should put and get", async () => {
     const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     const bytes = sthis.txt.encode("bytes");
     await tblocks.put(cid, bytes);
@@ -85,7 +87,7 @@ describe("TransactionBlockstore with a completed transaction", function () {
   let cid2: CID;
   const sthis = ensureSuperThis();
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     cid2 = CID.parse("bafybeibgouhn5ktecpjuovt52zamzvm4dlve5ak7x6d5smms3itkhplnhm");
 
@@ -101,11 +103,11 @@ describe("TransactionBlockstore with a completed transaction", function () {
       return { head: [] };
     });
   });
-  it("should have transactions", async function () {
+  it("should have transactions", async () => {
     const ts = blocks.transactions;
     expect(ts.size).toEqual(2);
   });
-  it("should get", async function () {
+  it("should get", async () => {
     const value = (await blocks.get(cid)) as bs.AnyBlock;
     expect(value.cid).toEqual(cid);
     expect(value.bytes.toString()).toEqual(asUInt8Array("value", sthis).toString());
@@ -113,7 +115,7 @@ describe("TransactionBlockstore with a completed transaction", function () {
     const value2 = (await blocks.get(cid2)) as bs.AnyBlock;
     expect(value2.bytes.toString()).toEqual(asUInt8Array("value2", sthis).toString());
   });
-  it("should yield entries", async function () {
+  it("should yield entries", async () => {
     const blz = [];
     for await (const blk of blocks.entries()) {
       blz.push(blk);