voltaire-effect 0.2.23

package/src/crypto/HDWallet/HDWalletService.ts

@@ -0,0 +1,186 @@
+/**
+ * @fileoverview HDWalletService Effect service definition for hierarchical deterministic wallets.
+ * @module HDWallet/HDWalletService
+ * @since 0.0.1
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { MnemonicStrength } from "../Bip39/types.js";
+import type { HDWalletError } from "./errors.js";
+
+/**
+ * Represents a hierarchical deterministic wallet node.
+ *
+ * @description
+ * An HDNode contains the key material (private key, public key, chain code)
+ * at a specific point in the derivation tree. Each node can derive child nodes.
+ *
+ * @since 0.0.1
+ * @see {@link https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki | BIP-32}
+ */
+export type HDNode = object;
+
+/**
+ * Represents an HD derivation path as an array of indices.
+ *
+ * @description
+ * Each number represents a child index. Indices >= 0x80000000 (2^31) are hardened.
+ * For example, [44, 60, 0, 0, 0] with hardening on first three is BIP-44 Ethereum.
+ *
+ * @example
+ * ```typescript
+ * const path: HDPath = [44 + 0x80000000, 60 + 0x80000000, 0 + 0x80000000, 0, 0]
+ * ```
+ *
+ * @since 0.0.1
+ */
+export type HDPath = readonly number[];
+
+/**
+ * Shape interface for HD wallet service operations.
+ *
+ * @description
+ * Defines the contract for HD wallet implementations. All methods return Effect
+ * types for composable, type-safe async/error handling.
+ *
+ * @since 0.0.1
+ */
+export interface HDWalletServiceShape {
+	/**
+	 * Derives a child node from a parent node using the given path.
+	 * @param node - The parent HD node
+	 * @param path - Derivation path (e.g., "m/44'/60'/0'/0/0" or array of indices)
+	 * @returns Effect containing the derived child node
+	 *
+	 * @throws InvalidPathError - Path format invalid
+	 * @throws HardenedDerivationError - Hardened derivation attempted from public key
+	 * @throws InvalidKeyError - Child key derivation failed
+	 */
+	readonly derive: (
+		node: HDNode,
+		path: string | HDPath,
+	) => Effect.Effect<HDNode, HDWalletError>;
+
+	/**
+	 * Generates a new random BIP-39 mnemonic sentence.
+	 *
+	 * @param strength - Entropy bits: 128=12 words, 160=15, 192=18, 224=21, 256=24 (default: 128)
+	 * @returns Effect containing the space-separated mnemonic sentence
+	 *
+	 * @see Use `mnemonicToWords()` from `voltaire-effect/crypto/Bip39` if you need an array
+	 * @see {@link https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki | BIP-39 Specification}
+	 */
+	readonly generateMnemonic: (
+		strength?: MnemonicStrength,
+	) => Effect.Effect<string>;
+
+	/**
+	 * Creates an HD node from a seed.
+	 * @param seed - The 16-64 byte seed from mnemonic
+	 * @returns Effect containing the master HD node
+	 *
+	 * @throws InvalidSeedError - Seed length invalid
+	 * @throws InvalidKeyError - Master key derivation failed
+	 */
+	readonly fromSeed: (seed: Uint8Array) => Effect.Effect<HDNode, HDWalletError>;
+
+	/**
+	 * Creates a master HD node from a BIP-39 mnemonic sentence.
+	 * @param mnemonic - Space-separated mnemonic sentence
+	 * @param passphrase - Optional passphrase (default: "")
+	 * @returns Effect containing the master HD node
+	 *
+	 * @throws InvalidSeedError - Derived seed invalid
+	 * @throws InvalidKeyError - Master key derivation failed
+	 */
+	readonly fromMnemonic: (
+		mnemonic: string,
+		passphrase?: string,
+	) => Effect.Effect<HDNode, HDWalletError>;
+
+	/**
+	 * Converts a mnemonic phrase to a seed.
+	 * @param mnemonic - Array of mnemonic words (use mnemonicToWords() for sentences)
+	 * @returns Effect containing the 64-byte seed
+	 *
+	 * @throws InvalidSeedError - Mnemonic conversion failed
+	 */
+	readonly mnemonicToSeed: (
+		mnemonic: string[],
+	) => Effect.Effect<Uint8Array, HDWalletError>;
+
+	/**
+	 * Extracts the private key from an HD node.
+	 * @param node - The HD node
+	 * @returns Effect containing the 32-byte private key or null
+	 */
+	readonly getPrivateKey: (node: HDNode) => Effect.Effect<Uint8Array | null>;
+
+	/**
+	 * Extracts the public key from an HD node.
+	 * @param node - The HD node
+	 * @returns Effect containing the 33-byte compressed public key or null
+	 */
+	readonly getPublicKey: (node: HDNode) => Effect.Effect<Uint8Array | null>;
+}
+
+/**
+ * Hierarchical Deterministic wallet service for Effect-based applications.
+ * Implements BIP-32/BIP-39/BIP-44 for deterministic key derivation.
+ *
+ * @example
+ * ```typescript
+ * import { HDWalletService } from 'voltaire-effect/crypto'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import { mnemonicToWords } from 'voltaire-effect/crypto/Bip39'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const hd = yield* HDWalletService
+ *   const mnemonic = yield* hd.generateMnemonic(128)
+ *   const seed = yield* hd.mnemonicToSeed(mnemonicToWords(mnemonic))
+ *   const master = yield* hd.fromSeed(seed)
+ *   return yield* hd.derive(master, "m/44'/60'/0'/0/0")
+ * }).pipe(Effect.provide(HDWalletLive))
+ * ```
+ * @since 0.0.1
+ */
+export class HDWalletService extends Context.Tag("HDWalletService")<
+	HDWalletService,
+	HDWalletServiceShape
+>() {}
+
+/**
+ * Test layer for HDWalletService returning deterministic mock values.
+ *
+ * @description
+ * Provides mock implementations for unit testing. Returns the standard
+ * BIP-39 test vector mnemonic and empty byte arrays for keys.
+ * Use when testing application logic without cryptographic overhead.
+ *
+ * @example
+ * ```typescript
+ * import { HDWalletService, HDWalletTest, generateMnemonic } from 'voltaire-effect/crypto/HDWallet'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const testProgram = generateMnemonic(128).pipe(
+ *   Effect.provide(HDWalletTest)
+ * )
+ * // Returns: 'abandon abandon ... about'
+ * ```
+ *
+ * @since 0.0.1
+ */
+const TEST_MNEMONIC =
+	"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+
+export const HDWalletTest = Layer.succeed(HDWalletService, {
+	derive: (_node, _path) => Effect.succeed({} as HDNode),
+	generateMnemonic: (_strength) => Effect.succeed(TEST_MNEMONIC),
+	fromSeed: (_seed) => Effect.succeed({} as HDNode),
+	fromMnemonic: (_mnemonic, _passphrase) => Effect.succeed({} as HDNode),
+	mnemonicToSeed: (_mnemonic) => Effect.succeed(new Uint8Array(64)),
+	getPrivateKey: (_node) => Effect.succeed(new Uint8Array(32)),
+	getPublicKey: (_node) => Effect.succeed(new Uint8Array(33)),
+});

package/src/crypto/HDWallet/derive.ts

@@ -0,0 +1,348 @@
+/**
+ * @fileoverview HD wallet derivation operations for Effect.
+ * @module HDWallet/derive
+ * @since 0.0.1
+ */
+import * as Effect from "effect/Effect";
+import type { MnemonicStrength } from "../Bip39/types.js";
+import { type HDWalletError, InvalidKeyError } from "./errors.js";
+import {
+	type HDNode,
+	type HDPath,
+	HDWalletService,
+} from "./HDWalletService.js";
+
+/**
+ * Derives a child HD node from a parent node using the given path.
+ *
+ * @description
+ * Performs BIP-32 child key derivation using either a string path (e.g., "m/44'/60'/0'/0/0")
+ * or an array of indices. Hardened derivation is indicated by apostrophe in string paths
+ * or by adding 0x80000000 to numeric indices.
+ *
+ * @param node - The parent HD node to derive from
+ * @param path - Derivation path (e.g., "m/44'/60'/0'/0/0" or array of indices)
+ * @returns Effect containing the derived child node, requiring HDWalletService
+ *
+ * @example
+ * ```typescript
+ * import { derive, fromSeed } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const master = yield* fromSeed(seed)
+ *   return yield* derive(master, "m/44'/60'/0'/0/0")
+ * }).pipe(Effect.provide(HDWalletLive))
+ * ```
+ *
+ * @throws InvalidPathError if derivation path is invalid
+ * @throws HardenedDerivationError if hardened derivation is attempted from a public node
+ * @throws InvalidKeyError if child key derivation fails
+ * @see {@link fromSeed} to create the master node
+ * @since 0.0.1
+ */
+export const derive = (
+	node: HDNode,
+	path: string | HDPath,
+): Effect.Effect<HDNode, HDWalletError, HDWalletService> =>
+	Effect.gen(function* () {
+		const hdwallet = yield* HDWalletService;
+		return yield* hdwallet.derive(node, path);
+	});
+
+/**
+ * Generates a new random BIP-39 mnemonic phrase.
+ *
+ * @description
+ * Creates a cryptographically random mnemonic phrase using secure random number
+ * generation. The mnemonic encodes entropy plus a checksum, enabling wallet recovery.
+ *
+ * @param strength - Entropy bits: 128 = 12 words, 160 = 15, 192 = 18, 224 = 21, 256 = 24 (default: 128)
+ * @returns Effect containing the space-separated mnemonic sentence, requiring HDWalletService
+ *
+ * @example
+ * ```typescript
+ * import { generateMnemonic } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = generateMnemonic(256).pipe(Effect.provide(HDWalletLive))
+ * // Returns 24 words from BIP-39 wordlist, space-separated
+ * ```
+ *
+ * @throws Never fails
+ * @see {@link mnemonicToSeed} to convert mnemonic to seed
+ * @since 0.0.1
+ */
+export const generateMnemonic = (
+	strength: MnemonicStrength = 128,
+): Effect.Effect<string, never, HDWalletService> =>
+	Effect.gen(function* () {
+		const hdwallet = yield* HDWalletService;
+		return yield* hdwallet.generateMnemonic(strength);
+	});
+
+/**
+ * Creates a master HD node from a seed.
+ *
+ * @description
+ * Creates the root node of the HD tree from a 16-64 byte seed. The seed is typically
+ * derived from a BIP-39 mnemonic using PBKDF2. The master node is at path "m".
+ *
+ * @param seed - The 16-64 byte seed (typically from mnemonicToSeed)
+ * @returns Effect containing the master HD node, requiring HDWalletService
+ *
+ * @example
+ * ```typescript
+ * import { fromSeed, mnemonicToSeed } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import { mnemonicToWords } from 'voltaire-effect/crypto/Bip39'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const seed = yield* mnemonicToSeed(mnemonicToWords(mnemonic))
+ *   return yield* fromSeed(seed)
+ * }).pipe(Effect.provide(HDWalletLive))
+ * ```
+ *
+ * @throws InvalidSeedError if seed length is invalid
+ * @throws InvalidKeyError if master key derivation fails
+ * @see {@link mnemonicToSeed} to generate seed from mnemonic
+ * @see {@link derive} to derive child nodes
+ * @since 0.0.1
+ */
+export const fromSeed = (
+	seed: Uint8Array,
+): Effect.Effect<HDNode, HDWalletError, HDWalletService> =>
+	Effect.gen(function* () {
+		const hdwallet = yield* HDWalletService;
+		return yield* hdwallet.fromSeed(seed);
+	});
+
+/**
+ * Creates a master HD node from a mnemonic sentence.
+ *
+ * @description
+ * Converts the mnemonic to a seed and derives the master HD node.
+ *
+ * @param mnemonic - Space-separated mnemonic sentence
+ * @param passphrase - Optional passphrase (default: "")
+ * @returns Effect containing the master HD node, requiring HDWalletService
+ *
+ * @example
+ * ```typescript
+ * import { fromMnemonic } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = fromMnemonic("abandon abandon ...", "passphrase").pipe(
+ *   Effect.provide(HDWalletLive)
+ * )
+ * ```
+ *
+ * @throws InvalidSeedError if derived seed is invalid
+ * @throws InvalidKeyError if master key derivation fails
+ * @since 0.0.1
+ */
+export const fromMnemonic = (
+	mnemonic: string,
+	passphrase?: string,
+): Effect.Effect<HDNode, HDWalletError, HDWalletService> =>
+	Effect.gen(function* () {
+		const hdwallet = yield* HDWalletService;
+		return yield* hdwallet.fromMnemonic(mnemonic, passphrase);
+	});
+
+/**
+ * Converts a mnemonic phrase to a 64-byte seed.
+ *
+ * @description
+ * Uses PBKDF2-SHA512 with 2048 iterations to derive a 64-byte seed from the mnemonic.
+ * The seed is used to create the master HD node. An optional passphrase can be used
+ * for additional security (not implemented in this wrapper).
+ *
+ * @param mnemonic - Array of BIP-39 mnemonic words
+ * @returns Effect containing the 64-byte seed, requiring HDWalletService
+ *
+ * @example
+ * ```typescript
+ * import { mnemonicToSeed } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const words = ['abandon', 'abandon', 'abandon', 'abandon', 'abandon',
+ *                'abandon', 'abandon', 'abandon', 'abandon', 'abandon', 'abandon', 'about']
+ * const program = mnemonicToSeed(words).pipe(Effect.provide(HDWalletLive))
+ * ```
+ *
+ * @throws InvalidSeedError if mnemonic conversion fails
+ * @see {@link generateMnemonic} to create a mnemonic
+ * @see {@link withSeed} to ensure seed cleanup after use
+ * @see {@link fromSeed} to create master node from seed
+ * @since 0.0.1
+ */
+export const mnemonicToSeed = (
+	mnemonic: string[],
+): Effect.Effect<Uint8Array, HDWalletError, HDWalletService> =>
+	Effect.gen(function* () {
+		const hdwallet = yield* HDWalletService;
+		return yield* hdwallet.mnemonicToSeed(mnemonic);
+	});
+
+/**
+ * Derives a mnemonic seed, uses it, and zeroes it after use.
+ *
+ * @description
+ * Wraps {@link mnemonicToSeed} with `Effect.acquireRelease` to ensure the
+ * seed is wiped from memory after the provided effect completes.
+ *
+ * @param mnemonic - Array of BIP-39 mnemonic words
+ * @param use - Effect that consumes the derived seed
+ * @returns Effect containing the result of `use`
+ *
+ * @example
+ * ```typescript
+ * import { withSeed, fromSeed } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = withSeed(words, (seed) =>
+ *   fromSeed(seed)
+ * ).pipe(Effect.provide(HDWalletLive))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const withSeed = <R, E, A>(
+	mnemonic: string[],
+	use: (seed: Uint8Array) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | HDWalletError, R | HDWalletService> =>
+	Effect.acquireRelease(mnemonicToSeed(mnemonic), (seed) =>
+		Effect.sync(() => seed.fill(0)),
+	).pipe(Effect.flatMap(use), Effect.scoped);
+
+/**
+ * Extracts the private key from an HD node.
+ *
+ * @description
+ * Retrieves the 32-byte secp256k1 private key from the HD node. This key can be
+ * used for signing transactions and deriving Ethereum addresses. Returns null
+ * for neutered (public-key-only) nodes.
+ *
+ * @param node - The HD node containing the private key
+ * @returns Effect containing the 32-byte private key or null, requiring HDWalletService
+ *
+ * @example
+ * ```typescript
+ * import { getPrivateKey, derive, fromSeed } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const master = yield* fromSeed(seed)
+ *   const account = yield* derive(master, "m/44'/60'/0'/0/0")
+ *   return yield* getPrivateKey(account)
+ * }).pipe(Effect.provide(HDWalletLive))
+ * ```
+ *
+ * @throws Never fails
+ * @see {@link getPublicKey} to extract the public key
+ * @since 0.0.1
+ */
+export const getPrivateKey = (
+	node: HDNode,
+): Effect.Effect<Uint8Array | null, never, HDWalletService> =>
+	Effect.gen(function* () {
+		const hdwallet = yield* HDWalletService;
+		return yield* hdwallet.getPrivateKey(node);
+	});
+
+/**
+ * Extracts a private key, uses it, and zeroes it after use.
+ *
+ * @description
+ * Wraps {@link getPrivateKey} with `Effect.acquireRelease` to ensure key
+ * material is wiped from memory after the provided effect completes.
+ *
+ * @param node - The HD node containing the private key
+ * @param use - Effect that consumes the private key
+ * @returns Effect containing the result of `use`
+ *
+ * @example
+ * ```typescript
+ * import { withPrivateKey, derive, fromSeed } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const master = yield* fromSeed(seed)
+ *   const account = yield* derive(master, "m/44'/60'/0'/0/0")
+ *   return yield* withPrivateKey(account, (key) => Effect.sync(() => key))
+ * }).pipe(Effect.provide(HDWalletLive))
+ * ```
+ *
+ * @throws InvalidKeyError if the node does not contain a private key
+ * @since 0.0.1
+ */
+export const withPrivateKey = <R, E, A>(
+	node: HDNode,
+	use: (key: Uint8Array) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | HDWalletError, R | HDWalletService> =>
+	Effect.acquireRelease<Uint8Array | null, never, HDWalletService, void, never>(
+		getPrivateKey(node),
+		(key) =>
+			Effect.sync(() => {
+				if (key) {
+					key.fill(0);
+				}
+			}),
+	).pipe(
+		Effect.flatMap(
+			(key): Effect.Effect<A, E | HDWalletError, R> =>
+				key
+					? use(key)
+					: Effect.fail(
+							new InvalidKeyError({
+								message: "HD node does not contain a private key.",
+							}),
+						),
+		),
+		Effect.scoped,
+	);
+
+/**
+ * Extracts the public key from an HD node.
+ *
+ * @description
+ * Retrieves the 33-byte compressed secp256k1 public key from the HD node.
+ * The public key can be used to derive Ethereum addresses (keccak256 of
+ * uncompressed key, take last 20 bytes).
+ *
+ * @param node - The HD node containing the public key
+ * @returns Effect containing the 33-byte compressed public key or null, requiring HDWalletService
+ *
+ * @example
+ * ```typescript
+ * import { getPublicKey, derive, fromSeed } from 'voltaire-effect/crypto/HDWallet'
+ * import { HDWalletLive } from 'voltaire-effect/native'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const master = yield* fromSeed(seed)
+ *   const account = yield* derive(master, "m/44'/60'/0'/0/0")
+ *   return yield* getPublicKey(account) // 33 bytes, compressed format
+ * }).pipe(Effect.provide(HDWalletLive))
+ * ```
+ *
+ * @throws Never fails
+ * @see {@link getPrivateKey} to extract the private key
+ * @since 0.0.1
+ */
+export const getPublicKey = (
+	node: HDNode,
+): Effect.Effect<Uint8Array | null, never, HDWalletService> =>
+	Effect.gen(function* () {
+		const hdwallet = yield* HDWalletService;
+		return yield* hdwallet.getPublicKey(node);
+	});

package/src/crypto/HDWallet/errors.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Error types and mapping helpers for HDWallet Effect wrappers.
+ *
+ * @module HDWallet/errors
+ * @since 0.0.1
+ */
+
+import * as Data from "effect/Data";
+
+/**
+ * Invalid BIP-32/44 derivation path format.
+ *
+ * @since 0.0.1
+ */
+export class InvalidPathError extends Data.TaggedError("InvalidPathError")<{
+	readonly path: string;
+	readonly message: string;
+	readonly cause?: unknown;
+}> {}
+
+/**
+ * Seed bytes invalid for BIP-32 master key derivation.
+ * Seed must be 16-64 bytes (128-512 bits) per BIP-32.
+ *
+ * @since 0.0.1
+ */
+export class InvalidSeedError extends Data.TaggedError("InvalidSeedError")<{
+	readonly seedLength: number;
+	readonly message: string;
+	readonly cause?: unknown;
+}> {}
+
+/**
+ * Cannot perform hardened derivation from extended public key.
+ * Hardened paths (with ') require private key.
+ *
+ * @since 0.0.1
+ */
+export class HardenedDerivationError extends Data.TaggedError(
+	"HardenedDerivationError",
+)<{
+	readonly path: string;
+	readonly index: number;
+	readonly message: string;
+}> {}
+
+/**
+ * Child key derivation produced invalid key material.
+ * This is rare but possible per BIP-32.
+ *
+ * @since 0.0.1
+ */
+export class InvalidKeyError extends Data.TaggedError("InvalidKeyError")<{
+	readonly message: string;
+	readonly cause?: unknown;
+}> {}
+
+/**
+ * Union of all HDWallet error types.
+ *
+ * @since 0.0.1
+ */
+export type HDWalletError =
+	| InvalidPathError
+	| InvalidSeedError
+	| HardenedDerivationError
+	| InvalidKeyError;
+
+const getMessage = (error: unknown): string =>
+	error instanceof Error ? error.message : String(error);
+
+/**
+ * Maps unknown errors to appropriate HDWallet error type.
+ *
+ * @since 0.0.1
+ */
+export const mapToHDWalletError = (
+	error: unknown,
+	context: { path?: string; seedLength?: number },
+): HDWalletError => {
+	if (error instanceof InvalidPathError) return error;
+	if (error instanceof InvalidSeedError) return error;
+	if (error instanceof HardenedDerivationError) return error;
+	if (error instanceof InvalidKeyError) return error;
+
+	const message = getMessage(error);
+	const normalized = message.toLowerCase();
+
+	if (normalized.includes("hardened") || normalized.includes("public")) {
+		return new HardenedDerivationError({
+			path: context.path ?? "unknown",
+			index: -1,
+			message: `Cannot derive hardened path from public key: ${message}`,
+		});
+	}
+
+	if (normalized.includes("path") || normalized.includes("derivation")) {
+		return new InvalidPathError({
+			path: context.path ?? "unknown",
+			message: `Invalid derivation path: ${message}`,
+			cause: error,
+		});
+	}
+
+	if (
+		normalized.includes("seed") ||
+		normalized.includes("mnemonic") ||
+		normalized.includes("length")
+	) {
+		return new InvalidSeedError({
+			seedLength: context.seedLength ?? -1,
+			message: `Invalid seed: ${message}`,
+			cause: error,
+		});
+	}
+
+	return new InvalidKeyError({
+		message: `Key derivation failed: ${message}`,
+		cause: error,
+	});
+};