@fireproof/core 0.19.121 → 0.20.0-dev-preview-05

package/tests/blockstore/interceptor-gateway.test.ts

@@ -0,0 +1,122 @@
+import { Result, URI } from "@adviser/cement";
+import { bs, fireproof, SuperThis } from "@fireproof/core";
+
+class TestInterceptor extends bs.PassThroughGateway {
+  readonly fn = vitest.fn();
+
+  async buildUrl(sthis: SuperThis, baseUrl: URI, key: string): Promise<Result<bs.SerdeGatewayBuildUrlReturn>> {
+    const ret = await super.buildUrl(sthis, baseUrl, key);
+    this.fn("buildUrl", ret);
+    return ret;
+  }
+
+  async start(sthis: SuperThis, baseUrl: URI): Promise<Result<bs.SerdeGatewayStartReturn>> {
+    const ret = await super.start(sthis, baseUrl);
+    this.fn("start", ret);
+    return ret;
+  }
+  async close(sthis: SuperThis, baseUrl: URI): Promise<Result<bs.SerdeGatewayCloseReturn>> {
+    const ret = await super.close(sthis, baseUrl);
+    this.fn("close", ret);
+    return ret;
+  }
+  async delete(sthis: SuperThis, baseUrl: URI): Promise<Result<bs.SerdeGatewayDeleteReturn>> {
+    const ret = await super.delete(sthis, baseUrl);
+    this.fn("delete", ret);
+    return ret;
+  }
+  async destroy(sthis: SuperThis, baseUrl: URI): Promise<Result<bs.SerdeGatewayDestroyReturn>> {
+    const ret = await super.destroy(sthis, baseUrl);
+    this.fn("destroy", ret);
+    return ret;
+  }
+  async put<T>(sthis: SuperThis, url: URI, body: bs.FPEnvelope<T>): Promise<Result<bs.SerdeGatewayPutReturn<T>>> {
+    const ret = await super.put<T>(sthis, url, body);
+    this.fn("put", ret);
+    return ret;
+  }
+  async get<S>(sthis: SuperThis, url: URI): Promise<Result<bs.SerdeGatewayGetReturn<S>>> {
+    const ret = await super.get<S>(sthis, url);
+    this.fn("get", ret);
+    return ret;
+  }
+  async subscribe(
+    sthis: SuperThis,
+    url: URI,
+    callback: (meta: bs.FPEnvelopeMeta) => Promise<void>,
+  ): Promise<Result<bs.SerdeGatewaySubscribeReturn>> {
+    const ret = await super.subscribe(sthis, url, callback);
+    this.fn("subscribe", ret);
+    return ret;
+  }
+}
+
+describe("InterceptorGateway", () => {
+  it("passthrough", async () => {
+    const gwi = new TestInterceptor();
+    const db = fireproof("interceptor-gateway", {
+      gatewayInterceptor: gwi,
+    });
+    expect(
+      await db.put({
+        _id: "foo",
+        foo: 4,
+      }),
+    );
+    expect(await db.get("foo")).toEqual({
+      _id: "foo",
+      foo: 4,
+    });
+    await db.close();
+    await db.destroy();
+    // await sleep(1000);
+    expect(gwi.fn.mock.calls.length).toBe(42);
+    // might be a stupid test
+    expect(gwi.fn.mock.calls.map((i) => i[0]).sort() /* not ok there are some operation */).toEqual(
+      [
+        "start",
+        "start",
+        "buildUrl",
+        "get",
+        "buildUrl",
+        "get",
+        "start",
+        "start",
+        "buildUrl",
+        "get",
+        "buildUrl",
+        "put",
+        "buildUrl",
+        "put",
+        "buildUrl",
+        "put",
+        "start",
+        "start",
+        "start",
+        "start",
+        "close",
+        "close",
+        "close",
+        "close",
+        "close",
+        "close",
+        "close",
+        "close",
+        "buildUrl",
+        "get",
+        "close",
+        "close",
+        "close",
+        "close",
+        "destroy",
+        "destroy",
+        "destroy",
+        "destroy",
+        "destroy",
+        "destroy",
+        "destroy",
+        "destroy",
+      ].sort() /* not ok there are some operation */,
+    );
+  });
+});

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

@@ -0,0 +1,130 @@
+import { bs, PARAM, rt } from "@fireproof/core";
+import { runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
+import { base58btc } from "multiformats/bases/base58";
+import { mockSuperThis } from "../helpers.js";
+import { KeyBagProviderIndexDB } from "@fireproof/core/web";
+
+describe("KeyBag indexdb and file", () => {
+  let url: URI;
+  const sthis = mockSuperThis();
+  beforeAll(async () => {
+    await sthis.start();
+    if (runtimeFn().isBrowser) {
+      url = URI.from("indexdb://fp-keybag");
+    } else {
+      url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
+    }
+  });
+  it("default-path", async () => {
+    const old = sthis.env.get("FP_KEYBAG_URL");
+    sthis.env.delete("FP_KEYBAG_URL");
+    const kb = await rt.kb.getKeyBag(sthis);
+    if (runtimeFn().isBrowser) {
+      expect(kb.rt.url.toString()).toBe(`indexdb://fp-keybag`);
+    } else {
+      expect(kb.rt.url.toString()).toBe(`file://${sthis.env.get("HOME")}/.fireproof/keybag`);
+    }
+    sthis.env.set("FP_KEYBAG_URL", old);
+  });
+  it("from env", async () => {
+    const old = sthis.env.get("FP_KEYBAG_URL");
+    sthis.env.set("FP_KEYBAG_URL", url.toString());
+    const kb = await rt.kb.getKeyBag(sthis);
+    expect(kb.rt.url.toString()).toBe(url.toString());
+    sthis.env.set("FP_KEYBAG_URL", old);
+  });
+  it("simple add", async () => {
+    const kb = await rt.kb.getKeyBag(sthis, {
+      url: url.toString(),
+      crypto: toCryptoRuntime({
+        randomBytes: (size) => new Uint8Array(size).map((_, i) => i),
+      }),
+    });
+    const name = "setkey" + Math.random();
+    expect((await kb.getNamedKey(name, true)).isErr()).toBeTruthy();
+
+    const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
+    const res = await kb.setNamedKey(name, key);
+    expect(res.isOk()).toBeTruthy();
+    expect((await kb.getNamedKey(name, true)).Ok()).toEqual(res.Ok());
+
+    const name2 = "implicit";
+    const created = await kb.getNamedKey(name2);
+    expect(created.isOk()).toBeTruthy();
+
+    expect((await kb.getNamedKey(name2)).Ok()).toEqual(created.Ok());
+
+    let diskBag: rt.kb.KeyItem;
+    let diskBag2: rt.kb.KeyItem;
+    const provider = await kb.rt.getBag();
+    if (runtimeFn().isBrowser) {
+      const p = provider as KeyBagProviderIndexDB;
+      diskBag = await p._prepare().then((db) => db.get("bag", name));
+      diskBag2 = await p._prepare().then((db) => db.get("bag", name2));
+    } else {
+      const p = provider as rt.gw.file.KeyBagProviderFile;
+      const { sysFS } = await p._prepare(name);
+
+      diskBag = await sysFS.readfile((await p._prepare(name)).fName).then((data) => {
+        return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeyItem;
+      });
+      diskBag2 = await sysFS.readfile((await p._prepare(name2)).fName).then((data) => {
+        return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeyItem;
+      });
+    }
+    expect(await kb.toKeyWithFingerPrint(diskBag.key)).toEqual(res);
+    expect(await kb.toKeyWithFingerPrint(diskBag2.key)).toEqual(created);
+    const algo = {
+      name: "AES-GCM",
+      iv: kb.rt.crypto.randomBytes(12),
+      tagLength: 128,
+    };
+    const data = kb.rt.crypto.randomBytes(122);
+    expect(await kb.rt.crypto.encrypt(algo, res.Ok().key, data)).toEqual(await kb.rt.crypto.encrypt(algo, created.Ok().key, data));
+    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(diskBag.key), data)).toEqual(
+      await kb.rt.crypto.encrypt(algo, created.Ok().key, data),
+    );
+    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(diskBag2.key), data)).toEqual(
+      await kb.rt.crypto.encrypt(algo, created.Ok().key, data),
+    );
+  });
+});
+
+describe("KeyedCryptoStore", () => {
+  let loader: bs.Loadable;
+  // let logger: Logger;
+  let baseUrl: URI;
+  const sthis = mockSuperThis();
+  beforeEach(async () => {
+    await sthis.start();
+    // logger = MockLogger().logger;
+    let kbUrl: URI;
+    if (runtimeFn().isBrowser) {
+      kbUrl = URI.from("indexdb://fp-keybag");
+      baseUrl = URI.from("indexdb://fp-keyed-crypto-store");
+    } else {
+      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 = {
+      keyBag: () => rt.kb.getKeyBag(sthis, { url: kbUrl }),
+    } as bs.Loadable;
+  });
+  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({ sthis, url, loader }),
+      strt.makeMetaStore({ sthis, url, loader }),
+      strt.makeWALStore({ sthis, url, loader }),
+    ]) {
+      const store = await pstore;
+      // await store.start();
+      const kc = await store.keyedCrypto();
+      expect(kc.constructor.name).toBe("noCrypto");
+      // expect(kc.isEncrypting).toBe(false);
+    }
+  });
+});

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

@@ -1,18 +1,17 @@
-import { bs, ensureSuperThis, rt, SuperThis } from "@fireproof/core";
-import { BuildURI, Logger, MockLogger, runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
+import { bs, ensureSuperThis, PARAM, rt } from "@fireproof/core";
+import { BuildURI, runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
 import { base58btc } from "multiformats/bases/base58";
 import { sha256 as hasher } from "multiformats/hashes/sha2";
 import * as dagCodec from "@fireproof/vendor/@ipld/dag-cbor";
 import type { KeyBagProviderIndexDB } from "@fireproof/core/web";
-import type { KeyBagProviderFile } from "@fireproof/core/node";
+import { MockSuperThis, mockSuperThis } from "../helpers.js";
 
 describe("KeyBag", () => {
   let url: URI;
-  let sthis: SuperThis;
-  const mockLogger = MockLogger();
+  let sthis: MockSuperThis;
 
   beforeEach(async () => {
-    sthis = ensureSuperThis({ logger: mockLogger.logger });
+    sthis = mockSuperThis();
     await sthis.start();
     if (runtimeFn().isBrowser) {
       url = URI.from("indexdb://fp-keybag");
@@ -56,7 +55,7 @@ describe("KeyBag", () => {
     });
     sthis.env.set("FP_KEYBAG_URL", old);
     await sthis.logger.Flush();
-    expect(mockLogger.logCollector.Logs()).toEqual([
+    expect(sthis.ctx.logCollector.Logs()).toEqual([
       {
         level: "warn",
         module: "KeyBag",
@@ -94,7 +93,10 @@ describe("KeyBag", () => {
       diskBag = await p._prepare().then((db) => db.get("bag", name));
       diskBag2 = await p._prepare().then((db) => db.get("bag", name2));
     } else {
-      const p = provider as KeyBagProviderFile;
+      const p = provider as rt.gw.file.KeyBagProviderFile;
+      if (typeof p._prepare !== "function") {
+        return;
+      }
       const { sysFS } = await p._prepare(name);
 
       diskBag = await sysFS.readfile((await p._prepare(name)).fName).then((data) => {
@@ -123,99 +125,83 @@ describe("KeyBag", () => {
 });
 
 describe("KeyedCryptoStore", () => {
+  let loader: bs.Loadable;
   let kb: rt.kb.KeyBag;
-  let logger: Logger;
+  // let logger: Logger;
   let baseUrl: URI;
   const sthis = ensureSuperThis();
   beforeEach(async () => {
     await sthis.start();
-    logger = MockLogger().logger;
-    let kbUrl: URI;
-    if (runtimeFn().isBrowser) {
-      kbUrl = URI.from("indexdb://fp-keybag");
-      baseUrl = URI.from("indexdb://fp-keyed-crypto-store");
+    // logger = MockLogger().logger;
+    // let kbUrl: URI;
+    // if (runtimeFn().isBrowser) {
+    //   kbUrl = URI.from("indexdb://fp-keybag");
+    //   baseUrl = URI.from("indexdb://fp-keyed-crypto-store");
+    // } else {
+    //   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();
+
+    const envURL = sthis.env.get("FP_KEYBAG_URL");
+    if (envURL) {
+      baseUrl = bs.getDefaultURI(sthis, URI.from(envURL).protocol);
     } else {
-      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 = URI.from(sthis.env.get("FP_STORAGE_URL"));
+      baseUrl = bs.getDefaultURI(sthis);
     }
-    kb = await rt.kb.getKeyBag(sthis, {
-      url: kbUrl,
-    });
+    baseUrl = baseUrl.build().setParam(PARAM.NAME, "test").URI();
+    kb = await rt.kb.getKeyBag(sthis, {});
+    loader = {
+      keyBag: async () => kb,
+    } as bs.Loadable;
   });
   it("no crypto", async () => {
-    const loader = {
-      sthis,
-      name: "test",
-      ebOpts: {
-        keyBag: {
-          keyRuntime: kb.rt,
-        },
-        store: {
-          stores: {
-            base: baseUrl.build().setParam("storekey", "insecure"),
-          },
-        },
-      },
-    } as unknown as bs.Loadable;
-    const strt = bs.toStoreRuntime({}, sthis);
+    const strt = bs.toStoreRuntime(sthis);
+    const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
 
-    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url, loader }),
+      strt.makeMetaStore({ sthis, url, loader }),
+      strt.makeWALStore({ sthis, url, loader }),
+    ]) {
       const store = await pstore;
       // await store.start();
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("noCrypto");
       // expect(kc.isEncrypting).toBe(false);
+      expect(kc.constructor.name).toBe("noCrypto");
+      // expect(kc.isEncrypting).toBe(false);
     }
   });
 
   it("create key", async () => {
-    const loader = {
-      sthis,
-      name: "test",
-      ebOpts: {
-        keyBag: {
-          keyRuntime: kb.rt,
-        },
-        store: {
-          stores: {
-            base: baseUrl,
-          },
-        },
-      },
-    } as unknown as bs.Loadable;
-    const strt = bs.toStoreRuntime({}, sthis);
-    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
-      const store = await bs.ensureStart(await pstore, logger);
+    const strt = bs.toStoreRuntime(sthis);
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url: baseUrl, loader }),
+      strt.makeMetaStore({ sthis, url: baseUrl, loader }),
+      strt.makeWALStore({ sthis, url: baseUrl, loader }),
+    ]) {
+      const store = await pstore; // await bs.ensureStart(await pstore, logger);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       // expect(kc.isEncrypting).toBe(true);
-      expect(store.url().getParam("storekey")).toBe(`@test:${store.url().getParam("store")}@`);
+      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@test:${store.url().getParam(PARAM.STORE)}@`);
     }
   });
 
   it("key ref keybag", async () => {
     const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
     const genKey = await kb.setNamedKey("@heute@", key);
-    const loader = {
-      sthis,
-      name: "test",
-      ebOpts: {
-        keyBag: {
-          keyRuntime: kb.rt,
-        },
-        store: {
-          stores: {
-            base: baseUrl.build().setParam("storekey", "@heute@").URI(),
-          },
-        },
-      },
-    } as unknown as bs.Loadable;
-    const strt = bs.toStoreRuntime({}, sthis);
-    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
+    const url = baseUrl.build().setParam(PARAM.STORE_KEY, "@heute@").URI();
+    const strt = bs.toStoreRuntime(sthis);
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url, loader }),
+      strt.makeMetaStore({ sthis, url, loader }),
+      strt.makeWALStore({ sthis, url, loader }),
+    ]) {
       const store = await pstore;
       // await store.start();
-      expect(store.url().getParam("storekey")).toBe(`@heute@`);
+      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@heute@`);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       const testData = kb.rt.crypto.randomBytes(1024);
@@ -231,25 +217,17 @@ describe("KeyedCryptoStore", () => {
 
   it("key", async () => {
     const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const loader = {
-      sthis,
-      name: "test",
-      ebOpts: {
-        keyBag: {
-          keyRuntime: kb.rt,
-        },
-        store: {
-          stores: {
-            base: BuildURI.from(baseUrl).setParam("storekey", key),
-          },
-        },
-      },
-    } as unknown as bs.Loadable;
-    const strt = bs.toStoreRuntime({}, sthis);
-    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
+    const strt = bs.toStoreRuntime(sthis);
+    const url = baseUrl.build().setParam(PARAM.STORE_KEY, key).URI();
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url, loader }),
+      strt.makeMetaStore({ sthis, url, loader }),
+      strt.makeWALStore({ sthis, url, loader }),
+    ]) {
+      // for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
       const store = await pstore;
       // await store.start();
-      expect(store.url().getParam("storekey")).toBe(key);
+      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(key);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       const testData = kb.rt.crypto.randomBytes(1024);
@@ -268,14 +246,14 @@ describe("KeyedCrypto", () => {
   let keyStr: string;
   const sthis = ensureSuperThis();
   beforeEach(async () => {
-    let url: URI;
-    if (runtimeFn().isBrowser) {
-      url = URI.from("indexdb://fp-keybag");
-    } else {
-      url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-    }
+    // let url: URI;
+    // if (runtimeFn().isBrowser) {
+    //   url = URI.from("indexdb://fp-keybag");
+    // } else {
+    //   url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
+    // }
     kb = await rt.kb.getKeyBag(sthis, {
-      url,
+      // url,
     });
     keyStr = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
     kycr = await rt.kc.keyedCryptoFactory(URI.from(`test://bla?storekey=${keyStr}`), kb, sthis);
@@ -309,26 +287,3 @@ describe("KeyedCrypto", () => {
     expect(blk).toEqual(blk2);
   });
 });
-
-// describe("KeyedCryptoStore RunLength", () => {
-//   const logger = MockLogger().logger;
-//   it("de/encode", () => {
-//     for (const data of [
-//       new Uint8Array(),
-//       new Uint8Array(10).fill(10),
-//       new Uint8Array(127).fill(127),
-//       new Uint8Array(128).fill(128),
-//       new Uint8Array(1024).fill(17),
-//     ]) {
-//       const res = rt.kc.encodeRunLength(data, logger);
-//       expect(res.length).toBeLessThanOrEqual(data.length + (data.length > 127 ? 4 : 1));
-//       for (let ofs = 0; ofs < 1024; ofs += 61) {
-//         const ofsRes = new Uint8Array([...new Uint8Array(ofs).fill(23), ...res]);
-//         const dec = rt.kc.decodeRunLength(ofsRes, ofs, logger);
-//         expect(dec.data).toEqual(data);
-//         expect(dec.data.length).toBe(data.length);
-//         expect(dec.next).toBe(ofs + data.length + (data.length > 127 ? 4 : 1));
-//       }
-//     }
-//   });
-// });

package/tests/blockstore/loader.test.ts

@@ -4,16 +4,18 @@ import { BlockView } from "multiformats";
 import { CID } from "multiformats/cid";
 import { MemoryBlockstore } from "@fireproof/vendor/@web3-storage/pail/block";
 import { CRDTMeta, IndexTransactionMeta, SuperThis, bs, ensureSuperThis, rt } from "@fireproof/core";
+import { simpleBlockOpts } from "../helpers.js";
 
 class MyMemoryBlockStore extends bs.EncryptedBlockstore {
   readonly memblock = new MemoryBlockstore();
   loader: bs.Loader;
   constructor(sthis: SuperThis) {
-    const ebOpts = {
-      name: "MyMemoryBlockStore",
-    };
+    const ebOpts = simpleBlockOpts(sthis, "MyMemoryBlockStore"); //, "MyMemoryBlockStore");
+    // const ebOpts = {
+    //   name: "MyMemoryBlockStore",
+    // } as bs.BlockstoreOpts;
     super(sthis, ebOpts);
-    this.loader = new bs.Loader("MyMemoryBlockStore", {}, sthis);
+    this.loader = new bs.Loader(sthis, ebOpts);
   }
   ready(): Promise<void> {
     return Promise.resolve();
@@ -62,7 +64,10 @@ describe("basic Loader simple", function () {
     await sthis.start();
     const mockM = new MyMemoryBlockStore(sthis);
     t = new bs.CarTransaction(mockM as bs.EncryptedBlockstore);
-    loader = new bs.Loader(testDbName, { public: true }, sthis);
+    loader = new bs.Loader(sthis, {
+      ...simpleBlockOpts(sthis, testDbName),
+      public: true,
+    });
     await loader.ready();
     block = await rt.mf.block.encode({
       value: { hello: "world" },
@@ -105,11 +110,15 @@ describe("basic Loader with two commits", function () {
     await loader.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const mockM = new MyMemoryBlockStore(sthis);
     t = new bs.CarTransaction(mockM);
-    loader = new bs.Loader("test-loader-two-commit", { public: true }, sthis);
+    loader = new bs.Loader(sthis, {
+      ...simpleBlockOpts(sthis, "test-loader-two-commit"),
+      public: true,
+    });
+
     block = await rt.mf.block.encode({
       value: { hello: "world" },
       hasher,
@@ -211,7 +220,7 @@ describe("basic Loader with index commits", function () {
     const name = "test-loader-index" + Math.random();
     await sthis.start();
     // t = new CarTransaction()
-    ib = new bs.EncryptedBlockstore(sthis, { name });
+    ib = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis, name));
     block = await rt.mf.block.encode({
       value: { hello: "world" },
       hasher,
@@ -255,7 +264,7 @@ describe("basic Loader with index commits", function () {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const reader = await ib.loader.loadCar(carCid![0]);
     expect(reader).toBeTruthy();
-    const parsed = await bs.parseCarFile<IndexTransactionMeta>(reader, ib.loader.logger);
+    const parsed = await bs.parseCarFile<IndexTransactionMeta>(reader, sthis.logger);
     expect(parsed.cars).toBeTruthy();
     expect(parsed.cars.length).toBe(0);
     expect(parsed.meta).toBeTruthy();