effective-indexer 0.2.1 → 0.2.3

package/README.md

@@ -2,6 +2,10 @@
 
 Lightweight EVM smart contract event indexer built with [Effect](https://effect.website).
 
+Index EVM events to your own database in minutes — no hosted lock-in, no PhD required.
+
+Repository: [github.com/cybervoid0/effective-indexer](https://github.com/cybervoid0/effective-indexer)
+
 Indexes smart contract events into SQLite with:
 - Historical backfill (`eth_getLogs` in chunks)
 - Live polling for new blocks
@@ -93,6 +97,7 @@ Returns `IndexerHandle`:
 | `dbPath` | `string` | `"./indexer.db"` | SQLite database path |
 | `contracts` | `ContractConfig[]` | — | Contracts to index |
 | `network` | `NetworkConfig` | see below | Network tuning |
+| `telemetry` | `TelemetryConfig` | see below | Backfill progress settings |
 | `logLevel` | `string` | `"info"` | Minimum log level |
 | `logFormat` | `string` | `"pretty"` | Log output format |
 | `enableTelemetry` | `boolean` | `true` | Set `false` for errors-only |
@@ -102,25 +107,196 @@ Returns `IndexerHandle`:
 ```ts
 {
   polling: {
-    intervalMs: 12000,     // block polling interval
-    confirmations: 1,       // blocks behind head to consider confirmed
+    intervalMs: 12000,       // block polling interval
+    confirmations: 1,        // blocks behind head to consider confirmed
   },
   logs: {
-    chunkSize: 5000,        // blocks per eth_getLogs request
-    maxRetries: 5,          // retry count on RPC failure
+    chunkSize: 5000,         // blocks per eth_getLogs request
+    maxRetries: 5,           // retry count on RPC failure
+    parallelRequests: 1,     // concurrent eth_getLogs requests during backfill
     retry: {
-      baseDelayMs: 1000,    // initial retry delay
-      maxDelayMs: 30000,    // cap for exponential backoff
+      baseDelayMs: 1000,     // initial retry delay
+      maxDelayMs: 30000,     // cap for exponential backoff
     },
   },
   reorg: {
-    depth: 20,              // block hash buffer depth for reorg detection
+    depth: 20,               // block hash buffer depth for reorg detection
   },
 }
 ```
 
 All fields are optional — defaults are shown above.
 
+### `TelemetryConfig`
+
+```ts
+{
+  telemetry: {
+    progress: {
+      enabled: true,         // show backfill progress in terminal
+      intervalMs: 3000,      // progress update frequency (ms, minimum 500)
+    },
+  },
+}
+```
+
+`enableTelemetry: false` disables progress rendering and keeps error-level logs only.
+
+When enabled, the indexer displays a live progress line during backfill:
+
+```
+[Backfill] Token 42.8% | 1,234,000/2,880,000 blocks | 3,450 blk/s | 12.4 ev/s | ETA 00:07:43 | p=3 | chunk=5000
+```
+
+On non-TTY environments, periodic info logs are emitted instead. A final summary is logged when backfill completes:
+
+```
+[Backfill complete] Token: 2,880,000 blocks | 45,230 events | 312 chunks | 00:13:54 (3,453 blk/s, 54.2 ev/s) | p=3 | chunkSize=5000
+```
+
+## Worker Setup (Recommended)
+
+Run the indexer as a dedicated long-lived worker process (not in request handlers).
+
+Create `scripts/indexer.ts`:
+
+```ts
+import { Indexer } from "effective-indexer"
+import type { Abi } from "viem"
+
+const transferAbi: Abi = [
+	{
+		type: "event",
+		name: "Transfer",
+		inputs: [
+			{ indexed: true, name: "from", type: "address" },
+			{ indexed: true, name: "to", type: "address" },
+			{ indexed: false, name: "value", type: "uint256" },
+		],
+	},
+]
+
+const indexer = Indexer.create({
+	rpcUrl: process.env.EVM_RPC_URL!,
+	dbPath: process.env.INDEXER_DB_PATH ?? "./data/events.db",
+	contracts: [
+		{
+			name: process.env.INDEXER_CONTRACT_NAME ?? "Token",
+			address: process.env.INDEXER_CONTRACT_ADDRESS!,
+			abi: transferAbi,
+			events: ["Transfer"],
+			startBlock: BigInt(process.env.INDEXER_START_BLOCK ?? "0"),
+		},
+	],
+	network: {
+		polling: {
+			intervalMs: Number(process.env.INDEXER_POLL_INTERVAL_MS ?? "12000"),
+			confirmations: Number(process.env.INDEXER_CONFIRMATIONS ?? "1"),
+		},
+		logs: {
+			chunkSize: Number(process.env.INDEXER_CHUNK_SIZE ?? "2000"),
+			parallelRequests: Number(process.env.INDEXER_PARALLEL_REQUESTS ?? "1"),
+			maxRetries: Number(process.env.INDEXER_MAX_RETRIES ?? "5"),
+			retry: {
+				baseDelayMs: Number(process.env.INDEXER_RETRY_BASE_MS ?? "1000"),
+				maxDelayMs: Number(process.env.INDEXER_RETRY_MAX_MS ?? "30000"),
+			},
+		},
+		reorg: {
+			depth: Number(process.env.INDEXER_REORG_DEPTH ?? "20"),
+		},
+	},
+	telemetry: {
+		progress: {
+			enabled: process.env.INDEXER_PROGRESS_ENABLED !== "false",
+			intervalMs: Number(process.env.INDEXER_PROGRESS_INTERVAL_MS ?? "3000"),
+		},
+	},
+	logLevel: (process.env.INDEXER_LOG_LEVEL ?? "info") as
+		| "trace"
+		| "debug"
+		| "info"
+		| "warning"
+		| "error"
+		| "none",
+	logFormat: (process.env.INDEXER_LOG_FORMAT ?? "pretty") as
+		| "pretty"
+		| "json"
+		| "structured",
+	enableTelemetry: process.env.INDEXER_TELEMETRY !== "false",
+})
+
+const start = async (): Promise<void> => {
+	await indexer.start()
+	console.log("Indexer worker started")
+
+	// Keep the process alive while indexing in background.
+	const keepAlive = setInterval(() => undefined, 60_000)
+
+	const stop = async (): Promise<void> => {
+		clearInterval(keepAlive)
+		await indexer.stop()
+		process.exit(0)
+	}
+
+	process.on("SIGINT", () => {
+		void stop()
+	})
+	process.on("SIGTERM", () => {
+		void stop()
+	})
+}
+
+start().catch(error => {
+	console.error("Indexer worker failed:", error)
+	process.exit(1)
+})
+```
+
+Create `.env`:
+
+```bash
+EVM_RPC_URL=https://your-rpc-url
+INDEXER_DB_PATH=./data/events.db
+INDEXER_CONTRACT_NAME=Token
+INDEXER_CONTRACT_ADDRESS=0xYourContractAddress
+INDEXER_START_BLOCK=0
+INDEXER_POLL_INTERVAL_MS=12000
+INDEXER_CONFIRMATIONS=1
+INDEXER_CHUNK_SIZE=2000
+INDEXER_PARALLEL_REQUESTS=1
+INDEXER_MAX_RETRIES=5
+INDEXER_RETRY_BASE_MS=1000
+INDEXER_RETRY_MAX_MS=30000
+INDEXER_REORG_DEPTH=20
+INDEXER_PROGRESS_ENABLED=true
+INDEXER_PROGRESS_INTERVAL_MS=3000
+INDEXER_LOG_LEVEL=info
+INDEXER_LOG_FORMAT=pretty
+INDEXER_TELEMETRY=true
+```
+
+Add scripts (with `tsx` installed):
+
+```bash
+npm install -D tsx
+```
+
+```json
+{
+  "scripts": {
+    "indexer:start": "node --import tsx ./scripts/indexer.ts",
+    "indexer:debug": "INDEXER_LOG_LEVEL=debug node --import tsx ./scripts/indexer.ts"
+  }
+}
+```
+
+Run:
+
+```bash
+npm run indexer:start
+```
+
 ### Network Tuning Profiles
 
 | Chain | `polling.intervalMs` | `polling.confirmations` | `logs.chunkSize` | `reorg.depth` |
@@ -167,6 +343,35 @@ The indexer uses Effect's native logging system. All log output is controlled vi
 - On restart, the indexer resumes from checkpoint and backfills missed blocks.
 - If RPC does not support `eth_getLogs`, indexing cannot work.
 
+## Parallel Backfill
+
+Set `network.logs.parallelRequests` to speed up historical backfill by issuing multiple `eth_getLogs` requests concurrently. Chunk ordering is preserved regardless of concurrency.
+
+```ts
+const indexer = Indexer.create({
+  rpcUrl: "https://eth.llamarpc.com",
+  contracts: [/* ... */],
+  network: {
+    logs: {
+      chunkSize: 2000,
+      parallelRequests: 4,
+    },
+  },
+})
+```
+
+**Recommended values**: Start with `parallelRequests: 3` and increase if the RPC allows. Public endpoints may rate-limit above 5-10 concurrent requests.
+
+### Benchmarking
+
+To measure the effect of parallelism:
+
+1. Use a fixed RPC endpoint and contract/block range
+2. Start with an empty database each run
+3. Compare `parallelRequests` values 1, 2, 3, 4
+4. Run 3 times each and take the median
+5. Use the progress summary line for timing: `[Backfill complete] ... blk/s`
+
 ## Development
 
 ```bash

package/dist/index.cjs

@@ -6,6 +6,20 @@ var viem = require('viem');
 var sql = require('@effect/sql');
 
 // src/index.ts
+var RpcError = class extends effect.Data.TaggedError("RpcError") {
+};
+var DecodeError = class extends effect.Data.TaggedError("DecodeError") {
+};
+var StorageError = class extends effect.Data.TaggedError("StorageError") {
+};
+var ReorgDetected = class extends effect.Data.TaggedError("ReorgDetected") {
+};
+var CheckpointError = class extends effect.Data.TaggedError("CheckpointError") {
+};
+var ConfigError = class extends effect.Data.TaggedError("ConfigError") {
+};
+
+// src/config.ts
 var resolveNetwork = (config) => {
   const n = config.network;
   return {
@@ -19,20 +33,46 @@ var resolveNetwork = (config) => {
       retry: {
         baseDelayMs: n?.logs?.retry?.baseDelayMs ?? 1e3,
         maxDelayMs: n?.logs?.retry?.maxDelayMs ?? 3e4
-      }
+      },
+      parallelRequests: n?.logs?.parallelRequests ?? 1
     },
     reorg: {
       depth: n?.reorg?.depth ?? 20
     }
   };
 };
+var resolveTelemetry = (config) => {
+  const t = config.telemetry;
+  return {
+    progress: {
+      enabled: t?.progress?.enabled ?? true,
+      intervalMs: t?.progress?.intervalMs ?? 3e3
+    }
+  };
+};
 var resolveConfig = (config) => {
   const network = resolveNetwork(config);
+  const telemetry = resolveTelemetry(config);
+  const pr = network.logs.parallelRequests;
+  if (!Number.isInteger(pr) || pr < 1) {
+    throw new ConfigError({
+      reason: "parallelRequests must be an integer >= 1",
+      field: "network.logs.parallelRequests"
+    });
+  }
+  const pi = telemetry.progress.intervalMs;
+  if (!Number.isInteger(pi) || !Number.isFinite(pi) || pi < 500) {
+    throw new ConfigError({
+      reason: "telemetry.progress.intervalMs must be an integer >= 500",
+      field: "telemetry.progress.intervalMs"
+    });
+  }
   return {
     rpcUrl: config.rpcUrl,
     dbPath: config.dbPath ?? "./indexer.db",
     contracts: config.contracts,
     network,
+    telemetry,
     logLevel: config.logLevel ?? "info",
     logFormat: config.logFormat ?? "pretty",
     enableTelemetry: config.enableTelemetry ?? true
@@ -76,20 +116,6 @@ var LoggerLive = (config) => {
     effect.Logger.minimumLogLevel(level)
   );
 };
-var RpcError = class extends effect.Data.TaggedError("RpcError") {
-};
-var DecodeError = class extends effect.Data.TaggedError("DecodeError") {
-};
-var StorageError = class extends effect.Data.TaggedError("StorageError") {
-};
-var ReorgDetected = class extends effect.Data.TaggedError("ReorgDetected") {
-};
-var CheckpointError = class extends effect.Data.TaggedError("CheckpointError") {
-};
-(class extends effect.Data.TaggedError("ConfigError") {
-});
-
-// src/services/RpcProvider.ts
 var toHexQuantity = (value) => `0x${value.toString(16)}`;
 var RpcProvider = class extends effect.Context.Tag("effective-indexer/RpcProvider")() {
 };
@@ -453,6 +479,195 @@ var EventDecoderLive = effect.Layer.succeed(EventDecoder, {
     logs.map((log) => decodeLog(contractName, abi, log)).filter((e) => e !== null)
   )
 });
+var computeSnapshot = (p) => {
+  const now = Date.now();
+  const elapsedMs = Math.max(now - p.startedAt, 1);
+  const elapsedSec = elapsedMs / 1e3;
+  const processed = Number(p.processedBlocks);
+  const total = Number(p.totalBlocks);
+  const percentage = total > 0 ? processed / total * 100 : 0;
+  const blocksPerSecond = elapsedSec > 0 ? processed / elapsedSec : 0;
+  const eventsPerSecond = elapsedSec > 0 ? p.totalEvents / elapsedSec : 0;
+  const remaining = total - processed;
+  const etaMs = blocksPerSecond > 0 ? remaining / blocksPerSecond * 1e3 : null;
+  return {
+    contractName: p.contractName,
+    totalBlocks: p.totalBlocks,
+    processedBlocks: p.processedBlocks,
+    totalEvents: p.totalEvents,
+    chunkCount: p.chunkCount,
+    elapsedMs,
+    blocksPerSecond,
+    eventsPerSecond,
+    percentage,
+    etaMs
+  };
+};
+var ProgressReporter = class extends effect.Context.Tag(
+  "effective-indexer/ProgressReporter"
+)() {
+};
+var ProgressReporterLive = effect.Layer.effect(
+  ProgressReporter,
+  effect.Effect.gen(function* () {
+    const state = yield* effect.Ref.make(/* @__PURE__ */ new Map());
+    return {
+      start: (contractName, totalBlocks) => effect.Ref.update(state, (map) => {
+        const next = new Map(map);
+        next.set(contractName, {
+          contractName,
+          totalBlocks,
+          processedBlocks: 0n,
+          totalEvents: 0,
+          chunkCount: 0,
+          startedAt: Date.now()
+        });
+        return next;
+      }),
+      update: (contractName, processedBlocks, eventsInChunk) => effect.Ref.update(state, (map) => {
+        const entry = map.get(contractName);
+        if (!entry) return map;
+        const boundedProcessed = processedBlocks > entry.totalBlocks ? entry.totalBlocks : processedBlocks;
+        const nextProcessed = boundedProcessed > entry.processedBlocks ? boundedProcessed : entry.processedBlocks;
+        const next = new Map(map);
+        next.set(contractName, {
+          ...entry,
+          processedBlocks: nextProcessed,
+          totalEvents: entry.totalEvents + eventsInChunk
+        });
+        return next;
+      }),
+      incrementChunks: (contractName) => effect.Ref.update(state, (map) => {
+        const entry = map.get(contractName);
+        if (!entry) return map;
+        const next = new Map(map);
+        next.set(contractName, {
+          ...entry,
+          chunkCount: entry.chunkCount + 1
+        });
+        return next;
+      }),
+      finish: (contractName) => effect.Ref.update(state, (map) => {
+        const next = new Map(map);
+        next.delete(contractName);
+        return next;
+      }),
+      getSnapshot: (contractName) => effect.Ref.get(state).pipe(
+        effect.Effect.map((map) => {
+          const entry = map.get(contractName);
+          return entry ? computeSnapshot(entry) : null;
+        })
+      ),
+      getAllSnapshots: () => effect.Ref.get(state).pipe(
+        effect.Effect.map((map) => Array.from(map.values()).map(computeSnapshot))
+      )
+    };
+  })
+);
+
+// src/services/ProgressRenderer.ts
+var formatDuration = (ms) => {
+  const totalSec = Math.floor(ms / 1e3);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  const pad = (n) => String(n).padStart(2, "0");
+  return h > 0 ? `${pad(h)}:${pad(m)}:${pad(s)}` : `${pad(m)}:${pad(s)}`;
+};
+var formatNumber = (n) => n.toLocaleString("en-US", { maximumFractionDigits: 0 });
+var formatRate = (n) => n >= 100 ? formatNumber(Math.round(n)) : n.toLocaleString("en-US", { maximumFractionDigits: 1 });
+var buildLine = (snap, config) => {
+  const pct = snap.percentage.toFixed(1);
+  const processed = formatNumber(Number(snap.processedBlocks));
+  const total = formatNumber(Number(snap.totalBlocks));
+  const bps = formatRate(snap.blocksPerSecond);
+  const eps = formatRate(snap.eventsPerSecond);
+  const eta = snap.etaMs !== null ? formatDuration(snap.etaMs) : "--:--";
+  const p = config.network.logs.parallelRequests;
+  const chunk = config.network.logs.chunkSize;
+  return `[Backfill] ${snap.contractName} ${pct}% | ${processed}/${total} blocks | ${bps} blk/s | ${eps} ev/s | ETA ${eta} | p=${p} | chunk=${chunk}`;
+};
+var buildSummaryLine = (snap, config) => {
+  const total = formatNumber(Number(snap.totalBlocks));
+  const events = formatNumber(snap.totalEvents);
+  const chunks = snap.chunkCount;
+  const dur = formatDuration(snap.elapsedMs);
+  const bps = formatRate(snap.blocksPerSecond);
+  const eps = formatRate(snap.eventsPerSecond);
+  const p = config.network.logs.parallelRequests;
+  const chunk = config.network.logs.chunkSize;
+  return `[Backfill complete] ${snap.contractName}: ${total} blocks | ${events} events | ${chunks} chunks | ${dur} (${bps} blk/s, ${eps} ev/s) | p=${p} | chunkSize=${chunk}`;
+};
+var ProgressRenderer = class extends effect.Context.Tag(
+  "effective-indexer/ProgressRenderer"
+)() {
+};
+var ProgressRendererLive = effect.Layer.effect(
+  ProgressRenderer,
+  effect.Effect.gen(function* () {
+    const config = yield* Config;
+    const reporter = yield* ProgressReporter;
+    const fiberRef = yield* effect.Ref.make(
+      effect.Option.none()
+    );
+    const enabled = config.enableTelemetry && config.telemetry.progress.enabled;
+    const intervalMs = config.telemetry.progress.intervalMs;
+    const isTTY = typeof process !== "undefined" && !!process.stdout?.isTTY;
+    const renderOnce = effect.Effect.gen(function* () {
+      const snapshots = yield* reporter.getAllSnapshots();
+      if (snapshots.length === 0) return;
+      if (isTTY) {
+        const { default: logUpdate } = yield* effect.Effect.promise(
+          () => import('log-update')
+        );
+        const pc = yield* effect.Effect.promise(() => import('picocolors'));
+        const lines = snapshots.map((s) => {
+          const raw = buildLine(s, config);
+          return pc.default.cyan(raw);
+        });
+        logUpdate(lines.join("\n"));
+      } else {
+        for (const s of snapshots) {
+          yield* effect.Effect.log(buildLine(s, config));
+        }
+      }
+    });
+    return {
+      startRendering: () => {
+        if (!enabled) return effect.Effect.void;
+        return effect.Effect.gen(function* () {
+          const fiber = yield* renderOnce.pipe(
+            effect.Effect.repeat(effect.Schedule.spaced(intervalMs)),
+            effect.Effect.asVoid,
+            effect.Effect.catchAll(() => effect.Effect.void),
+            effect.Effect.fork
+          );
+          yield* effect.Ref.set(fiberRef, effect.Option.some(fiber));
+        });
+      },
+      stopRendering: () => {
+        if (!enabled) return effect.Effect.void;
+        return effect.Effect.gen(function* () {
+          const maybeFiber = yield* effect.Ref.get(fiberRef);
+          if (effect.Option.isSome(maybeFiber)) {
+            yield* effect.Fiber.interrupt(maybeFiber.value);
+            yield* effect.Ref.set(fiberRef, effect.Option.none());
+            if (isTTY) {
+              const { default: logUpdate } = yield* effect.Effect.promise(
+                () => import('log-update')
+              );
+              logUpdate.clear();
+            }
+          }
+        });
+      },
+      renderFinalSummary: (snapshot, cfg) => {
+        if (!enabled) return effect.Effect.void;
+        return effect.Effect.log(buildSummaryLine(snapshot, cfg));
+      }
+    };
+  })
+);
 var buildTopicFilter = (abi, eventNames) => {
   const topics = [];
   for (const name of eventNames) {
@@ -484,6 +699,7 @@ var fetchLogs = (params) => effect.Stream.unwrap(
     if (chunks.length === 0) {
       return effect.Stream.empty;
     }
+    const concurrency = config.network.logs.parallelRequests;
     return effect.Stream.fromIterable(chunks).pipe(
       effect.Stream.mapEffect(
         (chunk) => effect.Effect.gen(function* () {
@@ -501,7 +717,9 @@ var fetchLogs = (params) => effect.Stream.unwrap(
                 const n = yield* effect.Ref.getAndUpdate(attempt, (a) => a + 1);
                 const rawDelay = 2 ** n * baseDelayMs;
                 const delayMs = Math.min(rawDelay, maxDelayMs);
-                yield* effect.Effect.logDebug("RPC getLogs failed, retrying").pipe(
+                yield* effect.Effect.logDebug(
+                  "RPC getLogs failed, retrying"
+                ).pipe(
                   effect.Effect.annotateLogs({
                     method: "eth_getLogs",
                     from: chunk.from.toString(),
@@ -534,7 +752,8 @@ var fetchLogs = (params) => effect.Stream.unwrap(
               )
             )
           );
-        })
+        }),
+        { concurrency }
       )
     );
   })
@@ -614,12 +833,15 @@ var ReorgDetectorLive = effect.Layer.effect(
 // src/pipeline/Indexer.ts
 var indexContract = (contract) => effect.Stream.unwrap(
   effect.Effect.gen(function* () {
+    const config = yield* Config;
     const rpc = yield* RpcProvider;
     const decoder = yield* EventDecoder;
     const checkpoint = yield* CheckpointManager;
     const reorgDetector = yield* ReorgDetector;
     const storage = yield* Storage;
     const blockCursor = yield* BlockCursor;
+    const progress = yield* ProgressReporter;
+    const renderer = yield* ProgressRenderer;
     const startBlock = yield* checkpoint.getStartBlock(
       contract.name,
       contract.startBlock ?? 0n
@@ -632,7 +854,13 @@ var indexContract = (contract) => effect.Stream.unwrap(
       })
     );
     const topics = buildTopicFilter(contract.abi, contract.events);
-    const backfillStream = startBlock <= currentHead ? fetchLogs({
+    const needsBackfill = startBlock <= currentHead;
+    const totalBackfillBlocks = currentHead - startBlock + 1n;
+    if (needsBackfill) {
+      yield* progress.start(contract.name, totalBackfillBlocks);
+    }
+    const processedBlocksRef = yield* effect.Ref.make(0n);
+    const backfillStream = needsBackfill ? fetchLogs({
       address: contract.address,
       topics,
       fromBlock: startBlock,
@@ -681,6 +909,18 @@ var indexContract = (contract) => effect.Stream.unwrap(
               lastBlock.blockHash
             );
           }
+          const chunkSize = BigInt(config.network.logs.chunkSize);
+          const lastProcessed = yield* effect.Ref.modify(processedBlocksRef, (current) => {
+            const advanced = current + chunkSize;
+            const next = advanced > totalBackfillBlocks ? totalBackfillBlocks : advanced;
+            return [next, next];
+          });
+          yield* progress.update(
+            contract.name,
+            lastProcessed,
+            withTimestamp.length
+          );
+          yield* progress.incrementChunks(contract.name);
           yield* effect.Effect.logDebug("Chunk indexed").pipe(
             effect.Effect.annotateLogs({
               events: withTimestamp.length.toString(),
@@ -760,27 +1000,37 @@ var indexContract = (contract) => effect.Stream.unwrap(
       ),
       effect.Stream.flatMap(effect.Stream.fromIterable)
     );
+    const backfillTransition = needsBackfill ? effect.Stream.execute(
+      effect.Effect.gen(function* () {
+        const snapshot = yield* progress.getSnapshot(contract.name);
+        if (snapshot) {
+          yield* renderer.renderFinalSummary(snapshot, config);
+        }
+        yield* progress.finish(contract.name);
+        yield* effect.Effect.log("Backfill complete, switching to live");
+      })
+    ) : effect.Stream.execute(effect.Effect.log("Backfill complete, switching to live"));
     return effect.Stream.concat(
       backfillStream,
-      effect.Stream.concat(
-        effect.Stream.execute(effect.Effect.log("Backfill complete, switching to live")),
-        liveStream
-      )
+      effect.Stream.concat(backfillTransition, liveStream)
     );
   }).pipe(effect.Effect.annotateLogs("contract", contract.name))
 );
 var runIndexer = effect.Effect.gen(function* () {
   const config = yield* Config;
   const storage = yield* Storage;
+  const renderer = yield* ProgressRenderer;
   yield* storage.initialize.pipe(effect.Effect.withLogSpan("storage_init"));
   yield* effect.Effect.log("Indexer starting").pipe(
     effect.Effect.annotateLogs({
       contracts: config.contracts.length.toString()
     })
   );
+  yield* renderer.startRendering();
   const streams = config.contracts.map((c) => indexContract(c));
   yield* effect.Stream.mergeAll(streams, { concurrency: streams.length }).pipe(
     effect.Stream.runDrain,
+    effect.Effect.ensuring(renderer.stopRendering()),
     effect.Effect.tapError(
       (err) => effect.Effect.logError("Indexer error").pipe(
         effect.Effect.annotateLogs({
@@ -870,6 +1120,10 @@ var buildLayers = (config) => {
     effect.Layer.provide(effect.Layer.merge(StorageLayer, ConfigLayer))
   );
   const QueryLayer = QueryApiLive.pipe(effect.Layer.provide(StorageLayer));
+  const ProgressReporterLayer = ProgressReporterLive;
+  const ProgressRendererLayer = ProgressRendererLive.pipe(
+    effect.Layer.provide(effect.Layer.merge(ConfigLayer, ProgressReporterLayer))
+  );
   return effect.Layer.mergeAll(
     ConfigLayer,
     StorageLayer,
@@ -879,6 +1133,8 @@ var buildLayers = (config) => {
     CursorLayer,
     ReorgLayer,
     QueryLayer,
+    ProgressReporterLayer,
+    ProgressRendererLayer,
     LoggerLayer
   );
 };
@@ -952,6 +1208,10 @@ exports.EventDecoder = EventDecoder;
 exports.EventDecoderLive = EventDecoderLive;
 exports.Indexer = Indexer;
 exports.LoggerLive = LoggerLive;
+exports.ProgressRenderer = ProgressRenderer;
+exports.ProgressRendererLive = ProgressRendererLive;
+exports.ProgressReporter = ProgressReporter;
+exports.ProgressReporterLive = ProgressReporterLive;
 exports.QueryApi = QueryApi;
 exports.QueryApiLive = QueryApiLive;
 exports.ReorgDetector = ReorgDetector;
@@ -960,6 +1220,7 @@ exports.RpcProvider = RpcProvider;
 exports.RpcProviderLive = RpcProviderLive;
 exports.Storage = Storage;
 exports.StorageLive = StorageLive;
+exports.computeSnapshot = computeSnapshot;
 exports.createIndexer = createIndexer;
 exports.resolveConfig = resolveConfig;
 //# sourceMappingURL=index.cjs.map