voltaire-effect 0.3.0 → 1.0.1

package/src/primitives/Hex/from.ts

@@ -8,15 +8,15 @@
 import {
 	type HexType,
 	Hex as VoltaireHex,
-	InvalidFormatError,
 } from "@tevm/voltaire/Hex";
+import { ValidationError } from "@tevm/voltaire/errors";
 import { Effect } from "effect";
 
 /**
  * Parse any input (string or Uint8Array) to Hex.
  *
  * @param value - String or bytes to convert
- * @returns Effect with HexType or InvalidFormatError
+ * @returns Effect with HexType or ValidationError
  *
  * @example
  * ```ts
@@ -31,8 +31,16 @@ import { Effect } from "effect";
  */
 export const from = (
 	value: string | Uint8Array,
-): Effect.Effect<HexType, InvalidFormatError> =>
+): Effect.Effect<HexType, ValidationError> =>
 	Effect.try({
 		try: () => VoltaireHex.from(value),
-		catch: (e) => e as InvalidFormatError,
+		catch: (error) =>
+			new ValidationError(
+				error instanceof Error ? error.message : "Invalid hex input",
+				{
+					value,
+					expected: "hex string (0x-prefixed) or Uint8Array",
+					cause: error instanceof Error ? error : undefined,
+				},
+			),
 	});

package/src/primitives/Signature/from.ts

@@ -5,6 +5,7 @@
  */
 import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
 import * as Effect from "effect/Effect";
+import { ValidationError } from "@tevm/voltaire/errors";
 
 /**
  * Creates a Signature from various input formats.
@@ -31,8 +32,16 @@ export const from = (
 				v?: number;
 				algorithm?: "secp256k1" | "p256" | "ed25519";
 		  },
-): Effect.Effect<SignatureType, Error> =>
+): Effect.Effect<SignatureType, ValidationError> =>
 	Effect.try({
 		try: () => Signature.from(value),
-		catch: (e) => e as Error,
+		catch: (error) =>
+			new ValidationError(
+				error instanceof Error ? error.message : "Invalid signature input",
+				{
+					value,
+					expected: "signature bytes or {r, s, v} object",
+					cause: error instanceof Error ? error : undefined,
+				},
+			),
 	});

package/src/primitives/Transaction/EIP2930/index.ts

@@ -1,16 +1,16 @@
 import { EIP2930 } from "@tevm/voltaire/Transaction";
 
-export const {
-	TransactionEIP2930,
-	deserialize,
-	serialize,
-	hash,
-	getSigningHash,
-	getSender,
-	verifySignature,
-	Hash,
-	GetSigningHash,
-	VerifySignature,
-} = EIP2930;
+export type TransactionEIP2930Type = ReturnType<typeof EIP2930.TransactionEIP2930>;
+
+export const TransactionEIP2930 = EIP2930.TransactionEIP2930;
+export const deserialize = EIP2930.deserialize;
+export const serialize = EIP2930.serialize;
+export const hash: (tx: TransactionEIP2930Type) => Uint8Array = EIP2930.hash;
+export const getSigningHash: (tx: TransactionEIP2930Type) => Uint8Array = EIP2930.getSigningHash;
+export const getSender = EIP2930.getSender;
+export const verifySignature: (tx: TransactionEIP2930Type) => boolean = EIP2930.verifySignature;
+export const Hash = EIP2930.Hash;
+export const GetSigningHash = EIP2930.GetSigningHash;
+export const VerifySignature = EIP2930.VerifySignature;
 
 export { EIP2930 };

package/src/primitives/Transaction/EIP4844/index.ts

@@ -1,18 +1,18 @@
 import { EIP4844 } from "@tevm/voltaire/Transaction";
 
-export const {
-	TransactionEIP4844,
-	deserialize,
-	serialize,
-	hash,
-	getSigningHash,
-	getSender,
-	verifySignature,
-	getEffectiveGasPrice,
-	getBlobGasCost,
-	Hash,
-	GetSigningHash,
-	VerifySignature,
-} = EIP4844;
+export type TransactionEIP4844Type = ReturnType<typeof EIP4844.TransactionEIP4844>;
+
+export const TransactionEIP4844 = EIP4844.TransactionEIP4844;
+export const deserialize = EIP4844.deserialize;
+export const serialize = EIP4844.serialize;
+export const hash: (tx: TransactionEIP4844Type) => Uint8Array = EIP4844.hash;
+export const getSigningHash: (tx: TransactionEIP4844Type) => Uint8Array = EIP4844.getSigningHash;
+export const getSender = EIP4844.getSender;
+export const verifySignature: (tx: TransactionEIP4844Type) => boolean = EIP4844.verifySignature;
+export const getEffectiveGasPrice = EIP4844.getEffectiveGasPrice;
+export const getBlobGasCost = EIP4844.getBlobGasCost;
+export const Hash = EIP4844.Hash;
+export const GetSigningHash = EIP4844.GetSigningHash;
+export const VerifySignature = EIP4844.VerifySignature;
 
 export { EIP4844 };

package/src/primitives/Transaction/EIP7702/index.ts

@@ -1,17 +1,17 @@
 import { EIP7702 } from "@tevm/voltaire/Transaction";
 
-export const {
-	TransactionEIP7702,
-	deserialize,
-	serialize,
-	hash,
-	getSigningHash,
-	getSender,
-	verifySignature,
-	getEffectiveGasPrice,
-	Hash,
-	GetSigningHash,
-	VerifySignature,
-} = EIP7702;
+export type TransactionEIP7702Type = ReturnType<typeof EIP7702.TransactionEIP7702>;
+
+export const TransactionEIP7702 = EIP7702.TransactionEIP7702;
+export const deserialize = EIP7702.deserialize;
+export const serialize = EIP7702.serialize;
+export const hash: (tx: TransactionEIP7702Type) => Uint8Array = EIP7702.hash;
+export const getSigningHash: (tx: TransactionEIP7702Type) => Uint8Array = EIP7702.getSigningHash;
+export const getSender = EIP7702.getSender;
+export const verifySignature: (tx: TransactionEIP7702Type) => boolean = EIP7702.verifySignature;
+export const getEffectiveGasPrice = EIP7702.getEffectiveGasPrice;
+export const Hash = EIP7702.Hash;
+export const GetSigningHash = EIP7702.GetSigningHash;
+export const VerifySignature = EIP7702.VerifySignature;
 
 export { EIP7702 };

package/src/primitives/Transaction/Legacy/index.ts

@@ -1,17 +1,17 @@
 import { Legacy } from "@tevm/voltaire/Transaction";
 
-export const {
-	TransactionLegacy,
-	deserialize,
-	serialize,
-	hash,
-	getChainId,
-	getSigningHash,
-	getSender,
-	verifySignature,
-	Hash,
-	GetSigningHash,
-	VerifySignature,
-} = Legacy;
+export type TransactionLegacyType = ReturnType<typeof Legacy.TransactionLegacy>;
+
+export const TransactionLegacy = Legacy.TransactionLegacy;
+export const deserialize = Legacy.deserialize;
+export const serialize = Legacy.serialize;
+export const hash: (this: TransactionLegacyType) => Uint8Array = Legacy.hash;
+export const getChainId = Legacy.getChainId;
+export const getSigningHash: (this: TransactionLegacyType) => Uint8Array = Legacy.getSigningHash;
+export const getSender = Legacy.getSender;
+export const verifySignature: (this: TransactionLegacyType) => boolean = Legacy.verifySignature;
+export const Hash = Legacy.Hash;
+export const GetSigningHash = Legacy.GetSigningHash;
+export const VerifySignature = Legacy.VerifySignature;
 
 export { Legacy };

package/src/primitives/TransactionHash/index.ts

@@ -47,10 +47,11 @@ export { Hex } from "./Hex.js";
 // Re-export pure functions from voltaire
 import { TransactionHash } from "@tevm/voltaire";
 
-export const equals = TransactionHash.equals;
+export const equals = (a: TransactionHashType, b: TransactionHashType): boolean =>
+	TransactionHash.equals(a as unknown as Parameters<typeof TransactionHash.equals>[0], b as unknown as Parameters<typeof TransactionHash.equals>[1]);
 export const toHex = (
 	hash: Uint8Array & { readonly __tag: "TransactionHash" },
-): string => TransactionHash.toHex(hash as any);
+): string => TransactionHash.toHex(hash as unknown as Parameters<typeof TransactionHash.toHex>[0]);
 
 // Type export
 export type TransactionHashType = Uint8Array & {

package/src/primitives/TransactionIndex/index.ts

@@ -45,8 +45,8 @@ export { Number } from "./Number.js";
 // Re-export pure functions from voltaire
 import { TransactionIndex } from "@tevm/voltaire";
 
-export const equals = TransactionIndex.equals;
-export const toNumber = TransactionIndex.toNumber;
+export const equals: (a: TransactionIndexType, b: TransactionIndexType) => boolean = TransactionIndex.equals;
+export const toNumber: (index: TransactionIndexType) => number = TransactionIndex.toNumber;
 
 // Type export
 import type { TransactionIndex as _TransactionIndex } from "@tevm/voltaire";

package/src/primitives/Trie/Trie.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Trie from "./index.js";
+
+describe("Trie Effect wrappers", () => {
+	it("init returns empty trie", async () => {
+		const trie = await Effect.runPromise(Trie.init());
+		expect(trie.root).toBe(null);
+		expect(trie.nodes.size).toBe(0);
+	});
+
+	it("put-get round trip", async () => {
+		const program = Effect.gen(function* () {
+			const trie = yield* Trie.init();
+			const key = new Uint8Array([0x01, 0x02]);
+			const value = new Uint8Array([0xaa, 0xbb]);
+			const updated = yield* Trie.put(trie, key, value);
+			return yield* Trie.get(updated, key);
+		});
+		const result = await Effect.runPromise(program);
+		expect(result).toEqual(new Uint8Array([0xaa, 0xbb]));
+	});
+
+	it("del removes key", async () => {
+		const program = Effect.gen(function* () {
+			let trie = yield* Trie.init();
+			const key = new Uint8Array([0x01]);
+			trie = yield* Trie.put(trie, key, new Uint8Array([0xaa]));
+			trie = yield* Trie.del(trie, key);
+			return yield* Trie.get(trie, key);
+		});
+		const result = await Effect.runPromise(program);
+		expect(result).toBe(null);
+	});
+
+	it("rootHash returns 32 bytes", async () => {
+		const program = Effect.gen(function* () {
+			let trie = yield* Trie.init();
+			trie = yield* Trie.put(trie, new Uint8Array([1]), new Uint8Array([2]));
+			return Trie.rootHash(trie);
+		});
+		const hash = await Effect.runPromise(program);
+		expect(hash.length).toBe(32);
+	});
+
+	it("clear resets trie", async () => {
+		const program = Effect.gen(function* () {
+			let trie = yield* Trie.init();
+			trie = yield* Trie.put(trie, new Uint8Array([1]), new Uint8Array([2]));
+			trie = yield* Trie.clear(trie);
+			return yield* Trie.get(trie, new Uint8Array([1]));
+		});
+		const result = await Effect.runPromise(program);
+		expect(result).toBe(null);
+	});
+
+	it("prove-verify round trip", async () => {
+		const program = Effect.gen(function* () {
+			let trie = yield* Trie.init();
+			trie = yield* Trie.put(trie, new Uint8Array([0x10]), new Uint8Array([1]));
+			trie = yield* Trie.put(trie, new Uint8Array([0x20]), new Uint8Array([2]));
+			const root = Trie.rootHash(trie);
+			const proof = yield* Trie.prove(trie, new Uint8Array([0x10]));
+			return yield* Trie.verify(root, new Uint8Array([0x10]), proof.proof);
+		});
+		const result = await Effect.runPromise(program);
+		expect(result.valid).toBe(true);
+		expect(result.value).toEqual(new Uint8Array([1]));
+	});
+});

package/src/primitives/Trie/TrieSchema.ts

@@ -0,0 +1,26 @@
+import type { Trie } from "@tevm/voltaire";
+import * as ParseResult from "effect/ParseResult";
+import * as Schema from "effect/Schema";
+
+type TrieType = Trie.TrieType;
+
+const TrieTypeSchema = Schema.declare<TrieType>(
+	(u): u is TrieType => {
+		if (typeof u !== "object" || u === null) return false;
+		return "nodes" in u && "root" in u;
+	},
+	{ identifier: "Trie" },
+);
+
+/**
+ * Effect Schema for validating Trie structures.
+ * Identity transform - validates the trie structure.
+ *
+ * @since 0.0.1
+ */
+export const TrieSchema: Schema.Schema<TrieType, TrieType> =
+	Schema.transformOrFail(TrieTypeSchema, TrieTypeSchema, {
+		strict: true,
+		decode: (t, _options, _ast) => ParseResult.succeed(t),
+		encode: (t) => ParseResult.succeed(t),
+	}).annotations({ identifier: "TrieSchema" });

package/src/primitives/Trie/clear.ts

@@ -0,0 +1,16 @@
+import { Trie } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+
+type TrieType = Trie.TrieType;
+
+/**
+ * Reset trie to empty state.
+ *
+ * @param trie - The trie to clear
+ * @returns Effect yielding an empty trie
+ * @since 0.0.1
+ */
+export const clear = (
+	trie: TrieType,
+): Effect.Effect<TrieType, never> =>
+	Effect.succeed(Trie.clear(trie));

package/src/primitives/Trie/del.ts

@@ -0,0 +1,18 @@
+import { Trie } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+
+type TrieType = Trie.TrieType;
+
+/**
+ * Delete a key from the trie. Returns new trie (immutable).
+ *
+ * @param trie - The trie to delete from
+ * @param key - Key to delete
+ * @returns Effect yielding the updated trie
+ * @since 0.0.1
+ */
+export const del = (
+	trie: TrieType,
+	key: Uint8Array,
+): Effect.Effect<TrieType, never> =>
+	Effect.succeed(Trie.del(trie, key));

package/src/primitives/Trie/get.ts

@@ -0,0 +1,18 @@
+import { Trie } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+
+type TrieType = Trie.TrieType;
+
+/**
+ * Look up a value in the trie by key. Returns null if not found.
+ *
+ * @param trie - The trie to search
+ * @param key - Key to look up
+ * @returns Effect yielding the value or null
+ * @since 0.0.1
+ */
+export const get = (
+	trie: TrieType,
+	key: Uint8Array,
+): Effect.Effect<Uint8Array | null, never> =>
+	Effect.succeed(Trie.get(trie, key));

package/src/primitives/Trie/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Trie module for Merkle Patricia Trie operations.
+ * Provides Effect-based functions for trie initialization, insertion, lookup,
+ * deletion, and Merkle proof generation/verification.
+ *
+ * @example
+ * ```typescript
+ * import * as Trie from 'voltaire-effect/primitives/Trie'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const trie = yield* Trie.init()
+ *   const updated = yield* Trie.put(trie, key, value)
+ *   return Trie.rootHash(updated)
+ * })
+ * ```
+ *
+ * @since 0.0.1
+ * @module
+ */
+
+export { TrieSchema, TrieSchema as Schema } from "./TrieSchema.js";
+export { clear } from "./clear.js";
+export { del } from "./del.js";
+export { get } from "./get.js";
+export { init } from "./init.js";
+export { prove } from "./prove.js";
+export { put } from "./put.js";
+export { rootHash } from "./rootHash.js";
+export { verify } from "./verify.js";

package/src/primitives/Trie/init.ts

@@ -0,0 +1,13 @@
+import { Trie } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+
+type TrieType = Trie.TrieType;
+
+/**
+ * Initializes a new empty Merkle Patricia Trie.
+ *
+ * @returns Effect yielding an empty TrieType
+ * @since 0.0.1
+ */
+export const init = (): Effect.Effect<TrieType, never> =>
+	Effect.succeed(Trie.init());

package/src/primitives/Trie/prove.ts

@@ -0,0 +1,19 @@
+import { Trie } from "@tevm/voltaire";
+import type { TrieProof } from "@tevm/voltaire/Trie";
+import * as Effect from "effect/Effect";
+
+type TrieType = Trie.TrieType;
+
+/**
+ * Generate a Merkle proof for a key.
+ *
+ * @param trie - The trie to generate proof from
+ * @param key - Key to prove
+ * @returns Effect yielding the proof
+ * @since 0.0.1
+ */
+export const prove = (
+	trie: TrieType,
+	key: Uint8Array,
+): Effect.Effect<TrieProof, never> =>
+	Effect.succeed(Trie.prove(trie, key));

package/src/primitives/Trie/put.ts

@@ -0,0 +1,20 @@
+import { Trie } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+
+type TrieType = Trie.TrieType;
+
+/**
+ * Insert a key-value pair into the trie. Returns new trie (immutable).
+ *
+ * @param trie - The trie to insert into
+ * @param key - Key bytes
+ * @param value - Value bytes
+ * @returns Effect yielding the updated trie
+ * @since 0.0.1
+ */
+export const put = (
+	trie: TrieType,
+	key: Uint8Array,
+	value: Uint8Array,
+): Effect.Effect<TrieType, never> =>
+	Effect.succeed(Trie.put(trie, key, value));

package/src/primitives/Trie/rootHash.ts

@@ -0,0 +1,14 @@
+import { Trie } from "@tevm/voltaire";
+
+type TrieType = Trie.TrieType;
+
+/**
+ * Compute the 32-byte root hash of the trie.
+ * Pure function - never throws.
+ *
+ * @param trie - The trie to hash
+ * @returns 32-byte root hash as Uint8Array
+ * @since 0.0.1
+ */
+export const rootHash = (trie: TrieType): Uint8Array =>
+	Trie.rootHash(trie);

package/src/primitives/Trie/verify.ts

@@ -0,0 +1,18 @@
+import { Trie } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+
+/**
+ * Verify a Merkle proof against a root hash.
+ *
+ * @param root - Expected 32-byte root hash
+ * @param key - Key to verify
+ * @param proof - Array of RLP-encoded proof nodes
+ * @returns Effect yielding { value, valid }
+ * @since 0.0.1
+ */
+export const verify = (
+	root: Uint8Array,
+	key: Uint8Array,
+	proof: ReadonlyArray<Uint8Array>,
+): Effect.Effect<{ value: Uint8Array | null; valid: boolean }, never> =>
+	Effect.succeed(Trie.verify(root, key, proof));

package/src/primitives/Uint/from.ts

@@ -6,6 +6,7 @@
 
 import { Uint256, type Type as Uint256Type } from "@tevm/voltaire/Uint";
 import * as Effect from "effect/Effect";
+import { ValidationError } from "@tevm/voltaire/errors";
 
 /**
  * Create Uint256 from bigint, number, or string.
@@ -28,8 +29,16 @@ import * as Effect from "effect/Effect";
  */
 export const from = (
 	value: bigint | number | string,
-): Effect.Effect<Uint256Type, Error> =>
+): Effect.Effect<Uint256Type, ValidationError> =>
 	Effect.try({
 		try: () => Uint256.from(value),
-		catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+		catch: (error) =>
+			new ValidationError(
+				error instanceof Error ? error.message : "Invalid Uint256 input",
+				{
+					value,
+					expected: "bigint, number, or string (decimal or hex)",
+					cause: error instanceof Error ? error : undefined,
+				},
+			),
 	});

package/src/primitives/Uint16/index.ts

@@ -54,6 +54,7 @@ export { String } from "./String.js";
 
 // Re-export pure functions from voltaire
 import { BrandedUint16 } from "@tevm/voltaire";
+import type { Uint16Type } from "./Uint16Schema.js";
 
 export const equals = BrandedUint16.equals;
 export const plus = BrandedUint16.plus;
@@ -61,10 +62,10 @@ export const minus = BrandedUint16.minus;
 export const times = BrandedUint16.times;
 export const toNumber = BrandedUint16.toNumber;
 export const toHex = BrandedUint16.toHex;
-export const MAX = BrandedUint16.MAX;
-export const MIN = BrandedUint16.MIN;
-export const ZERO = BrandedUint16.ZERO;
-export const ONE = BrandedUint16.ONE;
+export const MAX: Uint16Type = BrandedUint16.MAX;
+export const MIN: Uint16Type = BrandedUint16.MIN;
+export const ZERO: Uint16Type = BrandedUint16.ZERO;
+export const ONE: Uint16Type = BrandedUint16.ONE;
 
 // Type export
 export type { Uint16Type } from "./Uint16Schema.js";

package/src/primitives/Uint64/index.ts

@@ -54,6 +54,7 @@ export { String } from "./String.js";
 
 // Re-export pure functions from voltaire
 import { Uint64 } from "@tevm/voltaire";
+import type { Uint64Type } from "./Uint64Schema.js";
 
 export const equals = Uint64.equals;
 export const plus = Uint64.plus;
@@ -62,10 +63,10 @@ export const times = Uint64.times;
 export const toBigInt = Uint64.toBigInt;
 export const toNumber = Uint64.toNumber;
 export const toHex = Uint64.toHex;
-export const MAX = Uint64.MAX;
-export const MIN = Uint64.MIN;
-export const ZERO = Uint64.ZERO;
-export const ONE = Uint64.ONE;
+export const MAX: Uint64Type = Uint64.MAX;
+export const MIN: Uint64Type = Uint64.MIN;
+export const ZERO: Uint64Type = Uint64.ZERO;
+export const ONE: Uint64Type = Uint64.ONE;
 
 // Type export
 export type { Uint64Type } from "./Uint64Schema.js";

package/src/primitives/Uint8/index.ts

@@ -54,6 +54,7 @@ export { String } from "./String.js";
 
 // Re-export pure functions from voltaire
 import { BrandedUint8 } from "@tevm/voltaire";
+import type { Uint8Type } from "./Uint8Schema.js";
 
 export const equals = BrandedUint8.equals;
 export const plus = BrandedUint8.plus;
@@ -61,10 +62,10 @@ export const minus = BrandedUint8.minus;
 export const times = BrandedUint8.times;
 export const toNumber = BrandedUint8.toNumber;
 export const toHex = BrandedUint8.toHex;
-export const MAX = BrandedUint8.MAX;
-export const MIN = BrandedUint8.MIN;
-export const ZERO = BrandedUint8.ZERO;
-export const ONE = BrandedUint8.ONE;
+export const MAX: Uint8Type = BrandedUint8.MAX;
+export const MIN: Uint8Type = BrandedUint8.MIN;
+export const ZERO: Uint8Type = BrandedUint8.ZERO;
+export const ONE: Uint8Type = BrandedUint8.ONE;
 
 // Type export
 export type { Uint8Type } from "./Uint8Schema.js";

package/src/primitives/index.ts

@@ -1,5 +1,4 @@
-// Abi module temporarily disabled - requires @tevm/voltaire subpath exports
-// export * as Abi from "./Abi/index.js";
+export * as Abi from "./Abi/index.js";
 export * as AccessList from "./AccessList/index.js";
 export * as AccountState from "./AccountState/index.js";
 export * as Address from "./Address/index.js";
@@ -121,6 +120,8 @@ export * as SyncStatus from "./SyncStatus/index.js";
 export * as TokenBalance from "./TokenBalance/index.js";
 export * as TokenId from "./TokenId/index.js";
 export * as TopicFilter from "./TopicFilter/index.js";
+// TODO: Re-enable when @tevm/voltaire exports Trie
+// export * as Trie from "./Trie/index.js";
 export * as TraceConfig from "./TraceConfig/index.js";
 export * as TraceResult from "./TraceResult/index.js";
 export * as Transaction from "./Transaction/index.js";