voltaire-effect 0.2.23 → 0.2.25

package/src/services/Provider/actions/simulateContract.test.ts

@@ -32,46 +32,34 @@ const createMockProvider = (
 	callResult: `0x${string}`,
 ): Layer.Layer<ProviderService> => {
 	const mockProvider: ProviderShape = {
-		getBlockNumber: () => Effect.succeed(123n),
-		getBlock: () => Effect.succeed({} as any),
-		getBlockTransactionCount: () => Effect.succeed(0n),
-		getBalance: () => Effect.succeed(0n),
-		getTransactionCount: () => Effect.succeed(0n),
-		getCode: () => Effect.succeed("0x" as const),
-		getStorageAt: () => Effect.succeed("0x" as const),
-		getTransaction: () => Effect.succeed({} as any),
-		getTransactionReceipt: () => Effect.succeed({} as any),
-		waitForTransactionReceipt: () => Effect.succeed({} as any),
-		call: () => Effect.succeed(callResult),
-		estimateGas: () => Effect.succeed(21000n),
-		createAccessList: () => Effect.succeed({ accessList: [], gasUsed: "0x0" }),
-		getLogs: () => Effect.succeed([]),
-		createEventFilter: () => Effect.succeed("0x1" as any),
-		createBlockFilter: () => Effect.succeed("0x1" as any),
-		createPendingTransactionFilter: () => Effect.succeed("0x1" as any),
-		getFilterChanges: () => Effect.succeed([]),
-		getFilterLogs: () => Effect.succeed([]),
-		uninstallFilter: () => Effect.succeed(true),
-		getChainId: () => Effect.succeed(1),
-		getGasPrice: () => Effect.succeed(1000000000n),
-		getMaxPriorityFeePerGas: () => Effect.succeed(1000000000n),
-		getFeeHistory: () =>
-			Effect.succeed({
-				oldestBlock: "0x0",
-				baseFeePerGas: [],
-				gasUsedRatio: [],
-			}),
-		watchBlocks: () => {
-			throw new Error("Not implemented in mock");
+		request: <T>(method: string, _params?: unknown[]) => {
+			switch (method) {
+				case "eth_call":
+					return Effect.succeed(callResult as T);
+				case "eth_chainId":
+					return Effect.succeed("0x1" as T);
+				default:
+					return Effect.succeed(null as T);
+			}
 		},
-		backfillBlocks: () => {
-			throw new Error("Not implemented in mock");
+	};
+	return Layer.succeed(ProviderService, mockProvider);
+};
+
+const createErrorMockProvider = (
+	error: TransportError,
+): Layer.Layer<ProviderService> => {
+	const mockProvider: ProviderShape = {
+		request: <T>(method: string, _params?: unknown[]) => {
+			switch (method) {
+				case "eth_call":
+					return Effect.fail(error);
+				case "eth_chainId":
+					return Effect.succeed("0x1" as T);
+				default:
+					return Effect.succeed(null as T);
+			}
 		},
-		sendRawTransaction: () => Effect.succeed("0x" as `0x${string}`),
-		getUncle: () => Effect.succeed({} as any),
-		getProof: () => Effect.succeed({} as any),
-		getBlobBaseFee: () => Effect.succeed(0n),
-		getTransactionConfirmations: () => Effect.succeed(0n),
 	};
 	return Layer.succeed(ProviderService, mockProvider);
 };
@@ -134,49 +122,16 @@ describe("simulateContract", () => {
 
 		let capturedRequest: any;
 		const mockProvider: ProviderShape = {
-			getBlockNumber: () => Effect.succeed(123n),
-			getBlock: () => Effect.succeed({} as any),
-			getBlockTransactionCount: () => Effect.succeed(0n),
-			getBalance: () => Effect.succeed(0n),
-			getTransactionCount: () => Effect.succeed(0n),
-			getCode: () => Effect.succeed("0x" as const),
-			getStorageAt: () => Effect.succeed("0x" as const),
-			getTransaction: () => Effect.succeed({} as any),
-			getTransactionReceipt: () => Effect.succeed({} as any),
-			waitForTransactionReceipt: () => Effect.succeed({} as any),
-			call: (request) => {
-				capturedRequest = request;
-				return Effect.succeed(trueResult);
-			},
-			estimateGas: () => Effect.succeed(21000n),
-			createAccessList: () =>
-				Effect.succeed({ accessList: [], gasUsed: "0x0" }),
-			getLogs: () => Effect.succeed([]),
-			createEventFilter: () => Effect.succeed("0x1" as any),
-			createBlockFilter: () => Effect.succeed("0x1" as any),
-			createPendingTransactionFilter: () => Effect.succeed("0x1" as any),
-			getFilterChanges: () => Effect.succeed([]),
-			getFilterLogs: () => Effect.succeed([]),
-			uninstallFilter: () => Effect.succeed(true),
-			getChainId: () => Effect.succeed(1),
-			getGasPrice: () => Effect.succeed(1000000000n),
-			getMaxPriorityFeePerGas: () => Effect.succeed(1000000000n),
-			getFeeHistory: () =>
-				Effect.succeed({
-					oldestBlock: "0x0",
-					baseFeePerGas: [],
-					gasUsedRatio: [],
-				}),
-			sendRawTransaction: () => Effect.succeed("0x" as `0x${string}`),
-			getUncle: () => Effect.succeed({} as any),
-			getProof: () => Effect.succeed({} as any),
-			getBlobBaseFee: () => Effect.succeed(0n),
-			getTransactionConfirmations: () => Effect.succeed(0n),
-			watchBlocks: () => {
-				throw new Error("Not implemented in mock");
-			},
-			backfillBlocks: () => {
-				throw new Error("Not implemented in mock");
+			request: <T>(method: string, params?: unknown[]) => {
+				switch (method) {
+					case "eth_call":
+						capturedRequest = params?.[0];
+						return Effect.succeed(trueResult as T);
+					case "eth_chainId":
+						return Effect.succeed("0x1" as T);
+					default:
+						return Effect.succeed(null as T);
+				}
 			},
 		};
 		const provider = Layer.succeed(ProviderService, mockProvider);
@@ -253,57 +208,13 @@ describe("simulateContract", () => {
 				"0000000000000000000000000000000000000000000000000000000000000015" +
 				"5472616e7366657220616d6f756e74206578636565647300000000000000";
 
-			const mockProvider: ProviderShape = {
-				getBlockNumber: () => Effect.succeed(123n),
-				getBlock: () => Effect.succeed({} as any),
-				getBlockTransactionCount: () => Effect.succeed(0n),
-				getBalance: () => Effect.succeed(0n),
-				getTransactionCount: () => Effect.succeed(0n),
-				getCode: () => Effect.succeed("0x" as const),
-				getStorageAt: () => Effect.succeed("0x" as const),
-				getTransaction: () => Effect.succeed({} as any),
-				getTransactionReceipt: () => Effect.succeed({} as any),
-				waitForTransactionReceipt: () => Effect.succeed({} as any),
-				call: () =>
-					Effect.fail(
-						new TransportError({
-							code: 3,
-							message: "execution reverted",
-							data: revertData,
-						}),
-					),
-				estimateGas: () => Effect.succeed(21000n),
-				createAccessList: () =>
-					Effect.succeed({ accessList: [], gasUsed: "0x0" }),
-				getLogs: () => Effect.succeed([]),
-				createEventFilter: () => Effect.succeed("0x1" as any),
-				createBlockFilter: () => Effect.succeed("0x1" as any),
-				createPendingTransactionFilter: () => Effect.succeed("0x1" as any),
-				getFilterChanges: () => Effect.succeed([]),
-				getFilterLogs: () => Effect.succeed([]),
-				uninstallFilter: () => Effect.succeed(true),
-				getChainId: () => Effect.succeed(1),
-				getGasPrice: () => Effect.succeed(1000000000n),
-				getMaxPriorityFeePerGas: () => Effect.succeed(1000000000n),
-				getFeeHistory: () =>
-					Effect.succeed({
-						oldestBlock: "0x0",
-						baseFeePerGas: [],
-						gasUsedRatio: [],
-					}),
-				sendRawTransaction: () => Effect.succeed("0x" as `0x${string}`),
-				getUncle: () => Effect.succeed({} as any),
-				getProof: () => Effect.succeed({} as any),
-				getBlobBaseFee: () => Effect.succeed(0n),
-				getTransactionConfirmations: () => Effect.succeed(0n),
-				watchBlocks: () => {
-					throw new Error("Not implemented in mock");
-				},
-				backfillBlocks: () => {
-					throw new Error("Not implemented in mock");
-				},
-			};
-			const provider = Layer.succeed(ProviderService, mockProvider);
+			const provider = createErrorMockProvider(
+				new TransportError({
+					code: 3,
+					message: "execution reverted",
+					data: revertData,
+				}),
+			);
 
 			const program = simulateContract({
 				address: "0x1234567890123456789012345678901234567890",
@@ -320,56 +231,12 @@ describe("simulateContract", () => {
 		});
 
 		it("propagates transport errors", async () => {
-			const mockProvider: ProviderShape = {
-				getBlockNumber: () => Effect.succeed(123n),
-				getBlock: () => Effect.succeed({} as any),
-				getBlockTransactionCount: () => Effect.succeed(0n),
-				getBalance: () => Effect.succeed(0n),
-				getTransactionCount: () => Effect.succeed(0n),
-				getCode: () => Effect.succeed("0x" as const),
-				getStorageAt: () => Effect.succeed("0x" as const),
-				getTransaction: () => Effect.succeed({} as any),
-				getTransactionReceipt: () => Effect.succeed({} as any),
-				waitForTransactionReceipt: () => Effect.succeed({} as any),
-				call: () =>
-					Effect.fail(
-						new TransportError({
-							code: -32603,
-							message: "network error: connection refused",
-						}),
-					),
-				estimateGas: () => Effect.succeed(21000n),
-				createAccessList: () =>
-					Effect.succeed({ accessList: [], gasUsed: "0x0" }),
-				getLogs: () => Effect.succeed([]),
-				createEventFilter: () => Effect.succeed("0x1" as any),
-				createBlockFilter: () => Effect.succeed("0x1" as any),
-				createPendingTransactionFilter: () => Effect.succeed("0x1" as any),
-				getFilterChanges: () => Effect.succeed([]),
-				getFilterLogs: () => Effect.succeed([]),
-				uninstallFilter: () => Effect.succeed(true),
-				getChainId: () => Effect.succeed(1),
-				getGasPrice: () => Effect.succeed(1000000000n),
-				getMaxPriorityFeePerGas: () => Effect.succeed(1000000000n),
-				getFeeHistory: () =>
-					Effect.succeed({
-						oldestBlock: "0x0",
-						baseFeePerGas: [],
-						gasUsedRatio: [],
-					}),
-				sendRawTransaction: () => Effect.succeed("0x" as `0x${string}`),
-				getUncle: () => Effect.succeed({} as any),
-				getProof: () => Effect.succeed({} as any),
-				getBlobBaseFee: () => Effect.succeed(0n),
-				getTransactionConfirmations: () => Effect.succeed(0n),
-				watchBlocks: () => {
-					throw new Error("Not implemented in mock");
-				},
-				backfillBlocks: () => {
-					throw new Error("Not implemented in mock");
-				},
-			};
-			const provider = Layer.succeed(ProviderService, mockProvider);
+			const provider = createErrorMockProvider(
+				new TransportError({
+					code: -32603,
+					message: "network error: connection refused",
+				}),
+			);
 
 			const program = simulateContract({
 				address: "0x1234567890123456789012345678901234567890",
@@ -386,56 +253,12 @@ describe("simulateContract", () => {
 		});
 
 		it("propagates timeout errors", async () => {
-			const mockProvider: ProviderShape = {
-				getBlockNumber: () => Effect.succeed(123n),
-				getBlock: () => Effect.succeed({} as any),
-				getBlockTransactionCount: () => Effect.succeed(0n),
-				getBalance: () => Effect.succeed(0n),
-				getTransactionCount: () => Effect.succeed(0n),
-				getCode: () => Effect.succeed("0x" as const),
-				getStorageAt: () => Effect.succeed("0x" as const),
-				getTransaction: () => Effect.succeed({} as any),
-				getTransactionReceipt: () => Effect.succeed({} as any),
-				waitForTransactionReceipt: () => Effect.succeed({} as any),
-				call: () =>
-					Effect.fail(
-						new TransportError({
-							code: -32000,
-							message: "request timeout",
-						}),
-					),
-				estimateGas: () => Effect.succeed(21000n),
-				createAccessList: () =>
-					Effect.succeed({ accessList: [], gasUsed: "0x0" }),
-				getLogs: () => Effect.succeed([]),
-				createEventFilter: () => Effect.succeed("0x1" as any),
-				createBlockFilter: () => Effect.succeed("0x1" as any),
-				createPendingTransactionFilter: () => Effect.succeed("0x1" as any),
-				getFilterChanges: () => Effect.succeed([]),
-				getFilterLogs: () => Effect.succeed([]),
-				uninstallFilter: () => Effect.succeed(true),
-				getChainId: () => Effect.succeed(1),
-				getGasPrice: () => Effect.succeed(1000000000n),
-				getMaxPriorityFeePerGas: () => Effect.succeed(1000000000n),
-				getFeeHistory: () =>
-					Effect.succeed({
-						oldestBlock: "0x0",
-						baseFeePerGas: [],
-						gasUsedRatio: [],
-					}),
-				sendRawTransaction: () => Effect.succeed("0x" as `0x${string}`),
-				getUncle: () => Effect.succeed({} as any),
-				getProof: () => Effect.succeed({} as any),
-				getBlobBaseFee: () => Effect.succeed(0n),
-				getTransactionConfirmations: () => Effect.succeed(0n),
-				watchBlocks: () => {
-					throw new Error("Not implemented in mock");
-				},
-				backfillBlocks: () => {
-					throw new Error("Not implemented in mock");
-				},
-			};
-			const provider = Layer.succeed(ProviderService, mockProvider);
+			const provider = createErrorMockProvider(
+				new TransportError({
+					code: -32000,
+					message: "request timeout",
+				}),
+			);
 
 			const program = simulateContract({
 				address: "0x1234567890123456789012345678901234567890",

package/src/services/Provider/actions/simulateContract.ts

@@ -20,6 +20,7 @@ import {
 	ProviderService,
 	ProviderValidationError,
 } from "../ProviderService.js";
+import { call } from "../functions/call.js";
 
 type AddressType = BrandedAddress.AddressType;
 type HexType = BrandedHex.HexType;
@@ -128,8 +129,6 @@ export const simulateContract = <
 	ProviderService
 > =>
 	Effect.gen(function* () {
-		const provider = yield* ProviderService;
-
 		const addressHex =
 			typeof params.address === "string"
 				? params.address
@@ -153,7 +152,7 @@ export const simulateContract = <
 			gas: params.gas,
 		};
 
-		const rawResult = yield* provider.call(callRequest, params.blockTag);
+		const rawResult = yield* call(callRequest, params.blockTag);
 
 		const fn = (params.abi as readonly { type: string; name?: string }[]).find(
 			(item): item is BrandedAbi.Function.FunctionType =>

package/src/services/Provider/ens/getEnsAddress.ts

@@ -5,7 +5,8 @@
  */
 
 import * as Effect from "effect/Effect";
-import { ProviderService } from "../ProviderService.js";
+import { call } from "../functions/call.js";
+import type { ProviderService } from "../ProviderService.js";
 import { ENS_UNIVERSAL_RESOLVER_ADDRESS } from "./constants.js";
 import { EnsError } from "./EnsError.js";
 import {
@@ -53,8 +54,6 @@ export const getEnsAddress = (
 		const { name, universalResolverAddress = ENS_UNIVERSAL_RESOLVER_ADDRESS } =
 			params;
 
-		const provider = yield* ProviderService;
-
 		const node = namehash(name);
 		const dnsName = dnsEncode(name);
 		const addrCallData = encodeAddrCall(node);
@@ -81,17 +80,15 @@ export const getEnsAddress = (
 		const callData =
 			`0x${selector}${offset1}${offset2}${len1}${data1}${len2}${data2}` as `0x${string}`;
 
-		const result = yield* provider
-			.call({
-				to: universalResolverAddress,
-				data: callData,
-			})
-			.pipe(
-				Effect.mapError(
-					(e) =>
-						new EnsError(name, `Failed to resolve ENS name: ${e.message}`, e),
-				),
-			);
+		const result = yield* call({
+			to: universalResolverAddress,
+			data: callData,
+		}).pipe(
+			Effect.mapError(
+				(e) =>
+					new EnsError(name, `Failed to resolve ENS name: ${e.message}`, e),
+			),
+		);
 
 		// Decode the resolve result - first word is offset to data, then length, then data
 		if (!result || result === "0x") {

package/src/services/Provider/ens/getEnsName.ts

@@ -5,7 +5,8 @@
  */
 
 import * as Effect from "effect/Effect";
-import { ProviderService } from "../ProviderService.js";
+import { call } from "../functions/call.js";
+import type { ProviderService } from "../ProviderService.js";
 import { ENS_UNIVERSAL_RESOLVER_ADDRESS } from "./constants.js";
 import { EnsError } from "./EnsError.js";
 import { bytesToHex, dnsEncode, toReverseName } from "./utils.js";
@@ -51,8 +52,6 @@ export const getEnsName = (
 			universalResolverAddress = ENS_UNIVERSAL_RESOLVER_ADDRESS,
 		} = params;
 
-		const provider = yield* ProviderService;
-
 		const reverseName = toReverseName(address);
 		const dnsName = dnsEncode(reverseName);
 
@@ -69,21 +68,19 @@ export const getEnsName = (
 
 		const callData = `0x${selector}${offset}${len}${data}` as `0x${string}`;
 
-		const result = yield* provider
-			.call({
-				to: universalResolverAddress,
-				data: callData,
-			})
-			.pipe(
-				Effect.mapError(
-					(e) =>
-						new EnsError(
-							address,
-							`Failed to reverse resolve address: ${e.message}`,
-							e,
-						),
-				),
-			);
+		const result = yield* call({
+			to: universalResolverAddress,
+			data: callData,
+		}).pipe(
+			Effect.mapError(
+				(e) =>
+					new EnsError(
+						address,
+						`Failed to reverse resolve address: ${e.message}`,
+						e,
+					),
+			),
+		);
 
 		if (!result || result === "0x") {
 			return null;

package/src/services/Provider/ens/getEnsResolver.ts

@@ -5,7 +5,8 @@
  */
 
 import * as Effect from "effect/Effect";
-import { ProviderService } from "../ProviderService.js";
+import { call } from "../functions/call.js";
+import type { ProviderService } from "../ProviderService.js";
 import { ENS_REGISTRY_ADDRESS } from "./constants.js";
 import { EnsError } from "./EnsError.js";
 import { namehash } from "./utils.js";
@@ -45,8 +46,6 @@ export const getEnsResolver = (
 	Effect.gen(function* () {
 		const { name, registryAddress = ENS_REGISTRY_ADDRESS } = params;
 
-		const provider = yield* ProviderService;
-
 		const node = namehash(name);
 
 		// Encode resolver(bytes32) call
@@ -56,17 +55,15 @@ export const getEnsResolver = (
 
 		const callData = `0x${selector}${nodeHex}` as `0x${string}`;
 
-		const result = yield* provider
-			.call({
-				to: registryAddress,
-				data: callData,
-			})
-			.pipe(
-				Effect.mapError(
-					(e) =>
-						new EnsError(name, `Failed to get ENS resolver: ${e.message}`, e),
-				),
-			);
+		const result = yield* call({
+			to: registryAddress,
+			data: callData,
+		}).pipe(
+			Effect.mapError(
+				(e) =>
+					new EnsError(name, `Failed to get ENS resolver: ${e.message}`, e),
+			),
+		);
 
 		if (!result || result === "0x" || result.length < 66) {
 			return null;

package/src/services/Provider/ens/getEnsText.ts

@@ -5,7 +5,8 @@
  */
 
 import * as Effect from "effect/Effect";
-import { ProviderService } from "../ProviderService.js";
+import { call } from "../functions/call.js";
+import type { ProviderService } from "../ProviderService.js";
 import { ENS_UNIVERSAL_RESOLVER_ADDRESS } from "./constants.js";
 import { EnsError } from "./EnsError.js";
 import {
@@ -61,8 +62,6 @@ export const getEnsText = (
 			universalResolverAddress = ENS_UNIVERSAL_RESOLVER_ADDRESS,
 		} = params;
 
-		const provider = yield* ProviderService;
-
 		const node = namehash(name);
 		const dnsName = dnsEncode(name);
 		const textCallData = encodeTextCall(node, key);
@@ -87,21 +86,19 @@ export const getEnsText = (
 		const callData =
 			`0x${selector}${offset1}${offset2}${len1}${data1}${len2}${data2}` as `0x${string}`;
 
-		const result = yield* provider
-			.call({
-				to: universalResolverAddress,
-				data: callData,
-			})
-			.pipe(
-				Effect.mapError(
-					(e) =>
-						new EnsError(
-							{ name, key },
-							`Failed to get ENS text record: ${e.message}`,
-							e,
-						),
-				),
-			);
+		const result = yield* call({
+			to: universalResolverAddress,
+			data: callData,
+		}).pipe(
+			Effect.mapError(
+				(e) =>
+					new EnsError(
+						{ name, key },
+						`Failed to get ENS text record: ${e.message}`,
+						e,
+					),
+			),
+		);
 
 		if (!result || result === "0x") {
 			return null;

package/src/services/Provider/functions/backfillBlocks.ts

@@ -0,0 +1,97 @@
+/**
+ * @fileoverview Free function to backfill historical blocks.
+ *
+ * @module Provider/functions/backfillBlocks
+ * @since 0.4.0
+ */
+
+import {
+	type BackfillOptions,
+	type BlockInclude,
+	type BlocksEvent,
+	BlockStream as CoreBlockStream,
+} from "@tevm/voltaire/block";
+import * as Effect from "effect/Effect";
+import * as Runtime from "effect/Runtime";
+import * as Stream from "effect/Stream";
+import { TransportError } from "../../Transport/TransportError.js";
+import { ProviderService } from "../ProviderService.js";
+import { ProviderStreamError, type BackfillBlocksError } from "../types.js";
+
+/**
+ * Backfills historical blocks within a range.
+ *
+ * Fetches blocks in chunks with dynamic sizing to handle RPC limits.
+ * No reorg tracking for backfill (historical blocks are final).
+ *
+ * @param options - Backfill options including fromBlock and toBlock
+ * @returns Stream yielding BlocksEvents with blocks and metadata
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect, Stream } from 'effect'
+ * import { backfillBlocks, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = backfillBlocks({
+ *   fromBlock: 18000000n,
+ *   toBlock: 18001000n,
+ *   include: 'transactions'
+ * }).pipe(
+ *   Stream.tap((event) =>
+ *     Effect.sync(() => {
+ *       console.log('Backfilled blocks:', event.blocks.length)
+ *     })
+ *   ),
+ *   Stream.runDrain,
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const backfillBlocks = <TInclude extends BlockInclude = "header">(
+	options: BackfillOptions<TInclude>,
+): Stream.Stream<BlocksEvent<TInclude>, BackfillBlocksError, ProviderService> =>
+	Stream.unwrap(
+		Effect.gen(function* () {
+			const svc = yield* ProviderService;
+			const runtime = yield* Effect.runtime<never>();
+			const provider = {
+				request: async ({
+					method,
+					params,
+				}: {
+					method: string;
+					params?: unknown[];
+				}) =>
+					Runtime.runPromise(runtime)(svc.request(method, params)),
+				on: () => {},
+				removeListener: () => {},
+			};
+			const coreStream = CoreBlockStream({ provider: provider as any });
+			const cleanup = () => {
+				(coreStream as unknown as { destroy?: () => void }).destroy?.();
+			};
+			return Stream.acquireRelease(
+				Effect.sync(() => coreStream.backfill(options)),
+				() => Effect.sync(cleanup),
+			).pipe(
+				Stream.flatMap((generator) =>
+					Stream.fromAsyncIterable(
+						{ [Symbol.asyncIterator]: () => generator },
+						(error) =>
+							error instanceof TransportError
+								? error
+								: new ProviderStreamError(
+										{ method: "backfillBlocks", options },
+										error instanceof Error
+											? error.message
+											: "BlockStream error",
+										{ cause: error instanceof Error ? error : undefined },
+									),
+					),
+				),
+			);
+		}),
+	);