@fireproof/core 0.20.0-dev-preview-24 → 0.20.0-dev-preview-26

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

@@ -5,6 +5,8 @@ import { sha256 as hasher } from "multiformats/hashes/sha2";
 import * as dagCodec from "@ipld/dag-cbor";
 import type { KeyBagProviderIndexedDB } from "@fireproof/core/indexeddb";
 import { MockSuperThis, mockSuperThis } from "../helpers.js";
+import { KeyWithFingerPrint } from "../../src/blockstore/types.js";
+import { toKeyWithFingerPrint } from "../../src/runtime/key-bag.js";
 
 describe("KeyBag", () => {
   let url: URI;
@@ -45,11 +47,19 @@ describe("KeyBag", () => {
     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);
+    const keyName = "extract.test" + Math.random();
+    const res = await kb.getNamedKey(keyName, false, keyStr);
     expect(res.isOk()).toBeTruthy();
-    const gkb = await kb.getNamedExtractableKey("extract.test", true);
+    const gkb = await kb.getNamedKey(keyName, true);
     expect(gkb.isOk()).toBeTruthy();
-    expect(await gkb.Ok().extract()).toEqual({
+
+    expect(
+      await gkb
+        .Ok()
+        .get()
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        .then((i) => i!.extract()),
+    ).toEqual({
       key,
       keyStr,
     });
@@ -67,26 +77,23 @@ describe("KeyBag", () => {
   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);
+    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";
+    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: rt.kb.KeyItem;
-    let diskBag2: rt.kb.KeyItem;
+    let diskBag: rt.kb.KeysItem;
+    let diskBag2: rt.kb.KeysItem;
     const provider = await kb.rt.getBagProvider();
     if (runtimeFn().isBrowser) {
       const p = provider as KeyBagProviderIndexedDB;
@@ -100,28 +107,126 @@ describe("KeyBag", () => {
       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 rt.kb.KeyItem;
+        return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeysItem;
       });
       diskBag2 = await sysFS.readfile((await p._prepare(name2)).fName).then((data) => {
-        return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeyItem;
+        return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeysItem;
       });
     }
-    expect(await kb.toKeyWithFingerPrint(diskBag.key)).toEqual(res);
-    expect(await kb.toKeyWithFingerPrint(diskBag2.key)).toEqual(created);
+    expect((await toKeyWithFingerPrint(kb, Object.values(diskBag.keys)[0].key)).Ok().fingerPrint).toEqual(
+      (await res.Ok().get())?.fingerPrint,
+    );
+    expect((await toKeyWithFingerPrint(kb, Object.values(diskBag2.keys)[0].key)).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);
-    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),
+    // 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(diskBag2.key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, created.Ok().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 rt.kb.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().asKeysItem())).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().asKeysItem())).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().asKeysItem())).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().asKeysItem())).keys).length).toBe(3);
+
+    expect(myKey.fingerPrint).not.toEqual(myKey3.fingerPrint);
+  });
+
+  it("default and multiple fingerprints", async () => {
+    const kb = await rt.kb.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, key)).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, key)).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);
+    }
+    await kb.flush();
+    const provider = await kb.rt.getBagProvider();
+    let diskBag: rt.kb.KeysItem;
+    if (!("_prepare" in provider)) {
+      diskBag = (await provider.get(name)) as rt.kb.KeysItem;
+    } else {
+      if (runtimeFn().isBrowser) {
+        const p = provider as KeyBagProviderIndexedDB;
+        diskBag = await p._prepare().then((db) => db.get("bag", name));
+      } else {
+        const p = provider as rt.gw.file.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 rt.kb.KeysItem;
+        });
+      }
+    }
+    expect(Object.values(diskBag.keys).length).toEqual(keys.length);
+  });
 });
 
 describe("KeyedCryptoStore", () => {
@@ -184,7 +289,7 @@ describe("KeyedCryptoStore", () => {
     ]) {
       const store = await pstore; // await bs.ensureStart(await pstore, logger);
       const kc = await store.keyedCrypto();
-      expect(kc.constructor.name).toBe("keyedCrypto");
+      expect(kc.constructor.name).toBe("cryptoAction");
       // expect(kc.isEncrypting).toBe(true);
       expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@test:${store.url().getParam(PARAM.STORE)}@`);
     }
@@ -192,7 +297,7 @@ describe("KeyedCryptoStore", () => {
 
   it("key ref keybag", async () => {
     const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const genKey = await kb.setNamedKey("@heute@", key);
+    const genKey = await kb.getNamedKey("@heute@", false, key);
     const url = baseUrl.build().setParam(PARAM.STORE_KEY, "@heute@").URI();
     const strt = bs.toStoreRuntime(sthis);
     for (const pstore of [
@@ -204,13 +309,14 @@ describe("KeyedCryptoStore", () => {
       // await store.start();
       expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@heute@`);
       const kc = await store.keyedCrypto();
-      expect(kc.constructor.name).toBe("keyedCrypto");
+      expect(kc.constructor.name).toBe("cryptoAction");
       const testData = kb.rt.crypto.randomBytes(1024);
       const iv = kb.rt.crypto.randomBytes(12);
-      const blk = await kc._encrypt({ bytes: testData, iv });
+      // 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 = genKey.Ok();
-      expect(fpkey.fingerPrint).toEqual(await kc.fingerPrint());
+      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);
     }
@@ -230,12 +336,13 @@ describe("KeyedCryptoStore", () => {
       // await store.start();
       expect(store.url().getParam(PARAM.STORE_KEY)).toBe(key);
       const kc = await store.keyedCrypto();
-      expect(kc.constructor.name).toBe("keyedCrypto");
+      expect(kc.constructor.name).toBe("cryptoAction");
       const testData = kb.rt.crypto.randomBytes(1024);
       const iv = kb.rt.crypto.randomBytes(12);
-      const blk = await kc._encrypt({ bytes: testData, iv });
+      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, iv });
+      const dec = await kc._decrypt({ bytes: blk, key: ks.key, iv });
       expect(dec).toEqual(testData);
     }
   });
@@ -243,7 +350,7 @@ describe("KeyedCryptoStore", () => {
 
 describe("KeyedCrypto", () => {
   let kb: rt.kb.KeyBag;
-  let kycr: bs.KeyedCrypto;
+  let kycr: bs.CryptoAction;
   let keyStr: string;
   const sthis = ensureSuperThis();
   beforeEach(async () => {
@@ -266,7 +373,8 @@ describe("KeyedCrypto", () => {
     const blk = (await codec.encode(testData)) as Uint8Array;
     const myDec = await rt.mf.block.decode<bs.IvKeyIdData, number, number>({ bytes: blk, hasher, codec: dagCodec });
     expect(myDec.value.iv).toEqual(iv);
-    expect(base58btc.encode(myDec.value.keyId)).toEqual(await kycr.fingerPrint());
+    const kc = (await kycr.key.get()) as KeyWithFingerPrint;
+    expect(base58btc.encode(myDec.value.keyId)).toEqual(kc.fingerPrint);
     const dec = await codec.decode(blk);
     expect(dec).toEqual(testData);
   });

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

@@ -127,7 +127,7 @@ describe("noop Gateway", function () {
     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,
+      type: bs.FPEnvelopeTypes.CAR,
       payload: fileContent.block,
     });
     expect(carPutResult.isOk()).toBeTruthy();
@@ -137,7 +137,7 @@ describe("noop Gateway", function () {
     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,
+      type: bs.FPEnvelopeTypes.CAR,
       payload: fileContent.block,
     });
     const carGetResult = await carGateway.get(ctx, carUrl.Ok());
@@ -150,7 +150,7 @@ describe("noop Gateway", function () {
     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,
+      type: bs.FPEnvelopeTypes.CAR,
       payload: fileContent.block,
     });
     const carDeleteResult = await carGateway.delete(ctx, carUrl.Ok());
@@ -187,7 +187,7 @@ describe("noop Gateway", function () {
     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,
+      type: bs.FPEnvelopeTypes.FILE,
       payload: fileContent.block,
     });
     expect(filePutResult.Ok()).toBeFalsy();
@@ -197,7 +197,7 @@ describe("noop Gateway", function () {
     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,
+      type: bs.FPEnvelopeTypes.FILE,
       payload: fileContent.block,
     });
     const fileGetResult = await fileGateway.get(ctx, fileUrl.Ok());
@@ -209,7 +209,7 @@ describe("noop Gateway", function () {
     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,
+      type: bs.FPEnvelopeTypes.FILE,
       payload: fileContent.block,
     });
     const fileDeleteResult = await fileGateway.delete(ctx, fileUrl.Ok());
@@ -236,7 +236,7 @@ describe("noop Gateway", function () {
     // const walTestDataString = JSON.stringify();
     // const walTestData = sthis.txt.encode(walTestDataString);
     const walPutResult = await walGateway.put(ctx, walUrl.Ok(), {
-      type: bs.FPEnvelopeType.WAL,
+      type: bs.FPEnvelopeTypes.WAL,
       payload: {
         operations: [],
         noLoaderOps: [],
@@ -275,7 +275,7 @@ describe("noop Gateway", function () {
     // });
     // const walTestData = sthis.txt.encode(walTestDataString);
     await walGateway.put(ctx, walUrl.Ok(), {
-      type: bs.FPEnvelopeType.WAL,
+      type: bs.FPEnvelopeTypes.WAL,
       payload: ref,
     });
     const walGetResult = await walGateway.get(ctx, walUrl.Ok());
@@ -308,7 +308,7 @@ describe("noop Gateway", function () {
       ],
     };
     await walGateway.put(ctx, walUrl.Ok(), {
-      type: bs.FPEnvelopeType.WAL,
+      type: bs.FPEnvelopeTypes.WAL,
       payload: ref,
     });
     const walDeleteResult = await walGateway.delete(ctx, walUrl.Ok());
@@ -394,12 +394,16 @@ describe("noop Gateway subscribe", function () {
     let didCall = false;
     const p = new Future<void>();
 
-    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;
-      p.resolve();
-    })) as bs.UnsubscribeResult;
+    const metaSubscribeResult = (await metaGateway.subscribe(
+      ctx,
+      metaUrl.Ok().build().setParam(PARAM.SELF_REFLECT, "x").URI(),
+      async (data: bs.FPEnvelopeMeta) => {
+        // const decodedData = sthis.txt.decode(data);
+        expect(Array.isArray(data.payload)).toBeTruthy();
+        didCall = true;
+        p.resolve();
+      },
+    )) as bs.UnsubscribeResult;
     expect(metaSubscribeResult.isOk()).toBeTruthy();
     const ok = await db.put({ _id: "key1", hello: "world1" });
     expect(ok).toBeTruthy();

package/tests/gateway/fp-envelope-serialize.test.ts

@@ -3,15 +3,13 @@ import { mockSuperThis, simpleCID } from "../helpers.js";
 import { BuildURI, Result } from "@adviser/cement";
 import { toJSON } from "multiformats/link";
 
-const FPEnvelopeType = bs.FPEnvelopeType;
-
 describe("storage-content", () => {
   const sthis = mockSuperThis();
   it("car", async () => {
     const raw = new Uint8Array([55, 56, 57]);
     const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), Result.Ok(raw));
     expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeType.CAR);
+    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.CAR);
     expect(res.unwrap().payload).toEqual(raw);
   });
 
@@ -19,7 +17,7 @@ describe("storage-content", () => {
     const raw = new Uint8Array([55, 56, 57]);
     const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data").URI(), Result.Ok(raw));
     expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeType.FILE);
+    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.FILE);
     expect(res.unwrap().payload).toEqual(raw);
   });
 
@@ -34,7 +32,7 @@ describe("storage-content", () => {
     const raw = sthis.txt.encode(JSON.stringify(ref));
     const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=meta").URI(), Result.Ok(raw));
     expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeType.META);
+    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.META);
     const dbMetas = res.unwrap().payload as bs.DbMetaEvent[];
     expect(dbMetas.length).toBe(1);
     const dbMeta = dbMetas[0];
@@ -71,7 +69,7 @@ describe("storage-content", () => {
     const raw = sthis.txt.encode(JSON.stringify(ref));
     const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=wal").URI(), Result.Ok(raw));
     expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeType.WAL);
+    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.WAL);
     const walstate = res.unwrap().payload as bs.WALState;
     expect(
       walstate.fileOperations.map((i) => ({
@@ -96,7 +94,7 @@ describe("de-serialize", () => {
   const sthis = mockSuperThis();
   it("car", async () => {
     const msg = {
-      type: FPEnvelopeType.CAR,
+      type: bs.FPEnvelopeTypes.CAR,
       payload: new Uint8Array([55, 56, 57]),
     } satisfies bs.FPEnvelopeCar;
     const res = await rt.gw.fpSerialize(sthis, msg);
@@ -105,7 +103,7 @@ describe("de-serialize", () => {
 
   it("file", async () => {
     const msg = {
-      type: FPEnvelopeType.FILE,
+      type: bs.FPEnvelopeTypes.FILE,
       payload: new Uint8Array([55, 56, 57]),
     } satisfies bs.FPEnvelopeFile;
     const res = await rt.gw.fpSerialize(sthis, msg);
@@ -114,7 +112,7 @@ describe("de-serialize", () => {
 
   it("meta", async () => {
     const msg = {
-      type: FPEnvelopeType.META,
+      type: bs.FPEnvelopeTypes.META,
       payload: [
         await bs.createDbMetaEvent(
           sthis,
@@ -137,7 +135,7 @@ describe("de-serialize", () => {
 
   it("wal", async () => {
     const msg = {
-      type: FPEnvelopeType.WAL,
+      type: bs.FPEnvelopeTypes.WAL,
       payload: {
         fileOperations: [
           {
@@ -171,7 +169,7 @@ describe("de-serialize", () => {
     const raw = new Uint8Array([55, 56, 57]);
     const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), Result.Ok(raw));
     expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeType.CAR);
+    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.CAR);
     expect(res.unwrap().payload).toEqual(raw);
   });
 
@@ -179,7 +177,7 @@ describe("de-serialize", () => {
     const raw = new Uint8Array([55, 56, 57]);
     const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), Promise.resolve(raw));
     expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeType.CAR);
+    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.CAR);
     expect(res.unwrap().payload).toEqual(raw);
   });
 
@@ -191,7 +189,7 @@ describe("de-serialize", () => {
       Promise.resolve(Result.Ok(raw)),
     );
     expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeType.CAR);
+    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.CAR);
     expect(res.unwrap().payload).toEqual(raw);
   });
 
@@ -218,7 +216,7 @@ describe("de-serialize", () => {
 
   it("attach Key to Meta", async () => {
     const msg = {
-      type: FPEnvelopeType.META,
+      type: bs.FPEnvelopeTypes.META,
       payload: [
         await bs.createDbMetaEvent(
           sthis,