@fireproof/core-base 0.22.0-keybag → 0.23.1-dev-issue-1057

package/crdt-helpers.ts

@@ -1,408 +0,0 @@
-import { asyncBlockDecode } from "@fireproof/core-runtime";
-import { parse } from "multiformats/link";
-import { Block } from "multiformats/block";
-import { sha256 as hasher } from "multiformats/hashes/sha2";
-import * as codec from "@ipld/dag-cbor";
-import { put, get, entries } from "@web3-storage/pail/crdt";
-import {
-  EventBlockView,
-  EventLink,
-  Operation,
-  PutOperation,
-  Result,
-  BlockFetcher as PailBlockFetcher,
-} from "@web3-storage/pail/crdt/api";
-import { EventFetcher, vis } from "@web3-storage/pail/clock";
-import * as Batch from "@web3-storage/pail/crdt/batch";
-import { BlockFetcher, TransactionMeta, AnyLink, StoreRuntime } from "@fireproof/core-types-blockstore";
-import {
-  type EncryptedBlockstore,
-  CarTransactionImpl,
-  anyBlock2FPBlock,
-  doc2FPBlock,
-  fileBlock2FPBlock,
-} from "@fireproof/core-blockstore";
-import {
-  type IndexKeyType,
-  type DocUpdate,
-  type ClockHead,
-  type DocValue,
-  type CRDTMeta,
-  type ChangesOptions,
-  type DocFileMeta,
-  type DocFiles,
-  type DocSet,
-  type DocWithId,
-  type DocTypes,
-  throwFalsy,
-  CarTransaction,
-  BaseBlockstore,
-  PARAM,
-  NotFoundError,
-} from "@fireproof/core-types-base";
-import { Logger } from "@adviser/cement";
-import { Link, Version } from "multiformats";
-
-function toString<K extends IndexKeyType>(key: K, logger: Logger): string {
-  switch (typeof key) {
-    case "string":
-    case "number":
-      return key.toString();
-    default:
-      throw logger.Error().Msg("Invalid key type").AsError();
-  }
-}
-
-export function toPailFetcher(tblocks: BlockFetcher): PailBlockFetcher {
-  return {
-    get: async <T = unknown, C extends number = number, A extends number = number, V extends Version = 1>(
-      link: Link<T, C, A, V>,
-    ) => {
-      const block = await tblocks.get(link);
-      return block
-        ? ({
-            cid: block.cid,
-            bytes: block.bytes,
-          } as Block<T, C, A, V>)
-        : undefined;
-    },
-  };
-}
-
-export function sanitizeDocumentFields<T>(obj: T): T {
-  if (Array.isArray(obj)) {
-    return obj.map((item: unknown) => {
-      if (typeof item === "object" && item !== null) {
-        return sanitizeDocumentFields(item);
-      }
-      return item;
-    }) as T;
-  } else if (typeof obj === "object" && obj !== null) {
-    // Special case for Date objects - convert to ISO string
-    if (obj instanceof Date) {
-      return obj.toISOString() as unknown as T;
-    }
-
-    const typedObj = obj as Record<string, unknown>;
-    const result: Record<string, unknown> = {};
-    for (const key in typedObj) {
-      if (Object.hasOwnProperty.call(typedObj, key)) {
-        const value = typedObj[key];
-        if (value === null || (!Number.isNaN(value) && value !== undefined)) {
-          if (typeof value === "object" && !key.startsWith("_")) {
-            // Handle Date objects in properties
-            if (value instanceof Date) {
-              result[key] = (value as Date).toISOString();
-            } else {
-              const sanitized = sanitizeDocumentFields(value);
-              result[key] = sanitized;
-            }
-          } else {
-            result[key] = value;
-          }
-        }
-      }
-    }
-    return result as T;
-  }
-  return obj;
-}
-
-export async function applyBulkUpdateToCrdt<T extends DocTypes>(
-  store: StoreRuntime,
-  tblocks: CarTransaction,
-  head: ClockHead,
-  updates: DocUpdate<T>[],
-  logger: Logger,
-): Promise<CRDTMeta> {
-  let result: Result | null = null;
-  if (updates.length > 1) {
-    const batch = await Batch.create(toPailFetcher(tblocks), head);
-    for (const update of updates) {
-      const link = await writeDocContent(store, tblocks, update, logger);
-      await batch.put(toString(update.id, logger), link);
-    }
-    result = await batch.commit();
-  } else if (updates.length === 1) {
-    const link = await writeDocContent(store, tblocks, updates[0], logger);
-    result = await put(toPailFetcher(tblocks), head, toString(updates[0].id, logger), link);
-  }
-  if (!result) throw logger.Error().Uint64("updates.len", updates.length).Msg("Missing result").AsError();
-
-  if (result.event) {
-    for (const block of [
-      ...result.additions,
-      // ...result.removals,
-      result.event,
-    ]) {
-      tblocks.putSync(await anyBlock2FPBlock(block));
-    }
-  }
-  return { head: result.head }; // satisfies CRDTMeta;
-}
-
-// this whole thing can get pulled outside of the write queue
-async function writeDocContent<T extends DocTypes>(
-  store: StoreRuntime,
-  blocks: CarTransaction,
-  update: DocUpdate<T>,
-  logger: Logger,
-): Promise<AnyLink> {
-  let value: Partial<DocValue<T>>;
-  if (update.del) {
-    value = { del: true };
-  } else {
-    if (!update.value) throw logger.Error().Msg("Missing value").AsError();
-    await processFiles(store, blocks, update.value, logger);
-    value = { doc: update.value as DocWithId<T> };
-  }
-  // const ref = await encode({ value, hasher, codec });
-  const block = await doc2FPBlock(value);
-  // if (ref.cid.toString() !== block.cid.toString()) {
-  //   debugger
-  // }
-  blocks.putSync(block);
-  return block.cid;
-}
-
-async function processFiles<T extends DocTypes>(store: StoreRuntime, blocks: CarTransaction, doc: DocSet<T>, logger: Logger) {
-  if (doc._files) {
-    await processFileset(logger, store, blocks, doc._files);
-  }
-  if (doc._publicFiles) {
-    await processFileset(logger, store, blocks, doc._publicFiles /*, true*/);
-  }
-}
-
-async function processFileset(
-  logger: Logger,
-  store: StoreRuntime,
-  blocks: CarTransaction,
-  files: DocFiles /*, publicFiles = false */,
-) {
-  const dbBlockstore = blocks.parent as unknown as EncryptedBlockstore;
-  if (!dbBlockstore.loader) throw logger.Error().Msg("Missing loader, ledger name is required").AsError();
-  const t = new CarTransactionImpl(dbBlockstore); // maybe this should move to encrypted-blockstore
-  const didPut = [];
-  // let totalSize = 0
-  for (const filename in files) {
-    if (File === files[filename].constructor) {
-      const file = files[filename] as File;
-
-      // totalSize += file.size
-      const { cid, blocks: fileBlocks } = await store.encodeFile(file);
-      didPut.push(filename);
-      for (const block of fileBlocks) {
-        // console.log("processFileset", block.cid.toString())
-        t.putSync(await fileBlock2FPBlock(block));
-      }
-      files[filename] = { cid, type: file.type, size: file.size, lastModified: file.lastModified } as DocFileMeta;
-    } else {
-      const { cid, type, size, car, lastModified } = files[filename] as DocFileMeta;
-      if (cid && type && size && car) {
-        files[filename] = { cid, type, size, car, lastModified };
-      }
-    }
-  }
-
-  if (didPut.length) {
-    const car = await dbBlockstore.loader.commitFiles(
-      t,
-      { files } as unknown as TransactionMeta /* {
-      public: publicFiles,
-    } */,
-    );
-    if (car) {
-      for (const name of didPut) {
-        files[name] = { car, ...files[name] } as DocFileMeta;
-      }
-    }
-  }
-}
-
-export async function getValueFromCrdt<T extends DocTypes>(
-  blocks: BaseBlockstore,
-  head: ClockHead,
-  key: string,
-  logger: Logger,
-): Promise<DocValue<T>> {
-  if (!head.length) throw logger.Debug().Msg("Getting from an empty ledger").AsError();
-  // console.log("getValueFromCrdt-1", head, key)
-  const link = await get(toPailFetcher(blocks), head, key);
-  // console.log("getValueFromCrdt-2", key)
-  if (!link) {
-    // Use NotFoundError instead of logging an error
-    throw new NotFoundError(`Not found: ${key}`);
-  }
-  const ret = await getValueFromLink<T>(blocks, link, logger);
-  // console.log("getValueFromCrdt-3", key)
-  return ret;
-}
-
-export function readFiles<T extends DocTypes>(blocks: BaseBlockstore, { doc }: Partial<DocValue<T>>) {
-  if (!doc) return;
-  if (doc._files) {
-    readFileset(blocks as EncryptedBlockstore, doc._files);
-  }
-  if (doc._publicFiles) {
-    readFileset(blocks as EncryptedBlockstore, doc._publicFiles, true);
-  }
-}
-
-function readFileset(blocks: EncryptedBlockstore, files: DocFiles, isPublic = false) {
-  for (const filename in files) {
-    const fileMeta = files[filename] as DocFileMeta;
-    if (fileMeta.cid) {
-      if (isPublic) {
-        fileMeta.url = `https://${fileMeta.cid.toString()}.ipfs.w3s.link/`;
-      }
-      if (fileMeta.car) {
-        fileMeta.file = async () => {
-          const result = await blocks.ebOpts.storeRuntime.decodeFile(
-            {
-              get: async (cid: AnyLink) => {
-                return await blocks.getFile(throwFalsy(fileMeta.car), cid);
-              },
-            },
-            fileMeta.cid,
-            fileMeta,
-          );
-          if (result.isErr()) {
-            throw blocks.logger.Error().Any("error", result.Err()).Any("cid", fileMeta.cid).Msg("Error decoding file").AsError();
-          }
-
-          return result.unwrap();
-        };
-      }
-    }
-    files[filename] = fileMeta;
-  }
-}
-
-async function getValueFromLink<T extends DocTypes>(blocks: BlockFetcher, link: AnyLink, logger: Logger): Promise<DocValue<T>> {
-  const block = await blocks.get(link);
-  if (!block) throw logger.Error().Str("link", link.toString()).Msg(`Missing linked block`).AsError();
-  const { value } = (await asyncBlockDecode({ bytes: block.bytes, hasher, codec })) as { value: DocValue<T> };
-  const cvalue = {
-    ...value,
-    cid: link,
-  };
-  readFiles(blocks as EncryptedBlockstore, cvalue);
-  return cvalue;
-}
-
-class DirtyEventFetcher<T> extends EventFetcher<T> {
-  readonly logger: Logger;
-  constructor(logger: Logger, blocks: BlockFetcher) {
-    super(toPailFetcher(blocks));
-    this.logger = logger;
-  }
-  async get(link: EventLink<T>): Promise<EventBlockView<T>> {
-    try {
-      return await super.get(link);
-    } catch (e) {
-      this.logger.Error().Ref("link", link.toString()).Err(e).Msg("Missing event");
-      return { value: undefined } as unknown as EventBlockView<T>;
-    }
-  }
-}
-
-export async function clockChangesSince<T extends DocTypes>(
-  blocks: BlockFetcher,
-  head: ClockHead,
-  since: ClockHead,
-  opts: ChangesOptions,
-  logger: Logger,
-): Promise<{ result: DocUpdate<T>[]; head: ClockHead }> {
-  const eventsFetcher = (
-    opts.dirty ? new DirtyEventFetcher<Operation>(logger, blocks) : new EventFetcher<Operation>(toPailFetcher(blocks))
-  ) as EventFetcher<Operation>;
-  const keys = new Set<string>();
-  const updates = await gatherUpdates<T>(
-    blocks,
-    eventsFetcher,
-    head,
-    since,
-    [],
-    keys,
-    new Set<string>(),
-    opts.limit || Infinity,
-    logger,
-  );
-  return { result: updates.reverse(), head };
-}
-
-async function gatherUpdates<T extends DocTypes>(
-  blocks: BlockFetcher,
-  eventsFetcher: EventFetcher<Operation>,
-  head: ClockHead,
-  since: ClockHead,
-  updates: DocUpdate<T>[] = [],
-  keys: Set<string>,
-  didLinks: Set<string>,
-  limit: number,
-  logger: Logger,
-): Promise<DocUpdate<T>[]> {
-  if (limit <= 0) return updates;
-  // if (Math.random() < 0.001) console.log('gatherUpdates', head.length, since.length, updates.length)
-  const sHead = head.map((l) => l.toString());
-  for (const link of since) {
-    if (sHead.includes(link.toString())) {
-      return updates;
-    }
-  }
-  for (const link of head) {
-    if (didLinks.has(link.toString())) continue;
-    didLinks.add(link.toString());
-    const { value: event } = await eventsFetcher.get(link);
-    if (!event) continue;
-    const { type } = event.data;
-    let ops = [] as PutOperation[];
-    if (type === "batch") {
-      ops = event.data.ops as PutOperation[];
-    } else if (type === "put") {
-      ops = [event.data] as PutOperation[];
-    }
-    for (let i = ops.length - 1; i >= 0; i--) {
-      const { key, value } = ops[i];
-      if (!keys.has(key)) {
-        // todo option to see all updates
-        const docValue = await getValueFromLink<T>(blocks, value, logger);
-        if (key === PARAM.GENESIS_CID) {
-          continue;
-        }
-        updates.push({ id: key, value: docValue.doc, del: docValue.del, clock: link });
-        limit--;
-        keys.add(key);
-      }
-    }
-    if (event.parents) {
-      updates = await gatherUpdates(blocks, eventsFetcher, event.parents, since, updates, keys, didLinks, limit, logger);
-    }
-  }
-  return updates;
-}
-
-export async function* getAllEntries<T extends DocTypes>(blocks: BlockFetcher, head: ClockHead, logger: Logger) {
-  // return entries(blocks, head)
-  for await (const [key, link] of entries(toPailFetcher(blocks), head)) {
-    // console.log("getAllEntries", key, link);
-    if (key !== PARAM.GENESIS_CID) {
-      const docValue = await getValueFromLink(blocks, link, logger);
-      yield { id: key, value: docValue.doc, del: docValue.del } as DocUpdate<T>;
-    }
-  }
-}
-
-export async function* clockVis(blocks: BlockFetcher, head: ClockHead) {
-  for await (const line of vis(toPailFetcher(blocks), head)) {
-    yield line;
-  }
-}
-
-export async function getBlock(blocks: BlockFetcher, cidString: string) {
-  const block = await blocks.get(parse(cidString));
-  if (!block) throw new Error(`Missing block ${cidString}`);
-  const { cid, value } = await asyncBlockDecode({ bytes: block.bytes, codec, hasher });
-  return new Block({ cid, value, bytes: block.bytes });
-}

package/crdt.ts

@@ -1,275 +0,0 @@
-import type { Block } from "multiformats";
-import { Logger, ResolveOnce } from "@adviser/cement";
-import { EncryptedBlockstore, toStoreRuntime } from "@fireproof/core-blockstore";
-import {
-  clockChangesSince,
-  applyBulkUpdateToCrdt,
-  getValueFromCrdt,
-  readFiles,
-  getAllEntries,
-  clockVis,
-  getBlock,
-  sanitizeDocumentFields,
-} from "./crdt-helpers.js";
-import {
-  type DocUpdate,
-  type CRDTMeta,
-  type ClockHead,
-  type ChangesOptions,
-  type DocValue,
-  type IndexKeyType,
-  type DocWithId,
-  type Falsy,
-  type SuperThis,
-  type IndexTransactionMeta,
-  type LedgerOpts,
-  type BaseBlockstore,
-  type CRDT,
-  type CRDTClock,
-  type CarTransaction,
-  type DocTypes,
-  PARAM,
-  Ledger,
-  TraceEvent,
-} from "@fireproof/core-types-base";
-import { index, type Index } from "./indexer.js";
-// import { blockstoreFactory } from "./blockstore/transaction.js";
-import { ensureLogger, getCompactStrategy } from "@fireproof/core-runtime";
-import { CRDTClockImpl } from "./crdt-clock.js";
-import { TransactionMeta, BlockstoreOpts } from "@fireproof/core-types-blockstore";
-
-export type CRDTOpts = Omit<LedgerOpts, "storeUrls"> & {
-  readonly storeUrls: {
-    readonly data: LedgerOpts["storeUrls"]["data"];
-    readonly idx?: LedgerOpts["storeUrls"]["idx"];
-  };
-};
-
-function tracerAction(opts: CRDTOpts, parent?: Ledger) {
-  return (event: TraceEvent) => {
-    switch (event.event) {
-      case "idleFromCommitQueue":
-        opts.tracer({
-          event: "idleFromBlockstore",
-          blockstore: "data",
-          ledger: parent,
-        });
-        break;
-      case "busyFromCommitQueue":
-        opts.tracer({
-          event: "busyFromBlockstore",
-          blockstore: "data",
-          ledger: parent,
-          queueLen: event.queueLen,
-        });
-        break;
-      default:
-        return opts.tracer(event);
-    }
-  };
-}
-
-export class CRDTImpl implements CRDT {
-  readonly opts: CRDTOpts;
-
-  readonly blockstore: BaseBlockstore;
-  // we can run without an index instance
-  readonly indexBlockstore?: BaseBlockstore;
-  readonly indexers = new Map<string, Index<DocTypes, IndexKeyType>>();
-  readonly clock: CRDTClock;
-
-  readonly logger: Logger;
-  readonly sthis: SuperThis;
-  // self reference to fullfill HasCRDT
-  readonly crdt: CRDT;
-
-  readonly ledgerParent?: Ledger;
-
-  constructor(sthis: SuperThis, opts: CRDTOpts, parent?: Ledger) {
-    this.sthis = sthis;
-    this.ledgerParent = parent;
-    this.crdt = this;
-    this.logger = ensureLogger(sthis, "CRDTImpl");
-    this.opts = opts;
-    const rCompactStrategy = getCompactStrategy(this.opts.compactStrategy);
-    if (rCompactStrategy.isErr()) {
-      throw this.logger
-        .Error()
-        .Err(rCompactStrategy.Err())
-        .Str("compactorName", this.opts.compactStrategy)
-        .Msg("compactor not found")
-        .AsError();
-    }
-    const blockstoreOpts = {
-      tracer: tracerAction(opts, parent),
-      applyMeta: async (meta: TransactionMeta) => {
-        const crdtMeta = meta as CRDTMeta;
-        if (!crdtMeta.head) throw this.logger.Error().Msg("missing head").AsError();
-        // console.log("applyMeta-pre", crdtMeta.head, this.clock.head);
-        await this.clock.applyHead(crdtMeta.head, []);
-        // console.log("applyMeta-post", crdtMeta.head, this.clock.head);
-      },
-      compactStrategy: rCompactStrategy.Ok(),
-      gatewayInterceptor: opts.gatewayInterceptor,
-      // autoCompact: this.opts.autoCompact || 100,
-      storeRuntime: toStoreRuntime(this.sthis, this.opts.storeEnDe),
-      storeUrls: this.opts.storeUrls.data,
-      keyBag: this.opts.keyBag,
-      // public: this.opts.public,
-      meta: this.opts.meta,
-      // threshold: this.opts.threshold,
-    } satisfies BlockstoreOpts;
-
-    this.blockstore = new EncryptedBlockstore(sthis, blockstoreOpts, this);
-    if (this.opts.storeUrls.idx) {
-      this.indexBlockstore = new EncryptedBlockstore(
-        sthis,
-        {
-          tracer: opts.tracer,
-          // name: opts.name,
-          applyMeta: async (meta: TransactionMeta) => {
-            const idxCarMeta = meta as IndexTransactionMeta;
-            if (!idxCarMeta.indexes) throw this.logger.Error().Msg("missing indexes").AsError();
-            for (const [name, idx] of Object.entries(idxCarMeta.indexes)) {
-              index(this, name, undefined, idx);
-            }
-          },
-          gatewayInterceptor: opts.gatewayInterceptor,
-          storeRuntime: toStoreRuntime(this.sthis, this.opts.storeEnDe),
-          storeUrls: this.opts.storeUrls.idx,
-          keyBag: this.opts.keyBag,
-          // public: this.opts.public,
-        },
-        this,
-      );
-    }
-    this.clock = new CRDTClockImpl(this.blockstore);
-    this.clock.onZoom(() => {
-      for (const idx of this.indexers.values()) {
-        idx._resetIndex();
-      }
-    });
-  }
-
-  async bulk<T extends DocTypes>(updates: DocUpdate<T>[]): Promise<CRDTMeta> {
-    await this.ready();
-    updates = updates.map((dupdate: DocUpdate<T>) => ({
-      ...dupdate,
-      value: sanitizeDocumentFields(dupdate.value),
-    }));
-
-    if (this.clock.head.length === 0) {
-      // INJECT GENESIS Block
-      const value = { id: PARAM.GENESIS_CID, value: { _id: PARAM.GENESIS_CID } }; // satisfies DocUpdate<DocSet<DocTypes>>;
-      // const block = await encode({ value, hasher: sha256, codec: dagCodec });
-      await this._bulk([value]);
-    }
-    return await this._bulk(updates);
-  }
-
-  async _bulk<T extends DocTypes>(updates: DocUpdate<T>[]): Promise<CRDTMeta> {
-    const prevHead = [...this.clock.head];
-    const done = await this.blockstore.transaction<CRDTMeta>(async (blocks: CarTransaction): Promise<CRDTMeta> => {
-      const { head } = await applyBulkUpdateToCrdt<DocTypes>(
-        this.blockstore.ebOpts.storeRuntime,
-        blocks,
-        this.clock.head,
-        updates,
-        this.logger,
-      );
-      updates = updates.map((dupdate: DocUpdate<T>) => {
-        // if (!dupdate.value) throw new Error("missing value");
-        readFiles(this.blockstore, { doc: dupdate.value as DocWithId<DocTypes> });
-        return dupdate;
-      });
-      return { head };
-    });
-    await this.clock.applyHead(done.meta.head, prevHead, updates);
-    return done.meta;
-  }
-
-  readonly onceReady: ResolveOnce<void> = new ResolveOnce<void>();
-  async ready(): Promise<void> {
-    return this.onceReady.once(async () => {
-      try {
-        // console.log("bs-ready-pre")
-        // await this.blockstore.ready();
-        // console.log("bs-ready-post-1")
-        // await this.indexBlockstore?.ready();
-        // console.log("bs-ready-post-2")
-        // await this.clock.ready();
-        // console.log("bs-ready-post-3")
-        await Promise.all([
-          this.blockstore.ready(),
-          this.indexBlockstore ? this.indexBlockstore.ready() : Promise.resolve(),
-          this.clock.ready(),
-        ]);
-      } catch (e) {
-        throw this.logger.Error().Err(e).Msg(`CRDT is not ready`).AsError();
-      }
-    });
-  }
-
-  async close(): Promise<void> {
-    // await this.blockstore.close();
-    // await this.indexBlockstore.close();
-    // await this.clock.close();
-    await Promise.all([
-      this.blockstore.close(),
-      this.indexBlockstore ? this.indexBlockstore.close() : Promise.resolve(),
-      this.clock.close(),
-    ]);
-  }
-
-  async destroy(): Promise<void> {
-    await Promise.all([this.blockstore.destroy(), this.indexBlockstore ? this.indexBlockstore.destroy() : Promise.resolve()]);
-  }
-
-  // if (snap) await this.clock.applyHead(crdtMeta.head, this.clock.head)
-
-  async allDocs<T extends DocTypes>(): Promise<{ result: DocUpdate<T>[]; head: ClockHead }> {
-    await this.ready();
-    const result: DocUpdate<T>[] = [];
-    for await (const entry of getAllEntries<DocTypes>(this.blockstore, this.clock.head, this.logger)) {
-      result.push(entry as DocUpdate<T>);
-    }
-    return { result, head: this.clock.head };
-  }
-
-  async vis(): Promise<string> {
-    await this.ready();
-    const txt: string[] = [];
-    for await (const line of clockVis(this.blockstore, this.clock.head)) {
-      txt.push(line);
-    }
-    return txt.join("\n");
-  }
-
-  async getBlock(cidString: string): Promise<Block> {
-    await this.ready();
-    return await getBlock(this.blockstore, cidString);
-  }
-
-  async get(key: string): Promise<DocValue<DocTypes> | Falsy> {
-    await this.ready();
-    const result = await getValueFromCrdt<DocTypes>(this.blockstore, this.clock.head, key, this.logger);
-    if (result.del) return undefined;
-    return result;
-  }
-
-  async changes<T extends DocTypes>(
-    since: ClockHead = [],
-    opts: ChangesOptions = {},
-  ): Promise<{
-    result: DocUpdate<T>[];
-    head: ClockHead;
-  }> {
-    await this.ready();
-    return await clockChangesSince<T>(this.blockstore, this.clock.head, since, opts, this.logger);
-  }
-
-  async compact(): Promise<void> {
-    const blocks = this.blockstore as EncryptedBlockstore;
-    return await blocks.compact();
-  }
-}