voltaire-effect 0.2.23

package/src/crypto/EIP712/operations.ts

@@ -0,0 +1,220 @@
+/**
+ * @fileoverview EIP-712 typed data operations for Effect.
+ * @module EIP712/operations
+ * @since 0.0.1
+ */
+
+import type { AddressType } from "@tevm/voltaire/Address";
+import type {
+	Domain,
+	Message,
+	Signature,
+	TypeDefinitions,
+	TypedData,
+} from "@tevm/voltaire/EIP712";
+import type { HashType } from "@tevm/voltaire/Hash";
+import * as Effect from "effect/Effect";
+import { EIP712Service } from "./EIP712Service.js";
+
+/**
+ * Hashes typed structured data according to EIP-712.
+ *
+ * @description
+ * Computes the EIP-712 hash of typed data: keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message)).
+ * This hash is what gets signed for EIP-712 signatures.
+ *
+ * @param typedData - The typed data to hash (domain, types, primaryType, message)
+ * @returns Effect containing the 32-byte hash, requiring EIP712Service
+ *
+ * @example
+ * ```typescript
+ * import { hashTypedData, EIP712Live } from 'voltaire-effect/crypto/EIP712'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = hashTypedData(typedData).pipe(Effect.provide(EIP712Live))
+ * ```
+ *
+ * @throws Never fails if typedData is valid
+ * @see {@link signTypedData} to sign the hash
+ * @since 0.0.1
+ */
+export const hashTypedData = (
+	typedData: TypedData,
+): Effect.Effect<HashType, never, EIP712Service> =>
+	Effect.gen(function* () {
+		const eip712 = yield* EIP712Service;
+		return yield* eip712.hashTypedData(typedData);
+	});
+
+/**
+ * Signs typed structured data according to EIP-712.
+ *
+ * @description
+ * Signs the EIP-712 hash with a secp256k1 private key. Returns a signature
+ * with r, s components and recovery parameter v (27 or 28).
+ *
+ * @param typedData - The typed data to sign (domain, types, primaryType, message)
+ * @param privateKey - The 32-byte private key as bytes or 0x-prefixed hex string
+ * @returns Effect containing the signature {r, s, v}, requiring EIP712Service
+ *
+ * @example
+ * ```typescript
+ * import { signTypedData, EIP712Live } from 'voltaire-effect/crypto/EIP712'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = signTypedData(typedData, '0x...').pipe(Effect.provide(EIP712Live))
+ * ```
+ *
+ * @throws Never fails if inputs are valid
+ * @see {@link verifyTypedData} to verify signatures
+ * @see {@link recoverAddress} to recover signer address
+ * @since 0.0.1
+ */
+export const signTypedData = (
+	typedData: TypedData,
+	privateKey: Uint8Array | string,
+): Effect.Effect<Signature, never, EIP712Service> =>
+	Effect.gen(function* () {
+		const eip712 = yield* EIP712Service;
+		return yield* eip712.signTypedData(typedData, privateKey);
+	});
+
+/**
+ * Verifies an EIP-712 typed data signature.
+ *
+ * @description
+ * Recovers the signer address from the signature and compares it to the
+ * expected address. Returns true if they match.
+ *
+ * @param signature - The signature {r, s, v} to verify
+ * @param typedData - The typed data that was signed
+ * @param address - The expected 20-byte signer address
+ * @returns Effect containing true if signature is valid, requiring EIP712Service
+ *
+ * @example
+ * ```typescript
+ * import { verifyTypedData, signTypedData, EIP712Live } from 'voltaire-effect/crypto/EIP712'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const sig = yield* signTypedData(typedData, privateKey)
+ *   return yield* verifyTypedData(sig, typedData, address)
+ * }).pipe(Effect.provide(EIP712Live))
+ * ```
+ *
+ * @throws Never fails
+ * @see {@link signTypedData} to create signatures
+ * @since 0.0.1
+ */
+export const verifyTypedData = (
+	signature: Signature,
+	typedData: TypedData,
+	address: AddressType,
+): Effect.Effect<boolean, never, EIP712Service> =>
+	Effect.gen(function* () {
+		const eip712 = yield* EIP712Service;
+		return yield* eip712.verifyTypedData(signature, typedData, address);
+	});
+
+/**
+ * Recovers the signer address from an EIP-712 signature.
+ *
+ * @description
+ * Uses ecrecover to derive the Ethereum address that created the signature.
+ * This is the inverse of signing - given a signature and the original message,
+ * we can determine who signed it.
+ *
+ * @param signature - The signature {r, s, v}
+ * @param typedData - The typed data that was signed
+ * @returns Effect containing the 20-byte recovered address, requiring EIP712Service
+ *
+ * @example
+ * ```typescript
+ * import { recoverAddress, signTypedData, EIP712Live } from 'voltaire-effect/crypto/EIP712'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const sig = yield* signTypedData(typedData, privateKey)
+ *   return yield* recoverAddress(sig, typedData)
+ * }).pipe(Effect.provide(EIP712Live))
+ * ```
+ *
+ * @throws Never fails if signature is valid
+ * @see {@link verifyTypedData} for simpler verification
+ * @since 0.0.1
+ */
+export const recoverAddress = (
+	signature: Signature,
+	typedData: TypedData,
+): Effect.Effect<AddressType, never, EIP712Service> =>
+	Effect.gen(function* () {
+		const eip712 = yield* EIP712Service;
+		return yield* eip712.recoverAddress(signature, typedData);
+	});
+
+/**
+ * Hashes a domain separator according to EIP-712.
+ *
+ * @description
+ * Computes hashStruct for the EIP712Domain type. The domain separator
+ * ensures signatures are unique to a specific contract/chain/version.
+ *
+ * @param domain - Domain parameters {name?, version?, chainId?, verifyingContract?, salt?}
+ * @returns Effect containing the 32-byte domain separator hash, requiring EIP712Service
+ *
+ * @example
+ * ```typescript
+ * import { hashDomain, EIP712Live } from 'voltaire-effect/crypto/EIP712'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const domain = { name: 'MyDApp', version: '1', chainId: 1 }
+ * const program = hashDomain(domain).pipe(Effect.provide(EIP712Live))
+ * ```
+ *
+ * @throws Never fails if domain is valid
+ * @see {@link hashStruct} for arbitrary struct hashing
+ * @since 0.0.1
+ */
+export const hashDomain = (
+	domain: Domain,
+): Effect.Effect<HashType, never, EIP712Service> =>
+	Effect.gen(function* () {
+		const eip712 = yield* EIP712Service;
+		return yield* eip712.hashDomain(domain);
+	});
+
+/**
+ * Hashes a struct according to EIP-712 encoding.
+ *
+ * @description
+ * Computes hashStruct(primaryType, data) = keccak256(typeHash ‖ encodeData(data)).
+ * Used internally for message and domain hashing.
+ *
+ * @param primaryType - The name of the primary struct type (e.g., "Person")
+ * @param data - The struct data matching the type definition
+ * @param types - Type definitions mapping type names to field arrays
+ * @returns Effect containing the 32-byte struct hash, requiring EIP712Service
+ *
+ * @example
+ * ```typescript
+ * import { hashStruct, EIP712Live } from 'voltaire-effect/crypto/EIP712'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const types = { Person: [{ name: 'name', type: 'string' }] }
+ * const program = hashStruct('Person', { name: 'Alice' }, types)
+ *   .pipe(Effect.provide(EIP712Live))
+ * ```
+ *
+ * @throws Never fails if inputs are valid
+ * @see {@link hashDomain} for domain separator hashing
+ * @since 0.0.1
+ */
+export const hashStruct = (
+	primaryType: string,
+	data: Message,
+	types: TypeDefinitions,
+): Effect.Effect<HashType, never, EIP712Service> =>
+	Effect.gen(function* () {
+		const eip712 = yield* EIP712Service;
+		return yield* eip712.hashStruct(primaryType, data, types);
+	});

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

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "@effect/vitest";
+import { encodeParameters } from "@tevm/voltaire/Abi";
+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 { VerifyError } from "../Signature/errors.js";
+import { unwrapSignature, verifySignature, wrapSignature } from "./index.js";
+
+const ERC6492_SUFFIX =
+	"6492649264926492649264926492649264926492649264926492649264926492";
+
+const factoryAddress = "0x000000000000000000000000000000000000dead" as const;
+const factoryData = "0x1234" as const;
+const innerSignature = `0x${"11".repeat(65)}` as `0x${string}`;
+const messageHash = `0x${"22".repeat(32)}` as `0x${string}`;
+const signer = "0x000000000000000000000000000000000000babe" as const;
+
+const VALIDATOR_PARAMS = [
+	{ type: "address", name: "signer" },
+	{ type: "bytes32", name: "hash" },
+	{ type: "bytes", name: "signature" },
+] as const;
+
+describe("ERC6492", () => {
+	it.effect("wraps and unwraps signatures", () =>
+		Effect.gen(function* () {
+			const wrapped = yield* wrapSignature({
+				signature: innerSignature,
+				factoryAddress,
+				factoryData,
+			});
+
+			expect(wrapped.endsWith(ERC6492_SUFFIX)).toBe(true);
+
+			const unwrapped = yield* unwrapSignature(wrapped);
+			expect(unwrapped).not.toBeNull();
+			if (!unwrapped) return;
+
+			expect(Address.toHex(unwrapped.factoryAddress)).toBe(factoryAddress);
+			expect(Hex.toBytes(unwrapped.factoryData)).toEqual(
+				Hex.toBytes(factoryData),
+			);
+			expect(Hex.toBytes(unwrapped.signature)).toEqual(
+				Hex.toBytes(innerSignature),
+			);
+		}),
+	);
+
+	it.effect("returns null for non-wrapped signatures", () =>
+		Effect.gen(function* () {
+			const unwrapped = yield* unwrapSignature(innerSignature);
+			expect(unwrapped).toBeNull();
+		}),
+	);
+
+	it.effect("verifies using deployless validator", () =>
+		Effect.gen(function* () {
+			const calls: Array<{ data?: string }> = [];
+			const provider = {
+				call: (tx: { data?: `0x${string}` }) =>
+					Effect.sync(() => {
+						calls.push(tx);
+						return "0x01" as `0x${string}`;
+					}),
+			} as any;
+
+			const result = yield* verifySignature({
+				address: signer,
+				message: messageHash,
+				signature: innerSignature,
+				provider,
+			});
+
+			expect(result).toBe(true);
+			expect(calls.length).toBe(1);
+			const callData = calls[0]?.data ?? "";
+			const encodedParams = Hex.fromBytes(
+				encodeParameters(
+					VALIDATOR_PARAMS as any,
+					[signer, messageHash, innerSignature] as any,
+				),
+			);
+			expect(callData.endsWith(encodedParams.slice(2))).toBe(true);
+		}),
+	);
+
+	it.effect("surfaces revert reason from validator", () =>
+		Effect.gen(function* () {
+			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 exit = yield* Effect.exit(
+				verifySignature({
+					address: signer,
+					message: messageHash,
+					signature: innerSignature,
+					provider,
+				}),
+			);
+
+			expect(Exit.isFailure(exit)).toBe(true);
+			if (Exit.isFailure(exit) && exit.cause._tag === "Fail") {
+				const error = exit.cause.error as VerifyError;
+				expect(error).toBeInstanceOf(VerifyError);
+				expect(error.message).toContain("boom");
+			}
+		}),
+	);
+});

package/src/crypto/ERC6492/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview ERC-6492 signature helpers.
+ * @module ERC6492
+ * @since 0.2.14
+ */
+
+export { unwrapSignature } from "./unwrapSignature.js";
+export { verifySignature } from "./verifySignature.js";
+export { wrapSignature } from "./wrapSignature.js";

package/src/crypto/ERC6492/unwrapSignature.ts

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview Unwrap ERC-6492 signatures.
+ * @module ERC6492/unwrapSignature
+ * @since 0.2.14
+ */
+
+import { decodeParameters } from "@tevm/voltaire/Abi";
+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";
+
+const ERC6492_SUFFIX =
+	"0x6492649264926492649264926492649264926492649264926492649264926492" as const;
+
+const ERC6492_PARAMS = [
+	{ type: "address", name: "factory" },
+	{ type: "bytes", name: "factoryData" },
+	{ type: "bytes", name: "signature" },
+] as const;
+
+const normalizeHex = (value: Uint8Array | `0x${string}`): HexType =>
+	typeof value === "string" ? (value as HexType) : Hex.fromBytes(value);
+
+/**
+ * Unwrap an ERC-6492 signature into its components.
+ *
+ * @param signature - The wrapped signature
+ * @returns Effect containing unwrapped data or null if not wrapped
+ *
+ * @since 0.2.14
+ */
+export const unwrapSignature = (
+	signature: HexType | `0x${string}`,
+): Effect.Effect<
+	{
+		signature: HexType;
+		factoryAddress: AddressType;
+		factoryData: HexType;
+	} | null,
+	never
+> =>
+	Effect.sync(() => {
+		const lower = signature.toLowerCase();
+		const suffix = ERC6492_SUFFIX.slice(2);
+		if (!lower.endsWith(suffix)) {
+			return null;
+		}
+
+		const encoded =
+			`0x${lower.slice(2, lower.length - suffix.length)}` as const;
+
+		try {
+			const decoded = decodeParameters(
+				ERC6492_PARAMS as any,
+				Hex.toBytes(encoded),
+			) as unknown as [
+				`0x${string}` | Uint8Array,
+				`0x${string}` | Uint8Array,
+				`0x${string}` | Uint8Array,
+			];
+
+			const [factory, factoryData, innerSignature] = decoded;
+			return {
+				factoryAddress: Address(factory as any),
+				factoryData: normalizeHex(factoryData),
+				signature: normalizeHex(innerSignature),
+			};
+		} catch {
+			return null;
+		}
+	});

package/src/crypto/ERC6492/verifySignature.ts

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview Verify ERC-6492 signatures via deployless UniversalSigValidator.
+ * @module ERC6492/verifySignature
+ * @since 0.2.14
+ */
+
+import { decodeParameters, encodeParameters } from "@tevm/voltaire/Abi";
+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 { VerifyError } from "../Signature/errors.js";
+
+// Output from solc contracts/DeploylessUniversalSigValidator.sol --bin --optimize --optimize-runs=1
+const UNIVERSAL_VALIDATOR_BYTECODE =
+	"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" as const;
+
+const VALIDATOR_PARAMS = [
+	{ type: "address", name: "signer" },
+	{ type: "bytes32", name: "hash" },
+	{ type: "bytes", name: "signature" },
+] as const;
+
+const normalizeAddress = (
+	address: AddressType | `0x${string}`,
+): `0x${string}` =>
+	typeof address === "string" ? address : Address.toHex(address);
+
+const decodeRevertReason = (data: `0x${string}`): string | null => {
+	if (!data.startsWith("0x08c379a0")) {
+		return null;
+	}
+	try {
+		const decoded = decodeParameters(
+			[{ type: "string" }] as const,
+			Hex.toBytes(`0x${data.slice(10)}` as `0x${string}`),
+		) as unknown as [string];
+		return decoded[0];
+	} catch {
+		return null;
+	}
+};
+
+const normalizeCallResult = (value: HexType | `0x${string}`): `0x${string}` =>
+	typeof value === "string" ? value : Hex.fromBytes(value);
+
+/**
+ * Verify a signature with ERC-6492 support using a deployless universal validator.
+ *
+ * @param params - Signature verification inputs
+ * @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
+ */
+export const verifySignature = (params: {
+	address: AddressType | `0x${string}`;
+	message: HexType | `0x${string}`;
+	signature: HexType | `0x${string}`;
+	provider: ProviderService;
+}): Effect.Effect<boolean, VerifyError> =>
+	Effect.gen(function* () {
+		const messageHex = params.message as `0x${string}`;
+		const messageBytes = yield* Effect.try({
+			try: () => Hex.toBytes(messageHex),
+			catch: (e) =>
+				new VerifyError({
+					message: `Invalid message hash: ${e instanceof Error ? e.message : String(e)}`,
+					cause: e,
+				}),
+		});
+
+		if (messageBytes.length !== 32) {
+			return yield* Effect.fail(
+				new VerifyError({
+					message: `Invalid message hash length: expected 32 bytes, got ${messageBytes.length}`,
+				}),
+			);
+		}
+
+		const encodedParams = yield* Effect.try({
+			try: () =>
+				encodeParameters(
+					VALIDATOR_PARAMS as any,
+					[
+						normalizeAddress(params.address),
+						messageHex,
+						params.signature,
+					] as any,
+				),
+			catch: (e) =>
+				new VerifyError({
+					message: `Failed to encode validation calldata: ${e instanceof Error ? e.message : String(e)}`,
+					cause: e,
+				}),
+		});
+
+		const data =
+			`${UNIVERSAL_VALIDATOR_BYTECODE}${Hex.fromBytes(encodedParams).slice(2)}` as `0x${string}`;
+
+		const callResult = yield* params.provider.call({ data }).pipe(
+			Effect.mapError(
+				(e) =>
+					new VerifyError({
+						message: `Signature verification call failed: ${e instanceof Error ? e.message : String(e)}`,
+						cause: e,
+					}),
+			),
+		);
+
+		const callHex = normalizeCallResult(
+			callResult,
+		).toLowerCase() as `0x${string}`;
+		const revertReason = decodeRevertReason(callHex);
+		if (revertReason) {
+			return yield* Effect.fail(
+				new VerifyError({
+					message: `Signature verification reverted: ${revertReason}`,
+				}),
+			);
+		}
+
+		if (callHex === "0x01" || callHex === "0x1") {
+			return true;
+		}
+		if (callHex === "0x" || callHex === "0x00" || callHex === "0x0") {
+			return false;
+		}
+
+		return yield* Effect.fail(
+			new VerifyError({
+				message: `Unexpected result from UniversalSigValidator: ${callHex}`,
+			}),
+		);
+	});

package/src/crypto/ERC6492/wrapSignature.ts

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Wrap signatures for ERC-6492 counterfactual validation.
+ * @module ERC6492/wrapSignature
+ * @since 0.2.14
+ */
+
+import { encodeParameters } from "@tevm/voltaire/Abi";
+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";
+
+const ERC6492_SUFFIX =
+	"0x6492649264926492649264926492649264926492649264926492649264926492" as const;
+
+const ERC6492_PARAMS = [
+	{ type: "address", name: "factory" },
+	{ type: "bytes", name: "factoryData" },
+	{ type: "bytes", name: "signature" },
+] as const;
+
+const normalizeAddress = (
+	address: AddressType | `0x${string}`,
+): `0x${string}` =>
+	typeof address === "string" ? address : Address.toHex(address);
+
+/**
+ * Wrap a signature with ERC-6492 deployment data.
+ *
+ * @param params - Signature and factory data to wrap
+ * @param params.signature - The original signature bytes
+ * @param params.factoryAddress - Factory contract address
+ * @param params.factoryData - Factory calldata to deploy the account
+ * @returns Effect containing the wrapped signature
+ *
+ * @since 0.2.14
+ */
+export const wrapSignature = (params: {
+	signature: HexType | `0x${string}`;
+	factoryAddress: AddressType | `0x${string}`;
+	factoryData: HexType | `0x${string}`;
+}): Effect.Effect<HexType, never> =>
+	Effect.sync(() => {
+		const encoded = encodeParameters(
+			ERC6492_PARAMS as any,
+			[
+				normalizeAddress(params.factoryAddress),
+				params.factoryData,
+				params.signature,
+			] as any,
+		);
+
+		const encodedHex = Hex.fromBytes(encoded);
+		return `${encodedHex}${ERC6492_SUFFIX.slice(2)}` as HexType;
+	});