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

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

@@ -1,16 +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 { 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");
@@ -54,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",
@@ -88,11 +89,14 @@ describe("KeyBag", () => {
     let diskBag2: rt.kb.KeyItem;
     const provider = await kb.rt.getBag();
     if (runtimeFn().isBrowser) {
-      const p = provider as rt.kb.KeyBagProviderIndexDB;
+      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.kb.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) => {
@@ -121,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);
@@ -229,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);
@@ -266,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);
@@ -307,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();

package/tests/blockstore/store.test.ts

@@ -1,23 +1,27 @@
 import { CID } from "multiformats";
-import { bs, ensureSuperThis, NotFoundError, SuperThis } from "@fireproof/core";
+import { rt, bs, NotFoundError, SuperThis, PARAM, DbMeta, ensureSuperThis } from "@fireproof/core";
+import { noopUrl } from "../helpers.js";
+import { Result } from "@adviser/cement";
 
 function runtime(sthis: SuperThis) {
-  return bs.toStoreRuntime({}, sthis);
+  return bs.toStoreRuntime(sthis);
 }
 
-function mockLoader(sthis: SuperThis, name: string): bs.Loadable {
+async function mockLoader(sthis: SuperThis, name?: string): Promise<bs.StoreFactoryItem> {
+  const url = noopUrl(name);
   return {
     sthis,
-    name,
-    ebOpts: {
-      store: {},
-    },
-  } as bs.Loadable;
+    url: url,
+    loader: {
+      keyBag: () => rt.kb.getKeyBag(sthis),
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      handleDbMetasFromStore: (metas: DbMeta[]): Promise<void> => Promise.resolve(),
+    } as bs.Loader,
+  };
 }
 
 describe("DataStore", function () {
   let store: bs.DataStore;
-  let raw: bs.TestGateway;
 
   const sthis = ensureSuperThis();
   afterEach(async () => {
@@ -27,13 +31,12 @@ describe("DataStore", function () {
 
   beforeEach(async () => {
     await sthis.start();
-    store = await runtime(sthis).makeDataStore(mockLoader(sthis, "test"));
+    store = await runtime(sthis).makeDataStore(await mockLoader(sthis));
     await store.start();
-    raw = await bs.testStoreFactory(store.url(), sthis);
   });
 
   it("should have a name", function () {
-    expect(store.name).toEqual("test");
+    expect(store.url().getParam(PARAM.NAME)).toEqual("test");
   });
 
   it("should save a car", async function () {
@@ -42,14 +45,13 @@ describe("DataStore", function () {
       bytes: new Uint8Array([55, 56, 57]),
     };
     await store.save(car);
-    const data = await raw.get(store.url(), car.cid.toString());
+    const data = (await store.realGateway.getPlain(sthis, store.url(), car.cid.toString())).Ok();
     expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
   });
 });
 
 describe("DataStore with a saved car", function () {
   let store: bs.DataStore;
-  let raw: bs.TestGateway;
   let car: bs.AnyBlock;
 
   const sthis = ensureSuperThis();
@@ -61,9 +63,8 @@ describe("DataStore with a saved car", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeDataStore(mockLoader(sthis, "test2"));
+    store = await runtime(sthis).makeDataStore(await mockLoader(sthis, "test2"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url(), sthis);
     car = {
       cid: "cid" as unknown as CID,
       bytes: new Uint8Array([55, 56, 57, 80]),
@@ -72,7 +73,7 @@ describe("DataStore with a saved car", function () {
   });
 
   it("should have a car", async function () {
-    const data = await raw.get(store.url(), car.cid.toString());
+    const data = (await store.realGateway.getPlain(sthis, store.url(), car.cid.toString())).Ok();
     expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
   });
 
@@ -92,7 +93,6 @@ describe("DataStore with a saved car", function () {
 
 describe("MetaStore", function () {
   let store: bs.MetaStore;
-  let raw: bs.TestGateway;
 
   const sthis = ensureSuperThis();
 
@@ -103,13 +103,12 @@ describe("MetaStore", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeMetaStore(mockLoader(sthis, "test"));
+    store = await runtime(sthis).makeMetaStore(await mockLoader(sthis, "test"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url(), sthis);
   });
 
   it("should have a name", function () {
-    expect(store.name).toEqual("test");
+    expect(store.url().getParam(PARAM.NAME)).toEqual("test");
   });
 
   it("should save a header", async function () {
@@ -119,9 +118,11 @@ describe("MetaStore", function () {
       // key: undefined,
     };
     await store.save(h);
-    const file = await raw.get(store.url(), "main");
-    const [blockMeta] = await store.handleByteHeads(file);
-    const decodedHeader = blockMeta.dbMeta;
+    const file = await store.realGateway.getPlain(sthis, 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);
+    const decodedHeader = blockMeta.Ok().payload[0].dbMeta;
     expect(decodedHeader).toBeTruthy();
     expect(decodedHeader.cars).toBeTruthy();
     expect(decodedHeader.cars[0].toString()).toEqual(cid.toString());
@@ -130,7 +131,6 @@ describe("MetaStore", function () {
 
 describe("MetaStore with a saved header", function () {
   let store: bs.MetaStore;
-  let raw: bs.TestGateway;
   let cid: CID;
   const sthis = ensureSuperThis();
 
@@ -141,22 +141,31 @@ describe("MetaStore with a saved header", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeMetaStore(mockLoader(sthis, "test-saved-header"));
+    store = await runtime(sthis).makeMetaStore(await mockLoader(sthis, "test-saved-header"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url(), sthis);
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     await store.save({ cars: [cid] /*, key: undefined */ });
   });
 
+  // it("should load", async function () {
+  //   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 raw.get(store.url(), "main");
-    const data = sthis.txt.decode(bytes);
+    const bytes = await store.realGateway.getPlain(sthis, store.url(), "main");
+    const data = sthis.txt.decode(bytes.Ok());
     expect(data).toMatch(/parents/);
     const header = JSON.parse(data)[0];
     expect(header).toBeDefined();
     expect(header.parents).toBeDefined();
-    const [blockMeta] = await store.handleByteHeads(bytes);
-    const decodedHeader = blockMeta.dbMeta;
+    // const [blockMeta] = await store.handleByteHeads(bytes);
+
+    const blockMeta = (await rt.gw.fpDeserialize(sthis, store.url(), bytes)) as Result<bs.FPEnvelopeMeta>;
+    expect(blockMeta.Ok()).toBeTruthy();
+    expect(blockMeta.Ok().payload.length).toEqual(1);
+    const decodedHeader = blockMeta.Ok().payload[0].dbMeta;
     expect(decodedHeader).toBeDefined();
     expect(decodedHeader.cars).toBeDefined();
     expect(decodedHeader.cars[0].toString()).toEqual(cid.toString());

package/tests/blockstore/transaction.test.ts

@@ -1,18 +1,19 @@
 import { CID } from "multiformats";
 import { bs, ensureSuperThis, SuperThis } from "@fireproof/core";
+import { simpleBlockOpts } from "../helpers.js";
 
 describe("Fresh TransactionBlockstore", function () {
   let blocks: bs.BaseBlockstore;
   const sthis = ensureSuperThis();
   beforeEach(function () {
-    blocks = new bs.BaseBlockstore();
-  });
-  it("should not have a name", function () {
-    expect(blocks.name).toBeFalsy();
-  });
-  it("should not have a loader", function () {
-    expect(blocks.loader).toBeFalsy();
+    blocks = new bs.BaseBlockstore(simpleBlockOpts(sthis));
   });
+  // it("should not have a name", function () {
+  //   expect(blocks.name).toBeFalsy();
+  // });
+  // it("should not have a loader", function () {
+  //   expect(blocks.loader).toBeFalsy();
+  // });
   it("should not put", async function () {
     const value = sthis.txt.encode("value");
     const e = await blocks.put("key" as unknown as bs.AnyLink, value).catch((e) => e);
@@ -34,11 +35,11 @@ describe("TransactionBlockstore with name", function () {
   let blocks: bs.EncryptedBlockstore;
   const sthis = ensureSuperThis();
   beforeEach(function () {
-    blocks = new bs.EncryptedBlockstore(sthis, { name: "test" });
-  });
-  it("should have a name", function () {
-    expect(blocks.name).toEqual("test");
+    blocks = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis));
   });
+  // it("should have a name", function () {
+  //   expect(blocks.name).toEqual("test");
+  // });
   it("should have a loader", function () {
     expect(blocks.loader).toBeTruthy();
   });
@@ -58,7 +59,7 @@ describe("A transaction", function () {
   let blocks: bs.EncryptedBlockstore;
   const sthis = ensureSuperThis();
   beforeEach(async function () {
-    blocks = new bs.EncryptedBlockstore(sthis, { name: "test" });
+    blocks = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis, "test"));
     tblocks = new bs.CarTransaction(blocks);
     blocks.transactions.add(tblocks);
   });
@@ -88,7 +89,7 @@ describe("TransactionBlockstore with a completed transaction", function () {
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     cid2 = CID.parse("bafybeibgouhn5ktecpjuovt52zamzvm4dlve5ak7x6d5smms3itkhplnhm");
 
-    blocks = new bs.BaseBlockstore();
+    blocks = new bs.BaseBlockstore(simpleBlockOpts(sthis));
     await blocks.transaction(async (tblocks) => {
       await tblocks.put(cid, asUInt8Array("value", sthis));
       await tblocks.put(cid, asUInt8Array("value", sthis));