@effectstream/runtime 0.100.20 → 0.100.22

package/test/reproduction/sanity.test.ts

@@ -2,26 +2,90 @@
  * Sanity end-to-end test for the synthetic `test` chain (no fixes required).
  *
  * Proves the foundation this PR adds works: a TEST_MAIN clock + a TEST_PARALLEL
- * chain sync through the real runtime (`start()`), a config-declared event is
- * processed into `effectstream.primitive_accounting`, and committed state
- * survives a restart.
- *
- * Runs on whichever backend `setupHarness` picks: the default in-memory PGLite
- * (no external dependency) or real Postgres when `PGLITE=false`. Either way
- * each node runs in its own subprocess (see harness.ts / node-runner.ts), so a
- * restart is a genuine new OS process booting against the same database.
+ * chain sync through the real runtime (`start()` + PGLite), a config-declared
+ * event is processed into `effectstream.primitive_accounting`, and committed
+ * state survives a restart.
  *
  * (The buffering / resume / fast-catchup reproduction tests land alongside their
  * fixes in follow-up PRs — they assert behaviour that only those fixes provide.)
  */
 import { afterAll, beforeAll, expect, test } from "bun:test";
+import {
+  ConfigBuilder,
+  ConfigNetworkType,
+  ConfigSyncProtocolType,
+} from "@effectstream/config";
+import { TestChainControl } from "@effectstream/sync";
 import {
   countEventRows,
   type Harness,
   latestFinalizedHeight,
   setupHarness,
+  TEST_PRIMITIVE_TYPE,
+  waitForHeight,
+  waitUntilStable,
 } from "./harness.ts";
 
+const START_TIME = 1_700_000_000_000;
+const BLOCK_TIME_MS = 1000;
+
+function buildConfig() {
+  return new ConfigBuilder()
+    .setNamespace((b) => b.setSecurityNamespace("sync-sanity"))
+    .buildNetworks((b) =>
+      b
+        .addNetwork({
+          name: "clock",
+          type: ConfigNetworkType.TEST,
+          startTime: START_TIME,
+          blockTimeMS: BLOCK_TIME_MS,
+        })
+        .addNetwork({
+          name: "chainP",
+          type: ConfigNetworkType.TEST,
+          startTime: START_TIME,
+          blockTimeMS: BLOCK_TIME_MS,
+        })
+    )
+    .buildDeployments((b) => b)
+    .buildSyncProtocols((b) =>
+      b
+        .addMain(
+          (n) => n.clock,
+          () => ({
+            name: "mainClock",
+            type: ConfigSyncProtocolType.TEST_MAIN,
+            startBlockHeight: 1,
+            pollingInterval: 30,
+            stepSize: 1000,
+          }),
+        )
+        .addParallel(
+          (n) => (n as any).chainP,
+          () => ({
+            name: "parallelP",
+            type: ConfigSyncProtocolType.TEST_PARALLEL,
+            startBlockHeight: 1,
+            pollingInterval: 30,
+            stepSize: 1000,
+            delayMs: 0,
+            events: [{ atBlock: 50, payload: { marker: "evt50" } }],
+          }),
+        )
+    )
+    .buildPrimitives((b) =>
+      b.addPrimitive(
+        (sp) => (sp as any).parallelP,
+        () => ({
+          name: "testEvt",
+          type: TEST_PRIMITIVE_TYPE,
+          startBlockHeight: 1,
+        }),
+      )
+    )
+    .build();
+}
+
 let h: Harness;
 
 beforeAll(async () => {
@@ -33,42 +97,29 @@ afterAll(async () => {
 });
 
 test("test chain syncs, processes a configured event, and survives restart", async () => {
-  const events = [{ atBlock: 50, marker: "evt50" }];
-
   // Parallel tip (200) stays ahead of the main clock (100) so the merge is not
   // gated at the chunk boundary.
-  await h.runToHeight({
-    events,
-    tips: { mainClock: 100, parallelP: 200 },
-    target: 100,
-    apiPort: 19131,
-  });
+  TestChainControl.setTip("mainClock", 100);
+  TestChainControl.setTip("parallelP", 200);
+
+  const n1 = await h.runNode({ config: buildConfig(), apiPort: 19131 });
+  await waitForHeight(n1, h.pool, 100);
+  await waitUntilStable(n1, h.pool);
 
-  const height1 = await latestFinalizedHeight(h.pool);
-  const events1 = await countEventRows(h.pool, "evt50");
-  console.log(
-    `[sanity] after sync:    height ${height1} (expect 100), ` +
-      `evt50 rows ${events1} (expect 1)`,
-  );
-  expect(height1).toBe(100);
+  expect(await latestFinalizedHeight(h.pool)).toBe(100);
   // The event declared at block 50 was processed into primitive_accounting.
-  expect(events1).toBe(1);
+  expect(await countEventRows(h.pool, "evt50")).toBe(1);
+  await n1.stop();
+
+  // Restart: committed state must persist (chain already fully caught up).
+  await h.simulateRestart();
+  TestChainControl.setTip("mainClock", 100);
+  TestChainControl.setTip("parallelP", 200);
 
-  // Restart: a new process boots against the same database. Committed state must
-  // persist; the chain is already fully caught up, so nothing new is produced.
-  await h.runToHeight({
-    events,
-    tips: { mainClock: 100, parallelP: 200 },
-    target: 100,
-    apiPort: 19132,
-  });
+  const n2 = await h.runNode({ config: buildConfig(), apiPort: 19132 });
+  await waitUntilStable(n2, h.pool);
 
-  const height2 = await latestFinalizedHeight(h.pool);
-  const events2 = await countEventRows(h.pool, "evt50");
-  console.log(
-    `[sanity] after restart: height ${height2} (expect 100, was ${height1}), ` +
-      `evt50 rows ${events2} (expect 1, was ${events1})`,
-  );
-  expect(height2).toBe(100);
-  expect(events2).toBe(1);
+  expect(await latestFinalizedHeight(h.pool)).toBe(100);
+  expect(await countEventRows(h.pool, "evt50")).toBe(1);
+  await n2.stop();
 }, 60_000);

package/conciseinputhash-determinism.md

@@ -1,114 +0,0 @@
-# Bug Report: non-deterministic `effectstream_tx_hash` (`conciseInputHash`)
-
-**Package:** `@effectstream/node-sdk` — runtime
-**Location:** `runtime/src/process-blocks.ts` (scheduled-input loop, STEP 5)
-**Severity:** Medium — silent cross-node state divergence in a derived column; not (currently) consensus-relevant
-**Status:** Open
-
----
-
-## Summary
-
-When the runtime records the result of a **scheduled** STF input, it fabricates the
-`effectstream_tx_hash` with `Math.random()`. The value is therefore different on every run
-and on every node, so two nodes that replay the exact same source blocks produce **different
-`rollup_input_result.effectstream_tx_hash` values** for the same input. For a framework whose
-core promise is "the database is a pure function of the source blocks," this is a determinism
-hole.
-
-## The code
-
-`runtime/src/process-blocks.ts`, inside the loop over `scheduledData` (STEP 5):
-
-```ts
-const conciseInputHash = `0x${
-  Array(64).fill(0).map(() => Math.floor(Math.random() * 16).toString(16)).join("")
-}`;
-yield* until(
-  insertGameInputResult.run({
-    id: data.id,
-    success,
-    effectstream_tx_hash: Buffer.from(conciseInputHash),
-    index_in_block,
-    block_height: value.blockNumber,
-  }, dbConn),
-);
-```
-
-This runs only for **scheduled** inputs (engine-queued timers / derived inputs that have no
-real on-chain transaction), so the engine has to synthesize a hash. It does so randomly.
-
-## Why it matters / why it's currently masked
-
-- **Block hash is unaffected.** `generateEffectstreamBlockHash` (`@effectstream/crypto`) hashes
-  `blockInfo[].blockHash` (source-chain hashes) + the previous block hash — never
-  `effectstream_tx_hash`. So the block-hash chain stays deterministic; the divergence is
-  confined to the `rollup_input_result.effectstream_tx_hash` column and anything that reads it.
-- **Masked in tests.** The reproduction tests use a no-op STF (`stateMachinePayload: null`),
-  which schedules no STF inputs, so this branch never executes. That is exactly why
-  `consistency-snapshot.ts` lists `effectstream_tx_hash` in `VOLATILE_COLUMNS` and excludes it
-  — the snapshot would otherwise diff on every run once real STFs are involved.
-
-## Two existing quirks to fix alongside
-
-1. **Encoding bug.** `Buffer.from(conciseInputHash)` is given the *string* `"0x" + 64 hex`
-   with no encoding, so it stores 66 **UTF-8** bytes, not the 32 decoded bytes. Whatever
-   derivation replaces `Math.random()`, encode it deliberately (`Buffer.from(hex, "hex")`, or
-   commit to the `0x`-string form consistently).
-
-2. **Ordering prerequisite (the real root).** The hash inputs that give uniqueness
-   (`index_in_block`, and the STF execution order itself) are only deterministic if the
-   `scheduledData` order is deterministic. Today it is not fully:
-   ```ts
-   // TODO What should be the order of the scheduled data - per id?
-   const scheduledData = [...scheduledData1, ...scheduledData2];
-   ```
-   - `scheduledData1` (block-scheduled) is `ORDER BY id ASC` → deterministic given a
-     deterministic scheduling history.
-   - `scheduledData2` (timestamp-scheduled) is `ORDER BY future_ms_timestamp ASC` **only** —
-     **same-timestamp rows have no tiebreak**, so their order is arbitrary.
-
-   This is bigger than the hash: the same order drives **STF execution** and the
-   **`randomGenerator` (Prando) draw sequence**. If it isn't pinned, game state itself can
-   diverge; the random tx-hash is just the most visible symptom.
-
-## Suggested fixes (in order)
-
-### 1. Pin the scheduled-input order (prerequisite, do first)
-Give the queries a total deterministic sort and a deterministic merge:
-- timestamp list → `ORDER BY future_ms_timestamp ASC, id ASC` (break ties by `id`);
-- keep block-scheduled before timestamp-scheduled (or merge both by a single deterministic
-  key). This is required for deterministic STFs regardless of the hash, and it makes
-  `index_in_block` deterministic.
-
-### 2. Derive the hash deterministically (recommended)
-Replace `Math.random()` with a content-addressed hash over the input's identity + position,
-reusing the `sha512` already used for the block hash:
-
-```
-effectstream_tx_hash =
-  sha512(block_height ‖ index_in_block ‖ input_data ‖ from_address ‖ from_address_type)
-```
-
-- `block_height` + `index_in_block` give **uniqueness** (one result per position; needs fix #1).
-- `input_data` + `from_address` + `from_address_type` make it **content-addressed**
-  (tx-hash-like, collision-resistant). All are non-null columns already on the scheduled row.
-
-### Alternatives considered
-- **Reuse the seeded `Prando` (`new Prando(blockHash)`):** smallest change and deterministic,
-  but the shared `randomGenerator` is also consumed by the STFs — drawing hash bytes from it
-  would shift the RNG stream every later STF sees. Would require a *separate*
-  `new Prando(blockHash + ":txhash")`. Produces opaque (non-content) hashes.
-- **`H(data.id, block_height)`:** `id` is a global SERIAL counter — a weaker determinism
-  guarantee than the block-scoped `index_in_block`, and `block_height` adds nothing once `id`
-  is unique. Prefer `index_in_block`.
-- **Provenance: `H(origin_tx_hash, …)`:** ties to the originating real tx, but
-  `origin_tx_hash` is `null` for timestamp-scheduled inputs, so it needs a fallback.
-
-## Verification
-- Add a determinism test with a **real** STF (one that schedules a derived input) and assert
-  two from-scratch syncs produce identical `rollup_input_result.effectstream_tx_hash` —
-  i.e. drop `effectstream_tx_hash` from `VOLATILE_COLUMNS` once fixed and confirm
-  `consistency.test.ts` Test A still passes.
-- Cover the timestamp-tie case explicitly: schedule ≥2 inputs at the same `future_ms_timestamp`
-  and assert identical ordering / hashes across runs.

package/src/api/apply-status.ts

@@ -1,30 +0,0 @@
-/**
- * Apply-stage liveness for /debug/metrics.
- *
- * The serial finalized-block loop in main.ts calls recordAppliedBlock() right
- * after each block COMMITs; the /debug/metrics handler reads `appliedBlockStatus`
- * to report true lag (now − applied block timestamp). Unlike a protocol's `buf`
- * (fetch backlog), this stays high when the node is write/apply-bound.
- *
- * Process-global: one node runs per process, so a module-level singleton keeps
- * main.ts to a single call instead of threading a ref through startHttpServer.
- */
-export type AppliedBlockStatus = {
-  blockNumber: number | null;
-  timestamp: number | null;
-  appliedAtMs: number | null;
-};
-
-export const appliedBlockStatus: AppliedBlockStatus = {
-  blockNumber: null,
-  timestamp: null,
-  appliedAtMs: null,
-};
-
-export function recordAppliedBlock(
-  block: { blockNumber: number | bigint; timestamp: number | bigint },
-): void {
-  appliedBlockStatus.blockNumber = Number(block.blockNumber);
-  appliedBlockStatus.timestamp = Number(block.timestamp);
-  appliedBlockStatus.appliedAtMs = Date.now();
-}

package/src/coalesce.ts

@@ -1,291 +0,0 @@
-/** Empty-block coalescing during deep catch-up: fold consecutive no-op blocks into one transaction. */
-import type { ChainBlock } from "@effectstream/sync";
-import { call, type Operation, race, sleep, until } from "effection";
-import type { Pool, PoolClient } from "pg";
-import {
-  acquireDBMutex,
-  blockHeightDone,
-  deleteEmptyBlocks,
-  getEarliestScheduledBlockHeight,
-  getEarliestScheduledTimestamp,
-  getMigrationsForBlockHeight,
-  isTransientPgError,
-  poolErrors,
-  releaseDBMutex,
-  removePages,
-  saveLastBlock,
-  upsertPage,
-} from "@effectstream/db";
-import { Buffer } from "node:buffer";
-import { ComponentNames, log, SeverityNumber } from "@effectstream/log";
-import { generateEffectstreamBlockHash, Prando } from "@effectstream/crypto";
-import type { EffectstreamBlockHash } from "@effectstream/utils";
-import type { DBMigrations } from "@effectstream/runtime";
-
-/** Scheduled-input boundaries sampled once at run start (stable until the next non-empty block). */
-export type EmptyRunBoundaries = {
-  minScheduledBlockHeight: number | null;
-  minScheduledTimestampMs: number | null;
-};
-
-export const MAX_EMPTY_RUN = 5_000;
-
-const MAX_RETRY_BACKOFF_MS = 5_000;
-
-export function* loadEmptyRunBoundaries(
-  dbConn: Pool,
-): Operation<EmptyRunBoundaries> {
-  const [bh] = yield* until(getEarliestScheduledBlockHeight.run(undefined, dbConn));
-  const [ts] = yield* until(getEarliestScheduledTimestamp.run(undefined, dbConn));
-  return {
-    minScheduledBlockHeight: bh?.min_block_height ?? null,
-    minScheduledTimestampMs: ts?.min_timestamp != null
-      ? new Date(ts.min_timestamp).getTime()
-      : null,
-  };
-}
-
-/** Mirrors the empty-block checks in process-blocks.ts without DB/STF work. */
-export function isCoalescableEmptyBlock(
-  value: ChainBlock,
-  boundaries: EmptyRunBoundaries,
-  migrations: DBMigrations[] | undefined,
-): boolean {
-  if (value.primitives.length > 0) return false;
-  if (
-    getMigrationsForBlockHeight(migrations, value.blockNumber, value.blockNumber)
-      .length > 0
-  ) {
-    return false;
-  }
-  if (
-    boundaries.minScheduledBlockHeight != null &&
-    value.blockNumber >= boundaries.minScheduledBlockHeight
-  ) {
-    return false;
-  }
-  if (
-    boundaries.minScheduledTimestampMs != null &&
-    boundaries.minScheduledTimestampMs <= value.timestamp
-  ) {
-    return false;
-  }
-  return true;
-}
-
-export function* processCoalescedEmptyRun(
-  endpoint: ChainBlock,
-  pool: Pool,
-  previousBlockHash: EffectstreamBlockHash | null,
-): Operation<void> {
-  const lockName = `processing-blocks:${endpoint.blockNumber}`;
-  let attempt = 0;
-  while (true) {
-    let dbClient: PoolClient | undefined;
-    let transientErr: unknown;
-    try {
-      yield* acquireDBMutex(lockName);
-      dbClient = yield* until(pool.connect());
-      yield* writeEndpoint(
-        endpoint,
-        dbClient as unknown as Pool,
-        previousBlockHash,
-      );
-      return;
-    } catch (err) {
-      if (!isTransientPgError(err)) throw err;
-      transientErr = err;
-    } finally {
-      releaseDBMutex(lockName);
-      if (dbClient) {
-        try {
-          dbClient.release(transientErr as Error | undefined);
-        } catch {
-          /* already released/destroyed */
-        }
-      }
-    }
-
-    attempt++;
-    poolErrors.log(transientErr, ["sync-write"]);
-    const backoffMs = Math.min(500 * 2 ** (attempt - 1), MAX_RETRY_BACKOFF_MS);
-    log.local(
-      ComponentNames.EFFECTSTREAM_SYNC,
-      "block-processing",
-      SeverityNumber.WARN,
-      (l) =>
-        l(
-          `transient db error on coalesced run → block ${endpoint.blockNumber}; retry #${attempt} in ${backoffMs}ms: ${
-            String(transientErr)
-          }`,
-        ),
-    );
-    yield* sleep(backoffMs);
-  }
-}
-
-/** One transaction for the run endpoint; matches process-blocks.ts empty-block writes. */
-function* writeEndpoint(
-  endpoint: ChainBlock,
-  dbConn: Pool,
-  previousBlockHash: EffectstreamBlockHash | null,
-): Operation<void> {
-  const blockHash = generateEffectstreamBlockHash(endpoint, previousBlockHash);
-  const seed = new Prando(blockHash).seed.toString();
-  try {
-    yield* until(dbConn.query("BEGIN"));
-
-    yield* call(() =>
-      saveLastBlock.run({
-        block_height: endpoint.blockNumber,
-        ver: 0,
-        main_chain_block_hash: Buffer.from(endpoint.blockNumber.toString()),
-        seed,
-        ms_timestamp: new Date(endpoint.timestamp),
-      }, dbConn)
-    );
-
-    yield* call(() => deleteEmptyBlocks.run(undefined, dbConn));
-    yield* call(() =>
-      blockHeightDone.run({
-        block_hash: Buffer.from("0x0"),
-        block_height: endpoint.blockNumber,
-      }, dbConn)
-    );
-
-    for (const { protocol_name, lastPage } of endpoint.resumePages) {
-      yield* until(
-        upsertPage.run({
-          protocol_name,
-          page_number: lastPage.ownBlockNumber,
-          page: JSON.stringify(lastPage),
-        }, dbConn),
-      );
-      yield* until(
-        removePages.run({
-          protocol_name,
-          page_number: lastPage.ownBlockNumber,
-        }, dbConn),
-      );
-    }
-
-    yield* until(dbConn.query("COMMIT"));
-    poolErrors.markHealthy();
-  } catch (err) {
-    try {
-      yield* until(dbConn.query("ROLLBACK"));
-    } catch (rollbackErr) {
-      log.remote(
-        ComponentNames.EFFECTSTREAM_SYNC,
-        "block-processing",
-        SeverityNumber.WARN,
-        (l) =>
-          l(
-            `ROLLBACK failed for coalesced run → block ${endpoint.blockNumber} (connection likely dead): ${
-              String(rollbackErr)
-            }`,
-          ),
-      );
-    }
-    throw err;
-  }
-}
-
-export type FinalizedBlockSubscription = {
-  next(): Operation<IteratorResult<ChainBlock, void>>;
-};
-
-function* readFinalizedBlock(
-  subscription: FinalizedBlockSubscription,
-): Operation<{ tag: "item"; value: ChainBlock } | { tag: "done" }> {
-  const n = yield* subscription.next();
-  if (n.done) return { tag: "done" };
-  // IteratorResult value type does not narrow on `done` under non-strict tsconfig.
-  return { tag: "item", value: n.value as ChainBlock };
-}
-
-export type EmptyBlockCoalescerOptions = {
-  enabled: boolean;
-  subscription: FinalizedBlockSubscription;
-  pool: Pool;
-  migrations: DBMigrations[] | undefined;
-  /** Coalesce only while `now - block.timestamp` exceeds this. Undefined disables lag gating. */
-  lagThresholdMs: number | undefined;
-  getPreviousBlockHash: () => EffectstreamBlockHash | null;
-  onFlush: (endpoint: ChainBlock, length: number) => void;
-  idleFlushMs?: number;
-};
-
-export type EmptyBlockCoalescer = {
-  advance(): Operation<ChainBlock | undefined>;
-};
-
-export function createEmptyBlockCoalescer(
-  opts: EmptyBlockCoalescerOptions,
-): EmptyBlockCoalescer {
-  const idleFlushMs = opts.idleFlushMs ?? 250;
-  let pendingRun:
-    | { endpoint: ChainBlock; boundaries: EmptyRunBoundaries; length: number }
-    | null = null;
-
-  function* flush(): Operation<void> {
-    if (pendingRun == null) return;
-    const { endpoint, length } = pendingRun;
-    yield* processCoalescedEmptyRun(
-      endpoint,
-      opts.pool,
-      opts.getPreviousBlockHash(),
-    );
-    pendingRun = null;
-    opts.onFlush(endpoint, length);
-  }
-
-  function* nextItem(): Operation<
-    { tag: "item"; value: ChainBlock } | { tag: "done" } | { tag: "idle" }
-  > {
-    if (pendingRun == null) return yield* readFinalizedBlock(opts.subscription);
-    return yield* race([
-      readFinalizedBlock(opts.subscription),
-      (function* () {
-        yield* sleep(idleFlushMs);
-        return { tag: "idle" as const };
-      })(),
-    ]);
-  }
-
-  function* advance(): Operation<ChainBlock | undefined> {
-    if (!opts.enabled) {
-      const n = yield* readFinalizedBlock(opts.subscription);
-      return n.tag === "done" ? undefined : n.value;
-    }
-    while (true) {
-      const next = yield* nextItem();
-      if (next.tag === "idle") {
-        yield* flush();
-        continue;
-      }
-      if (next.tag === "done") {
-        yield* flush();
-        return undefined;
-      }
-      const value = next.value;
-      const behindTip = opts.lagThresholdMs != null &&
-        Date.now() - value.timestamp > opts.lagThresholdMs;
-      if (behindTip && value.primitives.length === 0) {
-        const boundaries = pendingRun?.boundaries ??
-          (yield* loadEmptyRunBoundaries(opts.pool));
-        if (isCoalescableEmptyBlock(value, boundaries, opts.migrations)) {
-          pendingRun = pendingRun
-            ? { boundaries, endpoint: value, length: pendingRun.length + 1 }
-            : { boundaries, endpoint: value, length: 1 };
-          if (pendingRun.length >= MAX_EMPTY_RUN) yield* flush();
-          continue;
-        }
-      }
-      yield* flush();
-      return value;
-    }
-  }
-
-  return { advance };
-}

package/test/coalesce.unit.test.ts

@@ -1,69 +0,0 @@
-import { expect, test } from "bun:test";
-import {
-  type EmptyRunBoundaries,
-  isCoalescableEmptyBlock,
-} from "../src/coalesce.ts";
-
-const NO_BOUNDARIES: EmptyRunBoundaries = {
-  minScheduledBlockHeight: null,
-  minScheduledTimestampMs: null,
-};
-
-function block(
-  blockNumber: number,
-  timestamp: number,
-  primitives: unknown[] = [],
-): any {
-  return { blockNumber, timestamp, blockInfo: [], resumePages: [], primitives };
-}
-
-test("empty block with no boundaries is coalescable", () => {
-  expect(isCoalescableEmptyBlock(block(10, 10_000), NO_BOUNDARIES, undefined))
-    .toBe(true);
-});
-
-test("block with on-chain content is NOT coalescable", () => {
-  expect(
-    isCoalescableEmptyBlock(block(10, 10_000, [{}]), NO_BOUNDARIES, undefined),
-  ).toBe(false);
-});
-
-test("block where a migration fires is NOT coalescable", () => {
-  const migrations = [{ name: "m1", sql: "", blockHeight: 10 }];
-  expect(isCoalescableEmptyBlock(block(10, 10_000), NO_BOUNDARIES, migrations))
-    .toBe(false);
-  expect(isCoalescableEmptyBlock(block(9, 9_000), NO_BOUNDARIES, migrations))
-    .toBe(true);
-});
-
-test("block at/after a pending block-height-scheduled input is NOT coalescable", () => {
-  const boundaries: EmptyRunBoundaries = {
-    minScheduledBlockHeight: 10,
-    minScheduledTimestampMs: null,
-  };
-  expect(isCoalescableEmptyBlock(block(9, 9_000), boundaries, undefined)).toBe(
-    true,
-  );
-  expect(isCoalescableEmptyBlock(block(10, 10_000), boundaries, undefined)).toBe(
-    false,
-  );
-  expect(isCoalescableEmptyBlock(block(11, 11_000), boundaries, undefined)).toBe(
-    false,
-  );
-});
-
-test("block at/after a due timestamp-scheduled input is NOT coalescable", () => {
-  const boundaries: EmptyRunBoundaries = {
-    minScheduledBlockHeight: null,
-    minScheduledTimestampMs: 10_000,
-  };
-  expect(isCoalescableEmptyBlock(block(9, 9_999), boundaries, undefined)).toBe(
-    true,
-  );
-  expect(isCoalescableEmptyBlock(block(10, 10_000), boundaries, undefined)).toBe(
-    false,
-  );
-  expect(isCoalescableEmptyBlock(block(11, 10_001), boundaries, undefined)).toBe(
-    false,
-  );
-});