voltaire-effect 0.2.23

package/src/crypto/Ed25519/Ed25519.test.ts

@@ -0,0 +1,472 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as VoltaireEd25519 from "@tevm/voltaire/Ed25519";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Ed25519Effect from "./index.js";
+
+describe("Ed25519", () => {
+	const testSeed = new Uint8Array(32).fill(0x42);
+	const testKeypair = VoltaireEd25519.keypairFromSeed(testSeed);
+	const testMessage = new TextEncoder().encode("Hello, world!");
+
+	describe("sign", () => {
+		it.effect("signs a message with a secret key", () =>
+			Effect.gen(function* () {
+				const result = yield* Ed25519Effect.sign(
+					testMessage,
+					testKeypair.secretKey,
+				);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(64);
+			}),
+		);
+
+		it.effect("produces deterministic signatures", () =>
+			Effect.gen(function* () {
+				const sig1 = yield* Ed25519Effect.sign(
+					testMessage,
+					testKeypair.secretKey,
+				);
+				const sig2 = yield* Ed25519Effect.sign(
+					testMessage,
+					testKeypair.secretKey,
+				);
+				expect(sig1).toEqual(sig2);
+			}),
+		);
+
+		it("fails with wrong key length (16 bytes)", async () => {
+			const wrongKey = new Uint8Array(16);
+			const exit = await Effect.runPromiseExit(
+				Ed25519Effect.sign(testMessage, wrongKey),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it("fails with wrong key length (64 bytes instead of 32)", async () => {
+			const wrongKey = new Uint8Array(64).fill(0x42);
+			const exit = await Effect.runPromiseExit(
+				Ed25519Effect.sign(testMessage, wrongKey),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it("fails with empty key", async () => {
+			const emptyKey = new Uint8Array(0);
+			const exit = await Effect.runPromiseExit(
+				Ed25519Effect.sign(testMessage, emptyKey),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it.effect("signs empty message", () =>
+			Effect.gen(function* () {
+				const emptyMessage = new Uint8Array(0);
+				const result = yield* Ed25519Effect.sign(
+					emptyMessage,
+					testKeypair.secretKey,
+				);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(64);
+			}),
+		);
+
+		it.effect("signs large message", () =>
+			Effect.gen(function* () {
+				const largeMessage = new Uint8Array(10000).fill(0xab);
+				const result = yield* Ed25519Effect.sign(
+					largeMessage,
+					testKeypair.secretKey,
+				);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(64);
+			}),
+		);
+
+		it.effect("produces different signatures for different messages", () =>
+			Effect.gen(function* () {
+				const msg1 = new TextEncoder().encode("Message 1");
+				const msg2 = new TextEncoder().encode("Message 2");
+				const sig1 = yield* Ed25519Effect.sign(msg1, testKeypair.secretKey);
+				const sig2 = yield* Ed25519Effect.sign(msg2, testKeypair.secretKey);
+				expect(sig1).not.toEqual(sig2);
+			}),
+		);
+
+		it.effect("produces different signatures for different keys", () =>
+			Effect.gen(function* () {
+				const seed1 = new Uint8Array(32).fill(0x11);
+				const seed2 = new Uint8Array(32).fill(0x22);
+				const keypair1 = VoltaireEd25519.keypairFromSeed(seed1);
+				const keypair2 = VoltaireEd25519.keypairFromSeed(seed2);
+				const sig1 = yield* Ed25519Effect.sign(testMessage, keypair1.secretKey);
+				const sig2 = yield* Ed25519Effect.sign(testMessage, keypair2.secretKey);
+				expect(sig1).not.toEqual(sig2);
+			}),
+		);
+
+		it.effect("handles all-zeros secret key", () =>
+			Effect.gen(function* () {
+				const zeroSeed = new Uint8Array(32);
+				const keypair = VoltaireEd25519.keypairFromSeed(zeroSeed);
+				const result = yield* Ed25519Effect.sign(
+					testMessage,
+					keypair.secretKey,
+				);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(64);
+			}),
+		);
+
+		it.effect("handles all-ones secret key", () =>
+			Effect.gen(function* () {
+				const onesSeed = new Uint8Array(32).fill(0xff);
+				const keypair = VoltaireEd25519.keypairFromSeed(onesSeed);
+				const result = yield* Ed25519Effect.sign(
+					testMessage,
+					keypair.secretKey,
+				);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(64);
+			}),
+		);
+	});
+
+	describe("verify", () => {
+		it.effect("verifies a valid signature", () =>
+			Effect.gen(function* () {
+				const signature = yield* Ed25519Effect.sign(
+					testMessage,
+					testKeypair.secretKey,
+				);
+				const isValid = yield* Ed25519Effect.verify(
+					signature,
+					testMessage,
+					testKeypair.publicKey,
+				);
+				expect(isValid).toBe(true);
+			}),
+		);
+
+		it.effect("returns false for wrong message", () =>
+			Effect.gen(function* () {
+				const signature = yield* Ed25519Effect.sign(
+					testMessage,
+					testKeypair.secretKey,
+				);
+				const wrongMessage = new TextEncoder().encode("Wrong message");
+				const isValid = yield* Ed25519Effect.verify(
+					signature,
+					wrongMessage,
+					testKeypair.publicKey,
+				);
+				expect(isValid).toBe(false);
+			}),
+		);
+
+		it.effect("returns false for wrong public key", () =>
+			Effect.gen(function* () {
+				const signature = yield* Ed25519Effect.sign(
+					testMessage,
+					testKeypair.secretKey,
+				);
+				const otherSeed = new Uint8Array(32).fill(0x99);
+				const otherKeypair = VoltaireEd25519.keypairFromSeed(otherSeed);
+				const isValid = yield* Ed25519Effect.verify(
+					signature,
+					testMessage,
+					otherKeypair.publicKey,
+				);
+				expect(isValid).toBe(false);
+			}),
+		);
+
+		it.effect("returns false for tampered signature", () =>
+			Effect.gen(function* () {
+				const signature = yield* Ed25519Effect.sign(
+					testMessage,
+					testKeypair.secretKey,
+				);
+				const tamperedSig = new Uint8Array(signature);
+				tamperedSig[0] ^= 0xff;
+				const isValid = yield* Ed25519Effect.verify(
+					tamperedSig,
+					testMessage,
+					testKeypair.publicKey,
+				);
+				expect(isValid).toBe(false);
+			}),
+		);
+
+		it.effect("returns false for all-zeros signature", () =>
+			Effect.gen(function* () {
+				const zeroSig = new Uint8Array(64);
+				const isValid = yield* Ed25519Effect.verify(
+					zeroSig,
+					testMessage,
+					testKeypair.publicKey,
+				);
+				expect(isValid).toBe(false);
+			}),
+		);
+
+		it("returns false for signature with wrong length", async () => {
+			const shortSig = new Uint8Array(32);
+			const exit = await Effect.runPromiseExit(
+				Ed25519Effect.verify(shortSig, testMessage, testKeypair.publicKey),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it("fails with public key of wrong length", async () => {
+			const signature = await Effect.runPromise(
+				Ed25519Effect.sign(testMessage, testKeypair.secretKey),
+			);
+			const wrongPubKey = new Uint8Array(16);
+			const exit = await Effect.runPromiseExit(
+				Ed25519Effect.verify(signature, testMessage, wrongPubKey),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it.effect("verifies empty message signature", () =>
+			Effect.gen(function* () {
+				const emptyMessage = new Uint8Array(0);
+				const signature = yield* Ed25519Effect.sign(
+					emptyMessage,
+					testKeypair.secretKey,
+				);
+				const isValid = yield* Ed25519Effect.verify(
+					signature,
+					emptyMessage,
+					testKeypair.publicKey,
+				);
+				expect(isValid).toBe(true);
+			}),
+		);
+
+		it.effect("verifies large message signature", () =>
+			Effect.gen(function* () {
+				const largeMessage = new Uint8Array(10000).fill(0xab);
+				const signature = yield* Ed25519Effect.sign(
+					largeMessage,
+					testKeypair.secretKey,
+				);
+				const isValid = yield* Ed25519Effect.verify(
+					signature,
+					largeMessage,
+					testKeypair.publicKey,
+				);
+				expect(isValid).toBe(true);
+			}),
+		);
+	});
+
+	describe("getPublicKey", () => {
+		it.effect("derives public key from secret key", () =>
+			Effect.gen(function* () {
+				const result = yield* Ed25519Effect.getPublicKey(testKeypair.secretKey);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(32);
+				expect(result).toEqual(testKeypair.publicKey);
+			}),
+		);
+
+		it("fails with wrong key length (16 bytes)", async () => {
+			const wrongKey = new Uint8Array(16);
+			const exit = await Effect.runPromiseExit(
+				Ed25519Effect.getPublicKey(wrongKey),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it("fails with wrong key length (64 bytes)", async () => {
+			const wrongKey = new Uint8Array(64).fill(0x42);
+			const exit = await Effect.runPromiseExit(
+				Ed25519Effect.getPublicKey(wrongKey),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it("fails with empty key", async () => {
+			const emptyKey = new Uint8Array(0);
+			const exit = await Effect.runPromiseExit(
+				Ed25519Effect.getPublicKey(emptyKey),
+			);
+			expect(Exit.isFailure(exit)).toBe(true);
+		});
+
+		it.effect("derives different public keys for different secret keys", () =>
+			Effect.gen(function* () {
+				const seed1 = new Uint8Array(32).fill(0x11);
+				const seed2 = new Uint8Array(32).fill(0x22);
+				const keypair1 = VoltaireEd25519.keypairFromSeed(seed1);
+				const keypair2 = VoltaireEd25519.keypairFromSeed(seed2);
+				const pubKey1 = yield* Ed25519Effect.getPublicKey(keypair1.secretKey);
+				const pubKey2 = yield* Ed25519Effect.getPublicKey(keypair2.secretKey);
+				expect(pubKey1).not.toEqual(pubKey2);
+			}),
+		);
+
+		it.effect(
+			"derives same public key for same secret key (deterministic)",
+			() =>
+				Effect.gen(function* () {
+					const pubKey1 = yield* Ed25519Effect.getPublicKey(
+						testKeypair.secretKey,
+					);
+					const pubKey2 = yield* Ed25519Effect.getPublicKey(
+						testKeypair.secretKey,
+					);
+					expect(pubKey1).toEqual(pubKey2);
+				}),
+		);
+
+		it.effect("handles all-zeros secret key", () =>
+			Effect.gen(function* () {
+				const zeroSeed = new Uint8Array(32);
+				const keypair = VoltaireEd25519.keypairFromSeed(zeroSeed);
+				const result = yield* Ed25519Effect.getPublicKey(keypair.secretKey);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(32);
+			}),
+		);
+	});
+
+	describe("Full Round Trip", () => {
+		it.effect("sign-verify round trip", () =>
+			Effect.gen(function* () {
+				const seed = new Uint8Array(32).fill(0xab);
+				const keypair = VoltaireEd25519.keypairFromSeed(seed);
+				const message = new TextEncoder().encode("Round trip test");
+				const signature = yield* Ed25519Effect.sign(message, keypair.secretKey);
+				const isValid = yield* Ed25519Effect.verify(
+					signature,
+					message,
+					keypair.publicKey,
+				);
+				expect(isValid).toBe(true);
+			}),
+		);
+
+		it.effect("getPublicKey matches keypair derivation", () =>
+			Effect.gen(function* () {
+				const seed = new Uint8Array(32).fill(0xcd);
+				const keypair = VoltaireEd25519.keypairFromSeed(seed);
+				const derivedPubKey = yield* Ed25519Effect.getPublicKey(
+					keypair.secretKey,
+				);
+				expect(derivedPubKey).toEqual(keypair.publicKey);
+			}),
+		);
+	});
+
+	describe("Ed25519Service", () => {
+		it.effect("provides sign through service layer", () =>
+			Effect.gen(function* () {
+				const ed = yield* Ed25519Effect.Ed25519Service;
+				const result = yield* ed.sign(testMessage, testKeypair.secretKey);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(64);
+			}).pipe(Effect.provide(Ed25519Effect.Ed25519Live)),
+		);
+
+		it.effect("provides verify through service layer", () =>
+			Effect.gen(function* () {
+				const signature = yield* Ed25519Effect.sign(
+					testMessage,
+					testKeypair.secretKey,
+				);
+				const ed = yield* Ed25519Effect.Ed25519Service;
+				const result = yield* ed.verify(
+					signature,
+					testMessage,
+					testKeypair.publicKey,
+				);
+				expect(result).toBe(true);
+			}).pipe(Effect.provide(Ed25519Effect.Ed25519Live)),
+		);
+
+		it.effect("provides getPublicKey through service layer", () =>
+			Effect.gen(function* () {
+				const ed = yield* Ed25519Effect.Ed25519Service;
+				const result = yield* ed.getPublicKey(testKeypair.secretKey);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(32);
+			}).pipe(Effect.provide(Ed25519Effect.Ed25519Live)),
+		);
+
+		it.effect("sign-verify through service layer", () =>
+			Effect.gen(function* () {
+				const ed = yield* Ed25519Effect.Ed25519Service;
+				const sig = yield* ed.sign(testMessage, testKeypair.secretKey);
+				const pubKey = yield* ed.getPublicKey(testKeypair.secretKey);
+				const result = yield* ed.verify(sig, testMessage, pubKey);
+				expect(result).toBe(true);
+			}).pipe(Effect.provide(Ed25519Effect.Ed25519Live)),
+		);
+	});
+
+	describe("Ed25519Test (mock layer)", () => {
+		it.effect("returns mock signature", () =>
+			Effect.gen(function* () {
+				const ed = yield* Ed25519Effect.Ed25519Service;
+				const result = yield* ed.sign(testMessage, testKeypair.secretKey);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(64);
+				expect(result.every((b) => b === 0)).toBe(true);
+			}).pipe(Effect.provide(Ed25519Effect.Ed25519Test)),
+		);
+
+		it.effect("returns true for verify", () =>
+			Effect.gen(function* () {
+				const ed = yield* Ed25519Effect.Ed25519Service;
+				const result = yield* ed.verify(
+					new Uint8Array(64),
+					testMessage,
+					testKeypair.publicKey,
+				);
+				expect(result).toBe(true);
+			}).pipe(Effect.provide(Ed25519Effect.Ed25519Test)),
+		);
+
+		it.effect("returns mock public key", () =>
+			Effect.gen(function* () {
+				const ed = yield* Ed25519Effect.Ed25519Service;
+				const result = yield* ed.getPublicKey(testKeypair.secretKey);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(32);
+				expect(result.every((b) => b === 0)).toBe(true);
+			}).pipe(Effect.provide(Ed25519Effect.Ed25519Test)),
+		);
+	});
+
+	describe("Known Vectors", () => {
+		it.effect("produces consistent signature for known seed", () =>
+			Effect.gen(function* () {
+				const knownSeed = new Uint8Array([
+					0x9d, 0x61, 0xb1, 0x9d, 0xef, 0xfd, 0x5a, 0x60, 0xba, 0x84, 0x4a,
+					0xf4, 0x92, 0xec, 0x2c, 0xc4, 0x44, 0x49, 0xc5, 0x69, 0x7b, 0x32,
+					0x69, 0x19, 0x70, 0x3b, 0xac, 0x03, 0x1c, 0xae, 0x7f, 0x60,
+				]);
+				const keypair = VoltaireEd25519.keypairFromSeed(knownSeed);
+				const emptyMessage = new Uint8Array(0);
+				const sig1 = yield* Ed25519Effect.sign(emptyMessage, keypair.secretKey);
+				const sig2 = yield* Ed25519Effect.sign(emptyMessage, keypair.secretKey);
+				expect(sig1).toEqual(sig2);
+				expect(sig1.length).toBe(64);
+			}),
+		);
+
+		it.effect("public key is 32 bytes for all valid seeds", () =>
+			Effect.gen(function* () {
+				for (let i = 0; i < 10; i++) {
+					const seed = new Uint8Array(32).fill(i);
+					const keypair = VoltaireEd25519.keypairFromSeed(seed);
+					const pubKey = yield* Ed25519Effect.getPublicKey(keypair.secretKey);
+					expect(pubKey.length).toBe(32);
+				}
+			}),
+		);
+	});
+});

package/src/crypto/Ed25519/Ed25519Live.ts

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Production layer for Ed25519Service using native implementation.
+ * @module Ed25519Live
+ * @since 0.0.1
+ */
+
+import * as Layer from "effect/Layer";
+import { Ed25519Service } from "./Ed25519Service.js";
+import { getPublicKey } from "./getPublicKey.js";
+import { sign } from "./sign.js";
+import { verify } from "./verify.js";
+
+/**
+ * Production layer for Ed25519Service using native Ed25519 implementation.
+ *
+ * @description
+ * Provides the live implementation backed by the high-performance native
+ * Ed25519 implementation from @tevm/voltaire. Use this layer in production
+ * applications for real cryptographic operations.
+ *
+ * @example
+ * ```typescript
+ * import { Ed25519Service, Ed25519Live } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * // Sign and verify a message
+ * const program = Effect.gen(function* () {
+ *   const ed = yield* Ed25519Service
+ *   const sig = yield* ed.sign(message, secretKey)
+ *   return yield* ed.verify(sig, message, publicKey)
+ * }).pipe(Effect.provide(Ed25519Live))
+ *
+ * const isValid = await Effect.runPromise(program)
+ * ```
+ *
+ * @see {@link Ed25519Service} - The service definition
+ * @see {@link Ed25519Test} - Test layer for unit testing
+ * @since 0.0.1
+ */
+export const Ed25519Live = Layer.succeed(Ed25519Service, {
+	sign,
+	verify,
+	getPublicKey,
+});

package/src/crypto/Ed25519/Ed25519Service.ts

@@ -0,0 +1,134 @@
+/**
+ * @fileoverview Ed25519 cryptographic signature service for Effect-based applications.
+ * Provides high-performance elliptic curve digital signatures.
+ * @module Ed25519Service
+ * @since 0.0.1
+ */
+
+import type {
+	Ed25519Error,
+	InvalidPublicKeyError,
+	InvalidSecretKeyError,
+	InvalidSignatureError,
+} from "@tevm/voltaire/Ed25519";
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+
+/**
+ * Shape interface for Ed25519 cryptographic service operations.
+ *
+ * @description
+ * Defines the contract for Ed25519 signature operations including signing,
+ * verification, and public key derivation. All operations return Effects
+ * that may fail with typed errors.
+ *
+ * @see {@link Ed25519Service} - The service using this shape
+ * @since 0.0.1
+ */
+export interface Ed25519ServiceShape {
+	/**
+	 * Signs a message using Ed25519 signature scheme.
+	 *
+	 * @description
+	 * Creates a 64-byte EdDSA signature using the Ed25519 curve.
+	 * The signature is deterministic - the same message and key always
+	 * produce the same signature.
+	 *
+	 * @param message - The message bytes to sign (any length)
+	 * @param secretKey - The 32-byte secret key
+	 * @returns Effect containing the 64-byte signature
+	 * @throws InvalidSecretKeyError - When the secret key is invalid
+	 * @throws Ed25519Error - When signing fails
+	 */
+	readonly sign: (
+		message: Uint8Array,
+		secretKey: Uint8Array,
+	) => Effect.Effect<Uint8Array, InvalidSecretKeyError | Ed25519Error>;
+
+	/**
+	 * Verifies an Ed25519 signature against a message and public key.
+	 *
+	 * @description
+	 * Validates that a signature was created by the holder of the private
+	 * key corresponding to the given public key for the specified message.
+	 *
+	 * @param signature - The 64-byte Ed25519 signature
+	 * @param message - The original message bytes
+	 * @param publicKey - The 32-byte public key
+	 * @returns Effect containing true if signature is valid, false otherwise
+	 * @throws InvalidSignatureError - When the signature format is invalid
+	 * @throws InvalidPublicKeyError - When the public key is invalid
+	 */
+	readonly verify: (
+		signature: Uint8Array,
+		message: Uint8Array,
+		publicKey: Uint8Array,
+	) => Effect.Effect<boolean, InvalidSignatureError | InvalidPublicKeyError>;
+
+	/**
+	 * Derives a public key from a secret key.
+	 *
+	 * @description
+	 * Computes the Ed25519 public key corresponding to a given secret key.
+	 * The derivation is one-way - the secret key cannot be recovered from
+	 * the public key.
+	 *
+	 * @param secretKey - The 32-byte secret key
+	 * @returns Effect containing the 32-byte public key
+	 * @throws InvalidSecretKeyError - When the secret key is invalid
+	 */
+	readonly getPublicKey: (
+		secretKey: Uint8Array,
+	) => Effect.Effect<Uint8Array, InvalidSecretKeyError>;
+}
+
+/**
+ * Ed25519 cryptographic service for Effect-based applications.
+ *
+ * @description
+ * Ed25519 is a high-speed, high-security elliptic curve digital signature
+ * algorithm. It provides fast signing and verification while being resistant
+ * to timing attacks and other side-channel attacks.
+ *
+ * Key features:
+ * - 32-byte keys and 64-byte signatures
+ * - Deterministic signatures (no random nonce)
+ * - Fast verification (~3x faster than ECDSA)
+ * - Used in Solana, Cardano, Polkadot, SSH, and many other protocols
+ *
+ * @example
+ * ```typescript
+ * import { Ed25519Service, Ed25519Live } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * // Complete sign and verify workflow
+ * const program = Effect.gen(function* () {
+ *   const ed = yield* Ed25519Service
+ *
+ *   // Derive public key from secret key
+ *   const publicKey = yield* ed.getPublicKey(secretKey)
+ *
+ *   // Sign a message
+ *   const message = new TextEncoder().encode('Hello, Ed25519!')
+ *   const signature = yield* ed.sign(message, secretKey)
+ *
+ *   // Verify the signature
+ *   const isValid = yield* ed.verify(signature, message, publicKey)
+ *   return { publicKey, signature, isValid }
+ * }).pipe(Effect.provide(Ed25519Live))
+ *
+ * const result = await Effect.runPromise(program)
+ * console.log(result.isValid) // true
+ * ```
+ *
+ * @see {@link Ed25519Live} - Production layer using native Ed25519
+ * @see {@link Ed25519Test} - Test layer with deterministic output
+ * @see {@link sign} - Standalone sign function
+ * @see {@link verify} - Standalone verify function
+ * @see {@link getPublicKey} - Standalone key derivation function
+ * @since 0.0.1
+ */
+export class Ed25519Service extends Context.Tag("Ed25519Service")<
+	Ed25519Service,
+	Ed25519ServiceShape
+>() {}

package/src/crypto/Ed25519/Ed25519Test.ts

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Test layer for Ed25519Service with deterministic mock values.
+ * @module Ed25519Test
+ * @since 0.0.1
+ */
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Ed25519Service } from "./Ed25519Service.js";
+
+/**
+ * Test layer for Ed25519Service returning deterministic mock values.
+ *
+ * @description
+ * Provides a mock implementation for unit testing that returns predictable
+ * values without performing actual cryptographic operations. Use this layer
+ * to test code that depends on Ed25519Service without cryptographic overhead.
+ *
+ * Mock behaviors:
+ * - `sign`: Returns a zero-filled 64-byte signature
+ * - `verify`: Always returns true
+ * - `getPublicKey`: Returns a zero-filled 32-byte public key
+ *
+ * @example
+ * ```typescript
+ * import { Ed25519Service, Ed25519Test } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const testProgram = Effect.gen(function* () {
+ *   const ed = yield* Ed25519Service
+ *
+ *   // Always returns true in test mode
+ *   const isValid = yield* ed.verify(signature, message, publicKey)
+ *
+ *   // Returns zero-filled 64-byte array
+ *   const sig = yield* ed.sign(message, secretKey)
+ *
+ *   return { isValid, sig }
+ * }).pipe(Effect.provide(Ed25519Test))
+ *
+ * const result = await Effect.runPromise(testProgram)
+ * console.log(result.isValid) // true
+ * console.log(result.sig.length) // 64
+ * ```
+ *
+ * @see {@link Ed25519Service} - The service definition
+ * @see {@link Ed25519Live} - Production implementation
+ * @since 0.0.1
+ */
+export const Ed25519Test = Layer.succeed(Ed25519Service, {
+	sign: (_message: Uint8Array, _secretKey: Uint8Array) =>
+		Effect.succeed(new Uint8Array(64)),
+	verify: (
+		_signature: Uint8Array,
+		_message: Uint8Array,
+		_publicKey: Uint8Array,
+	) => Effect.succeed(true),
+	getPublicKey: (_secretKey: Uint8Array) => Effect.succeed(new Uint8Array(32)),
+});