voltaire-effect 0.2.23 → 0.2.25

package/src/services/Transport/FallbackTransport.ts

@@ -90,7 +90,7 @@ const makeRetrySchedule = (retryCount: number, retryDelay: number) => {
  * @example Basic fallback between multiple HTTP transports
  * ```typescript
  * import { Effect } from 'effect'
- * import { FallbackTransport, HttpTransport, ProviderService, Provider } from 'voltaire-effect'
+ * import { FallbackTransport, HttpTransport, Provider, getBlockNumber } from 'voltaire-effect'
  *
  * const transport = FallbackTransport([
  *   HttpTransport('https://eth.llamarpc.com'),
@@ -99,8 +99,8 @@ const makeRetrySchedule = (retryCount: number, retryDelay: number) => {
  * ])
  *
  * const program = Effect.gen(function* () {
- *   const provider = yield* ProviderService
- *   return yield* provider.getBlockNumber()
+ *   const blockNumber = yield* getBlockNumber()
+ *   return blockNumber
  * }).pipe(
  *   Effect.provide(Provider),
  *   Effect.provide(transport)

package/src/services/Transport/HttpTransport.ts

@@ -170,7 +170,7 @@ interface JsonRpcResponse<T> {
  * ```typescript
  * import { Effect, Schedule } from 'effect'
  * import { FetchHttpClient } from '@effect/platform'
- * import { HttpTransport, Provider, ProviderService } from 'voltaire-effect'
+ * import { HttpTransport, Provider, getBlockNumber } from 'voltaire-effect'
  *
  * const transport = HttpTransport({
  *   url: 'https://mainnet.infura.io/v3/YOUR_KEY',
@@ -186,8 +186,8 @@ interface JsonRpcResponse<T> {
  * })
  *
  * const program = Effect.gen(function* () {
- *   const client = yield* ProviderService
- *   return yield* client.getBlockNumber()
+ *   const blockNumber = yield* getBlockNumber()
+ *   return blockNumber
  * }).pipe(
  *   Effect.provide(Provider),
  *   Effect.provide(transport),

package/src/services/Transport/config.ts

@@ -16,13 +16,13 @@
  * @example
  * ```typescript
  * import { Effect, Schedule } from "effect"
- * import { withTimeout, withRetrySchedule } from "voltaire-effect"
+ * import { getBalance, withTimeout, withRetrySchedule } from "voltaire-effect"
  *
  * // Default timeout is 30s with exponential backoff retries
- * const balance = yield* provider.getBalance(addr)
+ * const balance = yield* getBalance(addr)
  *
  * // This call uses a 5s timeout and custom retry schedule
- * const fastBalance = yield* provider.getBalance(addr).pipe(
+ * const fastBalance = yield* getBalance(addr).pipe(
  *   withTimeout("5 seconds"),
  *   withRetrySchedule(Schedule.recurs(1))
  * )
@@ -91,8 +91,8 @@ export const tracingRef: FiberRef.FiberRef<boolean> =
  *
  * @example
  * ```typescript
- * provider.getBalance(addr).pipe(withTimeout("5 seconds"))
- * provider.getBalance(addr).pipe(withTimeout(Duration.seconds(5)))
+ * getBalance(addr).pipe(withTimeout("5 seconds"))
+ * getBalance(addr).pipe(withTimeout(Duration.seconds(5)))
  * ```
  */
 export const withTimeout =
@@ -108,14 +108,14 @@ export const withTimeout =
  *
  * @example Simple retry count
  * ```typescript
- * provider.getBalance(addr).pipe(
+ * getBalance(addr).pipe(
  *   withRetrySchedule(Schedule.recurs(1))
  * )
  * ```
  *
  * @example Exponential backoff with jitter
  * ```typescript
- * provider.getBalance(addr).pipe(
+ * getBalance(addr).pipe(
  *   withRetrySchedule(
  *     Schedule.exponential("500 millis").pipe(
  *       Schedule.jittered,

package/src/services/Transport/index.ts

@@ -20,15 +20,14 @@
  * ```typescript
  * import { Effect } from 'effect'
  * import {
- *   TransportService,
  *   HttpTransport,
  *   Provider,
- *   ProviderService
+ *   getBlockNumber
  * } from 'voltaire-effect'
  *
  * const program = Effect.gen(function* () {
- *   const client = yield* ProviderService
- *   return yield* client.getBlockNumber()
+ *   const blockNumber = yield* getBlockNumber()
+ *   return blockNumber
  * }).pipe(
  *   Effect.provide(Provider),
  *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))

package/src/services/errors.test.ts

@@ -26,10 +26,8 @@ import {
 } from "./Contract/ContractTypes.js";
 import { KzgError } from "./Kzg/KzgService.js";
 import { Provider } from "./Provider/Provider.js";
-import {
-	ProviderResponseError,
-	ProviderService,
-} from "./Provider/ProviderService.js";
+import { getBlockNumber } from "./Provider/functions/index.js";
+import { ProviderResponseError } from "./Provider/ProviderService.js";
 import { SignerError } from "./Signer/SignerService.js";
 import {
 	DeserializeError,
@@ -261,10 +259,7 @@ describe("Error constructor standardization", () => {
 			const layer = Provider.pipe(Layer.provide(transport));
 
 			const exit = await Effect.runPromiseExit(
-				Effect.gen(function* () {
-					const provider = yield* ProviderService;
-					return yield* provider.getBlockNumber();
-				}).pipe(Effect.provide(layer)),
+				getBlockNumber().pipe(Effect.provide(layer)),
 			);
 
 			expect(Exit.isFailure(exit)).toBe(true);

package/src/services/index.ts

@@ -45,18 +45,20 @@
  * Type-safe smart contract interactions.
  * - {@link Contract} - Factory to create contract instances
  *
- * @example Typical usage pattern
+ * @example Typical usage pattern (using free functions - idiomatic Effect.ts)
  * ```typescript
  * import { Effect } from 'effect'
  * import {
- *   ProviderService,
+ *   getBlockNumber,
+ *   getBalance,
  *   Provider,
  *   HttpTransport
  * } from 'voltaire-effect'
  *
  * const program = Effect.gen(function* () {
- *   const provider = yield* ProviderService
- *   return yield* provider.getBlockNumber()
+ *   const blockNumber = yield* getBlockNumber()
+ *   const balance = yield* getBalance('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')
+ *   return { blockNumber, balance }
  * }).pipe(
  *   Effect.provide(Provider),
  *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
@@ -255,92 +257,8 @@ export {
 	NonceManagerService,
 	type NonceManagerShape,
 } from "./NonceManager/index.js";
-// Provider exports
-export {
-	type AccessListType,
-	Account as ProviderAccount,
-	AccountService as ProviderAccountService,
-	type AccountShape as ProviderAccountShape,
-	type BackfillBlocksError,
-	Blocks,
-	BlocksService,
-	type BlocksShape,
-	type BlockTag as ProviderBlockTag,
-	type BlockType,
-	type CallError,
-	type CallRequest,
-	type CreateAccessListError,
-	type CreateBlockFilterError,
-	type CreateEventFilterError,
-	type CreatePendingTransactionFilterError,
-	type EstimateGasError,
-	type EventFilter as ProviderEventFilter,
-	Events,
-	EventsService,
-	type EventsShape,
-	type FeeHistoryType,
-	type FilterChanges as ProviderFilterChanges,
-	type FilterId as ProviderFilterId,
-	type GetBalanceError,
-	type GetBlobBaseFeeError,
-	type GetBlockError,
-	type GetBlockNumberError,
-	type GetBlockTransactionCountError,
-	type GetChainIdError,
-	type GetCodeError,
-	type GetFeeHistoryError,
-	type GetFilterChangesError,
-	type GetFilterLogsError,
-	type GetGasPriceError,
-	type GetLogsError,
-	type GetMaxPriorityFeePerGasError,
-	type GetProofError,
-	type GetStorageAtError,
-	type GetTransactionConfirmationsError,
-	type GetTransactionCountError,
-	type GetTransactionError,
-	type GetTransactionReceiptError,
-	type GetUncleError,
-	type LogFilter as ProviderLogFilter,
-	type LogType,
-	Network,
-	NetworkService,
-	type NetworkShape,
-	Provider,
-	ProviderConfirmationsPendingError,
-	type ProviderError,
-	ProviderNotFoundError,
-	ProviderReceiptPendingError,
-	ProviderResponseError,
-	ProviderService,
-	type ProviderShape,
-	ProviderStreamError,
-	ProviderTimeoutError,
-	ProviderValidationError,
-	type ReceiptType,
-	type SendRawTransactionError,
-	type SimulateV1BlockResult,
-	type SimulateV1CallResult,
-	type SimulateV1Payload,
-	type SimulateV1Result,
-	type SimulateV2Payload,
-	type SimulateV2Result,
-	Simulation,
-	SimulationService,
-	type SimulationShape,
-	Streaming,
-	StreamingService,
-	type StreamingShape,
-	type SyncingStatus,
-	Transaction,
-	TransactionService,
-	type TransactionShape,
-	type TransactionType,
-	type UninstallFilterError,
-	type WaitForTransactionReceiptError,
-	type WatchBlocksError,
-	type WorkResult,
-} from "./Provider/index.js";
+// Provider exports - re-export everything from the Provider module
+export * from "./Provider/index.js";
 // Preset exports (layer composition helpers)
 export {
 	ArbitrumProvider,

package/src/services/presets/index.ts

@@ -11,11 +11,11 @@
  * @example Using MainnetProvider
  * ```typescript
  * import { Effect } from 'effect'
- * import { ProviderService, MainnetProvider } from 'voltaire-effect'
+ * import { getChainId, MainnetProvider } from 'voltaire-effect'
  *
  * const program = Effect.gen(function* () {
- *   const provider = yield* ProviderService
- *   return yield* provider.getChainId()
+ *   const chainId = yield* getChainId()
+ *   return chainId
  * }).pipe(Effect.provide(MainnetProvider('https://mainnet.infura.io/v3/YOUR_KEY')))
  *
  * await Effect.runPromise(program)
@@ -67,12 +67,11 @@ import { HttpTransport } from "../Transport/index.js";
  * @example
  * ```typescript
  * import { Effect } from 'effect'
- * import { ProviderService, MainnetProvider } from 'voltaire-effect'
+ * import { getBlockNumber, getChainId, MainnetProvider } from 'voltaire-effect'
  *
  * const program = Effect.gen(function* () {
- *   const provider = yield* ProviderService
- *   const blockNumber = yield* provider.getBlockNumber()
- *   const chainId = yield* provider.getChainId()
+ *   const blockNumber = yield* getBlockNumber()
+ *   const chainId = yield* getChainId()
  *   return { blockNumber, chainId }
  * }).pipe(Effect.provide(MainnetProvider('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY')))
  *
@@ -100,15 +99,15 @@ export const MainnetProvider = (url: string): Layer.Layer<ProviderService> =>
  * @example
  * ```typescript
  * import { Effect } from 'effect'
- * import { ProviderService, createProvider } from 'voltaire-effect'
+ * import { getChainId, createProvider } from 'voltaire-effect'
  *
  * // Works with any network
  * const arbitrumProvider = createProvider('https://arb1.arbitrum.io/rpc')
  * const optimismProvider = createProvider('https://mainnet.optimism.io')
  *
  * const program = Effect.gen(function* () {
- *   const provider = yield* ProviderService
- *   return yield* provider.getChainId()
+ *   const chainId = yield* getChainId()
+ *   return chainId
  * }).pipe(Effect.provide(arbitrumProvider))
  * ```
  */

package/src/services/presets/presets.test.ts

@@ -1,7 +1,12 @@
 import { describe, expect, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { Provider, ProviderService } from "../Provider/index.js";
+import {
+	Provider,
+	getBalance,
+	getBlockNumber,
+	getChainId,
+} from "../Provider/index.js";
 import { TestTransport } from "../Transport/index.js";
 import { createProvider, MainnetProvider } from "./index.js";
 
@@ -13,13 +18,8 @@ describe("presets", () => {
 					Layer.provide(TestTransport({ eth_chainId: "0x1" })),
 				);
 
-				const program = Effect.gen(function* () {
-					const provider = yield* ProviderService;
-					return yield* provider.getChainId();
-				}).pipe(Effect.provide(testLayer));
-
-				const result = yield* program;
-				expect(result).toBe(1);
+				const result = yield* getChainId().pipe(Effect.provide(testLayer));
+				expect(result).toBe(1n);
 			}),
 		);
 
@@ -29,12 +29,7 @@ describe("presets", () => {
 					Layer.provide(TestTransport({ eth_blockNumber: "0x1234" })),
 				);
 
-				const program = Effect.gen(function* () {
-					const provider = yield* ProviderService;
-					return yield* provider.getBlockNumber();
-				}).pipe(Effect.provide(testLayer));
-
-				const result = yield* program;
+				const result = yield* getBlockNumber().pipe(Effect.provide(testLayer));
 				expect(result).toBe(0x1234n);
 			}),
 		);
@@ -52,13 +47,8 @@ describe("presets", () => {
 					Layer.provide(TestTransport({ eth_chainId: "0xa4b1" })),
 				);
 
-				const program = Effect.gen(function* () {
-					const provider = yield* ProviderService;
-					return yield* provider.getChainId();
-				}).pipe(Effect.provide(testLayer));
-
-				const result = yield* program;
-				expect(result).toBe(42161);
+				const result = yield* getChainId().pipe(Effect.provide(testLayer));
+				expect(result).toBe(42161n);
 			}),
 		);
 
@@ -68,14 +58,9 @@ describe("presets", () => {
 					Layer.provide(TestTransport({ eth_getBalance: "0xde0b6b3a7640000" })),
 				);
 
-				const program = Effect.gen(function* () {
-					const provider = yield* ProviderService;
-					return yield* provider.getBalance(
-						"0x1234567890123456789012345678901234567890",
-					);
-				}).pipe(Effect.provide(testLayer));
-
-				const result = yield* program;
+				const result = yield* getBalance(
+					"0x1234567890123456789012345678901234567890",
+				).pipe(Effect.provide(testLayer));
 				expect(result).toBe(1000000000000000000n);
 			}),
 		);

package/src/standards/ERC165.test.ts

@@ -5,20 +5,19 @@ import * as Layer from "effect/Layer";
 import { ProviderService } from "../services/Provider/index.js";
 import * as ERC165 from "./ERC165.js";
 
+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(),
-	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]) 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(
@@ -96,7 +95,7 @@ describe("ERC165", () => {
 
 	describe("supportsInterface", () => {
 		it("returns true when contract supports interface", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000000000000000001",
 				),
@@ -110,11 +109,11 @@ describe("ERC165", () => {
 			);
 
 			expect(result).toBe(true);
-			expect(mockProvider.call).toHaveBeenCalled();
+			expect(mockCallFn).toHaveBeenCalled();
 		});
 
 		it("returns false when contract does not support interface", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000000000000000000",
 				),
@@ -131,7 +130,7 @@ describe("ERC165", () => {
 		});
 
 		it("returns false on empty response", async () => {
-			mockProvider.call.mockReturnValue(Effect.succeed("0x"));
+			mockCallFn.mockReturnValue(Effect.succeed("0x"));
 
 			const result = await Effect.runPromise(
 				ERC165.supportsInterface(
@@ -144,7 +143,7 @@ describe("ERC165", () => {
 		});
 
 		it("returns false on call failure", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.fail(new Error("execution reverted")),
 			);
 
@@ -161,7 +160,7 @@ describe("ERC165", () => {
 
 	describe("detectInterfaces", () => {
 		it("returns empty array when contract does not support ERC165", async () => {
-			mockProvider.call.mockReturnValue(
+			mockCallFn.mockReturnValue(
 				Effect.succeed(
 					"0x0000000000000000000000000000000000000000000000000000000000000000",
 				),
@@ -177,7 +176,7 @@ describe("ERC165", () => {
 		});
 
 		it("returns detected interfaces when contract supports ERC165", async () => {
-			mockProvider.call.mockImplementation(({ data }: { data: string }) => {
+			mockCallFn.mockImplementation(({ data }: { data: string }) => {
 				const encodedERC165 = "01ffc9a7";
 				const encodedERC721 = "80ac58cd";
 				const encodedERC721Metadata = "5b5e139f";

package/src/standards/ERC165.ts

@@ -1,6 +1,7 @@
 import { ERC165 as ERC165Impl } from "@tevm/voltaire";
 import * as Effect from "effect/Effect";
-import { ProviderService } from "../services/Provider/index.js";
+import { call } from "../services/Provider/functions/index.js";
+import type { ProviderService } from "../services/Provider/index.js";
 import { StandardsError } from "./errors.js";
 
 export const SELECTOR = ERC165Impl.SELECTOR;
@@ -37,18 +38,15 @@ export const supportsInterface = (
 	interfaceId: string,
 ): Effect.Effect<boolean, StandardsError, ProviderService> =>
 	Effect.gen(function* () {
-		const provider = yield* ProviderService;
 		const data = yield* encodeSupportsInterface(interfaceId);
 
-		const result = yield* provider
-			.call({ to: contract as `0x${string}`, data: data as `0x${string}` })
-			.pipe(
-				Effect.map((res) => {
-					if (!res || res === "0x") return false;
-					return ERC165Impl.decodeSupportsInterface(res);
-				}),
-				Effect.catchAll(() => Effect.succeed(false)),
-			);
+		const result = yield* call({ to: contract as `0x${string}`, data: data as `0x${string}` }).pipe(
+			Effect.map((res) => {
+				if (!res || res === "0x") return false;
+				return ERC165Impl.decodeSupportsInterface(res);
+			}),
+			Effect.catchAll(() => Effect.succeed(false)),
+		);
 
 		return result;
 	});

package/src/type-exports.test.ts

@@ -0,0 +1,37 @@
+/**
+ * @fileoverview Tests verifying type exports are accessible from root module
+ */
+import { describe, it, expectTypeOf } from "vitest";
+import type { AddressType, HexType, HashType, BrandedAddress, HexBrand, Sized } from "./index.js";
+
+describe("root type exports", () => {
+	it("AddressType is exported and usable", () => {
+		const addr: AddressType = new Uint8Array(20) as AddressType;
+		expectTypeOf(addr).toMatchTypeOf<Uint8Array>();
+	});
+
+	it("HexType is exported and usable", () => {
+		const hex: HexType = "0xdeadbeef" as HexType;
+		expectTypeOf(hex).toMatchTypeOf<string>();
+	});
+
+	it("HashType is exported and usable", () => {
+		const hash: HashType = new Uint8Array(32) as HashType;
+		expectTypeOf(hash).toMatchTypeOf<Uint8Array>();
+	});
+
+	it("BrandedAddress is exported", () => {
+		type Test = BrandedAddress;
+		expectTypeOf<Test>().not.toBeNever();
+	});
+
+	it("HexBrand is exported", () => {
+		type Test = HexBrand;
+		expectTypeOf<Test>().not.toBeNever();
+	});
+
+	it("Sized is exported", () => {
+		type Test = Sized<32>;
+		expectTypeOf<Test>().toMatchTypeOf<string>();
+	});
+});