@fireproof/core-test 0.23.0 → 0.23.1-dev-issue-1057

package/blockstore/keyed-crypto.test.ts

@@ -1,381 +0,0 @@
-import { BuildURI, LogCollector, 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 * as cborg from "cborg";
-import type { KeyBagProviderIndexedDB } from "@fireproof/core-gateways-indexeddb";
-import { mockLoader, MockSuperThis, mockSuperThis } from "../helpers.js";
-import { ensureSuperThis, keyedCryptoFactory, storeType2DataMetaWal } from "@fireproof/core-runtime";
-import { V2KeysItem, PARAM, StoreType } from "@fireproof/core-types-base";
-import { describe, beforeEach, it, expect } from "vitest";
-import { coerceMaterial, getKeyBag, KeyBag, toKeyWithFingerPrint } from "@fireproof/core-keybag";
-import { KeyBagProviderFile } from "@fireproof/core-gateways-file";
-import { CryptoAction, IvKeyIdData, KeyWithFingerPrint, Loadable } from "@fireproof/core-types-blockstore";
-import { createAttachedStores, getDefaultURI } from "@fireproof/core-blockstore";
-
-describe("KeyBag", () => {
-  let url: URI;
-  let sthis: MockSuperThis;
-
-  beforeEach(async () => {
-    sthis = mockSuperThis();
-    await sthis.start();
-    if (runtimeFn().isBrowser) {
-      url = URI.from("indexeddb://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 getKeyBag(sthis);
-    if (runtimeFn().isBrowser) {
-      expect(kb.rt.url.toString()).toBe(`indexeddb://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 getKeyBag(sthis);
-    expect(kb.rt.url.toString()).toBe(url.toString());
-    sthis.env.set("FP_KEYBAG_URL", old);
-  });
-
-  it("extract keyMaterial", async () => {
-    const dkb = await 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 getKeyBag(sthis);
-    const key = kb.rt.crypto.randomBytes(kb.rt.keyLength);
-    const keyStr = base58btc.encode(key);
-    const keyName = "extract.test" + Math.random();
-    const res = await kb.getNamedKey(keyName, false, keyStr);
-    expect(res.isOk()).toBeTruthy();
-    const gkb = await kb.getNamedKey(keyName, true);
-    expect(gkb.isOk()).toBeTruthy();
-
-    expect(
-      await gkb
-        .Ok()
-        .get()
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        .then((i) => i!.extract()),
-    ).toEqual({
-      key,
-      keyStr,
-    });
-    sthis.env.set("FP_KEYBAG_URL", old);
-    await sthis.logger.Flush();
-    expect(sthis.ctx.get<LogCollector>("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 getKeyBag(sthis, {
-      url: url.toString(),
-    });
-    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.getNamedKey(name, false, key);
-    expect(res.isOk()).toBeTruthy();
-    expect((await kb.getNamedKey(name, true)).Ok()).toEqual(res.Ok());
-
-    const name2 = "implicit" + Math.random();
-    const created = await kb.getNamedKey(name2);
-    expect(created.isOk()).toBeTruthy();
-
-    expect((await kb.getNamedKey(name2)).Ok()).toEqual(created.Ok());
-
-    let diskBag: V2KeysItem;
-    let diskBag2: V2KeysItem;
-    const provider = await kb.rt.getBagProvider();
-    if (runtimeFn().isBrowser) {
-      const p = provider as KeyBagProviderIndexedDB;
-      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;
-      if (typeof p._prepare !== "function") {
-        return;
-      }
-      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 V2KeysItem;
-      });
-      diskBag2 = await sysFS.readfile((await p._prepare(name2)).fName).then((data) => {
-        return JSON.parse(sthis.txt.decode(data)) as V2KeysItem;
-      });
-    }
-    expect((await toKeyWithFingerPrint(kb, coerceMaterial(kb, Object.values(diskBag.keys)[0].key), true)).Ok().fingerPrint).toEqual(
-      (await res.Ok().get())?.fingerPrint,
-    );
-    expect(
-      (await toKeyWithFingerPrint(kb, coerceMaterial(kb, Object.values(diskBag2.keys)[0].key), true)).Ok().fingerPrint,
-    ).toEqual((await created.Ok().get())?.fingerPrint);
-    const algo = {
-      name: "AES-GCM",
-      iv: kb.rt.crypto.randomBytes(12),
-      tagLength: 128,
-    };
-    const data = kb.rt.crypto.randomBytes(122);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    expect(await kb.rt.crypto.encrypt(algo, (await res.Ok().get())!.key, data))
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      .toEqual(await kb.rt.crypto.encrypt(algo, (await created.Ok().get())!.key, data));
-    const kf = (await created.Ok().get()) as KeyWithFingerPrint;
-    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(Object.values(diskBag.keys)[0].key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, kf.key, data),
-    );
-    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(Object.values(diskBag2.keys)[0].key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, kf.key, data),
-    );
-  });
-
-  it("default key", async () => {
-    const kb = await getKeyBag(sthis, {
-      url: url.build().setParam("extractKey", "_deprecated_internal_api"),
-    });
-    const name = "default-key" + Math.random();
-    const rMyKey = await kb.getNamedKey(name);
-
-    for (let i = 0; i < 10; ++i) {
-      expect(await kb.getNamedKey(name).then((i) => i.Ok().id)).toEqual(rMyKey.Ok().id);
-    }
-    expect(Object.keys((await kb.getNamedKey(name).then((i) => i.Ok().asV2KeysItem())).keys).length).toBe(1);
-
-    const myKey = (await rMyKey.Ok().get()) as KeyWithFingerPrint;
-    expect(myKey.fingerPrint).toMatch(/^z/);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    await rMyKey.Ok().upsert((await myKey.extract())!.key);
-    const myKey1 = (await rMyKey.Ok().get()) as KeyWithFingerPrint;
-    expect(myKey.fingerPrint).toEqual(myKey1.fingerPrint);
-
-    expect(Object.keys((await kb.getNamedKey(name).then((i) => i.Ok().asV2KeysItem())).keys).length).toBe(1);
-
-    const rMyKey1 = await kb.getNamedKey(name);
-    expect(rMyKey1.Ok()).toEqual(rMyKey.Ok());
-    const res1 = await rMyKey1.Ok().upsert(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    expect(res1.isOk()).toBeTruthy();
-
-    const myKey2 = (await rMyKey1.Ok().get()) as KeyWithFingerPrint;
-    expect(myKey.fingerPrint).toEqual(myKey2.fingerPrint);
-    expect(Object.keys((await kb.getNamedKey(name).then((i) => i.Ok().asV2KeysItem())).keys).length).toBe(2);
-
-    const res = await rMyKey1.Ok().upsert(kb.rt.crypto.randomBytes(kb.rt.keyLength), true);
-    expect(res.isOk()).toBeTruthy();
-    const myKey3 = (await rMyKey.Ok().get()) as KeyWithFingerPrint;
-    expect(Object.keys((await kb.getNamedKey(name).then((i) => i.Ok().asV2KeysItem())).keys).length).toBe(3);
-
-    expect(myKey.fingerPrint).not.toEqual(myKey3.fingerPrint);
-  });
-
-  it("default and multiple fingerprints", async () => {
-    const kb = await getKeyBag(sthis, {
-      url: url.toString(),
-      crypto: toCryptoRuntime({
-        randomBytes: (size) => new Uint8Array(size).map((_, i) => i),
-      }),
-    });
-    const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const name = "default-key" + Math.random();
-    const fpr = (await toKeyWithFingerPrint(kb, coerceMaterial(kb, key), true)).Ok().fingerPrint;
-    const rMyKey = await kb.getNamedKey(name, false, key);
-    expect(rMyKey.isOk()).toBeTruthy();
-    const myKey = rMyKey.Ok();
-
-    const rUpsert1 = await myKey.upsert(key, true);
-    expect(rUpsert1.Ok().modified).toBeFalsy();
-
-    expect((await myKey.get())?.fingerPrint).toEqual(fpr);
-    expect((await myKey.get(fpr))?.fingerPrint).toEqual(fpr);
-
-    const keys = [{ key, fpr }];
-    for (let i = 0; i < 10; ++i) {
-      const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-      const fpr = (await toKeyWithFingerPrint(kb, coerceMaterial(kb, key), true)).Ok().fingerPrint;
-      keys.push({ key, fpr });
-      const rUpsert = await myKey.upsert(key, true);
-      expect(rUpsert.Ok().modified).toBeTruthy();
-      for (const { fpr } of keys) {
-        expect((await myKey.get(fpr))?.fingerPrint).toEqual(fpr);
-      }
-      expect((await myKey.get())?.fingerPrint).toEqual(fpr);
-    }
-    const provider = await kb.rt.getBagProvider();
-    let diskBag: V2KeysItem;
-    if (!("_prepare" in provider)) {
-      diskBag = (await provider.get(name)) as V2KeysItem;
-    } else {
-      if (runtimeFn().isBrowser) {
-        const p = provider as KeyBagProviderIndexedDB;
-        diskBag = await p._prepare().then((db) => db.get("bag", name));
-      } else {
-        const p = provider as 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 V2KeysItem;
-        });
-      }
-    }
-    expect(Object.values(diskBag.keys).length).toEqual(keys.length);
-  });
-});
-
-describe("KeyedCryptoStore", () => {
-  let kb: KeyBag;
-  // let logger: Logger;
-  let baseUrl: URI;
-  const sthis = ensureSuperThis();
-  let loader: Loadable;
-  beforeEach(async () => {
-    await sthis.start();
-    // logger = MockLogger().logger;
-    // let kbUrl: URI;
-    // if (runtimeFn().isBrowser) {
-    //   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"));
-    //   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 = getDefaultURI(sthis, URI.from(envURL).protocol);
-    } else {
-      baseUrl = getDefaultURI(sthis);
-    }
-    baseUrl = baseUrl.build().setParam(PARAM.NAME, "test").URI();
-    kb = await getKeyBag(sthis, {});
-    loader = mockLoader(sthis);
-  });
-  it("no crypto", async () => {
-    const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
-
-    for (const pstore of (await createAttachedStores(url, loader, "insecure")).stores.baseStores) {
-      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 () => {
-    for (const pstore of (await 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");
-      // expect(kc.isEncrypting).toBe(true);
-      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(
-        `@test-${storeType2DataMetaWal(store.url().getParam(PARAM.STORE) as StoreType)}@`,
-      );
-    }
-  });
-
-  it("key ref keybag", async () => {
-    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();
-    for (const pstore of (await createAttachedStores(url, loader, "insecure")).stores.baseStores) {
-      const store = await pstore;
-      // await store.start();
-      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@heute@`);
-      const kc = await store.keyedCrypto();
-      expect(kc.constructor.name).toBe("cryptoAction");
-      const testData = kb.rt.crypto.randomBytes(1024);
-      const iv = kb.rt.crypto.randomBytes(12);
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const blk = await kc._encrypt({ bytes: testData, key: (await kc.key.get())!.key, iv });
-      expect(blk).not.toEqual(testData);
-      const fpkey = (await genKey.Ok().get()) as KeyWithFingerPrint;
-      expect(fpkey.fingerPrint).toEqual(fpkey.fingerPrint);
-      const dec = new Uint8Array(await kc.crypto.decrypt(kc.algo(iv), fpkey.key, blk));
-      expect(dec).toEqual(testData);
-    }
-  });
-
-  it("key", async () => {
-    const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const url = baseUrl.build().setParam(PARAM.STORE_KEY, key).URI();
-    for (const pstore of (await 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();
-      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(key);
-      const kc = await store.keyedCrypto();
-      expect(kc.constructor.name).toBe("cryptoAction");
-      const testData = kb.rt.crypto.randomBytes(1024);
-      const iv = kb.rt.crypto.randomBytes(12);
-      const ks = (await kc.key.get()) as KeyWithFingerPrint;
-      const blk = await kc._encrypt({ bytes: testData, key: ks.key, iv });
-      expect(blk).not.toEqual(testData);
-      const dec = await kc._decrypt({ bytes: blk, key: ks.key, iv });
-      expect(dec).toEqual(testData);
-    }
-  });
-});
-
-describe("KeyedCrypto", () => {
-  let kb: KeyBag;
-  let kycr: CryptoAction;
-  let keyStr: string;
-  const sthis = ensureSuperThis();
-  beforeEach(async () => {
-    // let url: URI;
-    // if (runtimeFn().isBrowser) {
-    //   url = URI.from("indexeddb://fp-keybag");
-    // } else {
-    //   url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-    // }
-    kb = await getKeyBag(sthis, {
-      // url,
-    });
-    keyStr = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    kycr = await keyedCryptoFactory(URI.from(`test://bla?storekey=${keyStr}`), kb, sthis);
-  });
-  it("codec explict iv", async () => {
-    const testData = kb.rt.crypto.randomBytes(1024);
-    const iv = kb.rt.crypto.randomBytes(12);
-    const codec = kycr.codec(iv, { noIVVerify: true });
-    const blk = (await codec.encode(testData)) as Uint8Array;
-    const myDec = cborg.decode(blk) as IvKeyIdData;
-    expect(myDec.iv).toEqual(iv);
-    const kc = (await kycr.key.get()) as KeyWithFingerPrint;
-    expect(base58btc.encode(myDec.keyId)).toEqual(kc.fingerPrint);
-    const dec = await codec.decode(blk);
-    expect(dec.data).toEqual(testData);
-  });
-
-  it("codec implict iv", async () => {
-    const testData = kb.rt.crypto.randomBytes(1024);
-    const codec = kycr.codec();
-    const blk = await codec.encode(testData);
-    expect(blk.length).toBeGreaterThanOrEqual(12 + testData.length);
-    const dec = await codec.decode(blk);
-    expect(dec.data).toEqual(testData);
-  });
-
-  it("codec implict iv same for multiple clients", async () => {
-    const testData = kb.rt.crypto.randomBytes(1024);
-    const codec = kycr.codec();
-    const blk = await codec.encode(testData);
-    const blk2 = await codec.encode(testData);
-    expect(blk).toEqual(blk2);
-  });
-});

package/blockstore/loader.test.ts

@@ -1,313 +0,0 @@
-import * as codec from "@ipld/dag-cbor";
-import { sha256 as hasher } from "multiformats/hashes/sha2";
-import { CID } from "multiformats/cid";
-import { CRDTMeta, CarTransaction, IndexTransactionMeta, SuperThis } from "@fireproof/core";
-import { simpleBlockOpts } from "../helpers.js";
-import {
-  EncryptedBlockstore,
-  Loader,
-  CompactionFetcher,
-  CarTransactionImpl,
-  anyBlock2FPBlock,
-  parseCarFile,
-} from "@fireproof/core-blockstore";
-import { asyncBlockEncode, ensureSuperThis } from "@fireproof/core-runtime";
-import {
-  FPBlock,
-  TransactionMeta,
-  isCarBlockItemReady,
-  CarGroup,
-  isCarBlockItemStale,
-  AnyLink,
-} from "@fireproof/core-types-blockstore";
-import { describe, afterEach, beforeEach, it, expect, assert } from "vitest";
-
-class MyMemoryBlockStore extends EncryptedBlockstore {
-  readonly memblock = new Map<string, FPBlock>();
-  loader: Loader;
-  constructor(sthis: SuperThis) {
-    const ebOpts = simpleBlockOpts(sthis, "MyMemoryBlockStore"); //, "MyMemoryBlockStore");
-    // const ebOpts = {
-    //   name: "MyMemoryBlockStore",
-    // } as BlockstoreOpts;
-    super(sthis, ebOpts);
-    this.loader = new Loader(sthis, ebOpts);
-  }
-  ready(): Promise<void> {
-    return Promise.resolve();
-  }
-  close(): Promise<void> {
-    return this.loader.close();
-  }
-  readonly transactions = new Set<CarTransaction>();
-  // readonly lastTxMeta?: TransactionMeta;
-  readonly compacting: boolean = false;
-
-  override async put(fp: FPBlock): Promise<void> {
-    this.memblock.set(fp.cid.toString(), fp);
-  }
-
-  // transaction<M ext(fn: (t: CarTransaction) => Promise<MetaType>, opts?: { noLoader: boolean }): Promise<MetaType> {
-  //   throw new Error("Method not implemented.");
-  // }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  getFile(car: AnyLink, cid: AnyLink, isPublic?: boolean): Promise<Uint8Array> {
-    throw new Error("Method not implemented.");
-  }
-  compact(): Promise<void> {
-    throw new Error("Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  defaultCompact(blocks: CompactionFetcher): Promise<TransactionMeta> {
-    throw new Error("Method not implemented.");
-  }
-}
-
-describe("basic Loader simple", function () {
-  let loader: Loader;
-  let block: FPBlock;
-  let t: CarTransaction;
-  const sthis = ensureSuperThis();
-
-  afterEach(async () => {
-    await loader.close();
-    await loader.destroy();
-  });
-
-  beforeEach(async () => {
-    const testDbName = "test-loader-commit";
-    await sthis.start();
-    const mockM = new MyMemoryBlockStore(sthis);
-    t = new CarTransactionImpl(mockM as EncryptedBlockstore);
-    loader = new Loader(sthis, {
-      ...simpleBlockOpts(sthis, testDbName),
-      public: true,
-    });
-    await loader.ready();
-    block = await anyBlock2FPBlock(
-      await asyncBlockEncode({
-        value: { hello: "world" },
-        hasher,
-        codec,
-      }),
-    );
-    await t.put(block);
-    await mockM.put(block);
-  });
-  it("should have an empty car log", function () {
-    expect(loader.carLog.length).toBe(0);
-  });
-  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], loader.attachedStores.local());
-    assert(isCarBlockItemReady(reader));
-    expect(reader).toBeTruthy();
-    const parsed = await parseCarFile<CRDTMeta>(reader, loader.logger);
-    expect(parsed.cars).toBeTruthy();
-    expect(parsed.cars.length).toBe(0);
-    expect(parsed.meta).toBeTruthy();
-    expect(parsed.meta.head).toBeTruthy();
-  });
-});
-
-describe("basic Loader with two commits", function () {
-  let loader: Loader;
-  let block: FPBlock;
-  let block2: FPBlock;
-  let block3: FPBlock;
-  let block4: FPBlock;
-  let t: CarTransaction;
-  let carCid: CarGroup;
-  let carCid0: CarGroup;
-
-  const sthis = ensureSuperThis();
-
-  afterEach(async () => {
-    await loader.close();
-    await loader.destroy();
-  });
-
-  beforeEach(async () => {
-    await sthis.start();
-    const mockM = new MyMemoryBlockStore(sthis);
-    t = new CarTransactionImpl(mockM);
-    loader = new Loader(sthis, {
-      ...simpleBlockOpts(sthis, "test-loader-two-commit"),
-      public: true,
-    });
-    await loader.ready();
-
-    block = await anyBlock2FPBlock(
-      await asyncBlockEncode({
-        value: { hello: "world" },
-        hasher,
-        codec,
-      }),
-    );
-    await t.put(block);
-    carCid0 = await loader.commit(t, { head: [block.cid] });
-
-    block2 = await anyBlock2FPBlock(
-      await asyncBlockEncode({
-        value: { hello: "universe" },
-        hasher,
-        codec,
-      }),
-    );
-    await t.put(block2);
-    carCid = await loader.commit(t, { head: [block2.cid] });
-
-    block3 = await anyBlock2FPBlock(
-      await asyncBlockEncode({
-        value: { hello: "multiverse" },
-        hasher,
-        codec,
-      }),
-    );
-    await t.put(block3);
-
-    block4 = await anyBlock2FPBlock(
-      await asyncBlockEncode({
-        value: { hello: "megaverse" },
-        hasher,
-        codec,
-      }),
-    );
-
-    await t.put(block4);
-  });
-
-  it("should have a car log", function () {
-    expect(loader.carLog.length).toBe(2);
-    expect(loader.carLog.asArray()[0].toString()).toBe(carCid.toString());
-    expect(loader.carLog.asArray()[1].toString()).toBe(carCid0.toString());
-  });
-
-  it("should commit", async () => {
-    const reader = await loader.loadCar(carCid[0], loader.attachedStores.local());
-    expect(reader).toBeTruthy();
-    assert(isCarBlockItemReady(reader));
-    const parsed = await parseCarFile<CRDTMeta>(reader, loader.logger);
-    expect(parsed.cars).toBeTruthy();
-    expect(parsed.compact.length).toBe(0);
-    expect(parsed.cars.length).toBe(1);
-    expect(parsed.meta).toBeTruthy();
-    expect(parsed.meta.head).toBeTruthy();
-  });
-
-  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], loader.attachedStores.local());
-    expect(reader).toBeTruthy();
-    assert(isCarBlockItemReady(reader));
-    const parsed = await parseCarFile<CRDTMeta>(reader, loader.logger);
-    expect(parsed.cars).toBeTruthy();
-    expect(parsed.compact.length).toBe(2);
-    expect(parsed.cars.length).toBe(0);
-    expect(parsed.meta).toBeTruthy();
-    expect(parsed.meta.head).toBeTruthy();
-  });
-
-  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 });
-    expect(loader.carLog.length).toBe(2);
-    expect(await cs.load(carCid[0])).toBeTruthy();
-    await loader.commit(t, { head: [block3.cid] }, { compact: true });
-    expect(loader.carLog.length).toBe(1);
-    const e0 = await cs.load(carCid[0]).catch((e) => e);
-    expect(e0 instanceof Error).toBeTruthy();
-    await loader.commit(t, { head: [block4.cid] }, { compact: false });
-    expect(loader.carLog.length).toBe(2);
-
-    const e = await loader.loadCar(carCid[0], loader.attachedStores.local());
-    expect(e).toBeTruthy();
-    assert(isCarBlockItemStale(e));
-    expect(e.item.status).toBe("stale");
-    expect(e.item.statusCause.message).toMatch(/(missing car file)|(not found)/);
-  }, 10000);
-});
-
-describe("basic Loader with index commits", function () {
-  let block: FPBlock;
-  let ib: EncryptedBlockstore;
-  let indexerResult: IndexTransactionMeta;
-  let cid: CID;
-  // let indexMap: Map<string, CID>;
-  const sthis = ensureSuperThis();
-
-  afterEach(async () => {
-    await ib.close();
-    await ib.destroy();
-  });
-
-  beforeEach(async () => {
-    const name = "test-loader-index" + Math.random();
-    await sthis.start();
-    // t = new CarTransaction()
-    ib = new EncryptedBlockstore(sthis, simpleBlockOpts(sthis, name));
-    await ib.ready();
-    block = await anyBlock2FPBlock(
-      await asyncBlockEncode({
-        value: { hello: "world" },
-        hasher,
-        codec,
-      }),
-    );
-    // console.log('block', block.cid)
-
-    cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
-    indexerResult = {
-      indexes: {
-        hello: {
-          byId: cid,
-          byKey: cid,
-          head: [cid as CID<unknown, number, number, 1>],
-          name: "hello",
-          map: "(doc) => doc.hello",
-        },
-      },
-    };
-    // indexMap = new Map();
-  });
-
-  it("should start with an empty car log", function () {
-    expect(ib.loader).toBeTruthy();
-    expect(ib.loader.carLog.length).toBe(0);
-  });
-
-  it("should commit the index metadata", async () => {
-    const { cars: carCid } = await ib.transaction<IndexTransactionMeta>(
-      async (t) => {
-        await t.put(block);
-        return indexerResult;
-      } /* , indexMap */,
-    );
-
-    expect(carCid).toBeTruthy();
-    expect(ib.loader).toBeTruthy();
-    const carLog = ib.loader.carLog;
-
-    expect(carLog.length).toBe(1);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const reader = await ib.loader.loadCar(carCid![0], ib.loader.attachedStores.local());
-    expect(reader).toBeTruthy();
-    assert(isCarBlockItemReady(reader));
-    const parsed = await parseCarFile<IndexTransactionMeta>(reader, sthis.logger);
-    expect(parsed.cars).toBeTruthy();
-    expect(parsed.cars.length).toBe(0);
-    expect(parsed.meta).toBeTruthy();
-    expect(parsed.meta.indexes).toBeTruthy();
-    const indexes = parsed.meta.indexes;
-    expect(indexes).toBeTruthy();
-    expect(indexes.hello).toBeTruthy();
-    expect(indexes.hello.map).toBe("(doc) => doc.hello");
-    expect(indexes.hello.name).toBe("hello");
-  });
-});