@evolu/common 4.1.1 → 5.0.1

package/dist/src/Sync.js

@@ -0,0 +1,126 @@
+import * as Http from "@effect/platform/HttpClient";
+import * as S from "@effect/schema/Schema";
+import { concatBytes } from "@noble/ciphers/utils";
+import { BinaryReader, BinaryWriter } from "@protobuf-ts/runtime";
+import * as Arr from "effect/Array";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import { absurd } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import { Config } from "./Config.js";
+import { merkleTreeToString, unsafeMerkleTreeFromString, } from "./Crdt.js";
+import { SecretBox } from "./Crypto.js";
+import { Owner } from "./Owner.js";
+import * as Protobuf from "./Protobuf.js";
+export const Sync = Context.GenericTag("Sync");
+// To preserve identity.
+export const initialSyncState = { _tag: "SyncStateInitial" };
+export class SyncFactory extends Context.Tag("SyncFactory")() {
+}
+export const createSync = Effect.gen(function* () {
+    const initContext = Context.empty().pipe(Context.add(SecretBox, yield* SecretBox));
+    const afterInitContext = yield* Deferred.make();
+    return Sync.of({
+        init: (owner) => Effect.logDebug(["Sync init", { owner }]).pipe(Effect.tap(Deferred.succeed(afterInitContext, initContext.pipe(Context.add(Owner, owner))))),
+        sync: ({ merkleTree, timestamp, messages }) => Effect.gen(function* () {
+            yield* Effect.logDebug([
+                "Sync request",
+                { merkleTree, timestamp, messages },
+            ]);
+            const secretBox = yield* SecretBox;
+            const owner = yield* Owner;
+            const config = yield* Config;
+            return yield* Effect.forEach(messages || [], ({ timestamp, ...newMessage }) => Effect.map(secretBox.seal(owner.encryptionKey, newMessageToBinary(newMessage)), (content) => ({ timestamp, content }))).pipe(Effect.map((encrypedMessages) => Protobuf.SyncRequest.toBinary({
+                messages: encrypedMessages,
+                userId: owner.id,
+                nodeId: timestamp.node,
+                merkleTree: merkleTreeToString(merkleTree),
+            }, binaryWriteOptions)), Effect.flatMap((body) => Http.request
+                .post(config.syncUrl)
+                .pipe(Http.request.uint8ArrayBody(body, "application/x-protobuf"), Http.client.fetchOk, Http.response.arrayBuffer)), Effect.map((buffer) => Protobuf.SyncResponse.fromBinary(new Uint8Array(buffer), binaryReadOptions)), Effect.flatMap((syncResponse) => Effect.forEach(syncResponse.messages, (encrypedMessage) => Effect.map(secretBox.open(owner.encryptionKey, encrypedMessage.content), (binary) => [binary, encrypedMessage.timestamp])).pipe(Effect.map(Arr.filterMap(([binary, timestamp]) => Option.map(newMessageFromBinary(binary), (newMessage) => ({ ...newMessage, timestamp })))), Effect.map((messages) => ({
+                messages,
+                merkleTree: unsafeMerkleTreeFromString(syncResponse.merkleTree),
+            })), Effect.tap((response) => Effect.logDebug(["Sync response", response])))), Effect.catchTag("RequestError", () => Effect.fail({
+                _tag: "SyncStateIsNotSynced",
+                error: { _tag: "NetworkError" },
+            })), Effect.catchTag("ResponseError", ({ response: { status } }) => {
+                switch (status) {
+                    case 402:
+                        return Effect.fail({
+                            _tag: "SyncStateIsNotSynced",
+                            error: { _tag: "PaymentRequiredError" },
+                        });
+                    default:
+                        return Effect.fail({
+                            _tag: "SyncStateIsNotSynced",
+                            error: { _tag: "ServerError", status },
+                        });
+                }
+            }));
+        }).pipe((effect) => Effect.flatMap(Deferred.await(afterInitContext), (context) => Effect.provide(effect, context))),
+    });
+});
+const newMessageToBinary = ({ value, ...rest }) => concatBytes(version1, Protobuf.MessageContent.toBinary({ value: valueToProtobuf(value), ...rest }, binaryWriteOptions));
+const version1 = new Uint8Array([0, 1]);
+const valueToProtobuf = (value) => {
+    switch (typeof value) {
+        case "string":
+            return { oneofKind: "stringValue", stringValue: value };
+        case "number":
+            return {
+                oneofKind: "numberValue",
+                numberValue: S.encodeSync(S.NumberFromString)(value),
+            };
+    }
+    if (value == null)
+        return { oneofKind: undefined };
+    if (Predicate.isUint8Array(value))
+        return { oneofKind: "bytesValue", bytesValue: value };
+    return { oneofKind: "jsonValue", jsonValue: JSON.stringify(value) };
+};
+// The 'protobuf-ts' uses TextEncoder, but polyfill fast-text-encoding
+// doesn't support the fatal option.
+// https://github.com/timostamm/protobuf-ts/issues/184#issuecomment-1658443836
+const binaryWriteOptions = {
+    writerFactory: () => new BinaryWriter({
+        encode: (input) => new TextEncoder().encode(input),
+    }),
+};
+const binaryReadOptions = {
+    readerFactory: (bytes) => new BinaryReader(bytes, {
+        decode: (input) => new TextDecoder().decode(input),
+    }),
+};
+const newMessageFromBinary = (binary) => {
+    if (!startsWithArray(binary, version1))
+        return Option.none();
+    const { value, ...content } = Protobuf.MessageContent.fromBinary(binary.slice(version1.length), binaryReadOptions);
+    return Option.some({ value: valueFromProtobuf(value), ...content });
+};
+const startsWithArray = (array, prefix) => {
+    if (prefix.length > array.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++) {
+        if (array[i] !== prefix[i])
+            return false;
+    }
+    return true;
+};
+const valueFromProtobuf = (value) => {
+    switch (value.oneofKind) {
+        case "numberValue":
+            return S.decodeSync(S.NumberFromString)(value.numberValue);
+        case "stringValue":
+            return value.stringValue;
+        case "bytesValue":
+            return value.bytesValue;
+        case "jsonValue":
+            return JSON.parse(value.jsonValue);
+        case undefined:
+            return null;
+        default:
+            return absurd(value);
+    }
+};

package/dist/src/index.d.ts

@@ -2,18 +2,15 @@ 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 "./ErrorStore.js";
+export * from "./Error.js";
 export * from "./Evolu.js";
 export * from "./Model.js";
 export * from "./Murmurhash.js";
-export * from "./OnCompletes.js";
 export * from "./Owner.js";
 export * from "./Platform.js";
 export * from "./Protobuf.js";
-export * from "./Public.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
-export * from "./SyncWorker.js";
+export * from "./Sync.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/dist/src/index.js

@@ -2,17 +2,14 @@ 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 "./ErrorStore.js";
+export * from "./Error.js";
 export * from "./Evolu.js";
 export * from "./Model.js";
 export * from "./Murmurhash.js";
-export * from "./OnCompletes.js";
 export * from "./Owner.js";
 export * from "./Platform.js";
 export * from "./Protobuf.js";
-export * from "./Public.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
-export * from "./SyncWorker.js";
+export * from "./Sync.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/common",
-  "version": "4.1.1",
+  "version": "5.0.1",
   "description": "Local-first platform designed for privacy, ease of use, and no vendor lock-in to sync and backup people's lifetime data",
   "keywords": [
     "evolu",
@@ -44,28 +44,30 @@
     "README.md"
   ],
   "dependencies": {
-    "@noble/ciphers": "^0.5.1",
+    "@noble/ciphers": "^0.5.2",
     "@noble/hashes": "^1.4.0",
     "@protobuf-ts/runtime": "^2.9.4",
-    "@scure/bip39": "^1.2.2",
+    "@scure/bip39": "^1.3.0",
     "kysely": "^0.27.3",
-    "nanoid": "^5.0.6"
+    "nanoid": "^5.0.7"
   },
   "devDependencies": {
-    "@effect/schema": "^0.64.10",
+    "@effect/platform": "^0.50.7",
+    "@effect/schema": "^0.66.10",
     "@protobuf-ts/plugin": "^2.9.4",
     "@protobuf-ts/protoc": "^2.9.4",
     "array-shuffle": "^3.0.0",
-    "effect": "2.4.10",
+    "effect": "^3.0.7",
     "eslint": "^8.57.0",
-    "typescript": "^5.4.3",
-    "vitest": "^1.4.0",
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.2",
     "@evolu/tsconfig": "0.0.2",
     "eslint-config-evolu": "1.0.0"
   },
   "peerDependencies": {
-    "@effect/schema": "^0.64.10",
-    "effect": "2.4.10"
+    "@effect/platform": "^0.50.7",
+    "@effect/schema": "^0.66.10",
+    "effect": "^3.0.0"
   },
   "publishConfig": {
     "access": "public"

package/src/Config.ts

@@ -1,62 +1,103 @@
 import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
-import { CreateIndexBuilder } from "kysely";
+import * as LogLevel from "effect/LogLevel";
+import * as Logger from "effect/Logger";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as Match from "effect/Match";
 
 export interface Config {
   /**
-   * Use the `indexes` property to define SQLite indexes.
+   * URL to reload browser tabs after {@link Owner} reset or restore.
    *
-   * Table and column names are not typed because Kysely doesn't support it.
-   *
-   * https://medium.com/@JasonWyatt/squeezing-performance-from-sqlite-indexes-indexes-c4e175f3c346
-   *
-   * @example
-   *   const indexes = [
-   *     createIndex("indexTodoCreatedAt").on("todo").column("createdAt"),
-   *
-   *     createIndex("indexTodoCategoryCreatedAt")
-   *       .on("todoCategory")
-   *       .column("createdAt"),
-   *   ];
+   * The default value is `/`.
    */
-  readonly indexes: ReadonlyArray<CreateIndexBuilder<any>>;
-
-  /** Log SQL. */
-  readonly logSql: boolean;
+  reloadUrl: string;
 
   /**
-   * Alternate URL to reload browser tabs after {@link Owner} reset or restore.
-   * The default value is `/`.
+   * URL for Evolu sync and backup server.
+   *
+   * The default value is `https://evolu.world`.
    */
-  readonly reloadUrl: string;
+  syncUrl: string;
 
-  /** Alternate URL for Evolu sync and backup server. */
-  readonly syncUrl: string;
+  /**
+   * Evolu is multitenant - it can run more instances concurrently. Every Evolu
+   * instance has to have its own unique name. Database files are separated and
+   * invisible to each other.
+   *
+   * The default value is: `Evolu`.
+   */
+  name: string;
 
   /**
-   * Evolu application name. For now, this is only useful for localhost
-   * development, where we want each application to have its own database. The
-   * default value is: "Evolu".
+   * Maximum physical clock drift allowed in ms.
+   *
+   * The default value is 5 * 60 * 1000 (5 minutes).
    */
-  readonly name: string;
+  maxDrift: number;
 
   /**
-   * Maximum physical clock drift allowed in ms. The default value is 5 * 60 *
-   * 1000 (5 minutes).
+   * Setting the minimum log level. The default value is `none`.
+   *
+   * For development, use `trace` to log all events and `debug` to log only
+   * events with values. For production, use `warning`.
    */
-  readonly maxDrift: number;
+  minimumLogLevel: "none" | "trace" | "debug" | "warning";
 }
 
-export const Config = Context.GenericTag<Config>("@services/Config");
+export const Config = Context.GenericTag<Config>("Config");
 
-const defaultConfig: Config = {
-  indexes: [],
-  logSql: false,
+export const defaultConfig: Config = {
   reloadUrl: "/",
   syncUrl: "https://evolu.world",
   name: "Evolu",
   maxDrift: 5 * 60 * 1000,
+  minimumLogLevel: "none",
 };
 
-export const ConfigLive = (config?: Partial<Config>): Layer.Layer<Config> =>
-  Layer.succeed(Config, Config.of({ ...defaultConfig, ...config }));
+/** https://effect.website/docs/guides/runtime */
+export const createRuntime = (
+  partialConfig?: Partial<Config>,
+): ManagedRuntime.ManagedRuntime<Config, never> => {
+  const config = { ...defaultConfig, ...partialConfig };
+  const ConfigLive = Layer.succeed(Config, config);
+
+  const minimumLogLevel = Match.value(config.minimumLogLevel).pipe(
+    Match.when("debug", () => LogLevel.Debug),
+    Match.when("none", () => LogLevel.None),
+    Match.when("trace", () => LogLevel.Trace),
+    Match.when("warning", () => LogLevel.Warning),
+    Match.exhaustive,
+  );
+
+  const evoluLayer =
+    config.minimumLogLevel === "none"
+      ? ConfigLive
+      : Layer.mergeAll(
+          ConfigLive,
+          Logger.minimumLogLevel(minimumLogLevel),
+          Logger.replace(Logger.defaultLogger, makeEvoluLogger(config.name)),
+        );
+
+  return ManagedRuntime.make(evoluLayer);
+};
+
+// TODO: Spans and Effect native variadic log args.
+const makeEvoluLogger = (name: string) =>
+  Logger.make(({ logLevel, message, date }) => {
+    const fn =
+      logLevel._tag === "Warning"
+        ? "warn"
+        : logLevel._tag === "Error"
+          ? "error"
+          : "log";
+
+    const hours = date.getHours().toString().padStart(2, "0");
+    const minutes = date.getMinutes().toString().padStart(2, "0");
+    const seconds = date.getSeconds().toString().padStart(2, "0");
+    const milliseconds = date.getMilliseconds().toString().padStart(3, "0");
+    const formattedDate = `${hours}:${minutes}:${seconds}:${milliseconds}`;
+
+    const messages: unknown[] = Array.isArray(message) ? message : [message];
+    globalThis.console[fn](`${formattedDate} [${name}]`, ...messages);
+  });

package/src/Crdt.ts

@@ -1,4 +1,5 @@
 import * as S from "@effect/schema/Schema";
+import * as Arr from "effect/Array";
 import * as Brand from "effect/Brand";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
@@ -7,7 +8,6 @@ import { pipe } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Number from "effect/Number";
 import * as Option from "effect/Option";
-import * as ReadonlyArray from "effect/ReadonlyArray";
 import * as String from "effect/String";
 import { Config } from "./Config.js";
 import { NanoIdGenerator, NodeId } from "./Crypto.js";
@@ -36,7 +36,7 @@ export const AllowedTimeRange = {
  * the device clock is out of range, Evolu will not store data until it's
  * fixed.
  */
-export const Millis = S.number.pipe(
+export const Millis = S.Number.pipe(
   S.greaterThan(AllowedTimeRange.greaterThan),
   S.lessThan(AllowedTimeRange.lessThan),
   S.brand("Millis"),
@@ -48,7 +48,7 @@ export const initialMillis = S.decodeSync(Millis)(
   AllowedTimeRange.greaterThan + 1,
 );
 
-export const Counter = S.number.pipe(S.between(0, 65535), S.brand("Counter"));
+export const Counter = S.Number.pipe(S.between(0, 65535), S.brand("Counter"));
 export type Counter = S.Schema.Type<typeof Counter>;
 
 const initialCounter = S.decodeSync(Counter)(0);
@@ -87,7 +87,7 @@ export const makeSyncTimestamp = (
 });
 
 export const makeInitialTimestamp = NanoIdGenerator.pipe(
-  Effect.flatMap(({ nanoidAsNodeId }) => nanoidAsNodeId),
+  Effect.flatMap(({ nodeId }) => nodeId),
   Effect.map(
     (node): Timestamp => ({
       millis: initialMillis,
@@ -97,15 +97,13 @@ export const makeInitialTimestamp = NanoIdGenerator.pipe(
   ),
 );
 
-export interface Time {
-  readonly now: Effect.Effect<Millis, TimestampTimeOutOfRangeError>;
-}
-
-export const Time = Context.GenericTag<Time>("@services/Time");
-
-export const TimeLive = Layer.succeed(
+export class Time extends Context.Tag("Time")<
   Time,
-  Time.of({
+  {
+    readonly now: Effect.Effect<Millis, TimestampTimeOutOfRangeError>;
+  }
+>() {
+  static Live = Layer.succeed(Time, {
     now: Effect.suspend(() => S.decode(Millis)(Date.now())).pipe(
       Effect.catchTag("ParseError", () =>
         Effect.fail<TimestampTimeOutOfRangeError>({
@@ -113,8 +111,8 @@ export const TimeLive = Layer.succeed(
         }),
       ),
     ),
-  }),
-);
+  });
+}
 
 /**
  * The TimestampError type represents all Timestamp-related errors. If such an
@@ -146,39 +144,33 @@ export interface TimestampTimeOutOfRangeError {
   readonly _tag: "TimestampTimeOutOfRangeError";
 }
 
-const getNextMillis = (
-  millis: ReadonlyArray<Millis>,
-): Effect.Effect<
-  Millis,
-  TimestampDriftError | TimestampTimeOutOfRangeError,
-  Time | Config
-> =>
-  Effect.gen(function* (_) {
-    const time = yield* _(Time);
-    const config = yield* _(Config);
+const getNextMillis = (millis: ReadonlyArray<Millis>) =>
+  Effect.gen(function* () {
+    const time = yield* Time;
+    const config = yield* Config;
 
-    const now = yield* _(time.now);
+    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,
-        }),
-      );
+      yield* Effect.fail<TimestampDriftError>({
+        _tag: "TimestampDriftError",
+        now,
+        next,
+      });
 
     return next;
   });
 
-const incrementCounter = (
-  counter: Counter,
-): Either.Either<Counter, TimestampCounterOverflowError> =>
+const incrementCounter = (counter: Counter) =>
   pipe(
     Number.increment(counter),
     S.decodeEither(Counter),
-    Either.mapLeft(() => ({ _tag: "TimestampCounterOverflowError" })),
+    Either.mapLeft(
+      (): TimestampCounterOverflowError => ({
+        _tag: "TimestampCounterOverflowError",
+      }),
+    ),
   );
 
 const counterMin = S.decodeSync(Counter)(0);
@@ -192,11 +184,11 @@ export const sendTimestamp = (
   | TimestampTimeOutOfRangeError,
   Time | Config
 > =>
-  Effect.gen(function* (_) {
-    const millis = yield* _(getNextMillis([timestamp.millis]));
+  Effect.gen(function* () {
+    const millis = yield* getNextMillis([timestamp.millis]);
     const counter =
       millis === timestamp.millis
-        ? yield* _(incrementCounter(timestamp.counter))
+        ? yield* incrementCounter(timestamp.counter)
         : counterMin;
     return { ...timestamp, millis, counter };
   });
@@ -217,23 +209,19 @@ export const receiveTimestamp = ({
 > =>
   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),
-    );
+      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 };
   });
@@ -262,17 +250,15 @@ export const millisToMerkleTreePath = (millis: Millis): MerkleTreePath =>
     .toString(3)
     .split("") as MerkleTreePath;
 
-const merkleTreePathToMillis = (path: MerkleTreePath): Millis =>
+const merkleTreePathToMillis = (path: MerkleTreePath) =>
   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 xorTimestampHashes = (a: TimestampHash | undefined, b: TimestampHash) =>
+  ((a || 0) ^ b) as TimestampHash;
 
 const insertKey = (
   tree: MerkleTree,
@@ -292,23 +278,22 @@ const insertKey = (
   };
 };
 
-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,
-    );
-  };
+export const insertIntoMerkleTree = (
+  tree: MerkleTree,
+  timestamp: Timestamp,
+): 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> =>
+const getSortedMerkleTreeKeys = (tree: MerkleTree) =>
   sortedMerkleTreeKeys.filter((key) => key in tree);
 
 export const diffMerkleTrees = (
@@ -326,7 +311,7 @@ export const diffMerkleTrees = (
   // the top of this function should pass)
   // eslint-disable-next-line no-constant-condition
   while (1) {
-    const keys = ReadonlyArray.dedupeWith(
+    const keys = Arr.dedupeWith(
       getSortedMerkleTreeKeys(node1).concat(getSortedMerkleTreeKeys(node2)),
       String.Equivalence,
     );