voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Hash/fromBytes.ts

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Create Hash from raw bytes.
+ *
+ * @module Hash/fromBytes
+ * @since 0.0.1
+ */
+
+import type { HashType } from "@tevm/voltaire/Hash";
+import * as Hash from "@tevm/voltaire/Hash";
+import * as Effect from "effect/Effect";
+import { ValidationError } from "@tevm/voltaire/errors";
+
+/**
+ * Create Hash from raw bytes.
+ *
+ * @description Creates a hash from a 32-byte Uint8Array.
+ * Can fail if input is wrong length.
+ *
+ * @param {Uint8Array} bytes - Raw bytes (must be 32 bytes)
+ * @returns {Effect.Effect<HashType, ValidationError>} Effect containing the hash
+ *
+ * @example
+ * ```typescript
+ * import * as Hash from 'voltaire-effect/primitives/Hash'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const hash = Effect.runSync(Hash.fromBytes(new Uint8Array(32)))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromBytes = (
+	bytes: Uint8Array,
+): Effect.Effect<HashType, ValidationError> =>
+	Effect.try({
+		try: () => Hash.fromBytes(bytes),
+		catch: (error) =>
+			new ValidationError(
+				error instanceof Error ? error.message : "Invalid bytes input",
+				{
+					value: bytes,
+					expected: "32-byte Uint8Array",
+					cause: error instanceof Error ? error : undefined,
+				},
+			),
+	});

package/src/primitives/Hash/fromHex.ts

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Create Hash from hex string.
+ *
+ * @module Hash/fromHex
+ * @since 0.0.1
+ */
+
+import type { HashType } from "@tevm/voltaire/Hash";
+import * as Hash from "@tevm/voltaire/Hash";
+import * as Effect from "effect/Effect";
+import { ValidationError } from "@tevm/voltaire/errors";
+
+/**
+ * Create Hash from hex string.
+ *
+ * @description Parses a 66-character hex string (with 0x prefix) into a 32-byte hash.
+ * Can fail if input is invalid format or wrong length.
+ *
+ * @param {string} hex - Hex string with optional 0x prefix
+ * @returns {Effect.Effect<HashType, ValidationError>} Effect containing the hash
+ *
+ * @example
+ * ```typescript
+ * import * as Hash from 'voltaire-effect/primitives/Hash'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const hash = Effect.runSync(Hash.fromHex('0x' + 'ab'.repeat(32)))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromHex = (hex: string): Effect.Effect<HashType, ValidationError> =>
+	Effect.try({
+		try: () => Hash.fromHex(hex),
+		catch: (error) =>
+			new ValidationError(
+				error instanceof Error ? error.message : "Invalid hex string",
+				{
+					value: hex,
+					expected: "66-character hex string (0x + 64 hex chars)",
+					cause: error instanceof Error ? error : undefined,
+				},
+			),
+	});

package/src/primitives/Hash/index.ts

@@ -46,20 +46,57 @@
  */
 
 export type { HashType } from "@tevm/voltaire/Hash";
-// Pure functions
-export { assert } from "./assert.js";
+
+// Re-export constants
+export { SIZE, ZERO } from "@tevm/voltaire/Hash";
+
+// Re-export DI factory functions for advanced use cases
+// Access via: Hash.Keccak256, Hash.MerkleRoot, etc.
+// Note: These are runtime exports that TypeScript types don't fully capture
+import { Hash as HashNamespace } from "@tevm/voltaire/functional";
+const _HashNs = HashNamespace as Record<string, unknown>;
+export const Concat = _HashNs["Concat"] as typeof HashNamespace.concat;
+export const Keccak256 = _HashNs["Keccak256"] as (
+	keccak: { keccak256: (data: Uint8Array) => Uint8Array },
+) => (data: Uint8Array | string) => import("@tevm/voltaire/Hash").HashType;
+export const Keccak256Hex = _HashNs["Keccak256Hex"] as (
+	keccak: { keccak256: (data: Uint8Array) => Uint8Array },
+) => (hex: string) => import("@tevm/voltaire/Hash").HashType;
+export const Keccak256String = _HashNs["Keccak256String"] as (
+	keccak: { keccak256: (data: Uint8Array) => Uint8Array },
+) => (str: string) => import("@tevm/voltaire/Hash").HashType;
+export const MerkleRoot = _HashNs["MerkleRoot"] as (
+	keccak: { keccak256: (data: Uint8Array) => Uint8Array },
+) => (leaves: readonly Uint8Array[]) => import("@tevm/voltaire/Hash").HashType;
+
 // Schemas
 export { Bytes } from "./Bytes.js";
+export { Hex } from "./Hex.js";
+
+// Constructors (fallible)
+export { from } from "./from.js";
+export { fromBytes } from "./fromBytes.js";
+export { fromHex } from "./fromHex.js";
+
+// Validation
+export { assert } from "./assert.js";
+export { isHash } from "./isHash.js";
+export { isValidHex } from "./isValidHex.js";
+export { isZero } from "./isZero.js";
+
+// Operations
 export { clone } from "./clone.js";
 export { concat } from "./concat.js";
 export { equals } from "./equals.js";
+export { slice } from "./slice.js";
+
+// Conversions
 export { format } from "./format.js";
-export { Hex } from "./Hex.js";
-export { isValidHex } from "./isValidHex.js";
-export { isZero } from "./isZero.js";
+export { toBytes } from "./toBytes.js";
+export { toHex } from "./toHex.js";
+export { toString } from "./toString.js";
+
+// Crypto
 export { keccak256, keccak256Hex, keccak256String } from "./keccak256.js";
 export { merkleRoot } from "./merkleRoot.js";
 export { random } from "./random.js";
-export { slice } from "./slice.js";
-export { toBytes } from "./toBytes.js";
-export { toString } from "./toString.js";

package/src/primitives/Hash/isHash.ts

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Check if value is a valid Hash.
+ *
+ * @module Hash/isHash
+ * @since 0.0.1
+ */
+
+import type { HashType } from "@tevm/voltaire/Hash";
+import * as Hash from "@tevm/voltaire/Hash";
+
+/**
+ * Check if value is a valid Hash.
+ *
+ * @description Type guard that checks if a value is a valid 32-byte hash.
+ * This is a pure synchronous function that never fails.
+ *
+ * @param {unknown} value - Value to check
+ * @returns {boolean} True if value is a valid HashType
+ *
+ * @example
+ * ```typescript
+ * import * as Hash from 'voltaire-effect/primitives/Hash'
+ *
+ * if (Hash.isHash(value)) {
+ *   // value is HashType
+ * }
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const isHash = (value: unknown): value is HashType => Hash.isHash(value);

package/src/primitives/Hash/toHex.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Convert Hash to hex string.
+ *
+ * @module Hash/toHex
+ * @since 0.0.1
+ */
+
+import type { HashType } from "@tevm/voltaire/Hash";
+import * as Hash from "@tevm/voltaire/Hash";
+
+/**
+ * Convert Hash to hex string.
+ *
+ * @description Converts a 32-byte hash to a 66-character hex string with 0x prefix.
+ * This is a pure synchronous function that never fails.
+ *
+ * @param {HashType} hash - Hash to convert
+ * @returns {string} Hex string with 0x prefix
+ *
+ * @example
+ * ```typescript
+ * import * as Hash from 'voltaire-effect/primitives/Hash'
+ *
+ * const hex = Hash.toHex(hash) // "0x..."
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const toHex = (hash: HashType): string => Hash.toHex(hash);