voltaire-effect 0.2.23 → 0.2.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voltaire-effect",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "description": "Effect-TS integration for Voltaire Ethereum primitives library",
   "author": "TEVM",
   "license": "MIT",
@@ -79,7 +79,7 @@
   "sideEffects": false,
   "peerDependencies": {
     "effect": "^3.12.0",
-    "@tevm/voltaire": "0.2.23"
+    "@tevm/voltaire": "0.2.25"
   },
   "dependencies": {
     "@effect/platform": "^0.77.0"

package/src/crypto/ERC6492/ERC6492.test.ts

@@ -4,6 +4,11 @@ import { Address } from "@tevm/voltaire/Address";
 import * as Hex from "@tevm/voltaire/Hex";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import {
+	ProviderService,
+	type ProviderShape,
+} from "../../services/Provider/index.js";
 import { VerifyError } from "../Signature/errors.js";
 import { unwrapSignature, verifySignature, wrapSignature } from "./index.js";
 
@@ -57,20 +62,25 @@ describe("ERC6492", () => {
 	it.effect("verifies using deployless validator", () =>
 		Effect.gen(function* () {
 			const calls: Array<{ data?: string }> = [];
-			const provider = {
-				call: (tx: { data?: `0x${string}` }) =>
-					Effect.sync(() => {
+
+			const mockProvider: ProviderShape = {
+				request: <T>(method: string, params?: unknown[]) => {
+					if (method === "eth_call") {
+						const tx = params?.[0] as { data?: string };
 						calls.push(tx);
-						return "0x01" as `0x${string}`;
-					}),
-			} as any;
+						return Effect.succeed("0x01" as T);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const MockProviderLayer = Layer.succeed(ProviderService, mockProvider);
 
 			const result = yield* verifySignature({
 				address: signer,
 				message: messageHash,
 				signature: innerSignature,
-				provider,
-			});
+			}).pipe(Effect.provide(MockProviderLayer));
 
 			expect(result).toBe(true);
 			expect(calls.length).toBe(1);
@@ -90,18 +100,26 @@ describe("ERC6492", () => {
 			const revertData = Hex.fromBytes(
 				encodeParameters([{ type: "string" }] as const, ["boom"] as any),
 			);
-			const provider = {
-				call: () =>
-					Effect.succeed(`0x08c379a0${revertData.slice(2)}` as `0x${string}`),
-			} as any;
+
+			const mockProvider: ProviderShape = {
+				request: <T>(method: string, _params?: unknown[]) => {
+					if (method === "eth_call") {
+						return Effect.succeed(
+							`0x08c379a0${revertData.slice(2)}` as T,
+						);
+					}
+					return Effect.succeed(null as T);
+				},
+			};
+
+			const MockProviderLayer = Layer.succeed(ProviderService, mockProvider);
 
 			const exit = yield* Effect.exit(
 				verifySignature({
 					address: signer,
 					message: messageHash,
 					signature: innerSignature,
-					provider,
-				}),
+				}).pipe(Effect.provide(MockProviderLayer)),
 			);
 
 			expect(Exit.isFailure(exit)).toBe(true);

package/src/crypto/ERC6492/verifySignature.ts

@@ -9,7 +9,8 @@ import { Address, type AddressType } from "@tevm/voltaire/Address";
 import type { HexType } from "@tevm/voltaire/Hex";
 import * as Hex from "@tevm/voltaire/Hex";
 import * as Effect from "effect/Effect";
-import type { ProviderShape as ProviderService } from "../../services/Provider/index.js";
+import { call } from "../../services/Provider/functions/index.js";
+import { ProviderService } from "../../services/Provider/index.js";
 import { VerifyError } from "../Signature/errors.js";
 
 // Output from solc contracts/DeploylessUniversalSigValidator.sol --bin --optimize --optimize-runs=1
@@ -52,7 +53,6 @@ const normalizeCallResult = (value: HexType | `0x${string}`): `0x${string}` =>
  * @param params.address - Expected signer address
  * @param params.message - 32-byte message hash
  * @param params.signature - Signature bytes (may be ERC-6492 wrapped)
- * @param params.provider - Provider service used for eth_call
  * @returns Effect containing true if signature is valid
  *
  * @since 0.2.14
@@ -61,8 +61,7 @@ export const verifySignature = (params: {
 	address: AddressType | `0x${string}`;
 	message: HexType | `0x${string}`;
 	signature: HexType | `0x${string}`;
-	provider: ProviderService;
-}): Effect.Effect<boolean, VerifyError> =>
+}): Effect.Effect<boolean, VerifyError, ProviderService> =>
 	Effect.gen(function* () {
 		const messageHex = params.message as `0x${string}`;
 		const messageBytes = yield* Effect.try({
@@ -102,7 +101,7 @@ export const verifySignature = (params: {
 		const data =
 			`${UNIVERSAL_VALIDATOR_BYTECODE}${Hex.fromBytes(encodedParams).slice(2)}` as `0x${string}`;
 
-		const callResult = yield* params.provider.call({ data }).pipe(
+		const callResult = yield* call({ data }).pipe(
 			Effect.mapError(
 				(e) =>
 					new VerifyError({

package/src/crypto/Keccak256/Keccak256.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
-import { hash, KeccakLive, KeccakService, KeccakTest } from "./index.js";
+import { hash, hashSync, KeccakLive, KeccakService, KeccakTest } from "./index.js";
 
 const bytesToHex = (bytes: Uint8Array): string => {
 	return (
@@ -263,3 +263,44 @@ describe("hash", () => {
 		expect(bytesToHex(hashResult)).toBe(bytesToHex(serviceResult));
 	});
 });
+
+describe("hashSync", () => {
+	it("hashes data synchronously without Effect service", () => {
+		const data = new Uint8Array([104, 101, 108, 108, 111]); // "hello"
+		const result = hashSync(data);
+		expect(result).toBeInstanceOf(Uint8Array);
+		expect(result.length).toBe(32);
+		expect(bytesToHex(result)).toBe(
+			"0x1c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8",
+		);
+	});
+
+	it("matches Effect-based hash result", async () => {
+		const data = new Uint8Array([1, 2, 3]);
+		const syncResult = hashSync(data);
+		const effectResult = await Effect.runPromise(
+			hash(data).pipe(Effect.provide(KeccakLive)),
+		);
+		expect(bytesToHex(syncResult)).toBe(bytesToHex(effectResult));
+	});
+
+	it("works with empty input", () => {
+		const result = hashSync(new Uint8Array(0));
+		expect(bytesToHex(result)).toBe(
+			"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+		);
+	});
+
+	it("works with large input", () => {
+		const result = hashSync(new Uint8Array(1024).fill(0x42));
+		expect(result).toBeInstanceOf(Uint8Array);
+		expect(result.length).toBe(32);
+	});
+
+	it("is deterministic", () => {
+		const data = new Uint8Array([1, 2, 3, 4, 5]);
+		const hash1 = hashSync(data);
+		const hash2 = hashSync(data);
+		expect(bytesToHex(hash1)).toBe(bytesToHex(hash2));
+	});
+});

package/src/crypto/Keccak256/hashSync.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Synchronous Keccak-256 hash function without Effect service layer.
+ *
+ * @description
+ * Provides a direct synchronous Keccak-256 hash function that bypasses the Effect
+ * service layer. Use this when you need a simple hash without Effect dependency
+ * injection overhead.
+ *
+ * @module Keccak256/hashSync
+ * @since 0.2.25
+ */
+
+import type { Keccak256Hash } from "@tevm/voltaire";
+import { Keccak256 } from "@tevm/voltaire";
+
+/**
+ * Computes the Keccak-256 hash of the provided data synchronously.
+ *
+ * @description
+ * This is a direct synchronous version of the Keccak-256 hash that does not
+ * require the Effect service layer. Use this when you need a simple hash
+ * operation without Effect dependency injection.
+ *
+ * For Effect-based applications that need testability and dependency injection,
+ * use {@link hash} with {@link KeccakService} instead.
+ *
+ * @param {Uint8Array} data - The input bytes to hash. Can be any length.
+ * @returns {Keccak256Hash} A 32-byte Keccak256Hash (branded Uint8Array)
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { hashSync } from 'voltaire-effect/crypto/Keccak256'
+ *
+ * const data = new Uint8Array([1, 2, 3])
+ * const result = hashSync(data)
+ * console.log(result) // Uint8Array(32) [...]
+ * ```
+ *
+ * @example Hashing a string
+ * ```typescript
+ * import { hashSync } from 'voltaire-effect/crypto/Keccak256'
+ *
+ * const message = new TextEncoder().encode('hello world')
+ * const hash = hashSync(message)
+ * ```
+ *
+ * @see {@link hash} - Effect-based version with dependency injection
+ * @see {@link KeccakService} - Service interface for Effect-based usage
+ * @since 0.2.25
+ */
+export const hashSync = (data: Uint8Array): Keccak256Hash => {
+	return Keccak256.hash(data);
+};

package/src/crypto/Keccak256/index.ts

@@ -41,6 +41,8 @@
  */
 
 export { hash } from "./hash.js";
+export { hashSync } from "./hashSync.js";
+export type { Keccak256Hash } from "@tevm/voltaire";
 export {
 	KeccakLive,
 	KeccakService,

package/src/index.ts

@@ -1,5 +1,10 @@
 // Primitives - explicit namespace exports
 
+// Re-export core types for direct import (e.g., import { AddressType } from 'voltaire-effect')
+export type { AddressType, BrandedAddress } from "@tevm/voltaire/Address";
+export type { HexType, Hex as HexBrand, Sized } from "@tevm/voltaire/Hex";
+export type { HashType } from "@tevm/voltaire/Hash";
+
 // Re-export voltaire error types for Effect compatibility
 export {
 	// Base errors
@@ -70,8 +75,8 @@ export * as SHA256 from "./crypto/SHA256/index.js";
 export * as X25519 from "./crypto/X25519/index.js";
 // JSON-RPC module
 export * as JsonRpc from "./jsonrpc/index.js";
-// Abi temporarily disabled - requires @tevm/voltaire subpath exports
-// export * as Abi from "./primitives/Abi/index.js";
+// ABI encoding/decoding
+export * as Abi from "./primitives/Abi/index.js";
 export * as AccessList from "./primitives/AccessList/index.js";
 export * as AccountState from "./primitives/AccountState/index.js";
 export * as Address from "./primitives/Address/index.js";

package/src/primitives/Abi/decode.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as S from "effect/Schema";
+import { fromArray } from "./AbiSchema.js";
+import { decode } from "./decode.js";
+
+const erc20Abi = S.decodeUnknownSync(fromArray)([
+	{
+		type: "function",
+		name: "balanceOf",
+		stateMutability: "view",
+		inputs: [{ name: "account", type: "address" }],
+		outputs: [{ type: "uint256" }],
+	},
+]);
+
+describe("decode", () => {
+	describe("success cases", () => {
+		it.effect("decodes balanceOf result", () =>
+			Effect.gen(function* () {
+				const encoded = new Uint8Array(32);
+				encoded[31] = 100;
+				const result = yield* decode(erc20Abi, "balanceOf", encoded);
+				expect(result).toBeInstanceOf(Array);
+			}),
+		);
+	});
+
+	describe("error cases", () => {
+		it("fails for unknown function", async () => {
+			const exit = await Effect.runPromiseExit(
+				decode(erc20Abi, "unknownFunction", new Uint8Array(32)),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+	});
+});

package/src/primitives/Abi/decode.ts

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Decodes function return values from ABI by function name.
+ * Provides Effect-based wrapper around the branded ABI decode method.
+ *
+ * @module Abi/decode
+ * @since 0.0.1
+ */
+
+import {
+	type Abi,
+	AbiDecodingError as AbiDecodingErrorClass,
+	type AbiDecodingError,
+	type AbiItemNotFoundError,
+	type ItemType,
+} from "@tevm/voltaire/Abi";
+import * as Effect from "effect/Effect";
+
+type AbiInput = readonly ItemType[];
+
+const toAbi = (input: AbiInput): Abi => input as unknown as Abi;
+
+type DecodeErrorType = AbiItemNotFoundError | AbiDecodingError;
+
+const isAbiError = (e: unknown): e is DecodeErrorType =>
+	e !== null &&
+	typeof e === "object" &&
+	"name" in e &&
+	(e.name === "AbiItemNotFoundError" || e.name === "AbiDecodingError");
+
+/**
+ * Decodes function return values from ABI by function name.
+ *
+ * @description
+ * Decodes the return data from a contract call using the function's output types.
+ *
+ * @param {AbiInput} abi - The contract ABI.
+ * @param {string} functionName - The function name whose outputs to decode.
+ * @param {Uint8Array} data - The encoded return data.
+ * @returns {Effect.Effect<readonly unknown[], AbiItemNotFoundError | AbiDecodingError>}
+ *   Effect yielding decoded return values.
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { decode } from 'voltaire-effect/primitives/Abi'
+ *
+ * const result = await Effect.runPromise(
+ *   decode(abi, 'balanceOf', returnData)
+ * )
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const decode = (
+	abi: AbiInput,
+	functionName: string,
+	data: Uint8Array,
+): Effect.Effect<readonly unknown[], AbiItemNotFoundError | AbiDecodingError> =>
+	Effect.try({
+		try: () => toAbi(abi).decode(functionName, data),
+		catch: (e) =>
+			isAbiError(e)
+				? e
+				: new AbiDecodingErrorClass("Failed to decode function result", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Abi/decodeData.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as S from "effect/Schema";
+import { fromArray } from "./AbiSchema.js";
+import { decodeData } from "./decodeData.js";
+
+const erc20Abi = S.decodeUnknownSync(fromArray)([
+	{
+		type: "function",
+		name: "transfer",
+		stateMutability: "nonpayable",
+		inputs: [
+			{ name: "to", type: "address" },
+			{ name: "amount", type: "uint256" },
+		],
+		outputs: [{ type: "bool" }],
+	},
+]);
+
+describe("decodeData", () => {
+	describe("error cases", () => {
+		it("fails for data too short", async () => {
+			const exit = await Effect.runPromiseExit(
+				decodeData(erc20Abi, new Uint8Array(2)),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it("fails for unknown selector", async () => {
+			const exit = await Effect.runPromiseExit(
+				decodeData(erc20Abi, new Uint8Array(68)),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+	});
+});

package/src/primitives/Abi/decodeData.ts

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Decodes function call data and identifies the function.
+ * Provides Effect-based wrapper around the branded ABI decodeData method.
+ *
+ * @module Abi/decodeData
+ * @since 0.0.1
+ */
+
+import {
+	type Abi,
+	AbiDecodingError as AbiDecodingErrorClass,
+	type AbiDecodingError,
+	type AbiInvalidSelectorError,
+	type AbiItemNotFoundError,
+	type ItemType,
+} from "@tevm/voltaire/Abi";
+import * as Effect from "effect/Effect";
+
+type AbiInput = readonly ItemType[];
+
+const toAbi = (input: AbiInput): Abi => input as unknown as Abi;
+
+type DecodeDataErrorType =
+	| AbiItemNotFoundError
+	| AbiInvalidSelectorError
+	| AbiDecodingError;
+
+const isAbiError = (e: unknown): e is DecodeDataErrorType =>
+	e !== null &&
+	typeof e === "object" &&
+	"name" in e &&
+	(e.name === "AbiItemNotFoundError" ||
+		e.name === "AbiInvalidSelectorError" ||
+		e.name === "AbiDecodingError");
+
+/**
+ * Decodes function call data and identifies the function.
+ *
+ * @description
+ * Parses encoded calldata to extract the function name and decoded arguments.
+ * The data must start with a 4-byte function selector.
+ *
+ * @param {AbiInput} abi - The contract ABI.
+ * @param {Uint8Array} data - The encoded function call data.
+ * @returns {Effect.Effect<{ functionName: string; args: readonly unknown[] }, AbiItemNotFoundError | AbiInvalidSelectorError | AbiDecodingError>}
+ *   Effect yielding the function name and decoded arguments.
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { decodeData } from 'voltaire-effect/primitives/Abi'
+ *
+ * const decoded = await Effect.runPromise(
+ *   decodeData(abi, calldata)
+ * )
+ * console.log(decoded.functionName) // 'transfer'
+ * console.log(decoded.args) // ['0x...', 100n]
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const decodeData = (
+	abi: AbiInput,
+	data: Uint8Array,
+): Effect.Effect<
+	{ functionName: string; args: readonly unknown[] },
+	AbiItemNotFoundError | AbiInvalidSelectorError | AbiDecodingError
+> =>
+	Effect.try({
+		try: () => toAbi(abi).decodeData(data),
+		catch: (e) =>
+			isAbiError(e)
+				? e
+				: new AbiDecodingErrorClass("Failed to decode function data", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Abi/decodeLog.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as S from "effect/Schema";
+import { fromArray } from "./AbiSchema.js";
+import { decodeLog } from "./decodeLog.js";
+
+const erc20Abi = S.decodeUnknownSync(fromArray)([
+	{
+		type: "event",
+		name: "Transfer",
+		inputs: [
+			{ name: "from", type: "address", indexed: true },
+			{ name: "to", type: "address", indexed: true },
+			{ name: "value", type: "uint256", indexed: false },
+		],
+	},
+]);
+
+describe("decodeLog", () => {
+	describe("error cases", () => {
+		it("fails for unknown event", async () => {
+			const exit = await Effect.runPromiseExit(
+				decodeLog(erc20Abi, {
+					data: new Uint8Array(32),
+					topics: [new Uint8Array(32)],
+				}),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+	});
+});

package/src/primitives/Abi/decodeLog.ts

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Decodes event log data using ABI.
+ * Provides Effect-based wrapper for parsing log entries.
+ *
+ * @module Abi/decodeLog
+ * @since 0.0.1
+ */
+
+import {
+	type Abi,
+	AbiDecodingError as AbiDecodingErrorClass,
+	type AbiDecodingError,
+	type AbiItemNotFoundError,
+	type ItemType,
+	decodeLog as _decodeLog,
+} from "@tevm/voltaire/Abi";
+import type { HexType } from "@tevm/voltaire/Hex";
+import * as Effect from "effect/Effect";
+
+type AbiInput = readonly ItemType[];
+
+const toAbi = (input: AbiInput): Abi => input as unknown as Abi;
+
+type DecodeLogErrorType = AbiItemNotFoundError | AbiDecodingError;
+
+const isAbiError = (e: unknown): e is DecodeLogErrorType =>
+	e !== null &&
+	typeof e === "object" &&
+	"name" in e &&
+	(e.name === "AbiItemNotFoundError" || e.name === "AbiDecodingError");
+
+/**
+ * Log input structure.
+ */
+export interface LogInput {
+	data: HexType | Uint8Array;
+	topics: readonly (HexType | Uint8Array)[];
+}
+
+/**
+ * Decodes event log data using ABI.
+ *
+ * @description
+ * Parses a log entry to extract the event name and decoded parameters.
+ * Supports both regular events (matched by topic0) and anonymous events.
+ *
+ * @param {AbiInput} abi - The contract ABI.
+ * @param {LogInput} log - The log object with data and topics.
+ * @returns {Effect.Effect<{ event: string; params: Record<string, unknown> }, AbiItemNotFoundError | AbiDecodingError>}
+ *   Effect yielding the event name and decoded parameters.
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { decodeLog } from 'voltaire-effect/primitives/Abi'
+ *
+ * const decoded = await Effect.runPromise(
+ *   decodeLog(abi, { data: '0x...', topics: ['0x...', ...] })
+ * )
+ * console.log(decoded.event) // 'Transfer'
+ * console.log(decoded.params) // { from: '0x...', to: '0x...', value: 100n }
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const decodeLog = (
+	abi: AbiInput,
+	log: LogInput,
+): Effect.Effect<
+	{ event: string; params: Record<string, unknown> },
+	AbiItemNotFoundError | AbiDecodingError
+> =>
+	Effect.try({
+		try: () => _decodeLog(toAbi(abi), log),
+		catch: (e) =>
+			isAbiError(e)
+				? e
+				: new AbiDecodingErrorClass("Failed to decode log", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Abi/decodeWrappedError.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Address, Bytes, Selector } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { decodeWrappedError } from "./decodeWrappedError.js";
+import { encodeWrappedError } from "./encodeWrappedError.js";
+
+describe("decodeWrappedError", () => {
+	describe("success cases", () => {
+		it.effect("decodes encoded wrapped error", () =>
+			Effect.gen(function* () {
+				const original = {
+					target: Address.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"),
+					selector: Selector.fromHex("0xa9059cbb"),
+					reason: Bytes.from(new Uint8Array([1, 2, 3])),
+					details: Bytes.from(new Uint8Array([4, 5, 6])),
+				};
+				const encoded = yield* encodeWrappedError(original);
+				const decoded = yield* decodeWrappedError(encoded);
+				expect(decoded.target).toBeDefined();
+				expect(decoded.selector).toBeDefined();
+			}),
+		);
+	});
+
+	describe("error cases", () => {
+		it("fails for data too short", async () => {
+			const exit = await Effect.runPromiseExit(
+				decodeWrappedError(new Uint8Array(2)),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it("fails for invalid selector", async () => {
+			const exit = await Effect.runPromiseExit(
+				decodeWrappedError(new Uint8Array(100)),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+	});
+});