voltaire-effect 0.2.23

package/src/services/Signer/index.ts

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview Signer module exports for signing and transaction operations.
+ *
+ * @module Signer
+ * @since 0.0.1
+ *
+ * @description
+ * This module provides the signer service for signing messages,
+ * transactions, and typed data. It includes the service definition,
+ * layer implementation, composition helpers, and all related types.
+ *
+ * Main exports:
+ * - {@link SignerService} - The service tag/interface
+ * - {@link Signer} - Namespace with Live layer and composition helpers
+ * - {@link SignerError} - Error type for failed operations
+ *
+ * Type exports:
+ * - {@link SignerShape} - Service interface shape
+ * - {@link TransactionRequest} - Transaction parameters type
+ *
+ * @example Typical usage with Signer.Live
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import {
+ *   SignerService,
+ *   Signer,
+ *   LocalAccount,
+ *   Provider,
+ *   HttpTransport
+ * } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const signer = yield* SignerService
+ *   return yield* signer.sendTransaction({
+ *     to: recipientAddress,
+ *     value: 1000000000000000000n
+ *   })
+ * }).pipe(
+ *   Effect.provide(Signer.Live),
+ *   Effect.provide(LocalAccount(privateKey)),
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://...'))
+ * )
+ * ```
+ *
+ * @example Using Signer.fromPrivateKey
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { SignerService, Signer, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const signerLayer = Signer.fromPrivateKey(privateKey, Provider)
+ *
+ * const program = Effect.gen(function* () {
+ *   const signer = yield* SignerService
+ *   return yield* signer.sendTransaction({ to: recipient, value: 1n })
+ * }).pipe(
+ *   Effect.provide(signerLayer),
+ *   Effect.provide(HttpTransport('https://...'))
+ * )
+ * ```
+ *
+ * @see {@link AccountService} - Required for signing operations
+ * @see {@link ProviderService} - Required for gas/nonce
+ * @see {@link TransportService} - Required for transaction broadcast
+ */
+
+export {
+	type Authorization,
+	// Wallet management actions
+	addChain,
+	type Caveat,
+	type ChainConfig,
+	type DeployContractParams,
+	type DeployContractResult,
+	deployContract,
+	getAddresses,
+	getPermissions,
+	type NativeCurrency,
+	type Permission,
+	type PermissionRequest,
+	type PrepareAuthorizationParams,
+	// EIP-7702 Authorization actions
+	prepareAuthorization,
+	requestPermissions,
+	type SignAuthorizationParams,
+	type SignedAuthorization,
+	signAuthorization,
+	switchChain,
+	type UnsignedAuthorization,
+	type WatchAssetOptions,
+	type WatchAssetParams,
+	type WatchAssetType,
+	type WriteContractParams,
+	watchAsset,
+	// Contract actions
+	writeContract,
+} from "./actions/index.js";
+export { Signer } from "./Signer.js";
+export {
+	type AddressInput,
+	type CallsStatus,
+	type SendCallsParams,
+	SignerError,
+	SignerService,
+	type SignerShape,
+	type TransactionRequest,
+	type WalletCapabilities,
+} from "./SignerService.js";

package/src/services/TransactionSerializer/DefaultTransactionSerializer.ts

@@ -0,0 +1,110 @@
+/**
+ * @fileoverview Default implementation of TransactionSerializerService.
+ *
+ * @module DefaultTransactionSerializer
+ * @since 0.1.0
+ *
+ * @description
+ * Provides the default implementation of TransactionSerializerService using
+ * @tevm/voltaire/Transaction primitives.
+ *
+ * @see {@link TransactionSerializerService} - The service interface
+ */
+
+import * as VoltaireTransaction from "@tevm/voltaire/Transaction";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import {
+	DeserializeError,
+	SerializeError,
+	TransactionSerializerService,
+} from "./TransactionSerializerService.js";
+
+/**
+ * Live implementation of TransactionSerializerService.
+ *
+ * @description
+ * Uses VoltaireTransaction.serialize(), VoltaireTransaction.deserialize(),
+ * and VoltaireTransaction.getSigningHash() for transaction operations.
+ *
+ * @since 0.1.0
+ */
+const TransactionSerializerLive: Layer.Layer<TransactionSerializerService> =
+	Layer.succeed(TransactionSerializerService, {
+		serialize: (tx) =>
+			Effect.try({
+				try: () => VoltaireTransaction.serialize(tx as VoltaireTransaction.Any),
+				catch: (error) =>
+					new SerializeError({
+						transaction: tx,
+						message: `Failed to serialize transaction: ${error instanceof Error ? error.message : String(error)}`,
+						cause: error,
+					}),
+			}),
+
+		deserialize: (bytes) =>
+			Effect.try({
+				try: () => VoltaireTransaction.deserialize(bytes),
+				catch: (error) =>
+					new DeserializeError({
+						bytes,
+						message: `Failed to deserialize transaction: ${error instanceof Error ? error.message : String(error)}`,
+						cause: error,
+					}),
+			}),
+
+		getSigningPayload: (tx) =>
+			Effect.try({
+				try: () =>
+					VoltaireTransaction.getSigningHash(
+						tx as VoltaireTransaction.Any,
+					) as Uint8Array,
+				catch: (error) =>
+					new SerializeError({
+						transaction: tx,
+						message: `Failed to get signing payload: ${error instanceof Error ? error.message : String(error)}`,
+						cause: error,
+					}),
+			}),
+	});
+
+/**
+ * Default transaction serializer namespace with layer.
+ *
+ * @since 0.1.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { TransactionSerializerService, DefaultTransactionSerializer } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const serializer = yield* TransactionSerializerService
+ *
+ *   // Serialize a transaction
+ *   const tx = {
+ *     type: 2,
+ *     chainId: 1n,
+ *     nonce: 0n,
+ *     maxFeePerGas: 20000000000n,
+ *     maxPriorityFeePerGas: 1000000000n,
+ *     gasLimit: 21000n,
+ *     to: '0x...',
+ *     value: 1000000000000000000n,
+ *     data: new Uint8Array(0),
+ *     accessList: []
+ *   }
+ *
+ *   const bytes = yield* serializer.serialize(tx)
+ *   const signingPayload = yield* serializer.getSigningPayload(tx)
+ *   const decoded = yield* serializer.deserialize(bytes)
+ * }).pipe(Effect.provide(DefaultTransactionSerializer.Live))
+ * ```
+ */
+export const DefaultTransactionSerializer = {
+	/**
+	 * Live layer providing TransactionSerializerService.
+	 */
+	Live: TransactionSerializerLive,
+} as const;

package/src/services/TransactionSerializer/TransactionSerializer.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Address, Hex } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { DefaultTransactionSerializer } from "./DefaultTransactionSerializer.js";
+import {
+	DeserializeError,
+	SerializeError,
+	TransactionSerializerService,
+} from "./TransactionSerializerService.js";
+
+const EIP1559_TX = {
+	type: 2 as const,
+	chainId: 1n,
+	nonce: 0n,
+	maxFeePerGas: 20000000000n,
+	maxPriorityFeePerGas: 1000000000n,
+	gasLimit: 21000n,
+	to: Address.from("0x1234567890123456789012345678901234567890"),
+	value: 1000000000000000000n,
+	data: Hex.toBytes("0x"),
+	accessList: [] as const,
+	yParity: 0,
+	r: new Uint8Array(32),
+	s: new Uint8Array(32),
+};
+
+describe("TransactionSerializerService", () => {
+	describe("serialize", () => {
+		it.effect("returns Uint8Array for valid transaction", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const result = yield* serializer.serialize(EIP1559_TX);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBeGreaterThan(0);
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+
+		it.effect("returns SerializeError for invalid transaction shape", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const invalidTx = { invalid: "transaction" };
+				const exit = yield* Effect.exit(serializer.serialize(invalidTx));
+				expect(Exit.isFailure(exit)).toBe(true);
+				if (Exit.isFailure(exit)) {
+					const error = exit.cause._tag === "Fail" ? exit.cause.error : null;
+					expect(error).toBeInstanceOf(SerializeError);
+					expect((error as SerializeError)._tag).toBe("SerializeError");
+					expect((error as SerializeError).transaction).toEqual(invalidTx);
+					expect((error as SerializeError).cause).toBeDefined();
+				}
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+
+		it.effect("can catch SerializeError by tag", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const result = yield* serializer
+					.serialize({})
+					.pipe(
+						Effect.catchTag("SerializeError", (e) =>
+							Effect.succeed(`caught: ${e._tag}`),
+						),
+					);
+				expect(result).toBe("caught: SerializeError");
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+	});
+
+	describe("deserialize", () => {
+		it.effect("returns transaction object for valid bytes", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const bytes = yield* serializer.serialize(EIP1559_TX);
+				const result = yield* serializer.deserialize(bytes);
+				expect(result).toBeDefined();
+				expect(typeof result).toBe("object");
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+
+		it.effect("returns DeserializeError for invalid bytes", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const invalidBytes = new Uint8Array([0xff, 0xfe, 0xfd]);
+				const exit = yield* Effect.exit(serializer.deserialize(invalidBytes));
+				expect(Exit.isFailure(exit)).toBe(true);
+				if (Exit.isFailure(exit)) {
+					const error = exit.cause._tag === "Fail" ? exit.cause.error : null;
+					expect(error).toBeInstanceOf(DeserializeError);
+					expect((error as DeserializeError)._tag).toBe("DeserializeError");
+					expect((error as DeserializeError).bytes).toEqual(invalidBytes);
+					expect((error as DeserializeError).cause).toBeDefined();
+				}
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+
+		it.effect("can catch DeserializeError by tag", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const result = yield* serializer
+					.deserialize(new Uint8Array([0x00]))
+					.pipe(
+						Effect.catchTag("DeserializeError", (e) =>
+							Effect.succeed(`caught: ${e._tag}`),
+						),
+					);
+				expect(result).toBe("caught: DeserializeError");
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+	});
+
+	describe("getSigningPayload", () => {
+		it.effect("returns 32-byte hash", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const result = yield* serializer.getSigningPayload(EIP1559_TX);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(32);
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+
+		it.effect("is deterministic - same tx produces same hash", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const hash1 = yield* serializer.getSigningPayload(EIP1559_TX);
+				const hash2 = yield* serializer.getSigningPayload(EIP1559_TX);
+				expect(hash1).toEqual(hash2);
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+
+		it.effect("different tx produces different hash", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const modifiedTx = { ...EIP1559_TX, nonce: 1n };
+				const hash1 = yield* serializer.getSigningPayload(EIP1559_TX);
+				const hash2 = yield* serializer.getSigningPayload(modifiedTx);
+				expect(hash1).not.toEqual(hash2);
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+
+		it.effect("returns SerializeError for invalid transaction", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const invalidTx = { type: 999, invalid: true };
+				const exit = yield* Effect.exit(
+					serializer.getSigningPayload(invalidTx),
+				);
+				expect(Exit.isFailure(exit)).toBe(true);
+				if (Exit.isFailure(exit)) {
+					const error = exit.cause._tag === "Fail" ? exit.cause.error : null;
+					expect(error).toBeInstanceOf(SerializeError);
+					expect((error as SerializeError).transaction).toEqual(invalidTx);
+				}
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+	});
+
+	describe("round-trip", () => {
+		it.effect("serialize -> deserialize preserves key fields", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const bytes = yield* serializer.serialize(EIP1559_TX);
+				const decoded = (yield* serializer.deserialize(bytes)) as Record<
+					string,
+					unknown
+				>;
+				expect(decoded.type).toBe(EIP1559_TX.type);
+				expect(decoded.chainId).toBe(EIP1559_TX.chainId);
+				expect(decoded.nonce).toBe(EIP1559_TX.nonce);
+				expect(decoded.maxFeePerGas).toBe(EIP1559_TX.maxFeePerGas);
+				expect(decoded.maxPriorityFeePerGas).toBe(
+					EIP1559_TX.maxPriorityFeePerGas,
+				);
+				expect(decoded.gasLimit).toBe(EIP1559_TX.gasLimit);
+				expect(decoded.value).toBe(EIP1559_TX.value);
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+
+		it.effect("preserves 'to' address in round-trip", () =>
+			Effect.gen(function* () {
+				const serializer = yield* TransactionSerializerService;
+				const bytes = yield* serializer.serialize(EIP1559_TX);
+				const decoded = (yield* serializer.deserialize(bytes)) as Record<
+					string,
+					unknown
+				>;
+				const toAddress = decoded.to as Uint8Array | string;
+				const expectedHex = Address.toHex(EIP1559_TX.to).toLowerCase();
+				if (toAddress instanceof Uint8Array) {
+					const hex = Array.from(toAddress)
+						.map((b) => b.toString(16).padStart(2, "0"))
+						.join("");
+					expect(`0x${hex}`).toBe(expectedHex);
+				} else if (typeof toAddress === "string") {
+					expect(toAddress.toLowerCase()).toBe(expectedHex);
+				}
+			}).pipe(Effect.provide(DefaultTransactionSerializer.Live)),
+		);
+	});
+});

package/src/services/TransactionSerializer/TransactionSerializerService.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Transaction serializer service definition.
+ *
+ * @module TransactionSerializerService
+ * @since 0.1.0
+ *
+ * @description
+ * Provides an Effect-based service for serializing and deserializing
+ * Ethereum transactions. Supports all transaction types (Legacy, EIP-2930,
+ * EIP-1559, EIP-4844, EIP-7702).
+ *
+ * The service provides:
+ * - Transaction serialization to RLP-encoded bytes
+ * - Transaction deserialization from RLP-encoded bytes
+ * - Signing payload extraction for transaction signing
+ *
+ * @see {@link DefaultTransactionSerializer} - The default implementation
+ */
+
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import type * as Effect from "effect/Effect";
+
+/**
+ * Error thrown when transaction serialization fails.
+ *
+ * @since 0.1.0
+ */
+export class SerializeError extends Data.TaggedError("SerializeError")<{
+	/** The transaction that failed to serialize */
+	readonly transaction: unknown;
+	/** Human-readable error message */
+	readonly message: string;
+	/** Underlying error that caused the failure */
+	readonly cause?: unknown;
+}> {}
+
+/**
+ * Error thrown when transaction deserialization fails.
+ *
+ * @since 0.1.0
+ */
+export class DeserializeError extends Data.TaggedError("DeserializeError")<{
+	/** The bytes that failed to deserialize */
+	readonly bytes: Uint8Array;
+	/** Human-readable error message */
+	readonly message: string;
+	/** Underlying error that caused the failure */
+	readonly cause?: unknown;
+}> {}
+
+/**
+ * Transaction serializer service for encoding/decoding transactions.
+ *
+ * @description
+ * Provides methods for serializing transactions to bytes and deserializing
+ * bytes back to transactions. Also provides signing payload extraction
+ * for use with external signers.
+ *
+ * @since 0.1.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { TransactionSerializerService, DefaultTransactionSerializer } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const serializer = yield* TransactionSerializerService
+ *   const bytes = yield* serializer.serialize(tx)
+ *   const decoded = yield* serializer.deserialize(bytes)
+ * }).pipe(Effect.provide(DefaultTransactionSerializer.Live))
+ * ```
+ */
+export class TransactionSerializerService extends Context.Tag(
+	"TransactionSerializerService",
+)<
+	TransactionSerializerService,
+	{
+		/**
+		 * Serialize a transaction to RLP-encoded bytes.
+		 *
+		 * @param tx - The transaction to serialize
+		 * @returns RLP-encoded transaction bytes
+		 */
+		readonly serialize: (
+			tx: unknown,
+		) => Effect.Effect<Uint8Array, SerializeError>;
+
+		/**
+		 * Deserialize RLP-encoded bytes to a transaction.
+		 *
+		 * @param bytes - The RLP-encoded transaction bytes
+		 * @returns The deserialized transaction
+		 */
+		readonly deserialize: (
+			bytes: Uint8Array,
+		) => Effect.Effect<unknown, DeserializeError>;
+
+		/**
+		 * Get the signing payload (hash) for a transaction.
+		 *
+		 * @description
+		 * Returns the hash that should be signed to create a valid transaction
+		 * signature. This is the RLP-encoded unsigned transaction hashed with
+		 * Keccak-256.
+		 *
+		 * @param tx - The transaction to get signing payload for
+		 * @returns The signing hash as bytes
+		 */
+		readonly getSigningPayload: (
+			tx: unknown,
+		) => Effect.Effect<Uint8Array, SerializeError>;
+	}
+>() {}

package/src/services/TransactionSerializer/index.ts

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Transaction serializer module exports.
+ *
+ * @module TransactionSerializer
+ * @since 0.1.0
+ *
+ * @description
+ * This module provides transaction serialization/deserialization services
+ * for Ethereum transactions.
+ *
+ * Main exports:
+ * - {@link TransactionSerializerService} - The service tag/interface
+ * - {@link DefaultTransactionSerializer} - Default implementation layer
+ * - {@link SerializeError} - Error type for serialization failures
+ * - {@link DeserializeError} - Error type for deserialization failures
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import {
+ *   TransactionSerializerService,
+ *   DefaultTransactionSerializer
+ * } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const serializer = yield* TransactionSerializerService
+ *   const bytes = yield* serializer.serialize(tx)
+ *   return bytes
+ * }).pipe(Effect.provide(DefaultTransactionSerializer.Live))
+ * ```
+ */
+
+export { DefaultTransactionSerializer } from "./DefaultTransactionSerializer.js";
+export {
+	DeserializeError,
+	SerializeError,
+	TransactionSerializerService,
+} from "./TransactionSerializerService.js";