voltaire-effect 0.2.23 → 0.2.25

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

@@ -36,25 +36,15 @@ const erc20Abi = S.decodeUnknownSync(fromArray)([
 	},
 ]);
 
+const mockCallFn = 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(),
-	waitForTransactionReceipt: vi.fn(),
-	getTransactionCount: vi.fn(),
-	getCode: vi.fn(),
-	getStorageAt: vi.fn(),
-	estimateGas: vi.fn(),
-	createAccessList: vi.fn(),
-	getChainId: vi.fn(),
-	getGasPrice: vi.fn(),
-	getMaxPriorityFeePerGas: vi.fn(),
-	getFeeHistory: vi.fn(),
-	getBlockTransactionCount: vi.fn(),
+	request: <T>(method: string, params?: unknown[]) => {
+		if (method === "eth_call") {
+			return mockCallFn(params?.[0], params?.[1]) as Effect.Effect<T, never>;
+		}
+		return Effect.succeed(null as T);
+	},
 };
 
 const MockProviderLayer = Layer.succeed(ProviderService, mockProvider as any);
@@ -90,7 +80,7 @@ describe("multicall", () => {
 			const balance2 =
 				"0x00000000000000000000000000000000000000000000021e19e0c9bab2400000" as HexType;
 
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{ success: true, returnData: balance1 },
@@ -120,12 +110,12 @@ describe("multicall", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalledTimes(1);
+			expect(mockCallFn).toHaveBeenCalledTimes(1);
 			expect(result).toEqual([1000000000000000000n, 10000000000000000000000n]);
 		});
 
 		it("calls Multicall3 at correct address", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{
@@ -150,7 +140,7 @@ describe("multicall", () => {
 
 			await Effect.runPromise(program.pipe(Effect.provide(MockProviderLayer)));
 
-			expect(mockProvider.call).toHaveBeenCalledWith(
+			expect(mockCallFn).toHaveBeenCalledWith(
 				expect.objectContaining({
 					to: "0xcA11bde05977b3631167028862bE2a173976CA11",
 				}),
@@ -164,7 +154,7 @@ describe("multicall", () => {
 			const balance1 =
 				"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType;
 
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{ success: true, returnData: balance1 },
@@ -202,7 +192,7 @@ describe("multicall", () => {
 			const balance1 =
 				"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType;
 
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{ success: true, returnData: balance1 },
@@ -247,7 +237,7 @@ describe("multicall", () => {
 			const balance2 =
 				"0x00000000000000000000000000000000000000000000021e19e0c9bab2400000" as HexType;
 
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{ success: true, returnData: balance1 },
@@ -291,7 +281,7 @@ describe("multicall", () => {
 			const balance3 =
 				"0x0000000000000000000000000000000000000000000000000000000000000005" as HexType;
 
-			mockProvider.call
+			mockCallFn
 				.mockReturnValueOnce(
 					Effect.succeed(
 						encodeMulticallResult([
@@ -333,7 +323,7 @@ describe("multicall", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalledTimes(2);
+			expect(mockCallFn).toHaveBeenCalledTimes(2);
 			expect(result).toEqual([
 				1000000000000000000n,
 				10000000000000000000000n,
@@ -344,7 +334,7 @@ describe("multicall", () => {
 
 	describe("single call", () => {
 		it("works with single contract call", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{
@@ -376,7 +366,7 @@ describe("multicall", () => {
 
 	describe("empty array", () => {
 		it("returns empty array for empty contracts", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(encodeMulticallResult([])),
 			);
 
@@ -393,8 +383,8 @@ describe("multicall", () => {
 	});
 
 	describe("block tag", () => {
-		it("passes block tag to provider.call", async () => {
-			mockProvider.call.mockReturnValue(
+		it("passes block tag to call", async () => {
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{
@@ -420,7 +410,7 @@ describe("multicall", () => {
 
 			await Effect.runPromise(program.pipe(Effect.provide(MockProviderLayer)));
 
-			expect(mockProvider.call).toHaveBeenCalledWith(
+			expect(mockCallFn).toHaveBeenCalledWith(
 				expect.any(Object),
 				"finalized",
 			);
@@ -456,7 +446,7 @@ describe("multicall", () => {
 				"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType;
 			const revertData = "0x08c379a0" as HexType;
 
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{ success: true, returnData: balance1 },
@@ -501,7 +491,7 @@ describe("multicall", () => {
 		});
 
 		it("handles all calls failing with allowFailure true", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{ success: false, returnData: "0x" },
@@ -539,7 +529,7 @@ describe("multicall", () => {
 			const balance1 =
 				"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType;
 
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					encodeMulticallResult([
 						{ success: true, returnData: balance1 },
@@ -586,7 +576,7 @@ describe("multicall", () => {
 
 	describe("transport error propagation", () => {
 		it("propagates transport errors", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: -32603,
@@ -618,7 +608,7 @@ describe("multicall", () => {
 		});
 
 		it("propagates timeout errors", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: -32000,
@@ -650,7 +640,7 @@ describe("multicall", () => {
 		});
 
 		it("propagates rate limit errors", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: 429,
@@ -682,7 +672,7 @@ describe("multicall", () => {
 		});
 
 		it("propagates Multicall3 contract not deployed error", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: -32000,

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

@@ -22,6 +22,7 @@ import {
 	ProviderService,
 	ProviderValidationError,
 } from "../ProviderService.js";
+import { call } from "../functions/call.js";
 import type { Abi } from "./readContract.js";
 
 type AddressType = BrandedAddress.AddressType;
@@ -214,7 +215,6 @@ export const multicall = <TContracts extends readonly ContractCall[]>(
 	ProviderService
 > =>
 	Effect.gen(function* () {
-		const provider = yield* ProviderService;
 		const allowFailure = params.allowFailure ?? true;
 
 		if (params.contracts.length === 0) {
@@ -245,7 +245,7 @@ export const multicall = <TContracts extends readonly ContractCall[]>(
 				[calls],
 			);
 
-			const result = yield* provider.call(
+			const result = yield* call(
 				{ to: MULTICALL3_ADDRESS, data },
 				params.blockTag,
 			);

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

@@ -155,25 +155,20 @@ const complexAbi = S.decodeUnknownSync(fromArray)([
 	},
 ]);
 
+const mockCallFn = 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(),
-	waitForTransactionReceipt: vi.fn(),
-	getTransactionCount: vi.fn(),
-	getCode: vi.fn(),
-	getStorageAt: vi.fn(),
-	estimateGas: vi.fn(),
-	createAccessList: vi.fn(),
-	getChainId: vi.fn(),
-	getGasPrice: vi.fn(),
-	getMaxPriorityFeePerGas: vi.fn(),
-	getFeeHistory: vi.fn(),
-	getBlockTransactionCount: vi.fn(),
+	request: <T>(method: string, params?: unknown[]) => {
+		if (method === "eth_call") {
+			return mockCallFn(params?.[0], params?.[1]) as Effect.Effect<T, never>;
+		}
+		return Effect.succeed(null as T);
+	},
+};
+
+// Helper to set up mock call return value
+const setMockCallReturn = (returnValue: Effect.Effect<unknown, unknown>) => {
+	mockCallFn.mockReturnValue(returnValue);
 };
 
 const MockProviderLayer = Layer.succeed(ProviderService, mockProvider as any);
@@ -186,7 +181,7 @@ describe("readContract", () => {
 	describe("ERC-20 balanceOf", () => {
 		it("reads balance with single argument", async () => {
 			const expectedBalance = 1000000000000000000n;
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType,
 				),
@@ -203,12 +198,12 @@ describe("readContract", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalled();
+			expect(mockCallFn).toHaveBeenCalled();
 			expect(result).toBe(expectedBalance);
 		});
 
 		it("accepts branded address input", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType,
 				),
@@ -232,7 +227,7 @@ describe("readContract", () => {
 
 	describe("functions with no arguments", () => {
 		it("reads totalSupply without args", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x00000000000000000000000000000000000000000000d3c21bcecceda1000000" as HexType,
 				),
@@ -248,12 +243,12 @@ describe("readContract", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalled();
+			expect(mockCallFn).toHaveBeenCalled();
 			expect(typeof result).toBe("bigint");
 		});
 
 		it("reads decimals", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000000000000000012" as HexType,
 				),
@@ -275,7 +270,7 @@ describe("readContract", () => {
 
 	describe("multi-return functions", () => {
 		it("reads getReserves with multiple return values", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					("0x" +
 						"00000000000000000000000000000000000000000000021e19e0c9bab2400000" +
@@ -301,7 +296,7 @@ describe("readContract", () => {
 
 	describe("complex arguments", () => {
 		it("handles two address arguments", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType,
 				),
@@ -321,12 +316,12 @@ describe("readContract", () => {
 				program.pipe(Effect.provide(MockProviderLayer)),
 			);
 
-			expect(mockProvider.call).toHaveBeenCalled();
+			expect(mockCallFn).toHaveBeenCalled();
 			expect(typeof result).toBe("bigint");
 		});
 
 		it("handles mixed argument types (address + bool)", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					("0x" +
 						"0000000000000000000000000000000000000000000000000de0b6b3a7640000" +
@@ -350,8 +345,8 @@ describe("readContract", () => {
 	});
 
 	describe("block tag", () => {
-		it("passes block tag to provider.call", async () => {
-			mockProvider.call.mockReturnValue(
+		it("passes block tag to call", async () => {
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType,
 				),
@@ -367,14 +362,14 @@ describe("readContract", () => {
 
 			await Effect.runPromise(program.pipe(Effect.provide(MockProviderLayer)));
 
-			expect(mockProvider.call).toHaveBeenCalledWith(
+			expect(mockCallFn).toHaveBeenCalledWith(
 				expect.any(Object),
 				"finalized",
 			);
 		});
 
 		it("uses latest by default", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType,
 				),
@@ -389,7 +384,7 @@ describe("readContract", () => {
 
 			await Effect.runPromise(program.pipe(Effect.provide(MockProviderLayer)));
 
-			expect(mockProvider.call).toHaveBeenCalledWith(
+			expect(mockCallFn).toHaveBeenCalledWith(
 				expect.any(Object),
 				undefined,
 			);
@@ -398,7 +393,7 @@ describe("readContract", () => {
 
 	describe("error handling", () => {
 		it("surfaces transport errors on call failure", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: -32000,
@@ -425,7 +420,7 @@ describe("readContract", () => {
 		});
 
 		it("preserves transport error message", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: -32000,
@@ -451,7 +446,7 @@ describe("readContract", () => {
 		});
 
 		it("fails when function not found in ABI", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" as HexType,
 				),
@@ -480,7 +475,7 @@ describe("readContract", () => {
 				"0000000000000000000000000000000000000000000000000000000000000020" +
 				"0000000000000000000000000000000000000000000000000000000000000012" +
 				"496e73756666696369656e742062616c616e63650000000000000000000000";
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: 3,
@@ -509,7 +504,7 @@ describe("readContract", () => {
 
 		it("handles contract revert with custom error", async () => {
 			const customErrorSelector = "0xcf479181";
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: 3,
@@ -537,7 +532,7 @@ describe("readContract", () => {
 		});
 
 		it("propagates transport errors", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: -32603,
@@ -564,7 +559,7 @@ describe("readContract", () => {
 		});
 
 		it("propagates timeout errors", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: -32000,
@@ -591,7 +586,7 @@ describe("readContract", () => {
 		});
 
 		it("propagates rate limit errors", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(
 					new TransportError({
 						code: 429,
@@ -618,7 +613,7 @@ describe("readContract", () => {
 		});
 
 		it("handles empty return data (0x) for function expecting outputs", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x" as HexType));
 
 			const program = readContract({
 				address: "0x6B175474E89094C44Da98b954EecdEfaE6E286AB",
@@ -635,7 +630,7 @@ describe("readContract", () => {
 		});
 
 		it("handles malformed hex (odd length)", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x123" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x123" as HexType));
 
 			const program = readContract({
 				address: "0x6B175474E89094C44Da98b954EecdEfaE6E286AB",
@@ -654,7 +649,7 @@ describe("readContract", () => {
 
 	describe("output type handling", () => {
 		it("handles address output type", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045" as HexType,
 				),
@@ -675,7 +670,7 @@ describe("readContract", () => {
 		});
 
 		it("handles bool output type - true", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000000000000000001" as HexType,
 				),
@@ -695,7 +690,7 @@ describe("readContract", () => {
 		});
 
 		it("handles bool output type - false", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000000000000000000" as HexType,
 				),
@@ -717,7 +712,7 @@ describe("readContract", () => {
 		it("handles bytes32 output type", async () => {
 			const merkleRoot =
 				"0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
-			mockProvider.call.mockReturnValue(Effect.succeed(merkleRoot as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed(merkleRoot as HexType));
 
 			const program = readContract({
 				address: "0x1234567890123456789012345678901234567890",
@@ -733,7 +728,7 @@ describe("readContract", () => {
 		});
 
 		it("handles dynamic array (uint256[]) output", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					("0x" +
 						"0000000000000000000000000000000000000000000000000000000000000020" +
@@ -763,7 +758,7 @@ describe("readContract", () => {
 		});
 
 		it("handles tuple/struct output", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					("0x" +
 						"000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045" +
@@ -789,7 +784,7 @@ describe("readContract", () => {
 		});
 
 		it("handles zero output function", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x" as HexType));
+			mockCallFn.mockReturnValue(Effect.succeed("0x" as HexType));
 
 			const program = readContract({
 				address: "0x1234567890123456789012345678901234567890",

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

@@ -22,6 +22,7 @@ import {
 	Hex,
 } from "@tevm/voltaire";
 import * as Effect from "effect/Effect";
+import { call } from "../functions/call.js";
 import {
 	type AddressInput,
 	type BlockTag,
@@ -269,8 +270,6 @@ export const readContract = <
 	ProviderService
 > =>
 	Effect.gen(function* () {
-		const provider = yield* ProviderService;
-
 		const addressHex =
 			typeof params.address === "string"
 				? params.address
@@ -282,10 +281,7 @@ export const readContract = <
 			(params.args ?? []) as unknown[],
 		);
 
-		const result = yield* provider.call(
-			{ to: addressHex, data },
-			params.blockTag,
-		);
+		const result = yield* call({ to: addressHex, data }, params.blockTag);
 
 		const fn = (params.abi as readonly AbiItem[]).find(
 			(item): item is BrandedAbi.Function.FunctionType =>