@freedomofpress/webcat 0.0.0-stage → 3.0.0

package/dist/lib/config.js

@@ -0,0 +1,45 @@
+import validator_set from "./validator_set.js";
+const defaults = {
+  /** {@inheritDoc WebcatConfig.namespace} */
+  namespace: "WEBCAT",
+  /** {@inheritDoc WebcatConfig.originCacheSize} */
+  originCacheSize: 32,
+  /** {@inheritDoc WebcatConfig.nonOriginCacheSize} */
+  nonOriginCacheSize: 8192,
+  /** {@inheritDoc WebcatConfig.bundlePath} */
+  bundlePath: "/.well-known/webcat/bundle.json",
+  /** {@inheritDoc WebcatConfig.bundlePrevPath} */
+  bundlePrevPath: "/.well-known/webcat/bundle-prev.json",
+  /** {@inheritDoc WebcatConfig.endpoint} */
+  endpoint: "https://webcat.freedom.press/",
+  /** {@inheritDoc WebcatConfig.localDataPath} */
+  localDataPath: "data",
+  /** {@inheritDoc WebcatConfig.validatorSet} */
+  validatorSet: validator_set,
+  chainId: "webcat-test-02",
+  // During alpha, update every hour. Wall-clock based so that sleep/suspend
+  // doesn't silently postpone updates.
+  /** {@inheritDoc WebcatConfig.updateInterval} */
+  updateInterval: 60 * 60 * 1e3,
+  // 1 hour
+  /** {@inheritDoc WebcatConfig.checkInterval} */
+  checkInterval: 5 * 60 * 1e3,
+  // poll every 5 minutes
+  /** {@inheritDoc WebcatConfig.fetchTimeout} */
+  fetchTimeout: 3e3,
+  // 3 second timeout for fetches
+  /** {@inheritDoc WebcatConfig.staticHookPath} */
+  staticHookPath: "dist/hooks/content.js",
+  /** {@inheritDoc WebcatConfig.iconPaths} */
+  iconPaths: (p) => `icons/${p.colorScheme}/${p.name}.SVG`,
+  /** {@inheritDoc WebcatConfig.pagePaths} */
+  pagePaths: (p) => `pages/${p.name}.html`
+};
+const test = Object.assign(Object.assign({}, defaults), {
+  originCacheSize: 2,
+  endpoint: "http://localhost:1234/"
+});
+export {
+  defaults,
+  test
+};

package/dist/lib/validator_set.d.ts

@@ -0,0 +1,4 @@
+import { ValidatorJson } from "@freedomofpress/cometbft/dist/types";
+
+declare const validator_set: ValidatorJson;
+export default validator_set;

package/dist/lib/validator_set.js

@@ -0,0 +1,20 @@
+const validators = [{ "address": "48926DF1CC10DBBFAA78953F9BE38E59020DE01D", "pub_key": { "type": "tendermint/PubKeyEd25519", "value": "zEK+pyAEhhCaoHYhhT+rrorJoc9kZbfY+JkbMtF8u5Y=" }, "power": "1", "name": null }, { "address": "A39CFEBE6E8CA10B6101C46884A6EB8E62D04417", "pub_key": { "type": "tendermint/PubKeyEd25519", "value": "8dZUej72UriKCPIDvk01c6yLaAB2ssYIli3fT3jKwSM=" }, "power": "1", "name": null }, { "address": "B734AC6CC1F14AAC8315FE8DBB07402ED4E45D72", "pub_key": { "type": "tendermint/PubKeyEd25519", "value": "WBK6Af3uKtC+VTv8x48f2TPoNnsebSXSBTIsJku/nQw=" }, "power": "1", "name": null }];
+const proposer = { "address": "B734AC6CC1F14AAC8315FE8DBB07402ED4E45D72", "pub_key": { "type": "tendermint/PubKeyEd25519", "value": "WBK6Af3uKtC+VTv8x48f2TPoNnsebSXSBTIsJku/nQw=" }, "power": "1", "name": null };
+const total_voting_power = "3";
+const count = "3";
+const total = "3";
+const validator_set = {
+  validators,
+  proposer,
+  total_voting_power,
+  count,
+  total
+};
+export {
+  count,
+  validator_set as default,
+  proposer,
+  total,
+  total_voting_power,
+  validators
+};

package/dist/lib/webcat/cache.d.ts

@@ -0,0 +1,200 @@
+import { KVStore } from "../browser/kvstore";
+import { Lock, Mutex } from "../browser/sync";
+declare const CacheKeySymbol: unique symbol;
+/** @internal */
+export type CacheKey<T> = string & {
+    [CacheKeySymbol]: T | undefined;
+};
+/**
+ * Constructs a cache key from a primary string key and a set of attributes,
+ * enabling arbitrary cache partitioning.
+ *
+ * @typeParam T - A string-indexed object type for cache attributes.
+ */
+export declare function CacheKey<T extends {
+    [index: string]: {
+        toString(): string;
+    };
+}>(key: string, attrs: T): CacheKey<T>;
+/**
+ * Checks whether a given {@link CacheKey} is in the specified partition.
+ *
+ * @typeParam P The type of the partition attribute object to check against.
+ * @typeParam T The type of the cache partition attributes of the key.
+ * @param key The key to check.
+ * @param partition The cache partition attributes.
+ * @returns true if the key has the specified attributes, i.e. is in the
+ * partition; false otherwise.
+ */
+export declare function isInPartition<P extends {
+    [index: string]: {
+        toString(): string;
+    };
+}, T extends P>(key: CacheKey<T>, partition: P): boolean;
+/**
+ * A fixed-size in-memory cache that automatically evicts the least recently
+ * used entry first when it reaches its size limit.
+ *
+ * @typeParam K The type of cache keys.
+ * @typeParam V The type of values store in this cache.
+ */
+export declare class LRUCache<K, V> {
+    #private;
+    /** @internal */
+    protected readonly mutex: Mutex;
+    /**
+     * @param limit The maximum number of entries held by the cache.
+     */
+    constructor(limit: number);
+    /** @internal */
+    constructor(limit: number, mutex: Mutex);
+    /**
+     * Reads a cached value.
+     *
+     * @param key The key to read.
+     * @returns A Promise that resolves with the value read.
+     */
+    get(key: K): Promise<V | undefined>;
+    /** @internal */
+    get(key: K, l?: Lock): Promise<V | undefined>;
+    /**
+     * Caches a value.
+     *
+     * @param key The key to use.
+     * @param value The value to cache.
+     */
+    set(key: K, value: V): Promise<void>;
+    /** @internal */
+    set(key: K, value: V, l?: Lock): Promise<void>;
+    /**
+     * @returns A Promise that resolves to true if the given key exists in the cache.
+     */
+    has(key: K): Promise<boolean>;
+    /** @internal */
+    has(key: K, l?: Lock): Promise<boolean>;
+    /**
+     * @returns A Promise that resolves to an array of the keys in the cache.
+     */
+    keys(): Promise<K[]>;
+    /** @internal */
+    keys(l?: Lock): Promise<K[]>;
+    /**
+     * Clears a single value from the cache.
+     *
+     * @param key The key to clear.
+     */
+    delete(key: K): Promise<void>;
+    /** @internal */
+    delete(key: K, l?: Lock): Promise<void>;
+    /**
+     * Clears all values from the cache.
+     */
+    clear(): Promise<void>;
+    /** @internal */
+    clear(l?: Lock): Promise<void>;
+}
+/**
+ * An object that can be converted to a {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object | Plain Old JavaScript Object}
+ * compatible with persistence APIs.
+ */
+export type Pojoifiable = {
+    /**
+     * @returns A POJO representation of the object.
+     */
+    toPOJO(): object;
+};
+/**
+ * Complementary interface to {@link Pojoifiable}.
+ */
+export interface Depojoifier<V> {
+    /**
+     * @param pojo An object created via {@link Pojoifiable.toPOJO}.
+     * @returns A corresponding {@link Pojoifiable} object.
+     */
+    fromPOJO(pojo: object): V;
+}
+/**
+ * Arguments for the {@link PersistentLRUCache} constructor:
+ *  1. limit: the maximum number of entries held by the cache
+ *  2. store: a {@link KVStore} instance to use for persistence
+ *  3. area: the name of the {@link browser.storage.StorageArea | storage area}
+ *    to use
+ *  4. (optional) depojoifier: a {@link Depojoifier} for converting persisted
+ *    POJOs to V; required if and only if V extends {@link Pojoifiable}.
+ *
+ * @typeParam V The type of values stored in the cache.
+ * @expand
+ */
+export type PersistentLRUCacheArgs<V> = V extends Pojoifiable ? [number, KVStore, "session" | "local", Depojoifier<V>] : [number, KVStore, "session" | "local"];
+/**
+ * A persistent {@link LRUCache}. Supported value types are limited by the
+ * storage API. In addition to JSON-ifiable values, i.e. Plain Old JavaScript
+ * Objects (POJOs), accepted by the storage API, arbitrary objects that
+ * implement the {@link Pojoifiable} interface can be cached. The conversion
+ * from {@link Pojoifiable} (and back via the {@link Depojoifier} interface) is
+ * handled automatically.
+ *
+ * @typeParam K The type of cache keys.
+ * @typeParam V The type of values store in this cache.
+ */
+export declare class PersistentLRUCache<K extends string, V extends Pojoifiable | unknown> extends LRUCache<K, V> {
+    #private;
+    /** @param args */
+    constructor(...[limit, store, area, depojoifier]: PersistentLRUCacheArgs<V>);
+    get(key: K): Promise<V | undefined>;
+    /** @internal */
+    get(key: K, l?: Lock): Promise<V | undefined>;
+    set(key: K, value: V): Promise<void>;
+    /** @internal */
+    set(key: K, value: V, l?: Lock): Promise<void>;
+    has(key: K): Promise<boolean>;
+    /** @internal */
+    has(key: K, l?: Lock): Promise<boolean>;
+    keys(): Promise<K[]>;
+    /** @internal */
+    keys(l?: Lock): Promise<K[]>;
+    delete(key: K): Promise<void>;
+    /** @internal */
+    delete(key: K, l?: Lock): Promise<void>;
+    clear(): Promise<void>;
+    /** @internal */
+    clear(l?: Lock): Promise<void>;
+}
+/**
+ * An unkeyed fixed-size in-memory cache that automatically evicts the least
+ * recently used entry first when it reaches its size limit.
+ *
+ * @typeParam T The type of values to store in this cache.
+ */
+export declare class LRUSet<T> {
+    #private;
+    /**
+     * @param limit The maximum number of entries held by the cache.
+     */
+    constructor(limit: number);
+    /**
+     * @returns A Promise that resolves to true if the given value exists in the cache.
+     */
+    has(value: T): Promise<boolean>;
+    /**
+     * Caches a value.
+     *
+     * @param value The value to cache.
+     */
+    add(value: T): Promise<void>;
+    /**
+     * @returns A Promise that resolves to an array of the values in the cache.
+     */
+    values(): Promise<T[]>;
+    /**
+     * Clears a single value from the cache.
+     *
+     * @param value The value to clear.
+     */
+    delete(value: T): Promise<void>;
+    /**
+     * Clears all values from the cache.
+     */
+    clear(): Promise<void>;
+}
+export {};

package/dist/lib/webcat/cache.js

@@ -0,0 +1,308 @@
+var __getProtoOf = Object.getPrototypeOf;
+var __reflectGet = Reflect.get;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var _cache, _limit, _store, _area, _depojoifier, _ready, _PersistentLRUCache_instances, load_fn, _cache2, _limit2;
+import { Mutex } from "../browser/sync.js";
+function CacheKey(key, attrs) {
+  return encodeURIComponent(key) + (attrs ? "?" + Object.keys(attrs).sort().map(
+    (name) => `${encodeURIComponent(name)}=${encodeURIComponent(attrs[name].toString())}`
+  ) : "");
+}
+function isInPartition(key, partition) {
+  const [_, q] = key.split("?");
+  if (q) {
+    const attrs = {};
+    q.split(",").forEach((attr) => {
+      const [name, value] = attr.split("=");
+      attrs[name] = value;
+    });
+    return Object.keys(partition).every(
+      (name) => partition[name].toString() === attrs[name]
+    );
+  }
+  return Object.keys(partition).length === 0;
+}
+class LRUCache {
+  constructor(limit, mutex) {
+    __privateAdd(this, _cache);
+    __privateAdd(this, _limit);
+    this.mutex = mutex || new Mutex();
+    __privateSet(this, _limit, limit);
+    __privateSet(this, _cache, /* @__PURE__ */ new Map());
+  }
+  async get(key, l) {
+    var _stack = [];
+    try {
+      const lock = __using(_stack, await this.mutex.acquire(l));
+      if (!__privateGet(this, _cache).has(key)) return void 0;
+      const value = __privateGet(this, _cache).get(key);
+      await this.set(key, value, lock);
+      return value;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async set(key, value, l) {
+    var _stack = [];
+    try {
+      const lock = __using(_stack, await this.mutex.acquire(l));
+      if (__privateGet(this, _cache).has(key)) {
+        await this.delete(key, lock);
+      } else if (__privateGet(this, _cache).size >= __privateGet(this, _limit)) {
+        const oldestKey = __privateGet(this, _cache).keys().next().value;
+        if (oldestKey !== void 0) {
+          await this.delete(oldestKey, lock);
+        }
+      }
+      __privateGet(this, _cache).set(key, value);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async has(key, l) {
+    var _stack = [];
+    try {
+      const _lock = __using(_stack, await this.mutex.acquire(l));
+      return __privateGet(this, _cache).has(key);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async keys(l) {
+    var _stack = [];
+    try {
+      const _lock = __using(_stack, await this.mutex.acquire(l));
+      return Array.from(__privateGet(this, _cache).keys());
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async delete(key, l) {
+    var _stack = [];
+    try {
+      const _lock = __using(_stack, await this.mutex.acquire(l));
+      __privateGet(this, _cache).delete(key);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async clear(l) {
+    var _stack = [];
+    try {
+      const _lock = __using(_stack, await this.mutex.acquire(l));
+      __privateGet(this, _cache).clear();
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+}
+_cache = new WeakMap();
+_limit = new WeakMap();
+const _PersistentLRUCache = class _PersistentLRUCache extends LRUCache {
+  /** @param args */
+  constructor(...[limit, store, area, depojoifier]) {
+    super(limit);
+    __privateAdd(this, _PersistentLRUCache_instances);
+    __privateAdd(this, _store);
+    __privateAdd(this, _area);
+    __privateAdd(this, _depojoifier);
+    __privateAdd(this, _ready);
+    __privateSet(this, _store, store);
+    __privateSet(this, _area, area);
+    __privateSet(this, _depojoifier, depojoifier);
+    __privateSet(this, _ready, __privateMethod(this, _PersistentLRUCache_instances, load_fn).call(this));
+  }
+  async get(key, l) {
+    await __privateGet(this, _ready);
+    return super.get(key, l);
+  }
+  async set(key, value, l) {
+    var _stack = [];
+    try {
+      await __privateGet(this, _ready);
+      const lock = __using(_stack, await this.mutex.acquire(l));
+      const pojo = value?.toPOJO?.() ?? value;
+      await super.set(key, value, lock);
+      await __privateGet(this, _store).set({ [key]: pojo }, __privateGet(this, _area));
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async has(key, l) {
+    await __privateGet(this, _ready);
+    return super.has(key, l);
+  }
+  async keys(l) {
+    await __privateGet(this, _ready);
+    return super.keys(l);
+  }
+  async delete(key, l) {
+    var _stack = [];
+    try {
+      await __privateGet(this, _ready);
+      const lock = __using(_stack, await this.mutex.acquire(l));
+      await __privateGet(this, _store).remove(key, __privateGet(this, _area));
+      return super.delete(key, lock);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async clear(l) {
+    var _stack = [];
+    try {
+      await __privateGet(this, _ready);
+      const lock = __using(_stack, await this.mutex.acquire(l));
+      await __privateGet(this, _store).clear("", __privateGet(this, _area));
+      return super.clear(lock);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+};
+_store = new WeakMap();
+_area = new WeakMap();
+_depojoifier = new WeakMap();
+_ready = new WeakMap();
+_PersistentLRUCache_instances = new WeakSet();
+load_fn = async function() {
+  const keys = await __privateGet(this, _store).getKeys("", __privateGet(this, _area));
+  for (const key of keys) {
+    const pojo = await __privateGet(this, _store).get(key, __privateGet(this, _area));
+    const v = __privateGet(this, _depojoifier)?.fromPOJO(pojo) ?? pojo;
+    await __superGet(_PersistentLRUCache.prototype, this, "set").call(this, key, v);
+  }
+};
+let PersistentLRUCache = _PersistentLRUCache;
+class LRUSet {
+  /**
+   * @param limit The maximum number of entries held by the cache.
+   */
+  constructor(limit) {
+    __privateAdd(this, _cache2);
+    __privateAdd(this, _limit2);
+    __privateSet(this, _limit2, limit);
+    __privateSet(this, _cache2, /* @__PURE__ */ new Set());
+  }
+  /**
+   * @returns A Promise that resolves to true if the given value exists in the cache.
+   */
+  async has(value) {
+    if (!__privateGet(this, _cache2).has(value)) return false;
+    __privateGet(this, _cache2).delete(value);
+    __privateGet(this, _cache2).add(value);
+    return true;
+  }
+  /**
+   * Caches a value.
+   *
+   * @param value The value to cache.
+   */
+  async add(value) {
+    if (__privateGet(this, _cache2).has(value)) {
+      __privateGet(this, _cache2).delete(value);
+    } else if (__privateGet(this, _cache2).size >= __privateGet(this, _limit2)) {
+      const oldestValue = __privateGet(this, _cache2).values().next().value;
+      if (oldestValue !== void 0) {
+        __privateGet(this, _cache2).delete(oldestValue);
+      }
+    }
+    __privateGet(this, _cache2).add(value);
+  }
+  /**
+   * @returns A Promise that resolves to an array of the values in the cache.
+   */
+  async values() {
+    return Array.from(__privateGet(this, _cache2).values());
+  }
+  /**
+   * Clears a single value from the cache.
+   *
+   * @param value The value to clear.
+   */
+  async delete(value) {
+    __privateGet(this, _cache2).delete(value);
+  }
+  /**
+   * Clears all values from the cache.
+   */
+  async clear() {
+    __privateGet(this, _cache2).clear();
+  }
+}
+_cache2 = new WeakMap();
+_limit2 = new WeakMap();
+export {
+  CacheKey,
+  LRUCache,
+  LRUSet,
+  PersistentLRUCache,
+  isInPartition
+};

package/dist/lib/webcat/canonicalize.d.ts

@@ -0,0 +1 @@
+export declare function canonicalize(object: unknown): string | null;

package/dist/lib/webcat/canonicalize.js

@@ -0,0 +1,58 @@
+const COMMA = ",";
+const COLON = ":";
+const LEFT_SQUARE_BRACKET = "[";
+const RIGHT_SQUARE_BRACKET = "]";
+const LEFT_CURLY_BRACKET = "{";
+const RIGHT_CURLY_BRACKET = "}";
+function canonicalizeString(string) {
+  const escapedString = string.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return '"' + escapedString + '"';
+}
+function canonicalize(object) {
+  const buffer = [];
+  if (typeof object === "string") {
+    buffer.push(canonicalizeString(object));
+  } else if (typeof object === "boolean") {
+    buffer.push(JSON.stringify(object));
+  } else if (Number.isInteger(object)) {
+    buffer.push(JSON.stringify(object));
+  } else if (object === null) {
+    buffer.push(JSON.stringify(object));
+  } else if (Array.isArray(object)) {
+    buffer.push(LEFT_SQUARE_BRACKET);
+    let first = true;
+    for (const element of object) {
+      if (!first) {
+        buffer.push(COMMA);
+      }
+      first = false;
+      const encoded = canonicalize(element);
+      if (encoded === null) return null;
+      buffer.push(encoded);
+    }
+    buffer.push(RIGHT_SQUARE_BRACKET);
+  } else if (typeof object === "object") {
+    buffer.push(LEFT_CURLY_BRACKET);
+    let first = true;
+    for (const property of Object.keys(object).sort()) {
+      if (!first) {
+        buffer.push(COMMA);
+      }
+      first = false;
+      buffer.push(canonicalizeString(property));
+      buffer.push(COLON);
+      const encoded = canonicalize(
+        object[property]
+      );
+      if (encoded === null) return null;
+      buffer.push(encoded);
+    }
+    buffer.push(RIGHT_CURLY_BRACKET);
+  } else {
+    return null;
+  }
+  return buffer.join("");
+}
+export {
+  canonicalize
+};

package/dist/lib/webcat/db.d.ts

@@ -0,0 +1,30 @@
+import { NamespacedKVStore } from "../browser/kvstore";
+import { CacheKey, LRUSet, PersistentLRUCache } from "./cache";
+import { BlockMeta, Database } from "./interfaces/database";
+import { CachePartition } from "./interfaces/originstate";
+import { OriginState } from "./originstate";
+/** @internal @inline */
+export type WebcatDatabaseConfig = {
+    /** A string prefix used for all persisted keys. */
+    namespace: string;
+    /** The number of {@link OriginState} objects to cache locally. */
+    originCacheSize: number;
+    /** The number of hostnames to store in-memory in the negative origin cache. */
+    nonOriginCacheSize: number;
+};
+/** A {@link Database} backed by a {@link NamespacedKVStore}. */
+export declare class WebcatDatabase extends NamespacedKVStore implements Database {
+    readonly origins: PersistentLRUCache<CacheKey<CachePartition>, OriginState>;
+    readonly nonOrigins: LRUSet<CacheKey<CachePartition>>;
+    /** A subnamespace for storing enrollment hashes. */
+    readonly enrollments: NamespacedKVStore;
+    constructor(config: WebcatDatabaseConfig);
+    updateList(leaves: readonly (readonly [string, string])[], meta: BlockMeta): Promise<void>;
+    getBlockMeta(): Promise<BlockMeta | null>;
+    listAllFQDNs(): Promise<string[]>;
+    getFQDNEnrollment(fqdn: string, cachePartition: CachePartition): Promise<Uint8Array>;
+    setLastChecked(): Promise<void>;
+    getLastChecked(): Promise<number | null>;
+    setLastUpdated(): Promise<void>;
+    getLastUpdated(): Promise<number | null>;
+}