@evolu/common 1.0.9 → 1.0.11

package/src/Crdt.ts

@@ -0,0 +1,375 @@
+import * as Schema from "@effect/schema/Schema";
+import {
+  Brand,
+  Context,
+  Effect,
+  Either,
+  Layer,
+  Number,
+  Option,
+  ReadonlyArray,
+  String,
+  pipe,
+} from "effect";
+import { Config } from "./Config.js";
+import { NanoId, NodeId } from "./Crypto.js";
+import { murmurhash } from "./Murmurhash.js";
+
+// https://muratbuffalo.blogspot.com/2014/07/hybrid-logical-clocks.html
+// https://jaredforsyth.com/posts/hybrid-logical-clocks/
+// https://github.com/clintharris/crdt-example-app_annotated/blob/master/shared/timestamp.js
+// https://github.com/actualbudget/actual/tree/master/packages/crdt
+
+export interface Timestamp {
+  readonly node: NodeId;
+  readonly millis: Millis;
+  readonly counter: Counter;
+}
+
+export const AllowedTimeRange = {
+  greaterThan: 860934419999,
+  lessThan: 2582803260000,
+};
+
+/**
+ * Millis represents a time that is valid for usage with the Merkle tree.
+ * It must be between Apr 13, 1997, and Nov 05, 2051, to ensure MinutesBase3
+ * length equals 16. We can find diff for two Merkle trees only within this range.
+ * If the device clock is out of range, Evolu will not store data until it's fixed.
+ */
+export const Millis = Schema.number.pipe(
+  Schema.greaterThan(AllowedTimeRange.greaterThan),
+  Schema.lessThan(AllowedTimeRange.lessThan),
+  Schema.brand("Millis"),
+);
+
+export type Millis = Schema.Schema.To<typeof Millis>;
+
+export const initialMillis = Schema.parseSync(Millis)(
+  AllowedTimeRange.greaterThan + 1,
+);
+
+export const Counter = Schema.number.pipe(
+  Schema.between(0, 65535),
+  Schema.brand("Counter"),
+);
+export type Counter = Schema.Schema.To<typeof Counter>;
+
+const initialCounter = Schema.parseSync(Counter)(0);
+
+export type TimestampHash = number & Brand.Brand<"TimestampHash">;
+
+export type TimestampString = string & Brand.Brand<"TimestampString">;
+
+export const timestampToString = (t: Timestamp): TimestampString =>
+  [
+    new Date(t.millis).toISOString(),
+    t.counter.toString(16).toUpperCase().padStart(4, "0"),
+    t.node,
+  ].join("-") as TimestampString;
+
+export const unsafeTimestampFromString = (s: TimestampString): Timestamp => {
+  const a = s.split("-");
+  return {
+    millis: Date.parse(a.slice(0, 3).join("-")).valueOf() as Millis,
+    counter: parseInt(a[3], 16) as Counter,
+    node: a[4] as NodeId,
+  };
+};
+
+export const timestampToHash = (t: Timestamp): TimestampHash =>
+  murmurhash(timestampToString(t)) as TimestampHash;
+
+const syncNodeId = Schema.parseSync(NodeId)("0000000000000000");
+
+export const makeSyncTimestamp = (
+  millis: Millis = initialMillis,
+): Timestamp => ({
+  millis,
+  counter: initialCounter,
+  node: syncNodeId,
+});
+
+export const makeInitialTimestamp = NanoId.pipe(
+  Effect.flatMap(({ nanoidAsNodeId }) => nanoidAsNodeId),
+  Effect.map(
+    (node): Timestamp => ({
+      millis: initialMillis,
+      counter: initialCounter,
+      node,
+    }),
+  ),
+);
+
+export interface Time {
+  readonly now: Effect.Effect<never, TimestampTimeOutOfRangeError, Millis>;
+}
+
+export const Time = Context.Tag<Time>("evolu/Time");
+
+export const TimeLive = Layer.succeed(
+  Time,
+  Time.of({
+    now: Effect.suspend(() => Schema.parse(Millis)(Date.now())).pipe(
+      Effect.catchTag("ParseError", () =>
+        Effect.fail<TimestampTimeOutOfRangeError>({
+          _tag: "TimestampTimeOutOfRangeError",
+        }),
+      ),
+    ),
+  }),
+);
+
+export type TimestampError =
+  | TimestampDriftError
+  | TimestampCounterOverflowError
+  | TimestampDuplicateNodeError
+  | TimestampTimeOutOfRangeError;
+
+export interface TimestampDriftError {
+  readonly _tag: "TimestampDriftError";
+  readonly next: Millis;
+  readonly now: Millis;
+}
+
+export interface TimestampCounterOverflowError {
+  readonly _tag: "TimestampCounterOverflowError";
+}
+
+export interface TimestampDuplicateNodeError {
+  readonly _tag: "TimestampDuplicateNodeError";
+  readonly node: NodeId;
+}
+
+export interface TimestampTimeOutOfRangeError {
+  readonly _tag: "TimestampTimeOutOfRangeError";
+}
+
+const getNextMillis = (
+  millis: ReadonlyArray<Millis>,
+): Effect.Effect<
+  Time | Config,
+  TimestampDriftError | TimestampTimeOutOfRangeError,
+  Millis
+> =>
+  Effect.gen(function* (_) {
+    const time = yield* _(Time);
+    const config = yield* _(Config);
+
+    const now = yield* _(time.now);
+    const next = Math.max(now, ...millis) as Millis;
+
+    if (next - now > config.maxDrift)
+      yield* _(
+        Effect.fail<TimestampDriftError>({
+          _tag: "TimestampDriftError",
+          now,
+          next,
+        }),
+      );
+
+    return next;
+  });
+
+const incrementCounter = (
+  counter: Counter,
+): Either.Either<TimestampCounterOverflowError, Counter> =>
+  pipe(
+    Number.increment(counter),
+    Schema.parseEither(Counter),
+    Either.mapLeft(() => ({ _tag: "TimestampCounterOverflowError" })),
+  );
+
+const counterMin = Schema.parseSync(Counter)(0);
+
+export const sendTimestamp = (
+  timestamp: Timestamp,
+): Effect.Effect<
+  Time | Config,
+  | TimestampDriftError
+  | TimestampCounterOverflowError
+  | TimestampTimeOutOfRangeError,
+  Timestamp
+> =>
+  Effect.gen(function* (_) {
+    const millis = yield* _(getNextMillis([timestamp.millis]));
+    const counter =
+      millis === timestamp.millis
+        ? yield* _(incrementCounter(timestamp.counter))
+        : counterMin;
+    return { ...timestamp, millis, counter };
+  });
+
+export const receiveTimestamp = ({
+  local,
+  remote,
+}: {
+  readonly local: Timestamp;
+  readonly remote: Timestamp;
+}): Effect.Effect<
+  Time | Config,
+  | TimestampDriftError
+  | TimestampCounterOverflowError
+  | TimestampDuplicateNodeError
+  | TimestampTimeOutOfRangeError,
+  Timestamp
+> =>
+  Effect.gen(function* (_) {
+    if (local.node === remote.node)
+      yield* _(
+        Effect.fail<TimestampDuplicateNodeError>({
+          _tag: "TimestampDuplicateNodeError",
+          node: local.node,
+        }),
+      );
+
+    const millis = yield* _(getNextMillis([local.millis, remote.millis]));
+    const counter = yield* _(
+      millis === local.millis && millis === remote.millis
+        ? incrementCounter(Math.max(local.counter, remote.counter) as Counter)
+        : millis === local.millis
+        ? incrementCounter(local.counter)
+        : millis === remote.millis
+        ? incrementCounter(remote.counter)
+        : Either.right(counterMin),
+    );
+
+    return { ...local, millis, counter };
+  });
+
+/**
+ * It's actually not Merkle Tree but a Merkleized prefix tree, aka Merkle Trie.
+ * https://decomposition.al/blog/2019/05/31/how-i-learned-about-merklix-trees-without-having-to-become-a-cryptocurrency-enthusiast
+ */
+export interface MerkleTree {
+  readonly hash?: TimestampHash;
+  readonly "0"?: MerkleTree;
+  readonly "1"?: MerkleTree;
+  readonly "2"?: MerkleTree;
+}
+
+export type MerkleTreeString = string & Brand.Brand<"MerkleTreeString">;
+
+export const initialMerkleTree = Object.create(null) as MerkleTree;
+
+type MerkleTreeKey = keyof Omit<MerkleTree, "hash">;
+
+type MerkleTreePath = ReadonlyArray<MerkleTreeKey>;
+
+export const millisToMerkleTreePath = (millis: Millis): MerkleTreePath =>
+  Math.floor(millis / 1000 / 60)
+    .toString(3)
+    .split("") as MerkleTreePath;
+
+const merkleTreePathToMillis = (path: MerkleTreePath): Millis =>
+  path.length === 0
+    ? initialMillis
+    : // 16 is the length of the base 3 value of the current time in minutes.
+      // Ensure it's padded to create the full value.
+      ((parseInt(path.join("").padEnd(16, "0"), 3) * 1000 * 60) as Millis);
+
+const xorTimestampHashes = (
+  a: TimestampHash | undefined,
+  b: TimestampHash,
+): TimestampHash => ((a || 0) ^ b) as TimestampHash;
+
+const insertKey = (
+  tree: MerkleTree,
+  path: MerkleTreePath,
+  hash: TimestampHash,
+): MerkleTree => {
+  if (path.length === 0) return tree;
+  const key = path[0];
+  const child = tree[key] || {};
+  return {
+    ...tree,
+    [key]: {
+      ...child,
+      ...insertKey(child, path.slice(1), hash),
+      hash: xorTimestampHashes(child.hash, hash),
+    },
+  };
+};
+
+export const insertIntoMerkleTree =
+  (timestamp: Timestamp) =>
+  (tree: MerkleTree): MerkleTree => {
+    const path = millisToMerkleTreePath(timestamp.millis);
+    const hash = timestampToHash(timestamp);
+    return insertKey(
+      { ...tree, hash: xorTimestampHashes(tree.hash, hash) },
+      path,
+      hash,
+    );
+  };
+
+const sortedMerkleTreeKeys: ReadonlyArray<MerkleTreeKey> = ["0", "1", "2"];
+
+const getSortedMerkleTreeKeys = (
+  tree: MerkleTree,
+): ReadonlyArray<MerkleTreeKey> =>
+  sortedMerkleTreeKeys.filter((key) => key in tree);
+
+export const diffMerkleTrees = (
+  tree1: MerkleTree,
+  tree2: MerkleTree,
+): Option.Option<Millis> => {
+  if (tree1.hash === tree2.hash) return Option.none();
+  let node1 = tree1;
+  let node2 = tree2;
+  let diffPath: MerkleTreePath = [];
+
+  // This loop will eventually stop when it traverses down to find
+  // where the hashes differ, or otherwise when there are no leaves
+  // left (this shouldn't happen, if that's the case the hash check at
+  // the top of this function should pass)
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    const keys = ReadonlyArray.dedupeWith(
+      getSortedMerkleTreeKeys(node1).concat(getSortedMerkleTreeKeys(node2)),
+      String.Equivalence,
+    );
+    let diffKey: MerkleTreeKey | null = null;
+
+    // Traverse down the trie through keys that are different. We
+    // traverse down the keys in order. Stop in two cases: either one
+    // of the nodes doesn't have the key or a different key isn't
+    // found. For the former case, we have to do that because pruning is
+    // lossy. We don't know if we've pruned off a changed key, so we
+    // can't traverse down anymore. For the latter case, it means two
+    // things: either we've hit the bottom of the tree, or the changed
+    // key has been pruned off. In the latter case, we have a "partial"
+    // key and will fill the rest with 0s. If multiple older
+    // messages were added into one trie, we might likely
+    // generate a time that only encompasses *some* of those
+    // messages. Pruning is lossy, and we traverse down the left-most
+    // changed time that we know of, because of pruning, it might take
+    // multiple passes to sync up a trie.
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const next1 = node1[key];
+      const next2 = node2[key];
+      if (!next1 || !next2) break;
+      if (next1.hash !== next2.hash) {
+        diffKey = key;
+        break;
+      }
+    }
+
+    if (!diffKey) {
+      return Option.some(merkleTreePathToMillis(diffPath));
+    }
+
+    diffPath = [...diffPath, diffKey];
+    node1 = node1[diffKey] || initialMerkleTree;
+    node2 = node2[diffKey] || initialMerkleTree;
+  }
+
+  return Option.none();
+};
+
+export const merkleTreeToString = (m: MerkleTree): MerkleTreeString =>
+  JSON.stringify(m) as MerkleTreeString;
+
+export const unsafeMerkleTreeFromString = (m: MerkleTreeString): MerkleTree =>
+  JSON.parse(m) as MerkleTree;

package/src/Crypto.ts

@@ -63,7 +63,7 @@ export const NanoIdLive = Layer.succeed(
  */
 export const slip21Derive = (
   seed: Uint8Array,
-  path: string[],
+  path: ReadonlyArray<string>,
 ): Effect.Effect<never, never, Uint8Array> =>
   Effect.sync(() => {
     let m = hmac(sha512, "Symmetric key seed", seed);

package/src/Db.ts

@@ -16,8 +16,13 @@ import {
 } from "effect";
 import * as Kysely from "kysely";
 import { urlAlphabet } from "nanoid";
+import {
+  initialMerkleTree,
+  makeInitialTimestamp,
+  merkleTreeToString,
+  timestampToString,
+} from "./Crdt.js";
 import { Bip39, Mnemonic, NanoId, slip21Derive } from "./Crypto.js";
-import { initialMerkleTree, merkleTreeToString } from "./MerkleTree.js";
 import { Id, SqliteBoolean, SqliteDate } from "./Model.js";
 import {
   createMessageTable,
@@ -33,7 +38,6 @@ import {
   Value,
   queryObjectToQuery,
 } from "./Sqlite.js";
-import { makeInitialTimestamp, timestampToString } from "./Timestamp.js";
 
 export type TableSchema = ReadonlyRecord.ReadonlyRecord<Value> & {
   readonly id: Id;

package/src/DbWorker.ts

@@ -12,6 +12,25 @@ import {
   pipe,
 } from "effect";
 import { Config, ConfigLive } from "./Config.js";
+import {
+  MerkleTree,
+  Time,
+  TimeLive,
+  Timestamp,
+  TimestampCounterOverflowError,
+  TimestampDriftError,
+  TimestampError,
+  TimestampString,
+  TimestampTimeOutOfRangeError,
+  diffMerkleTrees,
+  insertIntoMerkleTree,
+  makeSyncTimestamp,
+  merkleTreeToString,
+  receiveTimestamp,
+  sendTimestamp,
+  timestampToString,
+  unsafeTimestampFromString,
+} from "./Crdt.js";
 import { Bip39, Mnemonic, NanoId } from "./Crypto.js";
 import {
   Owner,
@@ -25,12 +44,6 @@ import {
 } from "./Db.js";
 import { QueryPatches, makePatches } from "./Diff.js";
 import { EvoluError, UnexpectedError, makeUnexpectedError } from "./Errors.js";
-import {
-  MerkleTree,
-  diffMerkleTrees,
-  insertIntoMerkleTree,
-  merkleTreeToString,
-} from "./MerkleTree.js";
 import { Id, SqliteDate, cast } from "./Model.js";
 import {
   insertIntoMessagesIfNew,
@@ -45,25 +58,12 @@ import { Query, Row, Sqlite, Value, queryObjectFromQuery } from "./Sqlite.js";
 import {
   Message,
   NewMessage,
+  NewMessageEquivalence,
   SyncState,
   SyncWorker,
   SyncWorkerOutputSyncResponse,
   SyncWorkerPostMessage,
 } from "./SyncWorker.js";
-import {
-  Time,
-  TimeLive,
-  Timestamp,
-  TimestampCounterOverflowError,
-  TimestampDriftError,
-  TimestampError,
-  TimestampString,
-  makeSyncTimestamp,
-  receiveTimestamp,
-  sendTimestamp,
-  timestampToString,
-  unsafeTimestampFromString,
-} from "./Timestamp.js";
 
 // TODO: Refactor to Effect.
 export interface DbWorker {
@@ -247,7 +247,7 @@ const readTimestampAndMerkleTree = Sqlite.pipe(
   ),
 );
 
-const mutateItemsToNewMessages = (
+export const mutateItemsToNewMessages = (
   items: ReadonlyArray.NonEmptyReadonlyArray<MutateItem>,
 ): ReadonlyArray.NonEmptyReadonlyArray<NewMessage> =>
   pipe(
@@ -285,6 +285,7 @@ const mutateItemsToNewMessages = (
       ),
     ),
     ReadonlyArray.flattenNonEmpty,
+    ReadonlyArray.dedupeNonEmptyWith(NewMessageEquivalence),
   );
 
 const ensureSchemaByMessages = (
@@ -395,7 +396,9 @@ const mutate = ({
   | RowsCacheRef
   | DbWorkerOnMessage
   | SyncWorkerPostMessage,
-  TimestampDriftError | TimestampCounterOverflowError,
+  | TimestampDriftError
+  | TimestampCounterOverflowError
+  | TimestampTimeOutOfRangeError,
   void
 > =>
   Effect.gen(function* (_) {

package/src/Errors.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { TimestampError } from "./Timestamp.js";
+import { TimestampError } from "./Crdt.js";
 
 export type EvoluError = UnexpectedError | TimestampError;
 

package/src/Evolu.ts

@@ -12,6 +12,7 @@ import {
 } from "effect";
 import { Simplify } from "kysely";
 import { Config, ConfigLive } from "./Config.js";
+import { Time, TimeLive } from "./Crdt.js";
 import { Bip39, NanoId } from "./Crypto.js";
 import {
   CommonColumns,
@@ -36,7 +37,6 @@ import { AppState, FlushSync } from "./Platform.js";
 import { Query, Row } from "./Sqlite.js";
 import { Store, StoreListener, StoreUnsubscribe, makeStore } from "./Store.js";
 import { SyncState } from "./SyncWorker.js";
-import { Time, TimeLive } from "./Timestamp.js";
 
 export interface Evolu<S extends Schema> {
   readonly subscribeError: ErrorStore["subscribe"];

package/src/Protobuf.ts

@@ -3,10 +3,9 @@
 // @generated from protobuf file "Protobuf.proto" (syntax proto3)
 // tslint:disable
 import { MessageType } from "@protobuf-ts/runtime";
-import { MerkleTreeString } from "./MerkleTree.js";
-import { OwnerId } from "./Db.js";
+import { MerkleTreeString, TimestampString } from "./Crdt.js";
 import { NodeId } from "./Crypto.js";
-import { TimestampString } from "./Timestamp.js";
+import { OwnerId } from "./Db.js";
 import { Id } from "./Model.js";
 /**
  * @generated from protobuf message SyncRequest

package/src/SyncWorker.ts

@@ -3,6 +3,7 @@ import { BinaryReader, BinaryWriter } from "@protobuf-ts/runtime";
 import {
   Context,
   Effect,
+  Equivalence,
   Function,
   Layer,
   Option,
@@ -11,14 +12,17 @@ import {
   absurd,
   identity,
 } from "effect";
-import { SecretBox } from "./Crypto.js";
-import { Owner } from "./Db.js";
-import { UnexpectedError, makeUnexpectedError } from "./Errors.js";
 import {
   MerkleTree,
+  Millis,
+  Timestamp,
+  TimestampString,
   merkleTreeToString,
   unsafeMerkleTreeFromString,
-} from "./MerkleTree.js";
+} from "./Crdt.js";
+import { SecretBox } from "./Crypto.js";
+import { Owner } from "./Db.js";
+import { UnexpectedError, makeUnexpectedError } from "./Errors.js";
 import { Id } from "./Model.js";
 import { Fetch, SyncLock } from "./Platform.js";
 import {
@@ -28,7 +32,6 @@ import {
   SyncResponse,
 } from "./Protobuf.js";
 import { JsonObjectOrArray, Value } from "./Sqlite.js";
-import { Millis, Timestamp, TimestampString } from "./Timestamp.js";
 
 export interface SyncWorker {
   readonly postMessage: (input: SyncWorkerInput) => void;
@@ -64,6 +67,15 @@ export interface NewMessage {
   readonly value: Value;
 }
 
+export const NewMessageEquivalence: Equivalence.Equivalence<NewMessage> = (
+  a,
+  b,
+) =>
+  a.table === b.table &&
+  a.row === b.row &&
+  a.column === b.column &&
+  JSON.stringify(a.value) === JSON.stringify(b.value);
+
 export interface Message extends NewMessage {
   readonly timestamp: TimestampString;
 }

package/src/index.ts

@@ -1,12 +1,12 @@
 export { jsonArrayFrom, jsonObjectFrom } from "kysely/helpers/sqlite";
 export * from "./Config.js";
+export * from "./Crdt.js";
 export * from "./Crypto.js";
 export * from "./Db.js";
 export * from "./DbWorker.js";
 export * from "./Diff.js";
 export * from "./Errors.js";
 export * from "./Evolu.js";
-export * from "./MerkleTree.js";
 export * from "./Model.js";
 export * from "./Murmurhash.js";
 export * from "./Platform.js";
@@ -15,4 +15,3 @@ export * from "./Sql.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
 export * from "./SyncWorker.js";
-export * from "./Timestamp.js";

package/dist/src/MerkleTree.d.ts

@@ -1,15 +0,0 @@
-import { Brand, Option } from "effect";
-import { Millis, Timestamp, TimestampHash } from "./Timestamp.js";
-export interface MerkleTree {
-    readonly hash?: TimestampHash;
-    readonly "0"?: MerkleTree;
-    readonly "1"?: MerkleTree;
-    readonly "2"?: MerkleTree;
-}
-export type MerkleTreeString = string & Brand.Brand<"MerkleTreeString">;
-export declare const initialMerkleTree: MerkleTree;
-export declare const insertIntoMerkleTree: (timestamp: Timestamp) => (tree: MerkleTree) => MerkleTree;
-export declare const diffMerkleTrees: (tree1: MerkleTree, tree2: MerkleTree) => Option.Option<Millis>;
-export declare const merkleTreeToString: (m: MerkleTree) => MerkleTreeString;
-export declare const unsafeMerkleTreeFromString: (m: MerkleTreeString) => MerkleTree;
-//# sourceMappingURL=MerkleTree.d.ts.map

package/dist/src/MerkleTree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MerkleTree.d.ts","sourceRoot":"","sources":["../../src/MerkleTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EACL,MAAM,EACN,SAAS,EACT,aAAa,EAEd,MAAM,gBAAgB,CAAC;AAKxB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;AAExE,eAAO,MAAM,iBAAiB,YAAoC,CAAC;AAwBnE,eAAO,MAAM,oBAAoB,cACnB,SAAS,YACd,UAAU,KAAG,UAKnB,CAAC;AAKJ,eAAO,MAAM,eAAe,UACnB,UAAU,SACV,UAAU,KAChB,aAAa,CAAC,MAAM,CAiBtB,CAAC;AAEF,eAAO,MAAM,kBAAkB,MAAO,UAAU,KAAG,gBACZ,CAAC;AAExC,eAAO,MAAM,0BAA0B,MAAO,gBAAgB,KAAG,UACpC,CAAC"}

package/dist/src/MerkleTree.js

@@ -1,49 +0,0 @@
-import { Option } from "effect";
-import { timestampToHash, } from "./Timestamp.js";
-export const initialMerkleTree = Object.create(null);
-const timestampToKey = (timestamp) => Math.floor(timestamp.millis / 1000 / 60).toString(3);
-const insertKey = (tree, key, hash) => {
-    if (key.length === 0)
-        return tree;
-    const childKey = key[0];
-    const child = tree[childKey] || {};
-    return {
-        ...tree,
-        [childKey]: {
-            ...child,
-            ...insertKey(child, key.slice(1), hash),
-            // @ts-expect-error undefined is OK
-            hash: child.hash ^ hash,
-        },
-    };
-};
-export const insertIntoMerkleTree = (timestamp) => (tree) => {
-    const key = timestampToKey(timestamp);
-    const hash = timestampToHash(timestamp);
-    // @ts-expect-error undefined is OK
-    return insertKey({ ...tree, hash: tree.hash ^ hash }, key, hash);
-};
-const keyToTimestamp = (key) => (parseInt(key.length > 0 ? key : "0", 3) * 1000 * 60);
-export const diffMerkleTrees = (tree1, tree2) => {
-    if (tree1.hash === tree2.hash)
-        return Option.none();
-    for1: for (let node1 = tree1, node2 = tree2, key = "";;) {
-        for (const k of ["0", "1", "2"]) {
-            const next1 = node1[k];
-            const next2 = node2[k];
-            if (!next1 && !next2)
-                continue;
-            if (!next1 || !next2)
-                break;
-            if (next1.hash !== next2.hash) {
-                key += k;
-                node1 = next1;
-                node2 = next2;
-                continue for1;
-            }
-        }
-        return Option.some(keyToTimestamp(key));
-    }
-};
-export const merkleTreeToString = (m) => JSON.stringify(m);
-export const unsafeMerkleTreeFromString = (m) => JSON.parse(m);