voltaire-effect 0.2.23 → 0.2.25

package/src/services/Contract/Contract.test.ts

@@ -101,20 +101,25 @@ const erc20Abi = S.decodeUnknownSync(fromArray)([
 	},
 ]) as any;
 
+const mockCallFn = vi.fn();
+const mockGetLogsFn = vi.fn();
+const mockEstimateGasFn = vi.fn();
+
 const mockProvider = {
-	call: vi.fn(),
-	getLogs: vi.fn(),
-	getBlockNumber: vi.fn(),
-	getBalance: vi.fn(),
-	getBlock: vi.fn(),
-	getTransaction: vi.fn(),
-	getTransactionReceipt: vi.fn(),
-	getTransactionCount: vi.fn(),
-	getCode: vi.fn(),
-	getStorageAt: vi.fn(),
-	estimateGas: vi.fn(),
-	getChainId: vi.fn(),
-	getGasPrice: vi.fn(),
+	request: <T>(method: string, params?: unknown[]) => {
+		switch (method) {
+			case "eth_call":
+				return mockCallFn(params?.[0], params?.[1]) as Effect.Effect<T, never>;
+			case "eth_getLogs":
+				return mockGetLogsFn(params?.[0]) as Effect.Effect<T, never>;
+			case "eth_estimateGas":
+				return mockEstimateGasFn(params?.[0]) as Effect.Effect<T, never>;
+			case "eth_chainId":
+				return Effect.succeed("0x1" as T);
+			default:
+				return Effect.succeed(null as T);
+		}
+	},
 };
 
 const mockSigner = {
@@ -219,7 +224,7 @@ describe("Contract", () => {
 	describe("read methods", () => {
 		it("calls eth_call with encoded function data", async () => {
 			const expectedBalance = 1000000000000000000n;
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType,
 				),
@@ -237,12 +242,12 @@ describe("Contract", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalled();
+			expect(mockCallFn).toHaveBeenCalled();
 			expect(result).toBe(expectedBalance);
 		});
 
 		it("handles view function with no args", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType,
 				),
@@ -258,7 +263,7 @@ describe("Contract", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalled();
+			expect(mockCallFn).toHaveBeenCalled();
 			expect(typeof result).toBe("bigint");
 		});
 
@@ -268,7 +273,7 @@ describe("Contract", () => {
 			const reserve0 = 1000000000000000000n;
 			const reserve1 = 2000000000000000000n;
 			const blockTimestamp = 1234567890n;
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					("0x" +
 						reserve0.toString(16).padStart(64, "0") +
@@ -296,7 +301,7 @@ describe("Contract", () => {
 		});
 
 		it("returns ContractCallError on failure", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(new Error("execution reverted")),
 			);
 
@@ -315,7 +320,7 @@ describe("Contract", () => {
 		});
 
 		it("returns ContractCallError for malformed return data (empty 0x)", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x" as HexType));
 
 			const program = Effect.gen(function* () {
 				const contract = yield* Contract(testAddress, erc20Abi);
@@ -336,7 +341,7 @@ describe("Contract", () => {
 		});
 
 		it("returns ContractCallError for return data too short", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x1234" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x1234" as HexType));
 
 			const program = Effect.gen(function* () {
 				const contract = yield* Contract(testAddress, erc20Abi);
@@ -357,7 +362,7 @@ describe("Contract", () => {
 		});
 
 		it("returns ContractCallError for odd-length hex", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x123" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x123" as HexType));
 
 			const program = Effect.gen(function* () {
 				const contract = yield* Contract(testAddress, erc20Abi);
@@ -702,7 +707,7 @@ describe("Contract", () => {
 
 	describe("simulate methods", () => {
 		it("calls eth_call without sending transaction", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000000000000000001" as HexType,
 				),
@@ -721,13 +726,13 @@ describe("Contract", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalled();
+			expect(mockCallFn).toHaveBeenCalled();
 			expect(mockSigner.sendTransaction).not.toHaveBeenCalled();
 			expect(result).toBe(true);
 		});
 
 		it("handles zero-output function (sync)", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x" as HexType));
 
 			const program = Effect.gen(function* () {
 				const contract = yield* Contract(testAddress, erc20Abi);
@@ -739,14 +744,14 @@ describe("Contract", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalled();
+			expect(mockCallFn).toHaveBeenCalled();
 			expect(result).toBeUndefined();
 		});
 	});
 
 	describe("getEvents", () => {
 		it("fetches and decodes events", async () => {
-			mockProvider.getLogs.mockReturnValue(
+			mockGetLogsFn.mockReturnValue(
 				Effect.succeed([
 					{
 						address: testAddress,
@@ -776,13 +781,13 @@ describe("Contract", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.getLogs).toHaveBeenCalled();
+			expect(mockGetLogsFn).toHaveBeenCalled();
 			expect(result.length).toBe(1);
 			expect(result[0].eventName).toBe("Transfer");
 		});
 
 		it("applies event filters", async () => {
-			mockProvider.getLogs.mockReturnValue(Effect.succeed([]));
+			mockGetLogsFn.mockReturnValue(Effect.succeed([]));
 
 			const program = Effect.gen(function* () {
 				const contract = yield* Contract(testAddress, erc20Abi);
@@ -796,8 +801,8 @@ describe("Contract", () => {
 
 			await Effect.runPromise(program.pipe(Effect.provide(MockProviderLayer)));
 
-			expect(mockProvider.getLogs).toHaveBeenCalled();
-			const callArgs = mockProvider.getLogs.mock.calls[0][0];
+			expect(mockGetLogsFn).toHaveBeenCalled();
+			const callArgs = mockGetLogsFn.mock.calls[0][0];
 			expect(callArgs.address).toBe(Address.toHex(testAddress));
 		});
 
@@ -820,7 +825,7 @@ describe("Contract", () => {
 		});
 
 		it("handles fromBlock: 0n (genesis block)", async () => {
-			mockProvider.getLogs.mockReturnValue(Effect.succeed([]));
+			mockGetLogsFn.mockReturnValue(Effect.succeed([]));
 
 			const program = Effect.gen(function* () {
 				const contract = yield* Contract(testAddress, erc20Abi);
@@ -832,13 +837,13 @@ describe("Contract", () => {
 
 			await Effect.runPromise(program.pipe(Effect.provide(MockProviderLayer)));
 
-			expect(mockProvider.getLogs).toHaveBeenCalled();
-			const callArgs = mockProvider.getLogs.mock.calls[0][0];
+			expect(mockGetLogsFn).toHaveBeenCalled();
+			const callArgs = mockGetLogsFn.mock.calls[0][0];
 			expect(callArgs.fromBlock).toBe("0x0");
 		});
 
 		it("handles large block numbers", async () => {
-			mockProvider.getLogs.mockReturnValue(Effect.succeed([]));
+			mockGetLogsFn.mockReturnValue(Effect.succeed([]));
 
 			const largeBlockNumber = 999999999999999n;
 			const program = Effect.gen(function* () {
@@ -850,13 +855,13 @@ describe("Contract", () => {
 
 			await Effect.runPromise(program.pipe(Effect.provide(MockProviderLayer)));
 
-			expect(mockProvider.getLogs).toHaveBeenCalled();
-			const callArgs = mockProvider.getLogs.mock.calls[0][0];
+			expect(mockGetLogsFn).toHaveBeenCalled();
+			const callArgs = mockGetLogsFn.mock.calls[0][0];
 			expect(callArgs.fromBlock).toBe(`0x${largeBlockNumber.toString(16)}`);
 		});
 
 		it("returns ContractEventError for wrong topics length", async () => {
-			mockProvider.getLogs.mockReturnValue(
+			mockGetLogsFn.mockReturnValue(
 				Effect.succeed([
 					{
 						address: testAddress,
@@ -890,7 +895,7 @@ describe("Contract", () => {
 		});
 
 		it("returns ContractEventError for malformed topic hex", async () => {
-			mockProvider.getLogs.mockReturnValue(
+			mockGetLogsFn.mockReturnValue(
 				Effect.succeed([
 					{
 						address: testAddress,
@@ -928,7 +933,7 @@ describe("Contract", () => {
 
 	describe("error handling", () => {
 		it("decode error from read method is catchable with Effect.catchTag", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x1234" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x1234" as HexType));
 
 			const abiWithMissingFn = [
 				{
@@ -957,7 +962,7 @@ describe("Contract", () => {
 		});
 
 		it("decode error from simulate method is catchable with Effect.catchTag", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x1234" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x1234" as HexType));
 
 			const abiWithMissingFn = [
 				{

package/src/services/Contract/Contract.ts

@@ -38,6 +38,7 @@ import {
 	type LogFilter as ProviderLogFilter,
 	ProviderService,
 } from "../Provider/index.js";
+import { call, getLogs } from "../Provider/functions/index.js";
 import { SignerService } from "../Signer/index.js";
 
 type AddressType = BrandedAddress.AddressType;
@@ -230,7 +231,6 @@ const ContractFactory: ContractFactory = <TAbi extends Abi>(
 	abi: TAbi,
 ): Effect.Effect<ContractInstance<TAbi>, never, ProviderService> =>
 	Effect.gen(function* () {
-		const provider = yield* ProviderService;
 		const abiItems = abi as readonly AbiItem[];
 		const addressHex =
 			typeof address === "string"
@@ -263,23 +263,21 @@ const ContractFactory: ContractFactory = <TAbi extends Abi>(
 			(
 				read as unknown as Record<
 					string,
-					(...args: unknown[]) => Effect.Effect<unknown, ContractCallError>
+					(...args: unknown[]) => Effect.Effect<unknown, ContractCallError, ProviderService>
 				>
 			)[fn.name] = (...args: unknown[]) =>
 				Effect.gen(function* () {
 					const data = encodeArgs(abiItems, fn.name, args);
-					const result = yield* provider
-						.call({ to: addressHex, data })
-						.pipe(
-							Effect.mapError(
-								(e) =>
-									new ContractCallError(
-										{ address: addressHex, method: fn.name, args },
-										e.message,
-										{ cause: e },
-									),
-							),
-						);
+					const result = yield* call({ to: addressHex, data }).pipe(
+						Effect.mapError(
+							(e) =>
+								new ContractCallError(
+									{ address: addressHex, method: fn.name, args },
+									e.message,
+									{ cause: e },
+								),
+						),
+					);
 					return yield* decodeResultE(abiItems, fn.name, result as HexType, {
 						address: addressHex,
 						args,
@@ -350,12 +348,12 @@ const ContractFactory: ContractFactory = <TAbi extends Abi>(
 			(
 				simulate as unknown as Record<
 					string,
-					(...args: unknown[]) => Effect.Effect<unknown, ContractCallError>
+					(...args: unknown[]) => Effect.Effect<unknown, ContractCallError, ProviderService>
 				>
 			)[fn.name] = (...args: unknown[]) =>
 				Effect.gen(function* () {
 					const data = encodeArgs(abiItems, fn.name, args);
-					const result = yield* provider.call({ to: addressHex, data }).pipe(
+					const result = yield* call({ to: addressHex, data }).pipe(
 						Effect.mapError(
 							(e) =>
 								new ContractCallError(
@@ -380,7 +378,7 @@ const ContractFactory: ContractFactory = <TAbi extends Abi>(
 		const getEvents = <E extends string>(
 			eventName: E,
 			filter?: EventFilter,
-		): Effect.Effect<DecodedEvent[], ContractEventError> =>
+		): Effect.Effect<DecodedEvent[], ContractEventError, ProviderService> =>
 			Effect.gen(function* () {
 				const topic = yield* getEventTopicE(abiItems, eventName, addressHex);
 
@@ -399,18 +397,16 @@ const ContractFactory: ContractFactory = <TAbi extends Abi>(
 					toBlock: toProviderBlockTag(filter?.toBlock),
 				};
 
-				const logs = yield* provider
-					.getLogs(logFilter)
-					.pipe(
-						Effect.mapError(
-							(e) =>
-								new ContractEventError(
-									{ address: addressHex, event: eventName, filter },
-									e.message,
-									{ cause: e },
-								),
-						),
-					);
+				const logs = yield* getLogs(logFilter).pipe(
+					Effect.mapError(
+						(e) =>
+							new ContractEventError(
+								{ address: addressHex, event: eventName, filter },
+								e.message,
+								{ cause: e },
+							),
+					),
+				);
 
 				return yield* Effect.forEach(logs, (log) =>
 					decodeEventLogE(abiItems, eventName, log, addressHex),

package/src/services/Contract/ContractTypes.ts

@@ -80,6 +80,7 @@ export type AbiItem = {
 export type Abi = readonly AbiItem[];
 
 import type * as Effect from "effect/Effect";
+import type { ProviderService } from "../Provider/index.js";
 import type { SignerService } from "../Signer/index.js";
 
 /**
@@ -283,7 +284,7 @@ export interface ContractInstance<TAbi extends Abi> {
 	readonly getEvents: <E extends ExtractEventNames<TAbi>>(
 		eventName: E,
 		filter?: EventFilter,
-	) => Effect.Effect<DecodedEvent[], ContractEventError>;
+	) => Effect.Effect<DecodedEvent[], ContractEventError, ProviderService>;
 }
 
 type ExtractViewFunctions<TAbi extends Abi> = Extract<
@@ -374,7 +375,8 @@ type ContractReadMethods<TAbi extends Abi> = {
 				? AbiOutputToTs<O>
 				: unknown
 			: unknown,
-		ContractCallError
+		ContractCallError,
+		ProviderService
 	>;
 };
 
@@ -407,6 +409,7 @@ type ContractSimulateMethods<TAbi extends Abi> = {
 				? AbiOutputToTs<O>
 				: unknown
 			: unknown,
-		ContractCallError
+		ContractCallError,
+		ProviderService
 	>;
 };

package/src/services/Contract/estimateGas.test.ts

@@ -32,8 +32,19 @@ const erc20Abi = S.decodeUnknownSync(fromArray)([
 	},
 ]);
 
+const mockEstimateGasFn = vi.fn();
+
 const mockProvider = {
-	estimateGas: vi.fn(),
+	request: <T>(method: string, params?: unknown[]) => {
+		switch (method) {
+			case "eth_estimateGas":
+				return mockEstimateGasFn(params?.[0]) as Effect.Effect<T, never>;
+			case "eth_chainId":
+				return Effect.succeed("0x1" as T);
+			default:
+				return Effect.succeed(null as T);
+		}
+	},
 };
 
 const MockProviderLayer = Layer.succeed(ProviderService, mockProvider as any);
@@ -43,10 +54,10 @@ describe("Contract.estimateGas", () => {
 		vi.clearAllMocks();
 	});
 
-	it("encodes data and calls provider.estimateGas", async () => {
+	it("encodes data and calls estimateGas", async () => {
 		const recipient = Address("0x1234567890123456789012345678901234567890");
 		const amount = 1000n;
-		mockProvider.estimateGas.mockReturnValue(Effect.succeed(45000n));
+		mockEstimateGasFn.mockReturnValue(Effect.succeed("0xafc8")); // 45000 in hex
 
 		const program = Effect.gen(function* () {
 			const contract = yield* Contract(testAddress, erc20Abi);
@@ -61,9 +72,9 @@ describe("Contract.estimateGas", () => {
 		);
 
 		expect(gas).toBe(45000n);
-		expect(mockProvider.estimateGas).toHaveBeenCalledTimes(1);
+		expect(mockEstimateGasFn).toHaveBeenCalledTimes(1);
 
-		const callArgs = mockProvider.estimateGas.mock.calls[0][0];
+		const callArgs = mockEstimateGasFn.mock.calls[0][0];
 		const expectedData = BrandedAbi.encodeFunction(
 			erc20Abi as unknown as BrandedAbi.Abi,
 			"transfer",
@@ -76,7 +87,7 @@ describe("Contract.estimateGas", () => {
 
 	it("passes value for payable methods", async () => {
 		const value = 1000000000000000000n;
-		mockProvider.estimateGas.mockReturnValue(Effect.succeed(21000n));
+		mockEstimateGasFn.mockReturnValue(Effect.succeed("0x5208")); // hex response from RPC
 
 		const program = Effect.gen(function* () {
 			const contract = yield* Contract(testAddress, erc20Abi);
@@ -85,7 +96,7 @@ describe("Contract.estimateGas", () => {
 
 		await Effect.runPromise(program.pipe(Effect.provide(MockProviderLayer)));
 
-		const callArgs = mockProvider.estimateGas.mock.calls[0][0];
+		const callArgs = mockEstimateGasFn.mock.calls[0][0];
 		const expectedData = BrandedAbi.encodeFunction(
 			erc20Abi as unknown as BrandedAbi.Abi,
 			"deposit",
@@ -93,12 +104,13 @@ describe("Contract.estimateGas", () => {
 		);
 
 		expect(callArgs.data as HexType).toBe(expectedData as HexType);
-		expect(callArgs.value).toBe(value);
+		// Value is hex-encoded for RPC
+		expect(callArgs.value).toBe(`0x${value.toString(16)}`);
 	});
 
 	it("maps provider errors to ContractCallError", async () => {
 		const recipient = Address("0x1234567890123456789012345678901234567890");
-		mockProvider.estimateGas.mockReturnValue(
+		mockEstimateGasFn.mockReturnValue(
 			Effect.fail(new Error("estimate failed")),
 		);
 

package/src/services/Contract/estimateGas.ts

@@ -7,6 +7,7 @@
 
 import { Address, BrandedAbi, type BrandedAddress } from "@tevm/voltaire";
 import * as Effect from "effect/Effect";
+import { estimateGas as estimateGasRpc } from "../Provider/functions/index.js";
 import { ProviderService } from "../Provider/index.js";
 import {
 	type Abi,
@@ -91,7 +92,6 @@ export const estimateGas = <
 	args?: WriteMethodArgs<TAbi, TFunctionName>,
 ): Effect.Effect<bigint, ContractCallError, ProviderService> =>
 	Effect.gen(function* () {
-		const provider = yield* ProviderService;
 		const addressHex = getAddressHex(contract.address as AddressType);
 		const abiItems = contract.abi as readonly AbiItem[];
 		const functionLabel = String(methodName);
@@ -138,26 +138,24 @@ export const estimateGas = <
 				),
 		});
 
-		return yield* provider
-			.estimateGas({
-				to: addressHex,
-				data,
-				value: options?.value,
-				gas: options?.gas,
-			})
-			.pipe(
-				Effect.mapError(
-					(e) =>
-						new ContractCallError(
-							{
-								address: addressHex,
-								method: functionLabel,
-								args: callArgs,
-								value: options?.value,
-							},
-							e.message,
-							{ cause: e },
-						),
-				),
-			);
+		return yield* estimateGasRpc({
+			to: addressHex,
+			data,
+			value: options?.value,
+			gas: options?.gas,
+		}).pipe(
+			Effect.mapError(
+				(e) =>
+					new ContractCallError(
+						{
+							address: addressHex,
+							method: functionLabel,
+							args: callArgs,
+							value: options?.value,
+						},
+						e.message,
+						{ cause: e },
+					),
+			),
+		);
 	});

package/src/services/Debug/Debug.ts

@@ -13,7 +13,7 @@ import type {
 	CallRequest,
 	HashInput,
 	TransactionIndexInput,
-} from "../Provider/ProviderService.js";
+} from "../Provider/types.js";
 import { TransportService } from "../Transport/TransportService.js";
 import { DebugService } from "./DebugService.js";
 

package/src/services/Debug/DebugService.ts

@@ -13,7 +13,7 @@ import type {
 	CallRequest,
 	HashInput,
 	TransactionIndexInput,
-} from "../Provider/ProviderService.js";
+} from "../Provider/types.js";
 import type { TransportError } from "../Transport/TransportError.js";
 
 /**

package/src/services/FeeEstimator/DefaultFeeEstimator.ts

@@ -18,6 +18,11 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { ProviderService } from "../Provider/index.js";
+import {
+	getGasPrice,
+	getBlock,
+	getMaxPriorityFeePerGas,
+} from "../Provider/functions/index.js";
 import {
 	FeeEstimationError,
 	FeeEstimatorService,
@@ -89,7 +94,6 @@ const makeDefaultFeeEstimator = (
 	Layer.effect(
 		FeeEstimatorService,
 		Effect.gen(function* () {
-			const provider = yield* ProviderService;
 			const multiplierNumerator = BigInt(
 				Math.round(baseFeeMultiplier * MULTIPLIER_PRECISION_NUMBER),
 			);
@@ -100,7 +104,7 @@ const makeDefaultFeeEstimator = (
 				ProviderService
 			> =>
 				Effect.gen(function* () {
-					const gasPrice = yield* provider.getGasPrice().pipe(
+					const gasPriceValue = yield* getGasPrice().pipe(
 						Effect.mapError(
 							(e) =>
 								new FeeEstimationError({
@@ -110,7 +114,7 @@ const makeDefaultFeeEstimator = (
 						),
 					);
 					const validatedGasPrice = yield* ensureReasonableGasPrice(
-						gasPrice,
+						gasPriceValue,
 						"Gas price",
 					);
 					return { gasPrice: validatedGasPrice };
@@ -123,7 +127,7 @@ const makeDefaultFeeEstimator = (
 			> =>
 				Effect.gen(function* () {
 					const [block, priorityFee] = yield* Effect.all([
-						provider.getBlock({ blockTag: "latest" }).pipe(
+						getBlock({ blockTag: "latest" }).pipe(
 							Effect.mapError(
 								(e) =>
 									new FeeEstimationError({
@@ -132,7 +136,7 @@ const makeDefaultFeeEstimator = (
 									}),
 							),
 						),
-						provider.getMaxPriorityFeePerGas().pipe(
+						getMaxPriorityFeePerGas().pipe(
 							Effect.mapError(
 								(e) =>
 									new FeeEstimationError({
@@ -185,7 +189,7 @@ const makeDefaultFeeEstimator = (
 					type === "legacy" ? estimateLegacy() : estimateEIP1559(),
 
 				getMaxPriorityFeePerGas: () =>
-					provider.getMaxPriorityFeePerGas().pipe(
+					getMaxPriorityFeePerGas().pipe(
 						Effect.mapError(
 							(e) =>
 								new FeeEstimationError({