voltaire-effect 0.3.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voltaire-effect",
-  "version": "0.3.0",
+  "version": "1.0.1",
   "description": "Effect-TS integration for Voltaire Ethereum primitives library",
   "author": "TEVM",
   "license": "MIT",
@@ -80,7 +80,7 @@
   "peerDependencies": {
     "@effect/platform": "^0.94.0",
     "effect": "^3.19.0",
-    "@tevm/voltaire": "0.2.28"
+    "@tevm/voltaire": "0.4.0"
   },
   "optionalDependencies": {
     "@effect/platform-browser": "^0.74.0",
@@ -91,12 +91,16 @@
     "@effect/platform": "^0.94.0",
     "@effect/platform-node": "^0.104.0",
     "@effect/vitest": "^0.27.0",
-    "effect": "^3.19.0",
+    "@types/node": "^22.0.0",
     "astro": "^5.0.0",
+    "effect": "^3.19.0",
     "tsup": "^8.4.0",
     "typescript": "^5.9.3",
     "vitest": "^2.1.8"
   },
+  "dependencies": {
+    "@shazow/whatsabi": "^0.25.0"
+  },
   "scripts": {
     "build": "tsup",
     "test": "vitest",

package/src/crypto/Signers/SignersService.ts

@@ -4,7 +4,7 @@
  * @since 0.0.1
  */
 
-import type { CryptoError, InvalidPrivateKeyError } from "@tevm/voltaire";
+import type { CryptoError, InvalidPrivateKeyError } from "./errors.js";
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 

package/src/crypto/Signers/errors.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Error types for Signers module using Effect TaggedError.
+ * @module Signers/errors
+ * @since 0.0.1
+ */
+
+import * as Data from "effect/Data";
+
+/**
+ * General cryptographic error during signing operations.
+ *
+ * @since 0.0.1
+ */
+export class CryptoError extends Data.TaggedError("CryptoError")<{
+	readonly message: string;
+	readonly cause?: unknown;
+}> {}
+
+/**
+ * Invalid private key format or value.
+ *
+ * @since 0.0.1
+ */
+export class InvalidPrivateKeyError extends Data.TaggedError(
+	"InvalidPrivateKeyError",
+)<{
+	readonly message: string;
+	readonly cause?: unknown;
+}> {}

package/src/crypto/Signers/index.ts

@@ -29,6 +29,7 @@
  * @see {@link https://eips.ethereum.org/EIPS/eip-191 | EIP-191}
  * @see {@link https://eips.ethereum.org/EIPS/eip-712 | EIP-712}
  */
+export { CryptoError, InvalidPrivateKeyError } from "./errors.js";
 export {
 	fromPrivateKey,
 	getAddress,

package/src/crypto/Signers/operations.ts

@@ -6,11 +6,9 @@
 
 import { Signers } from "@tevm/voltaire";
 import * as Effect from "effect/Effect";
+import { CryptoError, InvalidPrivateKeyError } from "./errors.js";
 import type { Signer } from "./SignersService.js";
 
-type CryptoError = Error;
-type InvalidPrivateKeyError = Error & { code: "INVALID_PRIVATE_KEY" };
-
 /**
  * Creates a signer from a private key.
  *
@@ -49,21 +47,37 @@ export const fromPrivateKey = (
 				signMessage: (message: string | Uint8Array) =>
 					Effect.tryPromise({
 						try: () => impl.signMessage(message),
-						catch: (e) => e as CryptoError,
+						catch: (e) =>
+							new CryptoError({
+								message: e instanceof Error ? e.message : String(e),
+								cause: e,
+							}),
 					}),
 				signTransaction: (transaction: unknown) =>
 					Effect.tryPromise({
 						try: () => impl.signTransaction(transaction),
-						catch: (e) => e as CryptoError,
+						catch: (e) =>
+							new CryptoError({
+								message: e instanceof Error ? e.message : String(e),
+								cause: e,
+							}),
 					}),
 				signTypedData: (typedData: unknown) =>
 					Effect.tryPromise({
 						try: () => impl.signTypedData(typedData),
-						catch: (e) => e as CryptoError,
+						catch: (e) =>
+							new CryptoError({
+								message: e instanceof Error ? e.message : String(e),
+								cause: e,
+							}),
 					}),
 			} as Signer;
 		},
-		catch: (e) => e as InvalidPrivateKeyError,
+		catch: (e) =>
+			new InvalidPrivateKeyError({
+				message: e instanceof Error ? e.message : String(e),
+				cause: e,
+			}),
 	});
 
 /**
@@ -119,5 +133,9 @@ export const recoverTransactionAddress = (
 ): Effect.Effect<string, CryptoError> =>
 	Effect.tryPromise({
 		try: () => Signers.recoverTransactionAddress(transaction),
-		catch: (e) => e as CryptoError,
+		catch: (e) =>
+			new CryptoError({
+				message: e instanceof Error ? e.message : String(e),
+				cause: e,
+			}),
 	});

package/src/crypto/index.ts

@@ -217,17 +217,16 @@ export {
 	verifyMessage,
 	verifyTypedData as verifyTypedDataSignature,
 } from "./Signature/index.js";
-// Signers module temporarily disabled - requires @tevm/voltaire exports update
-// export {
-// 	fromPrivateKey,
-// 	getAddress as signersGetAddress,
-// 	recoverTransactionAddress,
-// 	type Signer,
-// 	SignersLive,
-// 	SignersService,
-// 	type SignersServiceShape,
-// 	SignersTest,
-// } from "./Signers/index.js";
+export {
+	fromPrivateKey,
+	getAddress as signersGetAddress,
+	recoverTransactionAddress,
+	type Signer,
+	SignersLive,
+	SignersService,
+	type SignersServiceShape,
+	SignersTest,
+} from "./Signers/index.js";
 export {
 	computeSecret as x25519ComputeSecret,
 	generateKeyPair as x25519GenerateKeyPair,

package/src/index.ts

@@ -70,8 +70,7 @@ export * as P256 from "./crypto/P256/index.js";
 export * as Ripemd160 from "./crypto/Ripemd160/index.js";
 export * as Secp256k1 from "./crypto/Secp256k1/index.js";
 export * as SHA256 from "./crypto/SHA256/index.js";
-// Signers temporarily disabled - requires @tevm/voltaire exports update
-// export * as Signers from "./crypto/Signers/index.js";
+export * as Signers from "./crypto/Signers/index.js";
 export * as X25519 from "./crypto/X25519/index.js";
 // JSON-RPC module
 export * as JsonRpc from "./jsonrpc/index.js";

package/src/jsonrpc/Anvil.ts

@@ -1,16 +1,21 @@
-import { nextId } from "./IdCounter.js";
+import * as Effect from "effect/Effect";
+import { IdCounterService } from "./IdCounter.js";
 import type { JsonRpcRequestType } from "./Request.js";
 
 function makeRequest(
 	method: string,
 	params: unknown[] = [],
-): JsonRpcRequestType {
-	return {
-		jsonrpc: "2.0",
-		method,
-		params,
-		id: nextId(),
-	};
+): Effect.Effect<JsonRpcRequestType, never, IdCounterService> {
+	return Effect.gen(function* () {
+		const counter = yield* IdCounterService;
+		const id = yield* counter.next();
+		return {
+			jsonrpc: "2.0",
+			method,
+			params,
+			id,
+		};
+	});
 }
 
 export const MineRequest = (blocks?: number, interval?: number) =>

package/src/jsonrpc/Eth.ts

@@ -1,16 +1,21 @@
-import { nextId } from "./IdCounter.js";
+import * as Effect from "effect/Effect";
+import { IdCounterService } from "./IdCounter.js";
 import type { JsonRpcRequestType } from "./Request.js";
 
 function makeRequest(
 	method: string,
 	params: unknown[] = [],
-): JsonRpcRequestType {
-	return {
-		jsonrpc: "2.0",
-		method,
-		params,
-		id: nextId(),
-	};
+): Effect.Effect<JsonRpcRequestType, never, IdCounterService> {
+	return Effect.gen(function* () {
+		const counter = yield* IdCounterService;
+		const id = yield* counter.next();
+		return {
+			jsonrpc: "2.0",
+			method,
+			params,
+			id,
+		};
+	});
 }
 
 export const AccountsRequest = () => makeRequest("eth_accounts");

package/src/jsonrpc/Hardhat.ts

@@ -1,16 +1,21 @@
-import { nextId } from "./IdCounter.js";
+import * as Effect from "effect/Effect";
+import { IdCounterService } from "./IdCounter.js";
 import type { JsonRpcRequestType } from "./Request.js";
 
 function makeRequest(
 	method: string,
 	params: unknown[] = [],
-): JsonRpcRequestType {
-	return {
-		jsonrpc: "2.0",
-		method,
-		params,
-		id: nextId(),
-	};
+): Effect.Effect<JsonRpcRequestType, never, IdCounterService> {
+	return Effect.gen(function* () {
+		const counter = yield* IdCounterService;
+		const id = yield* counter.next();
+		return {
+			jsonrpc: "2.0",
+			method,
+			params,
+			id,
+		};
+	});
 }
 
 export const ResetRequest = (options?: {

package/src/jsonrpc/IdCounter.ts

@@ -1,7 +1,23 @@
-let idCounter = 0;
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Ref from "effect/Ref";
 
-export const nextId = (): number => ++idCounter;
-
-export const resetId = (): void => {
-	idCounter = 0;
+export type IdCounterShape = {
+	readonly next: () => Effect.Effect<number>;
 };
+
+export class IdCounterService extends Context.Tag("IdCounterService")<
+	IdCounterService,
+	IdCounterShape
+>() {}
+
+export const IdCounterLive: Layer.Layer<IdCounterService> = Layer.effect(
+	IdCounterService,
+	Effect.gen(function* () {
+		const ref = yield* Ref.make(0);
+		return {
+			next: () => Ref.updateAndGet(ref, (n) => n + 1),
+		};
+	}),
+);

package/src/jsonrpc/JsonRpc.test.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import { beforeEach, describe, expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import {
 	Anvil,
 	BatchRequest,
@@ -10,6 +10,7 @@ import {
 	EXECUTION_REVERTED,
 	ExecutionRevertedError,
 	Hardhat,
+	IdCounterLive,
 	INSUFFICIENT_FUNDS,
 	InsufficientFundsError,
 	isDisconnected,
@@ -28,7 +29,6 @@ import {
 	parseErrorCode,
 	Request,
 	Response,
-	resetId,
 	Txpool,
 	USER_REJECTED_REQUEST,
 	Wallet,
@@ -66,10 +66,13 @@ describe("JsonRpc", () => {
 			expect(Request.isNotification(req)).toBe(false);
 		});
 
-		it("withParams adds parameters to request", () => {
+		it("withParams adds parameters to request", async () => {
 			const base = Request.from({ method: "eth_getBalance", id: 1 });
 			const addParams = Request.withParams<[string, string]>(base);
-			const req = addParams(["0x1234", "latest"]);
+			const program = addParams(["0x1234", "latest"]).pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.params).toEqual(["0x1234", "latest"]);
 		});
 
@@ -98,10 +101,13 @@ describe("JsonRpc", () => {
 			expect(Request.isNotification(req)).toBe(false);
 		});
 
-		it("withParams auto-assigns id when undefined", () => {
+		it("withParams auto-assigns id when undefined", async () => {
 			const base = Request.from({ method: "eth_getBalance" });
 			const addParams = Request.withParams<[string, string]>(base);
-			const req = addParams(["0x1234", "latest"]);
+			const program = addParams(["0x1234", "latest"]).pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.id).toBeDefined();
 			expect(typeof req.id).toBe("number");
 		});
@@ -478,84 +484,123 @@ describe("JsonRpc", () => {
 	});
 
 	describe("Eth namespace", () => {
-		it("creates GetBalanceRequest", () => {
-			const req = Eth.GetBalanceRequest("0x1234", "latest");
+		it("creates GetBalanceRequest", async () => {
+			const program = Eth.GetBalanceRequest("0x1234", "latest").pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("eth_getBalance");
 			expect(req.params).toEqual(["0x1234", "latest"]);
 		});
 
-		it("creates BlockNumberRequest", () => {
-			const req = Eth.BlockNumberRequest();
+		it("creates BlockNumberRequest", async () => {
+			const program = Eth.BlockNumberRequest().pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("eth_blockNumber");
 		});
 
-		it("creates ChainIdRequest", () => {
-			const req = Eth.ChainIdRequest();
+		it("creates ChainIdRequest", async () => {
+			const program = Eth.ChainIdRequest().pipe(Effect.provide(IdCounterLive));
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("eth_chainId");
 		});
 
-		it("creates CallRequest", () => {
-			const req = Eth.CallRequest({ to: "0xabc", data: "0x123" }, "latest");
+		it("creates CallRequest", async () => {
+			const program = Eth.CallRequest(
+				{ to: "0xabc", data: "0x123" },
+				"latest",
+			).pipe(Effect.provide(IdCounterLive));
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("eth_call");
 		});
 
-		it("creates GetBlockByNumberRequest", () => {
-			const req = Eth.GetBlockByNumberRequest("0x1", false);
+		it("creates GetBlockByNumberRequest", async () => {
+			const program = Eth.GetBlockByNumberRequest("0x1", false).pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("eth_getBlockByNumber");
 			expect(req.params).toEqual(["0x1", false]);
 		});
 	});
 
 	describe("Wallet namespace", () => {
-		it("creates SwitchEthereumChainRequest", () => {
-			const req = Wallet.SwitchEthereumChainRequest("0x1");
+		it("creates SwitchEthereumChainRequest", async () => {
+			const program = Wallet.SwitchEthereumChainRequest("0x1").pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("wallet_switchEthereumChain");
 		});
 	});
 
 	describe("Net namespace", () => {
-		it("creates VersionRequest", () => {
-			const req = Net.VersionRequest();
+		it("creates VersionRequest", async () => {
+			const program = Net.VersionRequest().pipe(Effect.provide(IdCounterLive));
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("net_version");
 		});
 
-		it("creates ListeningRequest", () => {
-			const req = Net.ListeningRequest();
+		it("creates ListeningRequest", async () => {
+			const program = Net.ListeningRequest().pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("net_listening");
 		});
 
-		it("creates PeerCountRequest", () => {
-			const req = Net.PeerCountRequest();
+		it("creates PeerCountRequest", async () => {
+			const program = Net.PeerCountRequest().pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("net_peerCount");
 		});
 	});
 
 	describe("Web3 namespace", () => {
-		it("creates ClientVersionRequest", () => {
-			const req = Web3.ClientVersionRequest();
+		it("creates ClientVersionRequest", async () => {
+			const program = Web3.ClientVersionRequest().pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("web3_clientVersion");
 		});
 
-		it("creates Sha3Request", () => {
-			const req = Web3.Sha3Request("0x68656c6c6f");
+		it("creates Sha3Request", async () => {
+			const program = Web3.Sha3Request("0x68656c6c6f").pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("web3_sha3");
 			expect(req.params).toEqual(["0x68656c6c6f"]);
 		});
 	});
 
 	describe("Txpool namespace", () => {
-		it("creates StatusRequest", () => {
-			const req = Txpool.StatusRequest();
+		it("creates StatusRequest", async () => {
+			const program = Txpool.StatusRequest().pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("txpool_status");
 		});
 
-		it("creates ContentRequest", () => {
-			const req = Txpool.ContentRequest();
+		it("creates ContentRequest", async () => {
+			const program = Txpool.ContentRequest().pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("txpool_content");
 		});
 
-		it("creates InspectRequest", () => {
-			const req = Txpool.InspectRequest();
+		it("creates InspectRequest", async () => {
+			const program = Txpool.InspectRequest().pipe(
+				Effect.provide(IdCounterLive),
+			);
+			const req = await Effect.runPromise(program);
 			expect(req.method).toBe("txpool_inspect");
 		});
 	});
@@ -569,41 +614,61 @@ describe("JsonRpc", () => {
 	});
 
 	describe("ID Counter", () => {
-		beforeEach(() => {
-			resetId();
-		});
-
-		it("generates unique IDs across namespaces", () => {
-			const ids = new Set<number>();
-
-			// Generate requests from multiple namespaces
-			ids.add(Eth.BlockNumberRequest().id as number);
-			ids.add(Eth.ChainIdRequest().id as number);
-			ids.add(Net.VersionRequest().id as number);
-			ids.add(Web3.ClientVersionRequest().id as number);
-			ids.add(Txpool.StatusRequest().id as number);
-			ids.add(Wallet.GetPermissionsRequest().id as number);
-			ids.add(Anvil.GetAutomineRequest().id as number);
-			ids.add(Hardhat.MineRequest().id as number);
-
+		it("generates unique IDs across namespaces", async () => {
+			const program = Effect.gen(function* () {
+				const ids = new Set<number>();
+
+				// Generate requests from multiple namespaces
+				const req1 = yield* Eth.BlockNumberRequest();
+				ids.add(req1.id as number);
+				const req2 = yield* Eth.ChainIdRequest();
+				ids.add(req2.id as number);
+				const req3 = yield* Net.VersionRequest();
+				ids.add(req3.id as number);
+				const req4 = yield* Web3.ClientVersionRequest();
+				ids.add(req4.id as number);
+				const req5 = yield* Txpool.StatusRequest();
+				ids.add(req5.id as number);
+				const req6 = yield* Wallet.GetPermissionsRequest();
+				ids.add(req6.id as number);
+				const req7 = yield* Anvil.GetAutomineRequest();
+				ids.add(req7.id as number);
+				const req8 = yield* Hardhat.MineRequest();
+				ids.add(req8.id as number);
+
+				return ids;
+			}).pipe(Effect.provide(IdCounterLive));
+
+			const ids = await Effect.runPromise(program);
 			// All 8 IDs should be unique
 			expect(ids.size).toBe(8);
 		});
 
-		it("increments IDs sequentially", () => {
-			const id1 = Eth.BlockNumberRequest().id as number;
-			const id2 = Net.VersionRequest().id as number;
-			const id3 = Web3.ClientVersionRequest().id as number;
-
+		it("increments IDs sequentially", async () => {
+			const program = Effect.gen(function* () {
+				const req1 = yield* Eth.BlockNumberRequest();
+				const req2 = yield* Net.VersionRequest();
+				const req3 = yield* Web3.ClientVersionRequest();
+
+				return {
+					id1: req1.id as number,
+					id2: req2.id as number,
+					id3: req3.id as number,
+				};
+			}).pipe(Effect.provide(IdCounterLive));
+
+			const { id1, id2, id3 } = await Effect.runPromise(program);
 			expect(id2).toBe(id1 + 1);
 			expect(id3).toBe(id2 + 1);
 		});
 
-		it("resetId resets the counter", () => {
-			Eth.BlockNumberRequest();
-			Eth.ChainIdRequest();
-			resetId();
-			const id = Eth.BlockNumberRequest().id as number;
+		it("isolated counter starts fresh", async () => {
+			const program = Effect.gen(function* () {
+				const req = yield* Eth.BlockNumberRequest();
+				return req.id as number;
+			}).pipe(Effect.provide(IdCounterLive));
+
+			const id = await Effect.runPromise(program);
 			expect(id).toBe(1);
 		});
 	});

package/src/jsonrpc/Net.ts

@@ -1,16 +1,21 @@
-import { nextId } from "./IdCounter.js";
+import * as Effect from "effect/Effect";
+import { IdCounterService } from "./IdCounter.js";
 import type { JsonRpcRequestType } from "./Request.js";
 
 function makeRequest(
 	method: string,
 	params: unknown[] = [],
-): JsonRpcRequestType {
-	return {
-		jsonrpc: "2.0",
-		method,
-		params,
-		id: nextId(),
-	};
+): Effect.Effect<JsonRpcRequestType, never, IdCounterService> {
+	return Effect.gen(function* () {
+		const counter = yield* IdCounterService;
+		const id = yield* counter.next();
+		return {
+			jsonrpc: "2.0",
+			method,
+			params,
+			id,
+		};
+	});
 }
 
 export const VersionRequest = () => makeRequest("net_version");

package/src/jsonrpc/Request.ts

@@ -1,4 +1,5 @@
-import { nextId } from "./IdCounter.js";
+import * as Effect from "effect/Effect";
+import { IdCounterService } from "./IdCounter.js";
 
 export type JsonRpcIdType = number | string | null;
 
@@ -28,13 +29,20 @@ export function isNotification(request: JsonRpcRequestType): boolean {
 
 export function withParams<TParams>(
 	request: JsonRpcRequestType,
-): (params: TParams) => JsonRpcRequestType<TParams> {
-	return (params: TParams) => ({
-		jsonrpc: "2.0",
-		method: request.method,
-		params,
-		id: request.id ?? nextId(),
-	});
+): (
+	params: TParams,
+) => Effect.Effect<JsonRpcRequestType<TParams>, never, IdCounterService> {
+	return (params: TParams) =>
+		Effect.gen(function* () {
+			const counter = yield* IdCounterService;
+			const id = request.id ?? (yield* counter.next());
+			return {
+				jsonrpc: "2.0",
+				method: request.method,
+				params,
+				id,
+			};
+		});
 }
 
 export const Request = {