voltaire-effect 0.2.23

package/src/contract/EventStream.test.ts

@@ -0,0 +1,802 @@
+/**
+ * @fileoverview Tests for EventStream helpers.
+ */
+
+import { describe, expect, it } from "@effect/vitest";
+import { Address } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as S from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { EventSchema } from "../primitives/Abi/AbiSchema.js";
+import {
+	TransportError,
+	TransportService,
+	type TransportShape,
+} from "../services/Transport/index.js";
+import { makeEventStream } from "./EventStream.js";
+import { EventStreamError } from "./EventStreamError.js";
+
+// Cast to any to satisfy EventType constraint - schema returns EventItem which has
+// ParameterInternal[] but EventType expects Parameter[] with AbiType
+const transferEvent = S.decodeUnknownSync(EventSchema)({
+	type: "event",
+	name: "Transfer",
+	inputs: [
+		{ name: "from", type: "address", indexed: true },
+		{ name: "to", type: "address", indexed: true },
+		{ name: "value", type: "uint256", indexed: false },
+	],
+}) as any;
+
+const approvalEvent = S.decodeUnknownSync(EventSchema)({
+	type: "event",
+	name: "Approval",
+	inputs: [
+		{ name: "owner", type: "address", indexed: true },
+		{ name: "spender", type: "address", indexed: true },
+		{ name: "value", type: "uint256", indexed: false },
+	],
+}) as any;
+
+describe("EventStream", () => {
+	describe("EventStreamError", () => {
+		it("creates error with message", () => {
+			const error = new EventStreamError("test error");
+			expect(error.message).toBe("test error");
+			expect(error._tag).toBe("EventStreamError");
+		});
+
+		it("creates error with cause", () => {
+			const cause = new Error("underlying");
+			const error = new EventStreamError("test error", { cause });
+			expect(error.message).toContain("test error");
+			expect(error.cause).toBe(cause);
+		});
+
+		it("creates error with context", () => {
+			const error = new EventStreamError("test error", {
+				context: { fromBlock: 100n, toBlock: 200n },
+			});
+			expect(error.message).toBe("test error");
+			expect(error._tag).toBe("EventStreamError");
+		});
+
+		it("has correct name property", () => {
+			const error = new EventStreamError("test");
+			expect(error.name).toBe("EventStreamError");
+		});
+
+		it("is instanceof Error", () => {
+			const error = new EventStreamError("test");
+			expect(error instanceof Error).toBe(true);
+		});
+
+		it("preserves cause chain", () => {
+			const rootCause = new Error("root");
+			const intermediateCause = new Error("intermediate", { cause: rootCause });
+			const error = new EventStreamError("top level", {
+				cause: intermediateCause,
+			});
+			expect(error.cause).toBe(intermediateCause);
+			expect((error.cause as Error).cause).toBe(rootCause);
+		});
+
+		it("has stack trace", () => {
+			const error = new EventStreamError("test");
+			expect(error.stack).toBeDefined();
+			expect(error.stack).toContain("EventStreamError");
+		});
+	});
+
+	describe("makeEventStream", () => {
+		it("provides event streaming from TransportService", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					_method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => Effect.succeed("0x1" as T),
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				expect(eventStream.backfill).toBeDefined();
+				expect(eventStream.watch).toBeDefined();
+				expect(typeof eventStream.backfill).toBe("function");
+				expect(typeof eventStream.watch).toBe("function");
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+		});
+
+		it("backfill returns a Stream", async () => {
+			let blockNumberCalls = 0;
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						blockNumberCalls++;
+						return Effect.succeed("0x1234567" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 100n,
+					toBlock: 200n,
+				});
+				expect(stream).toBeDefined();
+				const results = yield* Stream.runCollect(stream);
+				expect(Array.from(results)).toEqual([]);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+			expect(blockNumberCalls).toBeGreaterThan(0);
+		});
+
+		it("backfill yields decoded events", async () => {
+			const mockLog = {
+				address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+				blockHash:
+					"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+				blockNumber: "0x64",
+				data: "0x0000000000000000000000000000000000000000000000000000000000000064",
+				logIndex: "0x0",
+				removed: false,
+				topics: [
+					"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+					"0x000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+					"0x000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+				],
+				transactionHash:
+					"0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				transactionIndex: "0x0",
+			};
+
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x1234567" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([mockLog] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 100n,
+					toBlock: 100n,
+				});
+				const results = yield* Stream.runCollect(stream);
+				const arr = Array.from(results);
+				expect(arr.length).toBe(1);
+				expect(arr[0]?.log.eventName).toBe("Transfer");
+				expect(arr[0]?.log.blockNumber).toBeDefined();
+				expect(arr[0]?.metadata.chainHead).toBe(0x1234567n);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+		});
+
+		it("watch returns a Stream", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x1234567" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.watch({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+				});
+				expect(stream).toBeDefined();
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+		});
+
+		it("backfill handles empty log results", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x100" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 10n,
+					toBlock: 20n,
+				});
+				const results = yield* Stream.runCollect(stream);
+				expect(Array.from(results)).toEqual([]);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+		});
+
+		it("backfill with filter object", async () => {
+			const mockLog = {
+				address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+				blockHash:
+					"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+				blockNumber: "0x64",
+				data: "0x0000000000000000000000000000000000000000000000000000000000000064",
+				logIndex: "0x0",
+				removed: false,
+				topics: [
+					"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+					"0x000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+					"0x000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+				],
+				transactionHash:
+					"0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				transactionIndex: "0x0",
+			};
+
+			let getLogsParams: unknown[] | undefined;
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x1234567" as T);
+					}
+					if (method === "eth_getLogs") {
+						getLogsParams = params;
+						return Effect.succeed([mockLog] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					filter: {
+						from: Address("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+					},
+					fromBlock: 100n,
+					toBlock: 100n,
+				});
+				const results = yield* Stream.runCollect(stream);
+				const arr = Array.from(results);
+				expect(arr.length).toBe(1);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+			expect(getLogsParams).toBeDefined();
+		});
+	});
+
+	describe("error handling", () => {
+		it("wraps transport errors as EventStreamError", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, TransportError> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x100" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.fail(
+							new TransportError({
+								code: -32000,
+								message: "RPC connection failed",
+							}),
+						);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 100n,
+					toBlock: 100n,
+				});
+				yield* Stream.runCollect(stream);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			const result = await Effect.runPromiseExit(program);
+			expect(result._tag).toBe("Failure");
+		});
+
+		it("handles malformed log data gracefully", async () => {
+			const malformedLog = {
+				address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+				blockHash:
+					"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+				blockNumber: "0x64",
+				data: "0x00",
+				logIndex: "0x0",
+				removed: false,
+				topics: [
+					"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+				],
+				transactionHash:
+					"0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				transactionIndex: "0x0",
+			};
+
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x1234567" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([malformedLog] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 100n,
+					toBlock: 100n,
+				});
+				yield* Stream.runCollect(stream);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			const result = await Effect.runPromiseExit(program);
+			expect(result._tag).toBeDefined();
+		});
+	});
+
+	describe("stream lifecycle", () => {
+		it("stream can be consumed incrementally", async () => {
+			let requestCount = 0;
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					requestCount++;
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x100" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 10n,
+					toBlock: 20n,
+				});
+				yield* Stream.runCollect(stream);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+			expect(requestCount).toBeGreaterThan(0);
+		});
+
+		it("multiple streams can run concurrently", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x100" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+
+				const stream1 = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 10n,
+					toBlock: 20n,
+				});
+
+				const stream2 = eventStream.backfill({
+					address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+					event: approvalEvent,
+					fromBlock: 10n,
+					toBlock: 20n,
+				});
+
+				const [results1, results2] = yield* Effect.all([
+					Stream.runCollect(stream1),
+					Stream.runCollect(stream2),
+				]);
+
+				expect(Array.from(results1)).toEqual([]);
+				expect(Array.from(results2)).toEqual([]);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+		});
+	});
+
+	describe("exports", () => {
+		it("exports from index", async () => {
+			const { EventStream, EventStreamError, makeEventStream } = await import(
+				"./index.js"
+			);
+			expect(EventStream).toBeDefined();
+			expect(EventStreamError).toBeDefined();
+			expect(makeEventStream).toBeDefined();
+		});
+	});
+
+	describe("reorg handling", () => {
+		it("processes logs with removed: true flag from RPC", async () => {
+			const removedLog = {
+				address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+				blockHash:
+					"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+				blockNumber: "0x64",
+				data: "0x0000000000000000000000000000000000000000000000000000000000000064",
+				logIndex: "0x0",
+				removed: true,
+				topics: [
+					"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+					"0x000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+					"0x000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+				],
+				transactionHash:
+					"0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				transactionIndex: "0x0",
+			};
+
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x1234567" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([removedLog] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 100n,
+					toBlock: 100n,
+				});
+				const results = yield* Stream.runCollect(stream);
+				const arr = Array.from(results);
+				expect(arr.length).toBe(1);
+				expect(arr[0]?.log.eventName).toBe("Transfer");
+				expect(arr[0]?.log.blockNumber).toBeDefined();
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+		});
+	});
+
+	describe("decode failures", () => {
+		it("handles unknown topics gracefully", async () => {
+			const unknownTopicLog = {
+				address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+				blockHash:
+					"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+				blockNumber: "0x64",
+				data: "0x0000000000000000000000000000000000000000000000000000000000000064",
+				logIndex: "0x0",
+				removed: false,
+				topics: [
+					"0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+					"0x000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+				],
+				transactionHash:
+					"0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+				transactionIndex: "0x0",
+			};
+
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x1234567" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([unknownTopicLog] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 100n,
+					toBlock: 100n,
+				});
+				yield* Stream.runCollect(stream);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			const result = await Effect.runPromiseExit(program);
+			expect(result._tag).toBe("Failure");
+		});
+	});
+
+	describe("range edge cases", () => {
+		it("handles fromBlock > toBlock", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x1234567" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 200n,
+					toBlock: 100n,
+				});
+				const results = yield* Stream.runCollect(stream);
+				expect(Array.from(results)).toEqual([]);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+		});
+	});
+
+	describe("transport error propagation", () => {
+		it("propagates eth_blockNumber transport errors as EventStreamError", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, TransportError> => {
+					if (method === "eth_blockNumber") {
+						return Effect.fail(
+							new TransportError({
+								code: -32000,
+								message: "eth_blockNumber failed",
+							}),
+						);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 100n,
+					toBlock: 200n,
+				});
+				yield* Stream.runCollect(stream);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			const result = await Effect.runPromiseExit(program);
+			expect(result._tag).toBe("Failure");
+		});
+
+		it("propagates eth_getLogs transport errors correctly", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, TransportError> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x100" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.fail(
+							new TransportError({
+								code: -32000,
+								message: "eth_getLogs failed",
+							}),
+						);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 100n,
+					toBlock: 100n,
+				});
+				yield* Stream.runCollect(stream);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			const result = await Effect.runPromiseExit(program);
+			expect(result._tag).toBe("Failure");
+		});
+	});
+
+	describe("empty responses", () => {
+		it("handles empty log array response", async () => {
+			let getLogsCalled = false;
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x100" as T);
+					}
+					if (method === "eth_getLogs") {
+						getLogsCalled = true;
+						return Effect.succeed([] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+					event: transferEvent,
+					fromBlock: 10n,
+					toBlock: 20n,
+				});
+				const results = yield* Stream.runCollect(stream);
+				expect(Array.from(results)).toEqual([]);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			await Effect.runPromise(program);
+			expect(getLogsCalled).toBe(true);
+		});
+	});
+
+	describe("invalid filter handling", () => {
+		it("handles invalid filter address format", async () => {
+			const mockTransport: TransportShape = {
+				request: <T>(
+					method: string,
+					_params?: unknown[],
+				): Effect.Effect<T, never> => {
+					if (method === "eth_blockNumber") {
+						return Effect.succeed("0x100" as T);
+					}
+					if (method === "eth_getLogs") {
+						return Effect.succeed([] as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const TestTransportLayer = Layer.succeed(TransportService, mockTransport);
+
+			const program = Effect.gen(function* () {
+				const eventStream = yield* makeEventStream();
+				const stream = eventStream.backfill({
+					address: "invalid-address" as `0x${string}`,
+					event: transferEvent,
+					fromBlock: 10n,
+					toBlock: 20n,
+				});
+				yield* Stream.runCollect(stream);
+			}).pipe(Effect.provide(TestTransportLayer));
+
+			const result = await Effect.runPromiseExit(program);
+			expect(result._tag).toBe("Failure");
+		});
+	});
+});