@fireproof/core 0.19.101 → 0.19.102

package/{node-filesystem-CFRXFSO7.js → node-filesystem-INX4ZTHE.js}

@@ -1,13 +1,13 @@
 import {
   toArrayBuffer
-} from "./chunk-HQ7D3PEU.js";
-import "./chunk-3EB3ENHT.js";
-import "./chunk-PZ5AY32C.js";
+} from "./chunk-WS3YRPIA.js";
+import "./chunk-OFGPKRCM.js";
 
 // src/runtime/gateways/file/node-filesystem.ts
+import { runtimeFn } from "@adviser/cement";
 var NodeFileSystem = class {
   async start() {
-    this.fs = await import("fs/promises");
+    this.fs = await import("node:fs/promises");
     return this;
   }
   async mkdir(path, options) {
@@ -27,16 +27,19 @@ var NodeFileSystem = class {
     return toArrayBuffer(ret);
   }
   stat(path) {
-    return this.fs.stat(path);
+    return this.fs?.stat(path);
   }
   async unlink(path) {
     return this.fs?.unlink(path);
   }
   async writefile(path, data) {
+    if (runtimeFn().isDeno) {
+      return this.fs?.writeFile(path, data);
+    }
     return this.fs?.writeFile(path, Buffer.from(data));
   }
 };
 export {
   NodeFileSystem
 };
-//# sourceMappingURL=node-filesystem-CFRXFSO7.js.map
+//# sourceMappingURL=node-filesystem-INX4ZTHE.js.map

package/node-filesystem-INX4ZTHE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/runtime/gateways/file/node-filesystem.ts"],"sourcesContent":["import type { PathLike, MakeDirectoryOptions, Stats, ObjectEncodingOptions } from \"node:fs\";\nimport type { mkdir, readdir, rm, copyFile, readFile, stat, unlink, writeFile } from \"node:fs/promises\";\nimport { toArrayBuffer } from \"./utils.js\";\nimport { SysFileSystem } from \"../../../types.js\";\nimport { runtimeFn } from \"@adviser/cement\";\n\nexport class NodeFileSystem implements SysFileSystem {\n  fs?: {\n    mkdir: typeof mkdir;\n    readdir: typeof readdir;\n    rm: typeof rm;\n    copyFile: typeof copyFile;\n    readFile: typeof readFile;\n    stat: typeof stat;\n    unlink: typeof unlink;\n    writeFile: typeof writeFile;\n  };\n\n  async start(): Promise<SysFileSystem> {\n    this.fs = await import(\"node:fs/promises\");\n    return this;\n  }\n  async mkdir(path: PathLike, options?: { recursive: boolean }): Promise<string | undefined> {\n    return this.fs?.mkdir(path, options);\n  }\n  async readdir(path: PathLike, options?: ObjectEncodingOptions): Promise<string[]> {\n    return this.fs?.readdir(path, options) as Promise<string[]>;\n  }\n  async rm(path: PathLike, options?: MakeDirectoryOptions & { recursive: boolean }): Promise<void> {\n    return this.fs?.rm(path, options);\n  }\n  async copyFile(source: PathLike, destination: PathLike): Promise<void> {\n    return this.fs?.copyFile(source, destination);\n  }\n  async readfile(path: PathLike, options?: { encoding: BufferEncoding; flag?: string }): Promise<Uint8Array> {\n    const ret = (await this.fs?.readFile(path, options)) as Buffer;\n    return toArrayBuffer(ret);\n  }\n  stat(path: PathLike): Promise<Stats> {\n    return this.fs?.stat(path) as Promise<Stats>;\n  }\n  async unlink(path: PathLike): Promise<void> {\n    return this.fs?.unlink(path);\n  }\n  async writefile(path: PathLike, data: Uint8Array | string): Promise<void> {\n    if (runtimeFn().isDeno) {\n      return this.fs?.writeFile(path, data);\n    }\n    return this.fs?.writeFile(path, Buffer.from(data));\n  }\n}\n\n// import { type NodeMap, join } from \"../../sys-container.js\";\n// import type { ObjectEncodingOptions, PathLike } from \"fs\";\n// import * as fs from \"fs/promises\";\n// import * as path from \"path\";\n// import * as os from \"os\";\n// import * as url from \"url\";\n// import { toArrayBuffer } from \"./utils.js\";\n\n// export async function createNodeSysContainer(): Promise<NodeMap> {\n//   // const nodePath = \"node:path\";\n//   // const nodeOS = \"node:os\";\n//   // const nodeURL = \"node:url\";\n//   // const nodeFS = \"node:fs\";\n//   // const fs = (await import(\"node:fs\")).promises;\n//   // const assert = \"assert\";\n//   // const path = await import(\"node:path\");\n//   return {\n//     state: \"node\",\n//     ...path,\n//     // ...(await import(\"node:os\")),\n//     // ...(await import(\"node:url\")),\n//     ...os,\n//     ...url,\n//     ...fs,\n//     join,\n//     stat: fs.stat as NodeMap[\"stat\"],\n//     readdir: fs.readdir as NodeMap[\"readdir\"],\n//     readfile: async (path: PathLike, options?: ObjectEncodingOptions): Promise<Uint8Array> => {\n//       const rs = await fs.readFile(path, options);\n//       return toArrayBuffer(rs);\n//     },\n//     writefile: fs.writeFile as NodeMap[\"writefile\"],\n//   };\n// }\n"],"mappings":";;;;;;AAIA,SAAS,iBAAiB;AAEnB,IAAM,iBAAN,MAA8C;AAAA,EAYnD,MAAM,QAAgC;AACpC,SAAK,KAAK,MAAM,OAAO,kBAAkB;AACzC,WAAO;AAAA,EACT;AAAA,EACA,MAAM,MAAM,MAAgB,SAA+D;AACzF,WAAO,KAAK,IAAI,MAAM,MAAM,OAAO;AAAA,EACrC;AAAA,EACA,MAAM,QAAQ,MAAgB,SAAoD;AAChF,WAAO,KAAK,IAAI,QAAQ,MAAM,OAAO;AAAA,EACvC;AAAA,EACA,MAAM,GAAG,MAAgB,SAAwE;AAC/F,WAAO,KAAK,IAAI,GAAG,MAAM,OAAO;AAAA,EAClC;AAAA,EACA,MAAM,SAAS,QAAkB,aAAsC;AACrE,WAAO,KAAK,IAAI,SAAS,QAAQ,WAAW;AAAA,EAC9C;AAAA,EACA,MAAM,SAAS,MAAgB,SAA4E;AACzG,UAAM,MAAO,MAAM,KAAK,IAAI,SAAS,MAAM,OAAO;AAClD,WAAO,cAAc,GAAG;AAAA,EAC1B;AAAA,EACA,KAAK,MAAgC;AACnC,WAAO,KAAK,IAAI,KAAK,IAAI;AAAA,EAC3B;AAAA,EACA,MAAM,OAAO,MAA+B;AAC1C,WAAO,KAAK,IAAI,OAAO,IAAI;AAAA,EAC7B;AAAA,EACA,MAAM,UAAU,MAAgB,MAA0C;AACxE,QAAI,UAAU,EAAE,QAAQ;AACtB,aAAO,KAAK,IAAI,UAAU,MAAM,IAAI;AAAA,IACtC;AACA,WAAO,KAAK,IAAI,UAAU,MAAM,OAAO,KAAK,IAAI,CAAC;AAAA,EACnD;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireproof/core",
-  "version": "0.19.101",
+  "version": "0.19.102",
   "description": "Live database for the web.",
   "type": "module",
   "module": "./index.js",

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

@@ -1,86 +1,219 @@
-import { bs, PARAM, rt } from "@fireproof/core";
-import { URI } from "@adviser/cement";
+import { bs, rt } from "@fireproof/core";
+import { BuildURI, Logger, MockLogger, runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
 import { base58btc } from "multiformats/bases/base58";
 import { sha256 as hasher } from "multiformats/hashes/sha2";
 import * as dagCodec from "@ipld/dag-cbor";
-import { mockSuperThis } from "../helpers";
+import { MockSuperThis, mockSuperThis } from "../helpers";
+
+describe("KeyBag", () => {
+  let url: URI;
+  let sthis: MockSuperThis;
+
+  beforeEach(async () => {
+    sthis = mockSuperThis();
+    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("extract keyMaterial", async () => {
+    const dkb = await rt.kb.getKeyBag(sthis);
+    const old = sthis.env.get("FP_KEYBAG_URL");
+    sthis.env.set("FP_KEYBAG_URL", BuildURI.from(dkb.rt.url).setParam("extractKey", "_deprecated_internal_api").toString());
+    const kb = await rt.kb.getKeyBag(sthis);
+    const key = kb.rt.crypto.randomBytes(kb.rt.keyLength);
+    const keyStr = base58btc.encode(key);
+    const res = await kb.setNamedKey("extract.test", keyStr);
+    expect(res.isOk()).toBeTruthy();
+    const gkb = await kb.getNamedExtractableKey("extract.test", true);
+    expect(gkb.isOk()).toBeTruthy();
+    expect(await gkb.Ok().extract()).toEqual({
+      key,
+      keyStr,
+    });
+    sthis.env.set("FP_KEYBAG_URL", old);
+    await sthis.logger.Flush();
+    expect(sthis.logCollector.Logs()).toEqual([
+      {
+        level: "warn",
+        module: "KeyBag",
+        msg: "extractKey is enabled via _deprecated_internal_api --- handle keys safely!!!",
+      },
+    ]);
+  });
+
+  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 rt.kb.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 { sysFS } = await p._prepare(name);
+
+      diskBag = await sysFS.readfile((await p._prepare(name)).fName).then((data) => {
+        return JSON.parse(new TextDecoder().decode(data)) as rt.kb.KeyItem;
+      });
+      diskBag2 = await sysFS.readfile((await p._prepare(name2)).fName).then((data) => {
+        return JSON.parse(new TextDecoder().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 kb: rt.kb.KeyBag;
-  // let logger: Logger;
+  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();
-
-    const envURL = sthis.env.get("FP_KEYBAG_URL");
-    if (envURL) {
-      baseUrl = bs.getDefaultURI(sthis, URI.from(envURL).protocol);
+    logger = MockLogger().logger;
+    let kbUrl: URI;
+    if (runtimeFn().isBrowser) {
+      kbUrl = URI.from("indexdb://fp-keybag");
+      baseUrl = URI.from("indexdb://fp-keyed-crypto-store");
     } else {
-      baseUrl = bs.getDefaultURI(sthis);
+      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 = baseUrl.build().setParam(PARAM.NAME, "test").URI();
     kb = await rt.kb.getKeyBag(sthis, {
-      // url: kbUrl,
+      url: kbUrl,
     });
   });
   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, keybag: kb }),
-      strt.makeMetaStore({ sthis, url, keybag: kb }),
-      strt.makeWALStore({ sthis, url, keybag: kb }),
-    ]) {
+    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);
+
+    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(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 strt = bs.toStoreRuntime(sthis);
-    for (const pstore of [
-      strt.makeDataStore({ sthis, url: baseUrl, keybag: kb }),
-      strt.makeMetaStore({ sthis, url: baseUrl, keybag: kb }),
-      strt.makeWALStore({ sthis, url: baseUrl, keybag: kb }),
-    ]) {
-      const store = await pstore; // await bs.ensureStart(await pstore, logger);
+    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 kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       // expect(kc.isEncrypting).toBe(true);
-      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@test:${store.url().getParam(PARAM.STORE)}@`);
+      expect(store.url().getParam("storekey")).toBe(`@test:${store.url().getParam("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 url = baseUrl.build().setParam(PARAM.STORE_KEY, "@heute@").URI();
-    const strt = bs.toStoreRuntime(sthis);
-    for (const pstore of [
-      strt.makeDataStore({ sthis, url, keybag: kb }),
-      strt.makeMetaStore({ sthis, url, keybag: kb }),
-      strt.makeWALStore({ sthis, url, keybag: kb }),
-    ]) {
+    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 store = await pstore;
       // await store.start();
-      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@heute@`);
+      expect(store.url().getParam("storekey")).toBe(`@heute@`);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       const testData = kb.rt.crypto.randomBytes(1024);
@@ -96,17 +229,25 @@ 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({ sthis, url, keybag: kb }),
-      strt.makeMetaStore({ sthis, url, keybag: kb }),
-      strt.makeWALStore({ sthis, url, keybag: kb }),
-    ]) {
-      // for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
+    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 store = await pstore;
       // await store.start();
-      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(key);
+      expect(store.url().getParam("storekey")).toBe(key);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       const testData = kb.rt.crypto.randomBytes(1024);
@@ -125,14 +266,14 @@ describe("KeyedCrypto", () => {
   let keyStr: string;
   const sthis = mockSuperThis();
   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);
@@ -166,3 +307,26 @@ 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,18 +4,17 @@ import { BlockView } from "multiformats";
 import { CID } from "multiformats/cid";
 import { MemoryBlockstore } from "@web3-storage/pail/block";
 import { CRDTMeta, IndexTransactionMeta, SuperThis, bs, rt } from "@fireproof/core";
-import { mockSuperThis, simpleBlockOpts } from "../helpers";
+import { mockSuperThis } from "../helpers";
 
 class MyMemoryBlockStore extends bs.EncryptedBlockstore {
   readonly memblock = new MemoryBlockstore();
   loader: bs.Loader;
   constructor(sthis: SuperThis) {
-    const ebOpts = simpleBlockOpts(sthis, "MyMemoryBlockStore"); //, "MyMemoryBlockStore");
-    // const ebOpts = {
-    //   name: "MyMemoryBlockStore",
-    // } as bs.BlockstoreOpts;
+    const ebOpts = {
+      name: "MyMemoryBlockStore",
+    };
     super(sthis, ebOpts);
-    this.loader = new bs.Loader(sthis, ebOpts);
+    this.loader = new bs.Loader("MyMemoryBlockStore", {}, sthis);
   }
   ready(): Promise<void> {
     return Promise.resolve();
@@ -64,10 +63,7 @@ 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(sthis, {
-      ...simpleBlockOpts(sthis, testDbName),
-      public: true,
-    });
+    loader = new bs.Loader(testDbName, { public: true }, sthis);
     await loader.ready();
     block = await rt.mf.block.encode({
       value: { hello: "world" },
@@ -104,20 +100,17 @@ describe("basic Loader with two commits", function () {
   let carCid0: bs.CarGroup;
 
   const sthis = mockSuperThis();
-  afterEach(async () => {
+
+  afterEach(async function () {
     await loader.close();
     await loader.destroy();
   });
 
-  beforeEach(async () => {
+  beforeEach(async function () {
     await sthis.start();
     const mockM = new MyMemoryBlockStore(sthis);
     t = new bs.CarTransaction(mockM);
-    loader = new bs.Loader(sthis, {
-      ...simpleBlockOpts(sthis, "test-loader-two-commit"),
-      public: true,
-    });
-
+    loader = new bs.Loader("test-loader-two-commit", { public: true }, sthis);
     block = await rt.mf.block.encode({
       value: { hello: "world" },
       hasher,
@@ -218,9 +211,8 @@ describe("basic Loader with index commits", function () {
   beforeEach(async function () {
     const name = "test-loader-index" + Math.random();
     await sthis.start();
-    await sthis.start();
     // t = new CarTransaction()
-    ib = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis, name));
+    ib = new bs.EncryptedBlockstore(sthis, { name });
     block = await rt.mf.block.encode({
       value: { hello: "world" },
       hasher,

package/tests/blockstore/store.test.ts

@@ -1,18 +1,21 @@
 import { CID } from "multiformats";
-import { bs, NotFoundError, SuperThis, rt } from "@fireproof/core";
-import { mockSuperThis, noopUrl } from "../helpers";
+import { bs, NotFoundError, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../helpers";
+
+const decoder = new TextDecoder("utf-8");
 
 function runtime(sthis: SuperThis) {
-  return bs.toStoreRuntime(sthis);
+  return bs.toStoreRuntime({}, sthis);
 }
 
-async function mockLoader(sthis: SuperThis, name?: string): Promise<bs.StoreFactoryItem> {
-  const url = noopUrl(name);
+function mockLoader(sthis: SuperThis, name: string): bs.Loadable {
   return {
     sthis,
-    url: url,
-    keybag: await rt.kb.getKeyBag(sthis),
-  };
+    name,
+    ebOpts: {
+      store: {},
+    },
+  } as bs.Loadable;
 }
 
 describe("DataStore", function () {
@@ -27,7 +30,7 @@ describe("DataStore", function () {
 
   beforeEach(async () => {
     await sthis.start();
-    store = await runtime(sthis).makeDataStore(await mockLoader(sthis));
+    store = await runtime(sthis).makeDataStore(mockLoader(sthis, "test"));
     await store.start();
     raw = await bs.testStoreFactory(store.url(), sthis);
   });
@@ -43,7 +46,7 @@ describe("DataStore", function () {
     };
     await store.save(car);
     const data = await raw.get(store.url(), car.cid.toString());
-    expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
+    expect(decoder.decode(data)).toEqual(decoder.decode(car.bytes));
   });
 });
 
@@ -51,6 +54,7 @@ describe("DataStore with a saved car", function () {
   let store: bs.DataStore;
   let raw: bs.TestGateway;
   let car: bs.AnyBlock;
+
   const sthis = mockSuperThis();
 
   afterEach(async () => {
@@ -60,10 +64,9 @@ describe("DataStore with a saved car", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeDataStore(await mockLoader(sthis, "test2"));
+    store = await runtime(sthis).makeDataStore(mockLoader(sthis, "test2"));
     await store.start();
     raw = await bs.testStoreFactory(store.url(), sthis);
-    raw = await bs.testStoreFactory(store.url(), sthis);
     car = {
       cid: "cid" as unknown as CID,
       bytes: new Uint8Array([55, 56, 57, 80]),
@@ -73,7 +76,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());
-    expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
+    expect(decoder.decode(data)).toEqual(decoder.decode(car.bytes));
   });
 
   it("should load a car", async function () {
@@ -103,7 +106,7 @@ describe("MetaStore", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeMetaStore(await mockLoader(sthis, "test"));
+    store = await runtime(sthis).makeMetaStore(mockLoader(sthis, "test"));
     await store.start();
     raw = await bs.testStoreFactory(store.url(), sthis);
   });
@@ -133,7 +136,6 @@ describe("MetaStore with a saved header", function () {
   let raw: bs.TestGateway;
   let cid: CID;
   const sthis = mockSuperThis();
-  // let onload: bs.DbMeta[];
 
   afterEach(async () => {
     await store.close();
@@ -142,22 +144,16 @@ describe("MetaStore with a saved header", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeMetaStore(await mockLoader(sthis, "test-saved-header"));
+    store = await runtime(sthis).makeMetaStore(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 data = decoder.decode(bytes);
     expect(data).toMatch(/parents/);
     const header = JSON.parse(data)[0];
     expect(header).toBeDefined();

package/tests/blockstore/transaction.test.ts

@@ -1,16 +1,16 @@
 import { CID } from "multiformats";
 import { bs, SuperThis } from "@fireproof/core";
-import { mockSuperThis, simpleBlockOpts } from "../helpers";
+import { mockSuperThis } from "../helpers";
 
 describe("Fresh TransactionBlockstore", function () {
   let blocks: bs.BaseBlockstore;
   const sthis = mockSuperThis();
   beforeEach(function () {
-    blocks = new bs.BaseBlockstore(simpleBlockOpts(sthis));
+    blocks = new bs.BaseBlockstore();
+  });
+  it("should not have a name", function () {
+    expect(blocks.name).toBeFalsy();
   });
-  // it("should not have a name", function () {
-  //   expect(blocks.name).toBeFalsy();
-  // });
   it("should not have a loader", function () {
     expect(blocks.loader).toBeFalsy();
   });
@@ -34,12 +34,12 @@ describe("Fresh TransactionBlockstore", function () {
 describe("TransactionBlockstore with name", function () {
   let blocks: bs.EncryptedBlockstore;
   const sthis = mockSuperThis();
-  beforeEach(async function () {
-    blocks = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis));
+  beforeEach(function () {
+    blocks = new bs.EncryptedBlockstore(sthis, { name: "test" });
+  });
+  it("should have a name", function () {
+    expect(blocks.name).toEqual("test");
   });
-  // it("should have a name", function () {
-  //   expect(blocks.name).toEqual("test");
-  // });
   it("should have a loader", function () {
     expect(blocks.loader).toBeTruthy();
   });
@@ -59,7 +59,7 @@ describe("A transaction", function () {
   let blocks: bs.EncryptedBlockstore;
   const sthis = mockSuperThis();
   beforeEach(async function () {
-    blocks = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis, "test"));
+    blocks = new bs.EncryptedBlockstore(sthis, { name: "test" });
     tblocks = new bs.CarTransaction(blocks);
     blocks.transactions.add(tblocks);
   });
@@ -89,7 +89,7 @@ describe("TransactionBlockstore with a completed transaction", function () {
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     cid2 = CID.parse("bafybeibgouhn5ktecpjuovt52zamzvm4dlve5ak7x6d5smms3itkhplnhm");
 
-    blocks = new bs.BaseBlockstore(simpleBlockOpts(sthis));
+    blocks = new bs.BaseBlockstore();
     await blocks.transaction(async (tblocks) => {
       await tblocks.put(cid, asUInt8Array("value", sthis));
       await tblocks.put(cid, asUInt8Array("value", sthis));