voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Rlp/isListData.ts

@@ -0,0 +1,21 @@
+import { type BrandedRlp, Rlp as VoltaireRlp } from "@tevm/voltaire/Rlp";
+
+/**
+ * Checks if value is RLP list data.
+ *
+ * @param value - Value to check
+ * @returns True if value is RLP list data structure
+ *
+ * @example
+ * ```typescript
+ * import { isListData } from 'voltaire-effect/primitives/Rlp'
+ *
+ * isListData({ type: 'list', value: [] }) // => true
+ * isListData({ type: 'bytes', value: new Uint8Array([1]) }) // => false
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const isListData = (
+	value: unknown,
+): value is BrandedRlp & { type: "list" } => VoltaireRlp.isListData(value);

package/src/primitives/Rlp/isString.ts

@@ -0,0 +1,46 @@
+import {
+	type RlpDecodingError,
+	RlpDecodingError as RlpDecodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+const isRlpDecodingError = (e: unknown): e is RlpDecodingError =>
+	e instanceof RlpDecodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpDecodingError");
+
+/**
+ * Checks if RLP-encoded data represents a string (byte array).
+ *
+ * @param data - RLP-encoded data
+ * @returns Effect that succeeds with boolean or fails with RlpDecodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { isString } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const bytes = new Uint8Array([0x83, 0x01, 0x02, 0x03])
+ * Effect.runSync(isString(bytes)) // => true
+ *
+ * const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03])
+ * Effect.runSync(isString(list)) // => false
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const isString = (
+	data: Uint8Array,
+): Effect.Effect<boolean, RlpDecodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.isString(data),
+		catch: (e) =>
+			isRlpDecodingError(e)
+				? e
+				: new RlpDecodingErrorClass("isString check failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/toJSON.ts

@@ -0,0 +1,20 @@
+import { type BrandedRlp, Rlp as VoltaireRlp } from "@tevm/voltaire/Rlp";
+
+/**
+ * Converts RLP Data to human-readable JSON format.
+ *
+ * @param data - RLP data structure
+ * @returns JSON-serializable representation
+ *
+ * @example
+ * ```typescript
+ * import { toJSON } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const data = { type: 'bytes', value: new Uint8Array([1, 2, 3]) }
+ * const json = toJSON(data)
+ * // => { type: 'bytes', value: [1, 2, 3] }
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const toJSON = (data: BrandedRlp): unknown => VoltaireRlp.toJSON(data);

package/src/primitives/Rlp/toRaw.ts

@@ -0,0 +1,31 @@
+import { type BrandedRlp, Rlp as VoltaireRlp } from "@tevm/voltaire/Rlp";
+
+/**
+ * Converts RLP Data structure to raw JavaScript values.
+ *
+ * @param data - RLP data structure to convert
+ * @returns Raw value (Uint8Array for bytes, array for list)
+ *
+ * @example
+ * ```typescript
+ * import { toRaw } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const data = { type: 'bytes', value: new Uint8Array([1, 2, 3]) }
+ * const raw = toRaw(data)
+ * // => Uint8Array([1, 2, 3])
+ *
+ * const listData = {
+ *   type: 'list',
+ *   value: [
+ *     { type: 'bytes', value: new Uint8Array([1]) },
+ *     { type: 'bytes', value: new Uint8Array([2]) }
+ *   ]
+ * }
+ * const rawList = toRaw(listData)
+ * // => [Uint8Array([1]), Uint8Array([2])]
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const toRaw = (data: BrandedRlp): Uint8Array | unknown[] =>
+	VoltaireRlp.toRaw(data);

package/src/primitives/Signature/Signature.test.ts

@@ -3,6 +3,8 @@ import { Hash } from "@tevm/voltaire";
 import { PrivateKey } from "@tevm/voltaire/PrivateKey";
 import * as Secp256k1 from "@tevm/voltaire/Secp256k1";
 import * as BaseSignature from "@tevm/voltaire/Signature";
+import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
 import * as S from "effect/Schema";
 import * as Signature from "./index.js";
 
@@ -494,3 +496,218 @@ describe("signature component validation", () => {
 		expect(BaseSignature.verify(sig, messageHash, publicKey)).toBe(false);
 	});
 });
+
+describe("new pure functions", () => {
+	const sig = S.decodeSync(Signature.Hex)(validSig65);
+
+	describe("getR", () => {
+		it("returns 32-byte R component", () => {
+			const r = Signature.getR(sig);
+			expect(r).toBeInstanceOf(Uint8Array);
+			expect(r.length).toBe(32);
+		});
+	});
+
+	describe("getS", () => {
+		it("returns 32-byte S component", () => {
+			const s = Signature.getS(sig);
+			expect(s).toBeInstanceOf(Uint8Array);
+			expect(s.length).toBe(32);
+		});
+	});
+
+	describe("getV", () => {
+		it("returns recovery value for secp256k1", () => {
+			const v = Signature.getV(sig);
+			expect(v).toBe(27);
+		});
+
+		it("returns derived v for 64-byte signature", () => {
+			const sig64 = S.decodeSync(Signature.Hex)(validSig64);
+			const v = Signature.getV(sig64);
+			expect(typeof v === "number" || v === undefined).toBe(true);
+		});
+	});
+
+	describe("toHex", () => {
+		it("returns hex string with prefix", () => {
+			const hex = Signature.toHex(sig);
+			expect(hex.startsWith("0x")).toBe(true);
+			expect(hex.length).toBe(132); // 0x + 130 chars
+		});
+	});
+
+	describe("toDER", () => {
+		it("returns DER-encoded bytes", () => {
+			const der = Signature.toDER(sig);
+			expect(der).toBeInstanceOf(Uint8Array);
+			expect(der[0]).toBe(0x30); // DER sequence tag
+		});
+	});
+
+	describe("toRpc", () => {
+		it("returns RPC format object", () => {
+			const rpc = Signature.toRpc(sig);
+			expect(rpc.r).toBeDefined();
+			expect(rpc.s).toBeDefined();
+			expect(typeof rpc.r).toBe("string");
+			expect(typeof rpc.s).toBe("string");
+		});
+	});
+
+	describe("toTuple", () => {
+		it("returns [yParity, r, s] tuple", () => {
+			const tuple = Signature.toTuple(sig);
+			expect(Array.isArray(tuple)).toBe(true);
+			expect(tuple.length).toBe(3);
+			expect(typeof tuple[0]).toBe("number");
+			expect(tuple[1]).toBeInstanceOf(Uint8Array);
+			expect(tuple[2]).toBeInstanceOf(Uint8Array);
+		});
+	});
+
+	describe("verify", () => {
+		it("verifies valid signature", () => {
+			const messageHash = Hash.from(new Uint8Array(32).fill(0x42));
+			const privateKey = PrivateKey.fromBytes(new Uint8Array(32).fill(1));
+			const publicKey = Secp256k1.derivePublicKey(privateKey);
+			const secpSig = Secp256k1.sign(messageHash, privateKey);
+			const sig = BaseSignature.fromSecp256k1(secpSig.r, secpSig.s, secpSig.v);
+			expect(Signature.verify(sig, messageHash, publicKey)).toBe(true);
+		});
+
+		it("rejects invalid signature", () => {
+			const messageHash = Hash.from(new Uint8Array(32).fill(0x42));
+			const privateKey = PrivateKey.fromBytes(new Uint8Array(32).fill(1));
+			const publicKey = Secp256k1.derivePublicKey(privateKey);
+			const invalidSig = BaseSignature.fromSecp256k1(
+				new Uint8Array(32).fill(0x11),
+				new Uint8Array(32).fill(0x22),
+				27,
+			);
+			expect(Signature.verify(invalidSig, messageHash, publicKey)).toBe(false);
+		});
+	});
+});
+
+describe("Effect-wrapped from* functions", () => {
+	describe("fromHex", () => {
+		it.effect("parses valid hex", () =>
+			Effect.gen(function* () {
+				const sig = yield* Signature.fromHex(validSig65);
+				expect(Signature.is(sig)).toBe(true);
+			}),
+		);
+
+		it.effect("fails on invalid hex", () =>
+			Effect.gen(function* () {
+				const result = yield* Effect.either(Signature.fromHex("invalid"));
+				expect(Either.isLeft(result)).toBe(true);
+			}),
+		);
+	});
+
+	describe("fromBytes", () => {
+		it.effect("parses valid bytes", () =>
+			Effect.gen(function* () {
+				const bytes = new Uint8Array(64).fill(0xab);
+				const sig = yield* Signature.fromBytes(bytes);
+				expect(Signature.is(sig)).toBe(true);
+			}),
+		);
+	});
+
+	describe("fromCompact", () => {
+		it.effect("parses compact format", () =>
+			Effect.gen(function* () {
+				const compact = new Uint8Array(64).fill(0xab);
+				const sig = yield* Signature.fromCompact(compact, "secp256k1");
+				expect(Signature.is(sig)).toBe(true);
+			}),
+		);
+	});
+
+	describe("fromDER", () => {
+		it.effect("parses DER format", () =>
+			Effect.gen(function* () {
+				const validDER = new Uint8Array([
+					0x30,
+					0x44,
+					0x02,
+					0x20,
+					...new Uint8Array(32).fill(0x01),
+					0x02,
+					0x20,
+					...new Uint8Array(32).fill(0x02),
+				]);
+				const sig = yield* Signature.fromDER(validDER, "secp256k1");
+				expect(Signature.is(sig)).toBe(true);
+			}),
+		);
+	});
+
+	describe("fromRpc", () => {
+		it.effect("parses RPC format", () =>
+			Effect.gen(function* () {
+				const sig = yield* Signature.fromRpc({
+					r: `0x${validR}`,
+					s: `0x${validS}`,
+					yParity: 0,
+				});
+				expect(Signature.is(sig)).toBe(true);
+			}),
+		);
+	});
+
+	describe("fromTuple", () => {
+		it.effect("parses tuple format", () =>
+			Effect.gen(function* () {
+				const r = new Uint8Array(32).fill(0xab);
+				const s = new Uint8Array(32).fill(0xcd);
+				const sig = yield* Signature.fromTuple([0, r, s]);
+				expect(Signature.is(sig)).toBe(true);
+			}),
+		);
+	});
+
+	describe("from", () => {
+		it.effect("parses from bytes", () =>
+			Effect.gen(function* () {
+				const bytes = new Uint8Array(64).fill(0xab);
+				const sig = yield* Signature.from(bytes);
+				expect(Signature.is(sig)).toBe(true);
+			}),
+		);
+	});
+});
+
+describe("constructor functions", () => {
+	describe("fromSecp256k1", () => {
+		it("creates secp256k1 signature", () => {
+			const r = new Uint8Array(32).fill(0x11);
+			const s = new Uint8Array(32).fill(0x22);
+			const sig = Signature.fromSecp256k1(r, s, 27);
+			expect(Signature.is(sig)).toBe(true);
+			expect(Signature.getAlgorithm(sig)).toBe("secp256k1");
+		});
+	});
+
+	describe("fromP256", () => {
+		it("creates p256 signature", () => {
+			const r = new Uint8Array(32).fill(0x11);
+			const s = new Uint8Array(32).fill(0x22);
+			const sig = Signature.fromP256(r, s);
+			expect(Signature.is(sig)).toBe(true);
+			expect(Signature.getAlgorithm(sig)).toBe("p256");
+		});
+	});
+
+	describe("fromEd25519", () => {
+		it("creates ed25519 signature", () => {
+			const bytes = new Uint8Array(64).fill(0x33);
+			const sig = Signature.fromEd25519(bytes);
+			expect(Signature.is(sig)).toBe(true);
+			expect(Signature.getAlgorithm(sig)).toBe("ed25519");
+		});
+	});
+});

package/src/primitives/Signature/from.ts

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Creates Signature from various inputs with Effect error handling.
+ * @module Signature/from
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+import * as Effect from "effect/Effect";
+
+/**
+ * Creates a Signature from various input formats.
+ *
+ * @param value - Input value (bytes or signature object with r, s, v)
+ * @returns Effect that succeeds with SignatureType or fails with parse error
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ * import { Effect } from 'effect'
+ *
+ * const sig = Effect.runSync(Signature.from(signatureBytes))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const from = (
+	value:
+		| Uint8Array
+		| {
+				r: Uint8Array;
+				s: Uint8Array;
+				v?: number;
+				algorithm?: "secp256k1" | "p256" | "ed25519";
+		  },
+): Effect.Effect<SignatureType, Error> =>
+	Effect.try({
+		try: () => Signature.from(value),
+		catch: (e) => e as Error,
+	});

package/src/primitives/Signature/fromBytes.ts

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Creates Signature from bytes with Effect error handling.
+ * @module Signature/fromBytes
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+import * as Effect from "effect/Effect";
+
+/**
+ * Creates a Signature from raw bytes.
+ *
+ * @param bytes - 64 or 65 byte array (r + s, optionally + v)
+ * @returns Effect that succeeds with SignatureType or fails with parse error
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ * import { Effect } from 'effect'
+ *
+ * const sig = Effect.runSync(Signature.fromBytes(new Uint8Array(65)))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromBytes = (
+	bytes: Uint8Array,
+): Effect.Effect<SignatureType, Error> =>
+	Effect.try({
+		try: () => Signature.fromBytes(bytes),
+		catch: (e) => e as Error,
+	});

package/src/primitives/Signature/fromCompact.ts

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Creates Signature from EIP-2098 compact format with Effect error handling.
+ * @module Signature/fromCompact
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+import * as Effect from "effect/Effect";
+
+/**
+ * Creates a Signature from EIP-2098 compact format.
+ *
+ * @param bytes - 64-byte compact signature
+ * @param algorithmOrV - Algorithm ('secp256k1' | 'p256') or explicit v value
+ * @returns Effect that succeeds with SignatureType or fails with parse error
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ * import { Effect } from 'effect'
+ *
+ * const sig = Effect.runSync(Signature.fromCompact(compactBytes, 'secp256k1'))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromCompact = (
+	bytes: Uint8Array,
+	algorithmOrV: "secp256k1" | "p256" | number = "secp256k1",
+): Effect.Effect<SignatureType, Error> =>
+	Effect.try({
+		try: () => Signature.fromCompact(bytes, algorithmOrV),
+		catch: (e) => e as Error,
+	});

package/src/primitives/Signature/fromDER.ts

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Creates Signature from DER format with Effect error handling.
+ * @module Signature/fromDER
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+import * as Effect from "effect/Effect";
+
+/**
+ * Creates a Signature from DER-encoded bytes.
+ *
+ * @param bytes - DER-encoded signature
+ * @param algorithm - Algorithm ('secp256k1' | 'p256')
+ * @param v - Optional recovery value for secp256k1
+ * @returns Effect that succeeds with SignatureType or fails with parse error
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ * import { Effect } from 'effect'
+ *
+ * const sig = Effect.runSync(Signature.fromDER(derBytes, 'secp256k1'))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromDER = (
+	bytes: Uint8Array,
+	algorithm: "secp256k1" | "p256" = "secp256k1",
+	v?: number,
+): Effect.Effect<SignatureType, Error> =>
+	Effect.try({
+		try: () => Signature.fromDER(bytes, algorithm, v),
+		catch: (e) => e as Error,
+	});

package/src/primitives/Signature/fromEd25519.ts

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview Creates Signature from Ed25519 bytes.
+ * @module Signature/fromEd25519
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Creates an Ed25519 Signature from 64-byte signature.
+ *
+ * @param bytes - 64-byte Ed25519 signature
+ * @returns SignatureType with ed25519 algorithm
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const sig = Signature.fromEd25519(signatureBytes)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromEd25519 = (bytes: Uint8Array): SignatureType =>
+	Signature.fromEd25519(bytes);

package/src/primitives/Signature/fromHex.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Creates Signature from hex string with Effect error handling.
+ * @module Signature/fromHex
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+import * as Effect from "effect/Effect";
+
+/**
+ * Creates a Signature from a hex string.
+ *
+ * @param hex - Hex string (64 or 65 bytes with 0x prefix)
+ * @returns Effect that succeeds with SignatureType or fails with parse error
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ * import { Effect } from 'effect'
+ *
+ * const sig = Effect.runSync(Signature.fromHex('0x' + 'ab'.repeat(32) + 'cd'.repeat(32) + '1b'))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromHex = (hex: string): Effect.Effect<SignatureType, Error> =>
+	Effect.try({
+		try: () => Signature.fromHex(hex),
+		catch: (e) => e as Error,
+	});

package/src/primitives/Signature/fromP256.ts

@@ -0,0 +1,25 @@
+/**
+ * @fileoverview Creates Signature from P-256 components.
+ * @module Signature/fromP256
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Creates a P-256 Signature from r and s components.
+ *
+ * @param r - 32-byte R component
+ * @param s - 32-byte S component
+ * @returns SignatureType with p256 algorithm
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const sig = Signature.fromP256(r, s)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromP256 = (r: Uint8Array, s: Uint8Array): SignatureType =>
+	Signature.fromP256(r, s);

package/src/primitives/Signature/fromRpc.ts

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Creates Signature from RPC format with Effect error handling.
+ * @module Signature/fromRpc
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+import * as Effect from "effect/Effect";
+
+/**
+ * Creates a Signature from Ethereum RPC format.
+ *
+ * @param rpc - RPC signature object with r, s, and optionally yParity or v
+ * @returns Effect that succeeds with SignatureType or fails with parse error
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ * import { Effect } from 'effect'
+ *
+ * const sig = Effect.runSync(Signature.fromRpc({
+ *   r: '0x...',
+ *   s: '0x...',
+ *   yParity: '0x0'
+ * }))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromRpc = (rpc: {
+	r: string;
+	s: string;
+	yParity?: string | number;
+	v?: string | number;
+}): Effect.Effect<SignatureType, Error> =>
+	Effect.try({
+		try: () => Signature.fromRpc(rpc),
+		catch: (e) => e as Error,
+	});

package/src/primitives/Signature/fromSecp256k1.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Creates Signature from secp256k1 components.
+ * @module Signature/fromSecp256k1
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Creates a secp256k1 Signature from r, s, and v components.
+ *
+ * @param r - 32-byte R component
+ * @param s - 32-byte S component
+ * @param v - Recovery value (27, 28, or chainId-derived)
+ * @returns SignatureType with secp256k1 algorithm
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const sig = Signature.fromSecp256k1(r, s, 27)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromSecp256k1 = (
+	r: Uint8Array,
+	s: Uint8Array,
+	v: number,
+): SignatureType => Signature.fromSecp256k1(r, s, v);

package/src/primitives/Signature/fromTuple.ts

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Creates Signature from tuple format with Effect error handling.
+ * @module Signature/fromTuple
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+import * as Effect from "effect/Effect";
+
+/**
+ * Creates a Signature from tuple format [yParity, r, s].
+ *
+ * @param tuple - Tuple of [yParity (0 or 1), r (32 bytes), s (32 bytes)]
+ * @param chainId - Optional chain ID for v value calculation
+ * @returns Effect that succeeds with SignatureType or fails with parse error
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ * import { Effect } from 'effect'
+ *
+ * const sig = Effect.runSync(Signature.fromTuple([0, r, s]))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromTuple = (
+	tuple: [number, Uint8Array, Uint8Array],
+	chainId?: number,
+): Effect.Effect<SignatureType, Error> =>
+	Effect.try({
+		try: () => Signature.fromTuple(tuple, chainId),
+		catch: (e) => e as Error,
+	});