@fireproof/core 0.20.0-dev-preview-17 → 0.20.0-dev-preview-19

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

@@ -1,51 +1,51 @@
 import { Result, URI } from "@adviser/cement";
-import { bs, fireproof, SuperThis } from "@fireproof/core";
+import { bs, fireproof } from "@fireproof/core";
 
 class TestInterceptor extends bs.PassThroughGateway {
   readonly fn = vitest.fn();
 
-  async buildUrl(sthis: SuperThis, baseUrl: URI, key: string): Promise<Result<bs.SerdeGatewayBuildUrlReturn>> {
-    const ret = await super.buildUrl(sthis, baseUrl, key);
+  async buildUrl(ctx: bs.SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<bs.SerdeGatewayBuildUrlReturn>> {
+    const ret = await super.buildUrl(ctx, baseUrl, key);
     this.fn("buildUrl", ret);
     return ret;
   }
 
-  async start(sthis: SuperThis, baseUrl: URI): Promise<Result<bs.SerdeGatewayStartReturn>> {
-    const ret = await super.start(sthis, baseUrl);
+  async start(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayStartReturn>> {
+    const ret = await super.start(ctx, baseUrl);
     this.fn("start", ret);
     return ret;
   }
-  async close(sthis: SuperThis, baseUrl: URI): Promise<Result<bs.SerdeGatewayCloseReturn>> {
-    const ret = await super.close(sthis, baseUrl);
+  async close(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayCloseReturn>> {
+    const ret = await super.close(ctx, baseUrl);
     this.fn("close", ret);
     return ret;
   }
-  async delete(sthis: SuperThis, baseUrl: URI): Promise<Result<bs.SerdeGatewayDeleteReturn>> {
-    const ret = await super.delete(sthis, baseUrl);
+  async delete(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayDeleteReturn>> {
+    const ret = await super.delete(ctx, baseUrl);
     this.fn("delete", ret);
     return ret;
   }
-  async destroy(sthis: SuperThis, baseUrl: URI): Promise<Result<bs.SerdeGatewayDestroyReturn>> {
-    const ret = await super.destroy(sthis, baseUrl);
+  async destroy(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayDestroyReturn>> {
+    const ret = await super.destroy(ctx, baseUrl);
     this.fn("destroy", ret);
     return ret;
   }
-  async put<T>(sthis: SuperThis, url: URI, body: bs.FPEnvelope<T>): Promise<Result<bs.SerdeGatewayPutReturn<T>>> {
-    const ret = await super.put<T>(sthis, url, body);
+  async put<T>(ctx: bs.SerdeGatewayCtx, url: URI, body: bs.FPEnvelope<T>): Promise<Result<bs.SerdeGatewayPutReturn<T>>> {
+    const ret = await super.put<T>(ctx, url, body);
     this.fn("put", ret);
     return ret;
   }
-  async get<S>(sthis: SuperThis, url: URI): Promise<Result<bs.SerdeGatewayGetReturn<S>>> {
-    const ret = await super.get<S>(sthis, url);
+  async get<S>(ctx: bs.SerdeGatewayCtx, url: URI): Promise<Result<bs.SerdeGatewayGetReturn<S>>> {
+    const ret = await super.get<S>(ctx, url);
     this.fn("get", ret);
     return ret;
   }
   async subscribe(
-    sthis: SuperThis,
+    ctx: bs.SerdeGatewayCtx,
     url: URI,
     callback: (meta: bs.FPEnvelopeMeta) => Promise<void>,
   ): Promise<Result<bs.SerdeGatewaySubscribeReturn>> {
-    const ret = await super.subscribe(sthis, url, callback);
+    const ret = await super.subscribe(ctx, url, callback);
     this.fn("subscribe", ret);
     return ret;
   }

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

@@ -1,4 +1,4 @@
-import { bs, PARAM, rt } from "@fireproof/core";
+import { bs, ensureSuperThis, PARAM, rt } from "@fireproof/core";
 import { runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
 import { base58btc } from "multiformats/bases/base58";
 import { mockSuperThis } from "../helpers.js";
@@ -56,7 +56,7 @@ describe("KeyBag indexdb and file", () => {
 
     let diskBag: rt.kb.KeyItem;
     let diskBag2: rt.kb.KeyItem;
-    const provider = await kb.rt.getBag();
+    const provider = await kb.rt.getBagProvider();
     if (runtimeFn().isBrowser) {
       const p = provider as KeyBagProviderIndexDB;
       diskBag = await p._prepare().then((db) => db.get("bag", name));
@@ -94,7 +94,7 @@ describe("KeyedCryptoStore", () => {
   let loader: bs.Loadable;
   // let logger: Logger;
   let baseUrl: URI;
-  const sthis = mockSuperThis();
+  const sthis = ensureSuperThis();
   beforeEach(async () => {
     await sthis.start();
     // logger = MockLogger().logger;
@@ -108,6 +108,7 @@ describe("KeyedCryptoStore", () => {
     }
     baseUrl = baseUrl.build().defParam(PARAM.NAME, "test").URI();
     loader = {
+      sthis,
       keyBag: () => rt.kb.getKeyBag(sthis, { url: kbUrl }),
     } as bs.Loadable;
   });
@@ -116,9 +117,9 @@ describe("KeyedCryptoStore", () => {
     const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
 
     for (const pstore of [
-      strt.makeDataStore({ sthis, url, loader }),
-      strt.makeMetaStore({ sthis, url, loader }),
-      strt.makeWALStore({ sthis, url, loader }),
+      strt.makeDataStore({ url, loader }),
+      strt.makeMetaStore({ url, loader }),
+      strt.makeWALStore({ url, loader }),
     ]) {
       const store = await pstore;
       // await store.start();

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

@@ -87,7 +87,7 @@ describe("KeyBag", () => {
 
     let diskBag: rt.kb.KeyItem;
     let diskBag2: rt.kb.KeyItem;
-    const provider = await kb.rt.getBag();
+    const provider = await kb.rt.getBagProvider();
     if (runtimeFn().isBrowser) {
       const p = provider as KeyBagProviderIndexDB;
       diskBag = await p._prepare().then((db) => db.get("bag", name));
@@ -152,6 +152,7 @@ describe("KeyedCryptoStore", () => {
     baseUrl = baseUrl.build().setParam(PARAM.NAME, "test").URI();
     kb = await rt.kb.getKeyBag(sthis, {});
     loader = {
+      sthis,
       keyBag: async () => kb,
     } as bs.Loadable;
   });
@@ -160,9 +161,9 @@ describe("KeyedCryptoStore", () => {
     const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
 
     for (const pstore of [
-      strt.makeDataStore({ sthis, url, loader }),
-      strt.makeMetaStore({ sthis, url, loader }),
-      strt.makeWALStore({ sthis, url, loader }),
+      strt.makeDataStore({ url, loader }),
+      strt.makeMetaStore({ url, loader }),
+      strt.makeWALStore({ url, loader }),
     ]) {
       const store = await pstore;
       // await store.start();
@@ -177,9 +178,9 @@ describe("KeyedCryptoStore", () => {
   it("create key", async () => {
     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 }),
+      strt.makeDataStore({ url: baseUrl, loader }),
+      strt.makeMetaStore({ url: baseUrl, loader }),
+      strt.makeWALStore({ url: baseUrl, loader }),
     ]) {
       const store = await pstore; // await bs.ensureStart(await pstore, logger);
       const kc = await store.keyedCrypto();
@@ -195,9 +196,9 @@ describe("KeyedCryptoStore", () => {
     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 }),
+      strt.makeDataStore({ url, loader }),
+      strt.makeMetaStore({ url, loader }),
+      strt.makeWALStore({ url, loader }),
     ]) {
       const store = await pstore;
       // await store.start();
@@ -220,9 +221,9 @@ describe("KeyedCryptoStore", () => {
     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 }),
+      strt.makeDataStore({ url, loader }),
+      strt.makeMetaStore({ url, loader }),
+      strt.makeWALStore({ url, loader }),
     ]) {
       // for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
       const store = await pstore;

package/tests/blockstore/store.test.ts

@@ -10,9 +10,10 @@ function runtime(sthis: SuperThis) {
 async function mockLoader(sthis: SuperThis, name?: string): Promise<bs.StoreFactoryItem> {
   const url = noopUrl(name);
   return {
-    sthis,
+    // sthis,
     url: url,
     loader: {
+      sthis,
       keyBag: () => rt.kb.getKeyBag(sthis),
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       handleDbMetasFromStore: (metas: DbMeta[]): Promise<void> => Promise.resolve(),
@@ -22,8 +23,9 @@ async function mockLoader(sthis: SuperThis, name?: string): Promise<bs.StoreFact
 
 describe("DataStore", function () {
   let store: bs.DataStore;
-
   const sthis = ensureSuperThis();
+  let loader: bs.StoreFactoryItem;
+
   afterEach(async () => {
     await store.close();
     await store.destroy();
@@ -31,7 +33,8 @@ describe("DataStore", function () {
 
   beforeEach(async () => {
     await sthis.start();
-    store = await runtime(sthis).makeDataStore(await mockLoader(sthis));
+    loader = await mockLoader(sthis);
+    store = await runtime(sthis).makeDataStore(loader);
     await store.start();
   });
 
@@ -45,7 +48,7 @@ describe("DataStore", function () {
       bytes: new Uint8Array([55, 56, 57]),
     };
     await store.save(car);
-    const data = (await store.realGateway.getPlain(sthis, store.url(), car.cid.toString())).Ok();
+    const data = (await store.realGateway.getPlain(loader, store.url(), car.cid.toString())).Ok();
     expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
   });
 });
@@ -53,6 +56,7 @@ describe("DataStore", function () {
 describe("DataStore with a saved car", function () {
   let store: bs.DataStore;
   let car: bs.AnyBlock;
+  let loader: bs.StoreFactoryItem;
 
   const sthis = ensureSuperThis();
 
@@ -63,7 +67,8 @@ describe("DataStore with a saved car", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeDataStore(await mockLoader(sthis, "test2"));
+    loader = await mockLoader(sthis, "test2");
+    store = await runtime(sthis).makeDataStore(loader);
     await store.start();
     car = {
       cid: "cid" as unknown as CID,
@@ -73,7 +78,7 @@ describe("DataStore with a saved car", function () {
   });
 
   it("should have a car", async function () {
-    const data = (await store.realGateway.getPlain(sthis, store.url(), car.cid.toString())).Ok();
+    const data = (await store.realGateway.getPlain(loader, store.url(), car.cid.toString())).Ok();
     expect(sthis.txt.decode(data)).toEqual(sthis.txt.decode(car.bytes));
   });
 
@@ -93,8 +98,8 @@ describe("DataStore with a saved car", function () {
 
 describe("MetaStore", function () {
   let store: bs.MetaStore;
-
   const sthis = ensureSuperThis();
+  let loader: bs.StoreFactoryItem;
 
   afterEach(async () => {
     await store.close();
@@ -103,7 +108,8 @@ describe("MetaStore", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeMetaStore(await mockLoader(sthis, "test"));
+    loader = await mockLoader(sthis, "test");
+    store = await runtime(sthis).makeMetaStore(loader);
     await store.start();
   });
 
@@ -118,7 +124,7 @@ describe("MetaStore", function () {
       // key: undefined,
     };
     await store.save(h);
-    const file = await store.realGateway.getPlain(sthis, store.url(), "main");
+    const file = await store.realGateway.getPlain(loader, 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);
@@ -133,6 +139,7 @@ describe("MetaStore with a saved header", function () {
   let store: bs.MetaStore;
   let cid: CID;
   const sthis = ensureSuperThis();
+  let loader: bs.StoreFactoryItem;
 
   afterEach(async () => {
     await store.close();
@@ -141,7 +148,8 @@ describe("MetaStore with a saved header", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    store = await runtime(sthis).makeMetaStore(await mockLoader(sthis, "test-saved-header"));
+    loader = await mockLoader(sthis, "test-saved-header");
+    store = await runtime(sthis).makeMetaStore(loader);
     await store.start();
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     await store.save({ cars: [cid] /*, key: undefined */ });
@@ -154,7 +162,7 @@ describe("MetaStore with a saved header", function () {
   // });
 
   it("should have a header", async function () {
-    const bytes = await store.realGateway.getPlain(sthis, store.url(), "main");
+    const bytes = await store.realGateway.getPlain(loader, store.url(), "main");
     const data = sthis.txt.decode(bytes.Ok());
     expect(data).toMatch(/parents/);
     const header = JSON.parse(data)[0];

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

@@ -41,6 +41,7 @@ describe("noop Gateway", function () {
   let fileGateway: bs.SerdeGateway;
   let walGateway: bs.SerdeGateway;
   const sthis = ensureSuperThis();
+  let ctx: { loader: bs.Loadable };
 
   afterEach(async function () {
     await db.close();
@@ -50,12 +51,13 @@ describe("noop Gateway", function () {
     db = LedgerFactory("test-gateway-" + sthis.nextId().str, {
       logger: sthis.logger,
     });
+    ctx = { loader: await db.crdt.blockstore.loader };
 
     // Extract stores from the loader
-    carStore = (await db.crdt.blockstore.loader?.carStore()) as bs.DataStore;
-    metaStore = (await db.crdt.blockstore.loader?.metaStore()) as bs.MetaStore;
-    fileStore = (await db.crdt.blockstore.loader?.fileStore()) as bs.DataStore;
-    walStore = (await db.crdt.blockstore.loader?.WALStore()) as bs.WALStore;
+    carStore = (await ctx.loader.carStore()) as bs.DataStore;
+    metaStore = (await ctx.loader.metaStore()) as bs.MetaStore;
+    fileStore = (await ctx.loader.fileStore()) as bs.DataStore;
+    walStore = (await ctx.loader.WALStore()) as bs.WALStore;
 
     // Extract and log gateways
     carGateway = carStore.realGateway;
@@ -112,19 +114,19 @@ describe("noop Gateway", function () {
 
   it("should build CAR Gateway URL", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const carUrl = await carGateway.buildUrl(sthis, carStore.url(), testKey);
+    const carUrl = await carGateway.buildUrl(ctx, carStore.url(), testKey);
     expect(carUrl.Ok().hasParam("key")).toBeTruthy();
   });
 
   it("should start CAR Gateway", async function () {
-    const url = await carGateway.start(sthis, carStore.url());
+    const url = await carGateway.start(ctx, carStore.url());
     expect(url.Ok().asObj()).toEqual(carStore.url().asObj());
   });
 
   it("should put data in CAR Gateway", async function () {
-    const carUrl = await carGateway.buildUrl(sthis, carStore.url(), fileContent.cid);
-    await carGateway.start(sthis, carStore.url());
-    const carPutResult = await carGateway.put(sthis, carUrl.Ok(), {
+    const carUrl = await carGateway.buildUrl(ctx, carStore.url(), fileContent.cid);
+    await carGateway.start(ctx, carStore.url());
+    const carPutResult = await carGateway.put(ctx, carUrl.Ok(), {
       type: bs.FPEnvelopeType.CAR,
       payload: fileContent.block,
     });
@@ -132,59 +134,59 @@ describe("noop Gateway", function () {
   });
 
   it("should get data from CAR Gateway", async function () {
-    const carUrl = await carGateway.buildUrl(sthis, carStore.url(), fileContent.cid);
-    await carGateway.start(sthis, carStore.url());
-    await carGateway.put(sthis, carUrl.Ok(), {
+    const carUrl = await carGateway.buildUrl(ctx, carStore.url(), fileContent.cid);
+    await carGateway.start(ctx, carStore.url());
+    await carGateway.put(ctx, carUrl.Ok(), {
       type: bs.FPEnvelopeType.CAR,
       payload: fileContent.block,
     });
-    const carGetResult = await carGateway.get(sthis, carUrl.Ok());
+    const carGetResult = await carGateway.get(ctx, carUrl.Ok());
     expect(carGetResult.Ok().type).toEqual("car");
     expect(carGetResult.Ok().payload).toEqual(fileContent.block);
     // customExpect(carGetResult.Ok(), (v) => expect(v).toEqual(testData), "carGetResult should match testData");
   });
 
   it("should delete data from CAR Gateway", async function () {
-    const carUrl = await carGateway.buildUrl(sthis, carStore.url(), fileContent.cid);
-    await carGateway.start(sthis, carStore.url());
-    await carGateway.put(sthis, carUrl.Ok(), {
+    const carUrl = await carGateway.buildUrl(ctx, carStore.url(), fileContent.cid);
+    await carGateway.start(ctx, carStore.url());
+    await carGateway.put(ctx, carUrl.Ok(), {
       type: bs.FPEnvelopeType.CAR,
       payload: fileContent.block,
     });
-    const carDeleteResult = await carGateway.delete(sthis, carUrl.Ok());
+    const carDeleteResult = await carGateway.delete(ctx, carUrl.Ok());
     expect(carDeleteResult.isOk()).toBeTruthy();
   });
 
   it("should close CAR Gateway", async function () {
-    await carGateway.close(sthis, carStore.url());
+    await carGateway.close(ctx, carStore.url());
   });
   it("should build Meta Gateway URL", async function () {
-    const metaUrl = await metaGateway.buildUrl(sthis, metaStore.url(), "main");
+    const metaUrl = await metaGateway.buildUrl(ctx, metaStore.url(), "main");
     expect(metaUrl.Ok()).toBeTruthy();
   });
 
   it("should start Meta Gateway", async function () {
-    await metaGateway.start(sthis, metaStore.url());
+    await metaGateway.start(ctx, metaStore.url());
   });
 
   it("should close Meta Gateway", async function () {
-    await metaGateway.start(sthis, metaStore.url());
-    await metaGateway.close(sthis, metaStore.url());
+    await metaGateway.start(ctx, metaStore.url());
+    await metaGateway.close(ctx, metaStore.url());
   });
 
   it("should build File Gateway URL", async function () {
-    const fileUrl = await fileGateway.buildUrl(sthis, fileStore.url(), fileContent.cid);
+    const fileUrl = await fileGateway.buildUrl(ctx, fileStore.url(), fileContent.cid);
     expect(fileUrl.Ok()).toBeTruthy();
   });
 
   it("should start File Gateway", async function () {
-    await fileGateway.start(sthis, fileStore.url());
+    await fileGateway.start(ctx, fileStore.url());
   });
 
   it("should put data to File Gateway", async function () {
-    const fileUrl = await fileGateway.buildUrl(sthis, fileStore.url(), fileContent.cid);
-    await fileGateway.start(sthis, fileStore.url());
-    const filePutResult = await fileGateway.put(sthis, fileUrl.Ok(), {
+    const fileUrl = await fileGateway.buildUrl(ctx, fileStore.url(), fileContent.cid);
+    await fileGateway.start(ctx, fileStore.url());
+    const filePutResult = await fileGateway.put(ctx, fileUrl.Ok(), {
       type: bs.FPEnvelopeType.FILE,
       payload: fileContent.block,
     });
@@ -192,48 +194,48 @@ describe("noop Gateway", function () {
   });
 
   it("should get data from File Gateway", async function () {
-    const fileUrl = await fileGateway.buildUrl(sthis, fileStore.url(), fileContent.cid);
-    await fileGateway.start(sthis, fileStore.url());
-    await fileGateway.put(sthis, fileUrl.Ok(), {
+    const fileUrl = await fileGateway.buildUrl(ctx, fileStore.url(), fileContent.cid);
+    await fileGateway.start(ctx, fileStore.url());
+    await fileGateway.put(ctx, fileUrl.Ok(), {
       type: bs.FPEnvelopeType.FILE,
       payload: fileContent.block,
     });
-    const fileGetResult = await fileGateway.get(sthis, fileUrl.Ok());
+    const fileGetResult = await fileGateway.get(ctx, fileUrl.Ok());
     expect(fileGetResult.Ok().type).toEqual("file");
     expect(fileGetResult.Ok().payload).toEqual(fileContent.block);
   });
 
   it("should delete data from File Gateway", async function () {
-    const fileUrl = await fileGateway.buildUrl(sthis, fileStore.url(), fileContent.cid);
-    await fileGateway.start(sthis, fileStore.url());
-    await fileGateway.put(sthis, fileUrl.Ok(), {
+    const fileUrl = await fileGateway.buildUrl(ctx, fileStore.url(), fileContent.cid);
+    await fileGateway.start(ctx, fileStore.url());
+    await fileGateway.put(ctx, fileUrl.Ok(), {
       type: bs.FPEnvelopeType.FILE,
       payload: fileContent.block,
     });
-    const fileDeleteResult = await fileGateway.delete(sthis, fileUrl.Ok());
+    const fileDeleteResult = await fileGateway.delete(ctx, fileUrl.Ok());
     expect(fileDeleteResult.isOk()).toBeTruthy();
   });
 
   it("should close File Gateway", async function () {
-    await fileGateway.close(sthis, fileStore.url());
+    await fileGateway.close(ctx, fileStore.url());
   });
   it("should build WAL Gateway URL", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const walUrl = await walGateway.buildUrl(sthis, walStore.url(), testKey);
+    const walUrl = await walGateway.buildUrl(ctx, walStore.url(), testKey);
     expect(walUrl.Ok()).toBeTruthy();
   });
 
   it("should start WAL Gateway", async function () {
-    await walGateway.start(sthis, walStore.url());
+    await walGateway.start(ctx, walStore.url());
   });
 
   it("should put data to WAL Gateway", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const walUrl = await walGateway.buildUrl(sthis, walStore.url(), testKey);
-    await walGateway.start(sthis, walStore.url());
+    const walUrl = await walGateway.buildUrl(ctx, walStore.url(), testKey);
+    await walGateway.start(ctx, walStore.url());
     // const walTestDataString = JSON.stringify();
     // const walTestData = sthis.txt.encode(walTestDataString);
-    const walPutResult = await walGateway.put(sthis, walUrl.Ok(), {
+    const walPutResult = await walGateway.put(ctx, walUrl.Ok(), {
       type: bs.FPEnvelopeType.WAL,
       payload: {
         operations: [],
@@ -246,8 +248,8 @@ describe("noop Gateway", function () {
 
   it("should get data from WAL Gateway", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const walUrl = await walGateway.buildUrl(sthis, walStore.url(), testKey);
-    await walGateway.start(sthis, walStore.url());
+    const walUrl = await walGateway.buildUrl(ctx, walStore.url(), testKey);
+    await walGateway.start(ctx, walStore.url());
     const ref: bs.WALState = {
       operations: [
         {
@@ -272,11 +274,11 @@ describe("noop Gateway", function () {
     //   fileOperations: [],
     // });
     // const walTestData = sthis.txt.encode(walTestDataString);
-    await walGateway.put(sthis, walUrl.Ok(), {
+    await walGateway.put(ctx, walUrl.Ok(), {
       type: bs.FPEnvelopeType.WAL,
       payload: ref,
     });
-    const walGetResult = await walGateway.get(sthis, walUrl.Ok());
+    const walGetResult = await walGateway.get(ctx, walUrl.Ok());
     expect(walGetResult.isOk()).toBeTruthy();
     // const okResult = walGetResult.Ok();
     // const decodedResult = sthis.txt.decode(okResult);
@@ -285,8 +287,8 @@ describe("noop Gateway", function () {
 
   it("should delete data from WAL Gateway", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const walUrl = await walGateway.buildUrl(sthis, walStore.url(), testKey);
-    await walGateway.start(sthis, walStore.url());
+    const walUrl = await walGateway.buildUrl(ctx, walStore.url(), testKey);
+    await walGateway.start(ctx, walStore.url());
     const ref: bs.WALState = {
       operations: [
         {
@@ -305,17 +307,17 @@ describe("noop Gateway", function () {
         },
       ],
     };
-    await walGateway.put(sthis, walUrl.Ok(), {
+    await walGateway.put(ctx, walUrl.Ok(), {
       type: bs.FPEnvelopeType.WAL,
       payload: ref,
     });
-    const walDeleteResult = await walGateway.delete(sthis, walUrl.Ok());
+    const walDeleteResult = await walGateway.delete(ctx, walUrl.Ok());
     expect(walDeleteResult.isOk()).toBeTruthy();
   });
 
   it("should close WAL Gateway", async function () {
-    await walGateway.start(sthis, walStore.url());
-    await walGateway.close(sthis, walStore.url());
+    await walGateway.start(ctx, walStore.url());
+    await walGateway.close(ctx, walStore.url());
   });
 
   // it("should have correct CAR Gateway properties", async function () {
@@ -370,6 +372,7 @@ describe("noop Gateway subscribe", function () {
 
   let metaGateway: bs.SerdeGateway;
   const sthis = ensureSuperThis();
+  let ctx: bs.SerdeGatewayCtx;
 
   afterEach(async function () {
     await db.close();
@@ -378,19 +381,20 @@ describe("noop Gateway subscribe", function () {
   beforeEach(async function () {
     db = fireproof("test-gateway-" + sthis.nextId().str);
 
+    ctx = { loader: db.ledger.crdt.blockstore.loader };
     // Extract stores from the loader
     metaStore = (await db.ledger.crdt.blockstore.loader?.metaStore()) as bs.MetaStore;
 
     metaGateway = metaStore.realGateway;
   });
   it("should subscribe to meta Gateway", async function () {
-    const metaUrl = await metaGateway.buildUrl(sthis, metaStore.url(), "main");
-    await metaGateway.start(sthis, metaStore.url());
+    const metaUrl = await metaGateway.buildUrl(ctx, metaStore.url(), "main");
+    await metaGateway.start(ctx, metaStore.url());
 
     let didCall = false;
     const p = new Future<void>();
 
-    const metaSubscribeResult = (await metaGateway.subscribe(sthis, metaUrl.Ok(), async (data: bs.FPEnvelopeMeta) => {
+    const metaSubscribeResult = (await metaGateway.subscribe(ctx, metaUrl.Ok(), async (data: bs.FPEnvelopeMeta) => {
       // const decodedData = sthis.txt.decode(data);
       expect(Array.isArray(data.payload)).toBeTruthy();
       didCall = true;
@@ -417,12 +421,15 @@ describe("Gateway", function () {
   // let walGateway: ExtendedGateway;
   const sthis = ensureSuperThis();
 
+  let ctx: bs.SerdeGatewayCtx;
+
   afterEach(async function () {
     await db.close();
     await db.destroy();
   });
   beforeEach(async function () {
     db = fireproof("test-gateway-" + sthis.nextId().str);
+    ctx = { loader: db.ledger.crdt.blockstore.loader };
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
@@ -441,9 +448,9 @@ describe("Gateway", function () {
   });
 
   it("should get data from Meta Gateway", async function () {
-    const metaUrl = await metaGateway.buildUrl(sthis, metaStore.url(), "main");
-    await metaGateway.start(sthis, metaStore.url());
-    const metaGetResult = await metaGateway.get(sthis, metaUrl.Ok());
+    const metaUrl = await metaGateway.buildUrl(ctx, metaStore.url(), "main");
+    await metaGateway.start(ctx, metaStore.url());
+    const metaGetResult = await metaGateway.get(ctx, metaUrl.Ok());
     expect(metaGetResult.isOk()).toBeTruthy();
     const meta = metaGetResult.Ok().payload as bs.DbMetaEvent[];
     // const metaGetResultOk = metaGetResult.Ok();
@@ -453,10 +460,10 @@ describe("Gateway", function () {
   });
 
   it("should delete data from Meta Gateway", async function () {
-    const metaUrl = await metaGateway.buildUrl(sthis, metaStore.url(), "main");
-    await metaGateway.start(sthis, metaStore.url());
+    const metaUrl = await metaGateway.buildUrl(ctx, metaStore.url(), "main");
+    await metaGateway.start(ctx, metaStore.url());
     // should we be testing .destroy() instead?
-    const metaDeleteResult = await metaGateway.delete(sthis, metaUrl.Ok());
+    const metaDeleteResult = await metaGateway.delete(ctx, metaUrl.Ok());
     expect(metaDeleteResult.isOk()).toBeTruthy();
   });
 });