@fireproof/core 0.20.5-dev-preview-1 → 0.20.5-dev-preview-3

package/runtime/wait-pr-multiformats/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/runtime/wait-pr-multiformats/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAC"}

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

@@ -87,14 +87,19 @@ export class URITrackGateway implements bs.Gateway {
     return this.memgw.destroy(baseUrl);
   }
 
-  put(url: URI, bytes: Uint8Array): Promise<bs.VoidResult> {
+  put(url: URI, bytes: Uint8Array, sthis: SuperThis): Promise<bs.VoidResult> {
+    // console.log("put", url.getParam(PARAM.KEY), url.toString());
     this.uriAdd(url);
-    return this.memgw.put(url, bytes);
+    return this.memgw.put(url.build().cleanParams("itis").URI(), bytes, sthis);
   }
 
-  get(url: URI): Promise<bs.GetResult> {
+  async get(url: URI, sthis: SuperThis): Promise<bs.GetResult> {
     this.uriAdd(url);
-    return this.memgw.get(url);
+    const ret = await this.memgw.get(url.build().cleanParams("itis").URI(), sthis);
+    // if (ret.isErr()) {
+    //   console.log("get-err", url.getParam(PARAM.KEY), url.toString());
+    // }
+    return ret;
   }
   delete(url: URI): Promise<bs.VoidResult> {
     this.uriAdd(url);
@@ -136,7 +141,7 @@ describe("InterceptorGateway", () => {
     await db.close();
     await db.destroy();
     // await sleep(1000);
-    expect(gwi.fn.mock.calls.length).toBe(58);
+    expect(gwi.fn.mock.calls.length).toBe(54);
     // might be a stupid test
     expect(gwi.fn.mock.calls.map((i) => i[0]).sort() /* not ok there are some operation */).toEqual(
       [
@@ -178,10 +183,6 @@ describe("InterceptorGateway", () => {
         "close",
         "close",
         "close",
-        "close",
-        "close",
-        "close",
-        "close",
         "buildUrl",
         "get",
         "close",

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

@@ -1,5 +1,5 @@
 import { bs, ensureSuperThis, PARAM, rt, StoreType, storeType2DataMetaWal } from "@fireproof/core";
-import { BuildURI, runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
+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";
@@ -64,7 +64,7 @@ describe("KeyBag", () => {
     });
     sthis.env.set("FP_KEYBAG_URL", old);
     await sthis.logger.Flush();
-    expect(sthis.ctx.logCollector.Logs()).toEqual([
+    expect(sthis.ctx.get<LogCollector>("logCollector")?.Logs()).toEqual([
       {
         level: "warn",
         module: "KeyBag",

package/tests/blockstore/loader.test.ts

@@ -1,13 +1,13 @@
 import * as codec from "@ipld/dag-cbor";
 import { sha256 as hasher } from "multiformats/hashes/sha2";
-import { BlockView } from "multiformats";
 import { CID } from "multiformats/cid";
-import { MemoryBlockstore } from "@web3-storage/pail/block";
 import { CRDTMeta, CarTransaction, IndexTransactionMeta, SuperThis, bs, ensureSuperThis, rt } from "@fireproof/core";
 import { simpleBlockOpts } from "../helpers.js";
+import { FPBlock, isCarBlockItemReady, isCarBlockItemStale } from "../../src/blockstore/index.js";
+import { anyBlock2FPBlock } from "../../src/blockstore/loader-helpers.js";
 
 class MyMemoryBlockStore extends bs.EncryptedBlockstore {
-  readonly memblock = new MemoryBlockstore();
+  readonly memblock = new Map<string, FPBlock>();
   loader: bs.Loader;
   constructor(sthis: SuperThis) {
     const ebOpts = simpleBlockOpts(sthis, "MyMemoryBlockStore"); //, "MyMemoryBlockStore");
@@ -27,8 +27,8 @@ class MyMemoryBlockStore extends bs.EncryptedBlockstore {
   // readonly lastTxMeta?: TransactionMeta;
   readonly compacting: boolean = false;
 
-  override async put(cid: bs.AnyAnyLink, block: Uint8Array): Promise<void> {
-    return this.memblock.put(cid, block);
+  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> {
@@ -50,7 +50,7 @@ class MyMemoryBlockStore extends bs.EncryptedBlockstore {
 
 describe("basic Loader simple", function () {
   let loader: bs.Loader;
-  let block: BlockView;
+  let block: FPBlock;
   let t: CarTransaction;
   const sthis = ensureSuperThis();
 
@@ -69,13 +69,15 @@ describe("basic Loader simple", function () {
       public: true,
     });
     await loader.ready();
-    block = await rt.mf.block.encode({
-      value: { hello: "world" },
-      hasher,
-      codec,
-    });
-    await t.put(block.cid, block.bytes);
-    await mockM.put(block.cid, block.bytes);
+    block = await anyBlock2FPBlock(
+      await rt.mf.block.encode({
+        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);
@@ -84,6 +86,7 @@ describe("basic Loader simple", function () {
     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 bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
@@ -95,10 +98,10 @@ describe("basic Loader simple", function () {
 
 describe("basic Loader with two commits", function () {
   let loader: bs.Loader;
-  let block: BlockView;
-  let block2: BlockView;
-  let block3: BlockView;
-  let block4: BlockView;
+  let block: FPBlock;
+  let block2: FPBlock;
+  let block3: FPBlock;
+  let block4: FPBlock;
   let t: CarTransaction;
   let carCid: bs.CarGroup;
   let carCid0: bs.CarGroup;
@@ -120,36 +123,44 @@ describe("basic Loader with two commits", function () {
     });
     await loader.ready();
 
-    block = await rt.mf.block.encode({
-      value: { hello: "world" },
-      hasher,
-      codec,
-    });
-    await t.put(block.cid, block.bytes);
+    block = await anyBlock2FPBlock(
+      await rt.mf.block.encode({
+        value: { hello: "world" },
+        hasher,
+        codec,
+      }),
+    );
+    await t.put(block);
     carCid0 = await loader.commit(t, { head: [block.cid] });
 
-    block2 = await rt.mf.block.encode({
-      value: { hello: "universe" },
-      hasher,
-      codec,
-    });
-    await t.put(block2.cid, block2.bytes);
+    block2 = await anyBlock2FPBlock(
+      await rt.mf.block.encode({
+        value: { hello: "universe" },
+        hasher,
+        codec,
+      }),
+    );
+    await t.put(block2);
     carCid = await loader.commit(t, { head: [block2.cid] });
 
-    block3 = await rt.mf.block.encode({
-      value: { hello: "multiverse" },
-      hasher,
-      codec,
-    });
-    await t.put(block3.cid, block3.bytes);
+    block3 = await anyBlock2FPBlock(
+      await rt.mf.block.encode({
+        value: { hello: "multiverse" },
+        hasher,
+        codec,
+      }),
+    );
+    await t.put(block3);
 
-    block4 = await rt.mf.block.encode({
-      value: { hello: "megaverse" },
-      hasher,
-      codec,
-    });
+    block4 = await anyBlock2FPBlock(
+      await rt.mf.block.encode({
+        value: { hello: "megaverse" },
+        hasher,
+        codec,
+      }),
+    );
 
-    await t.put(block4.cid, block4.bytes);
+    await t.put(block4);
   });
 
   it("should have a car log", function () {
@@ -161,6 +172,7 @@ describe("basic Loader with two commits", function () {
   it("should commit", async () => {
     const reader = await loader.loadCar(carCid[0], loader.attachedStores.local());
     expect(reader).toBeTruthy();
+    assert(isCarBlockItemReady(reader));
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
     expect(parsed.compact.length).toBe(0);
@@ -175,6 +187,7 @@ describe("basic Loader with two commits", function () {
 
     const reader = await loader.loadCar(compactCid[0], loader.attachedStores.local());
     expect(reader).toBeTruthy();
+    assert(isCarBlockItemReady(reader));
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
     expect(parsed.compact.length).toBe(2);
@@ -197,15 +210,16 @@ describe("basic Loader with two commits", function () {
     await loader.commit(t, { head: [block4.cid] }, { compact: false });
     expect(loader.carLog.length).toBe(2);
 
-    const e = await loader.loadCar(carCid[0], loader.attachedStores.local()).catch((e) => e);
+    const e = await loader.loadCar(carCid[0], loader.attachedStores.local());
     expect(e).toBeTruthy();
-    expect(e instanceof Error).toBeTruthy();
-    expect(e.message).toMatch(/(missing car file)|(not found)/);
+    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: BlockView;
+  let block: FPBlock;
   let ib: bs.EncryptedBlockstore;
   let indexerResult: IndexTransactionMeta;
   let cid: CID;
@@ -223,11 +237,13 @@ describe("basic Loader with index commits", function () {
     // t = new CarTransaction()
     ib = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis, name));
     await ib.ready();
-    block = await rt.mf.block.encode({
-      value: { hello: "world" },
-      hasher,
-      codec,
-    });
+    block = await anyBlock2FPBlock(
+      await rt.mf.block.encode({
+        value: { hello: "world" },
+        hasher,
+        codec,
+      }),
+    );
     // console.log('block', block.cid)
 
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
@@ -253,7 +269,7 @@ describe("basic Loader with index commits", function () {
   it("should commit the index metadata", async () => {
     const { cars: carCid } = await ib.transaction<IndexTransactionMeta>(
       async (t) => {
-        await t.put(block.cid, block.bytes);
+        await t.put(block);
         return indexerResult;
       } /* , indexMap */,
     );
@@ -266,6 +282,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], ib.loader.attachedStores.local());
     expect(reader).toBeTruthy();
+    assert(isCarBlockItemReady(reader));
     const parsed = await bs.parseCarFile<IndexTransactionMeta>(reader, sthis.logger);
     expect(parsed.cars).toBeTruthy();
     expect(parsed.cars.length).toBe(0);

package/tests/blockstore/standalone.test.ts

@@ -0,0 +1,152 @@
+import { BuildURI, runtimeFn, URI } from "@adviser/cement";
+import { ensureSuperThis, PARAM, CRDTImpl, CRDT, LedgerOpts, fireproof, bs, sleep } from "@fireproof/core";
+import { Link } from "multiformats";
+import { stripper } from "@adviser/cement/utils";
+import pLimit from "p-limit";
+
+describe("standalone", () => {
+  const sthis = ensureSuperThis();
+
+  describe("howto-loader", () => {
+    // beforeAll(async () => {
+    //   const db = fireproof("howto-loader", {
+    //     storeUrls: {
+    //       base: "file://dist/how-to-loader?store-key=insecure",
+    //     },
+    //   });
+    //   for (let cid = 0; cid < 1; cid++) {
+    //     const blk = new Array(3)
+    //       .fill(0)
+    //       .map((_, peer) => ({ _id: `test-${cid}:peer-${peer}`, value: { cid: `test-${cid}`, peer: `peer-${peer}` } }));
+    //     await db.bulk(blk);
+    //   }
+    //   // await db.compact()
+    //   await db.close();
+    // });
+
+    it("understand the writer", async () => {
+      const db = fireproof("howto-writer", {
+        storeUrls: {
+          base: "memory://how-to-writer",
+        },
+      });
+      await db.put({ _id: "test-1", value: { cid: "test-1", peer: "peer-1" } });
+      await db.close();
+    });
+
+    it.skip("understand loader", async () => {
+      const db = fireproof("howto-loader", {
+        storeUrls: {
+          base: "file://dist/how-to-loader?store-key=insecure",
+        },
+      });
+      const fn = vi.fn();
+      const loader = db.ledger.crdt.blockstore.loader as bs.Loader;
+      loader.cidCache.onSet(fn);
+      expect(fn).toHaveBeenCalledTimes(0);
+      await db.ready();
+      expect(
+        loader.cidCache.values().map((i) => {
+          const v = i.value.Ok();
+          return {
+            type: v.item.type,
+            cid: v.cid,
+            value: stripper(/(type|cid)/, v.item),
+          };
+        }),
+      ).toEqual([]);
+      // let last = 0
+      // for (let i = 0; i < 100; i++) {
+      //   if (last !== fn.mock.calls.length) {
+      //     console.log("fn", i, fn.mock.calls.length);
+      //     last = fn.mock.calls.length
+      //   }
+      //   await sleep(10);
+      // }
+      const ret = await db.allDocs();
+      expect(ret.rows.length).toBe(100);
+      expect(fn).toHaveBeenCalledTimes(109393);
+      await db.close();
+    });
+  });
+
+  describe("test-plimit", () => {
+    it("should work with plimit", async () => {
+      const limiter = pLimit(2);
+      let concurrent = 0;
+      const ret = await Promise.all(
+        Array(10)
+          .fill(0)
+          .map((_, i) => {
+            return limiter(async () => {
+              concurrent++;
+              expect(concurrent).toBeLessThanOrEqual(2);
+              await sleep(100);
+              concurrent--;
+              return i;
+            });
+          }),
+      );
+      expect(ret).toEqual(Array.from(Array(10).keys()));
+    });
+  });
+
+  describe.skip("crdt-stack", () => {
+    let crdt: CRDT;
+    beforeEach(async () => {
+      let uri: URI;
+      switch (true) {
+        case runtimeFn().isBrowser:
+          uri = BuildURI.from("indexeddb://standalone-peer-log").setParam(PARAM.NAME, "peer-log").URI();
+          break;
+        default:
+          uri = BuildURI.from("file://dist/standalone")
+            .setParam(PARAM.NAME, "peer-log")
+            .setParam(PARAM.STORE_KEY, "insecure")
+            .URI();
+          break;
+      }
+      // console.log("uri", uri.toString());
+      crdt = new CRDTImpl(sthis, {
+        name: "peer-log",
+        writeQueue: { chunkSize: 32 },
+        storeUrls: {
+          data: {
+            meta: uri.build().setParam(PARAM.STORE, "meta").setParam(PARAM.STORE_KEY, "insecure").URI(),
+            car: uri.build().setParam(PARAM.STORE, "car").setParam(PARAM.STORE_KEY, "insecure").URI(),
+            file: uri.build().setParam(PARAM.STORE, "file").setParam(PARAM.STORE_KEY, "insecure").URI(),
+            wal: uri.build().setParam(PARAM.STORE, "wal").setParam(PARAM.STORE_KEY, "insecure").URI(),
+          },
+        },
+      } as LedgerOpts);
+      await crdt.ready();
+    });
+    afterEach(async () => {
+      await crdt.close();
+    });
+
+    it.each(new Array(10).fill(0).map((_, i) => ({ cid: i })))("write:$cid", async ({ cid }) => {
+      const peers = new Array(10).fill(0).map((_, peer) => {
+        return { id: `test-${cid}:peer-${peer}`, value: { cid: `test-${cid}`, peer: `peer-${peer}` } };
+      });
+      await crdt.bulk(peers);
+    });
+    it("read", async () => {
+      for (let cid = 0; cid < 10; cid++) {
+        for (let peer = 0; peer < 10; peer++) {
+          const id = `test-${cid}:peer-${peer}`;
+          const res = (await crdt.get(id)) as unknown as { cid: Link; doc: { cid: string; peer: string } };
+          expect(res.doc).toEqual({ cid: `test-${cid}`, peer: `peer-${peer}` });
+        }
+      }
+    });
+    // for (let cid = 0; cid < 10; cid++) {
+    //   const gte = `test-${cid}`;
+    //   const ret = [];
+    //   for await (const [key, link] of entries(blk, root, { gte })) {
+    //     ret.push([key, link]);
+    //   }
+    //   expect(ret.length).toEqual(10);
+    // }
+  });
+});

package/tests/blockstore/store.test.ts

@@ -19,7 +19,8 @@ import { mockLoader, noopUrl } from "../helpers.js";
 describe("CarStore", function () {
   let store: bs.CarStore;
   const sthis = ensureSuperThis();
-  const loader = mockLoader(sthis);
+
+  let loader: bs.Loadable;
 
   afterEach(async () => {
     await store.close();
@@ -27,6 +28,7 @@ describe("CarStore", function () {
   });
 
   beforeEach(async () => {
+    loader = mockLoader(sthis);
     await sthis.start();
     const at = await bs.createAttachedStores(noopUrl("test"), loader);
     store = at.stores.car;
@@ -51,9 +53,9 @@ describe("CarStore", function () {
 describe("CarStore with a saved car", function () {
   let store: bs.CarStore;
   let car: bs.AnyBlock;
+  let loader: bs.Loadable;
 
   const sthis = ensureSuperThis();
-  const loader = mockLoader(sthis);
 
   afterEach(async () => {
     await store.close();
@@ -61,6 +63,7 @@ describe("CarStore with a saved car", function () {
   });
 
   beforeEach(async () => {
+    loader = mockLoader(sthis);
     await sthis.start();
 
     const at = await bs.createAttachedStores(noopUrl("test2"), loader);
@@ -95,7 +98,7 @@ describe("CarStore with a saved car", function () {
 describe("MetaStore", function () {
   let store: bs.MetaStore;
   const sthis = ensureSuperThis();
-  const loader = mockLoader(sthis);
+  let loader: bs.Loadable;
 
   afterEach(async () => {
     await store.close();
@@ -103,6 +106,7 @@ describe("MetaStore", function () {
   });
 
   beforeEach(async () => {
+    loader = mockLoader(sthis);
     await sthis.start();
     const at = await bs.createAttachedStores(noopUrl("test"), loader);
     store = at.stores.meta;
@@ -135,7 +139,7 @@ describe("MetaStore with a saved header", function () {
   let store: bs.MetaStore;
   let cid: CID;
   const sthis = ensureSuperThis();
-  const loader = mockLoader(sthis);
+  let loader: bs.Loadable;
 
   afterEach(async () => {
     await store.close();
@@ -143,6 +147,7 @@ describe("MetaStore with a saved header", function () {
   });
 
   beforeEach(async () => {
+    loader = mockLoader(sthis);
     await sthis.start();
     const at = await bs.createAttachedStores(noopUrl("test3-meta"), loader);
     store = at.stores.meta;
@@ -176,10 +181,12 @@ describe("MetaStore with a saved header", function () {
   });
 
   it("should load a header", async () => {
-    const loadeds = (await store.load()) as bs.DbMeta[];
-    const loaded = loadeds[0];
-    expect(loaded).toBeTruthy();
-    expect(loaded.cars).toBeTruthy();
-    expect(loaded.cars.toString()).toEqual(cid.toString());
+    const metaStream = store.stream();
+    for await (const cars of metaStream) {
+      // expect(loaded).toBeTruthy();
+      expect(cars).toBeTruthy();
+      expect(cars.map((i) => i.cars.map((i) => i.toString())).flat(2)).toEqual([cid.toString()]);
+      break;
+    }
   });
 });

package/tests/blockstore/transaction.test.ts

@@ -1,6 +1,9 @@
 import { CID } from "multiformats";
-import { BaseBlockstore, bs, CarTransaction, ensureSuperThis, SuperThis } from "@fireproof/core";
+import { BaseBlockstore, bs, CarTransaction, ensureSuperThis } from "@fireproof/core";
 import { simpleBlockOpts } from "../helpers.js";
+import { anyBlock2FPBlock } from "../../src/blockstore/loader-helpers.js";
+import { AnyLink } from "../../src/blockstore/index.js";
+import { to_uint8 } from "@adviser/cement";
 
 describe("Fresh TransactionBlockstore", function () {
   let blocks: BaseBlockstore;
@@ -17,7 +20,7 @@ describe("Fresh TransactionBlockstore", function () {
   // });
   it("should not put", async () => {
     const value = sthis.txt.encode("value");
-    const e = await blocks.put("key" as unknown as bs.AnyLink, value).catch((e) => e);
+    const e = await blocks.put(await anyBlock2FPBlock({ cid: "key" as unknown as AnyLink, bytes: value })).catch((e) => e);
     expect(e.message).toMatch(/transaction/g);
   });
   it("should yield a transaction", async () => {
@@ -49,7 +52,7 @@ describe("TransactionBlockstore with name", function () {
     const bytes = sthis.txt.encode("bytes");
     expect(blocks.loader).toBeTruthy();
     blocks.loader.getBlock = async (cid) => {
-      return { cid, bytes };
+      return anyBlock2FPBlock({ cid, bytes });
     };
     const value = await blocks.get("key" as unknown as bs.AnyAnyLink);
     expect(value).toEqual({ cid: "key" as unknown as bs.AnyAnyLink, bytes });
@@ -68,18 +71,18 @@ describe("A transaction", function () {
   it("should put and get", async () => {
     const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     const bytes = sthis.txt.encode("bytes");
-    await tblocks.put(cid, bytes);
+    await tblocks.put(await anyBlock2FPBlock({ cid, bytes }));
     expect(blocks.transactions.has(tblocks)).toBeTruthy();
     const got = await tblocks.get(cid);
-    expect(got).toBeTruthy();
-    expect(got?.cid).toEqual(cid);
-    expect(got?.bytes).toEqual(bytes);
+    assert(got, "missing block");
+    expect(got.cid).toEqual(cid);
+    expect(got.bytes).toEqual(bytes);
   });
 });
 
-function asUInt8Array(str: string, sthis: SuperThis) {
-  return sthis.txt.encode(str);
-}
+// function asUInt8Array(str: string, sthis: SuperThis) {
+//   return sthis.txt.encode(str);
+// }
 
 describe("TransactionBlockstore with a completed transaction", function () {
   let blocks: BaseBlockstore;
@@ -93,13 +96,13 @@ describe("TransactionBlockstore with a completed transaction", function () {
 
     blocks = new bs.BaseBlockstoreImpl(simpleBlockOpts(sthis));
     await blocks.transaction(async (tblocks) => {
-      await tblocks.put(cid, asUInt8Array("value", sthis));
-      await tblocks.put(cid, asUInt8Array("value", sthis));
+      await tblocks.put(await anyBlock2FPBlock({ cid, bytes: to_uint8("value") }));
+      await tblocks.put(await anyBlock2FPBlock({ cid, bytes: to_uint8("value") }));
       return { head: [] };
     });
     await blocks.transaction(async (tblocks) => {
-      await tblocks.put(cid, asUInt8Array("value", sthis));
-      await tblocks.put(cid2, asUInt8Array("value2", sthis));
+      await tblocks.put(await anyBlock2FPBlock({ cid, bytes: to_uint8("value") }));
+      await tblocks.put(await anyBlock2FPBlock({ cid: cid2, bytes: to_uint8("value2") }));
       return { head: [] };
     });
   });
@@ -110,10 +113,10 @@ describe("TransactionBlockstore with a completed transaction", function () {
   it("should get", async () => {
     const value = (await blocks.get(cid)) as bs.AnyBlock;
     expect(value.cid).toEqual(cid);
-    expect(value.bytes.toString()).toEqual(asUInt8Array("value", sthis).toString());
+    expect(value.bytes.toString()).toEqual(to_uint8("value").toString());
 
     const value2 = (await blocks.get(cid2)) as bs.AnyBlock;
-    expect(value2.bytes.toString()).toEqual(asUInt8Array("value2", sthis).toString());
+    expect(value2.bytes.toString()).toEqual(to_uint8("value2").toString());
   });
   it("should yield entries", async () => {
     const blz = [];

package/tests/fireproof/all-gateway.test.ts

@@ -2,33 +2,7 @@ import { Database, Ledger, LedgerFactory, PARAM, bs, ensureSuperThis, fireproof
 
 import { fileContent } from "./cars/bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i.js";
 import { simpleCID } from "../helpers.js";
-import { Future } from "@adviser/cement";
-
-// import { DataStore, MetaStore, WALState, WALStore } from "../../src/blockstore/types.js";
-// import { Gateway } from "../../src/blockstore/gateway.js";
-// import { FPEnvelopeMeta, FPEnvelopeType } from "../../src/blockstore/fp-envelope.js";
-
-// function customExpect(value: unknown, matcher: (val: unknown) => void, message: string): void {
-//   try {
-//     matcher(value);
-//   } catch (error) {
-//     void error;
-//     // console.error(error);
-//     throw new Error(message);
-//   }
-// }
-
-// interface ExtendedGateway extends bs.Gateway {
-//   readonly logger: Logger;
-//   readonly headerSize: number;
-//   readonly fidLength: number;
-// }
-
-// interface ExtendedStore {
-//   readonly gateway: ExtendedGateway;
-//   readonly _url: URI;
-//   readonly name: string;
-// }
+import { BuildURI, Future } from "@adviser/cement";
 
 describe("noop Gateway", function () {
   let db: Ledger;
@@ -381,6 +355,17 @@ describe("noop Gateway subscribe", function () {
   });
   beforeEach(async () => {
     db = fireproof("test-gateway-" + sthis.nextId().str);
+    await db.close();
+
+    db = fireproof("test-gateway-" + sthis.nextId().str, {
+      storeUrls: {
+        ...db.ledger.opts.storeUrls,
+        data: {
+          ...db.ledger.opts.storeUrls.data,
+          meta: BuildURI.from(db.ledger.opts.storeUrls.data.meta).setParam(PARAM.SELF_REFLECT, "x").URI(),
+        },
+      },
+    });
 
     await db.ready();