voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/EventLog/status.ts

@@ -0,0 +1,17 @@
+/**
+ * @module status
+ * @description Pure EventLog status functions
+ * @since 0.1.0
+ */
+import * as EventLog from "@tevm/voltaire/EventLog";
+import type { EventLogType } from "@tevm/voltaire/EventLog";
+
+/**
+ * Check if log was removed due to reorg
+ */
+export const isRemoved = (log: EventLogType): boolean => EventLog.isRemoved(log);
+
+/**
+ * Check if log was removed (alias)
+ */
+export const wasRemoved = (log: EventLogType): boolean => EventLog.wasRemoved(log);

package/src/primitives/EventLog/toRpc.ts

@@ -0,0 +1,49 @@
+/**
+ * @module toRpc
+ * @description Convert EventLog to RPC format
+ * @since 0.1.0
+ */
+import type { EventLogType } from "@tevm/voltaire/EventLog";
+import * as Hex from "@tevm/voltaire/Hex";
+
+interface RpcLog {
+  address: string;
+  topics: string[];
+  data: string;
+  blockNumber?: string;
+  transactionHash?: string;
+  transactionIndex?: string;
+  blockHash?: string;
+  logIndex?: string;
+  removed?: boolean;
+}
+
+/**
+ * Convert EventLog to RPC response format
+ */
+export const toRpc = (log: EventLogType): RpcLog => {
+  const result: RpcLog = {
+    address: Hex.fromBytes(log.address),
+    topics: log.topics.map((t) => Hex.fromBytes(t)),
+    data: Hex.fromBytes(log.data),
+  };
+  if (log.blockNumber !== undefined) {
+    result.blockNumber = `0x${log.blockNumber.toString(16)}`;
+  }
+  if (log.transactionHash !== undefined) {
+    result.transactionHash = Hex.fromBytes(log.transactionHash);
+  }
+  if (log.transactionIndex !== undefined) {
+    result.transactionIndex = `0x${log.transactionIndex.toString(16)}`;
+  }
+  if (log.blockHash !== undefined) {
+    result.blockHash = Hex.fromBytes(log.blockHash);
+  }
+  if (log.logIndex !== undefined) {
+    result.logIndex = `0x${log.logIndex.toString(16)}`;
+  }
+  if (log.removed !== undefined) {
+    result.removed = log.removed;
+  }
+  return result;
+};

package/src/primitives/Hardfork/HardforkSchema.ts

@@ -22,13 +22,13 @@ const HardforkTypeSchema = S.declare<HardforkType>(
  * @example
  * ```ts
  * import * as S from 'effect/Schema'
- * import { Schema } from 'voltaire-effect/primitives/Hardfork'
+ * import { HardforkSchema } from 'voltaire-effect/primitives/Hardfork'
  *
- * const fork = S.decodeSync(Schema)('london')
+ * const fork = S.decodeSync(HardforkSchema)('london')
  * ```
  * @since 0.0.1
  */
-export const Schema: S.Schema<HardforkType, string> = S.transformOrFail(
+export const HardforkSchema: S.Schema<HardforkType, string> = S.transformOrFail(
 	S.String,
 	HardforkTypeSchema,
 	{

package/src/primitives/Hardfork/allIds.ts

@@ -0,0 +1,13 @@
+/**
+ * @module allIds
+ * @description Get all hardfork IDs (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+
+/**
+ * Get all hardfork IDs in order
+ *
+ * @returns Array of all hardfork types in chronological order
+ */
+export const allIds = Hardfork.allIds;

package/src/primitives/Hardfork/allNames.ts

@@ -0,0 +1,13 @@
+/**
+ * @module allNames
+ * @description Get all hardfork names (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+
+/**
+ * Get all hardfork names in order
+ *
+ * @returns Array of all hardfork names in chronological order
+ */
+export const allNames = Hardfork.allNames;

package/src/primitives/Hardfork/compare.ts

@@ -0,0 +1,17 @@
+/**
+ * @module compare
+ * @description Compare hardforks (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+import type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+/**
+ * Compare two hardforks chronologically
+ *
+ * @param a - First hardfork
+ * @param b - Second hardfork
+ * @returns -1 if a < b, 0 if equal, 1 if a > b
+ */
+export const compare: (a: HardforkType, b: HardforkType) => number =
+	Hardfork.compare;

package/src/primitives/Hardfork/comparisons.ts

@@ -0,0 +1,45 @@
+/**
+ * @module comparisons
+ * @description Hardfork comparison predicates (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+import type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+/**
+ * Check if a > b chronologically
+ */
+export const gt: (a: HardforkType, b: HardforkType) => boolean = Hardfork.gt;
+
+/**
+ * Check if a >= b chronologically
+ */
+export const gte: (a: HardforkType, b: HardforkType) => boolean = Hardfork.gte;
+
+/**
+ * Check if a < b chronologically
+ */
+export const lt: (a: HardforkType, b: HardforkType) => boolean = Hardfork.lt;
+
+/**
+ * Check if a <= b chronologically
+ */
+export const lte: (a: HardforkType, b: HardforkType) => boolean = Hardfork.lte;
+
+/**
+ * Check if fork is after a minimum fork
+ */
+export const isAfter: (fork: HardforkType, minFork: HardforkType) => boolean =
+	Hardfork.isAfter;
+
+/**
+ * Check if fork is at least a minimum fork
+ */
+export const isAtLeast: (fork: HardforkType, minFork: HardforkType) => boolean =
+	Hardfork.isAtLeast;
+
+/**
+ * Check if fork is before a maximum fork
+ */
+export const isBefore: (fork: HardforkType, maxFork: HardforkType) => boolean =
+	Hardfork.isBefore;

package/src/primitives/Hardfork/equals.ts

@@ -0,0 +1,17 @@
+/**
+ * @module equals
+ * @description Check hardfork equality (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+import type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+/**
+ * Check if two hardforks are equal
+ *
+ * @param a - First hardfork
+ * @param b - Second hardfork
+ * @returns true if hardforks are the same
+ */
+export const equals: (a: HardforkType, b: HardforkType) => boolean =
+	Hardfork.equals;

package/src/primitives/Hardfork/features.ts

@@ -0,0 +1,61 @@
+/**
+ * @module features
+ * @description Hardfork feature checks (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+import type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+/**
+ * Check if hardfork has EIP-1153 (transient storage)
+ */
+export const hasEIP1153: (fork: HardforkType) => boolean = Hardfork.hasEIP1153;
+
+/**
+ * Check if hardfork has EIP-1559 (fee market)
+ */
+export const hasEIP1559: (fork: HardforkType) => boolean = Hardfork.hasEIP1559;
+
+/**
+ * Check if hardfork has EIP-3855 (PUSH0)
+ */
+export const hasEIP3855: (fork: HardforkType) => boolean = Hardfork.hasEIP3855;
+
+/**
+ * Check if hardfork has EIP-4844 (blobs)
+ */
+export const hasEIP4844: (fork: HardforkType) => boolean = Hardfork.hasEIP4844;
+
+/**
+ * Check if hardfork supports blob transactions
+ */
+export const supportsBlobs: (fork: HardforkType) => boolean =
+	Hardfork.supportsBlobs;
+
+/**
+ * Check if hardfork supports EIP-1559 fee market
+ */
+export const supportsEIP1559: (fork: HardforkType) => boolean =
+	Hardfork.supportsEIP1559;
+
+/**
+ * Check if hardfork supports PUSH0 opcode
+ */
+export const supportsPUSH0: (fork: HardforkType) => boolean =
+	Hardfork.supportsPUSH0;
+
+/**
+ * Check if hardfork supports transient storage
+ */
+export const supportsTransientStorage: (fork: HardforkType) => boolean =
+	Hardfork.supportsTransientStorage;
+
+/**
+ * Check if hardfork is Proof of Stake
+ */
+export const isPoS: (fork: HardforkType) => boolean = Hardfork.isPoS;
+
+/**
+ * Check if hardfork is post-Merge
+ */
+export const isPostMerge: (fork: HardforkType) => boolean = Hardfork.isPostMerge;

package/src/primitives/Hardfork/fromString.ts

@@ -0,0 +1,16 @@
+/**
+ * @module fromString
+ * @description Parse hardfork from string (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+import type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+/**
+ * Parse a hardfork from string name
+ *
+ * @param name - Hardfork name (case insensitive)
+ * @returns HardforkType or undefined if invalid
+ */
+export const fromString: (name: string) => HardforkType | undefined =
+	Hardfork.fromString;

package/src/primitives/Hardfork/index.ts

@@ -1,39 +1,149 @@
 /**
  * @module Hardfork
- * @description Ethereum hardfork constants and identifiers.
+ * @description Ethereum hardfork constants and utilities.
+ *
+ * Hardforks represent protocol upgrades that change EVM behavior, gas costs,
+ * or add new features.
+ *
+ * ## Type Declarations
+ *
+ * ```typescript
+ * import * as Hardfork from 'voltaire-effect/primitives/Hardfork'
+ *
+ * function checkFeatures(fork: Hardfork.HardforkType) {
+ *   // ...
+ * }
+ * ```
  *
  * ## Constants
  *
- * - `FRONTIER`, `HOMESTEAD`, `TANGERINE_WHISTLE`, `SPURIOUS_DRAGON`
- * - `BYZANTIUM`, `CONSTANTINOPLE`, `PETERSBURG`, `ISTANBUL`
- * - `MUIR_GLACIER`, `BERLIN`, `LONDON`, `ARROW_GLACIER`, `GRAY_GLACIER`
- * - `SHANGHAI`, `CANCUN`, `PRAGUE`
+ * ```typescript
+ * Hardfork.FRONTIER          // Original launch (July 2015)
+ * Hardfork.HOMESTEAD         // First planned hardfork
+ * Hardfork.BYZANTIUM         // Added REVERT, RETURNDATASIZE, etc.
+ * Hardfork.CONSTANTINOPLE    // Added CREATE2, shift opcodes
+ * Hardfork.ISTANBUL          // EIP-2200: Rebalanced SSTORE
+ * Hardfork.BERLIN            // EIP-2929: Cold/warm access
+ * Hardfork.LONDON            // EIP-1559: Base fee
+ * Hardfork.MERGE             // Proof of Stake transition
+ * Hardfork.SHANGHAI          // EIP-3855: PUSH0
+ * Hardfork.CANCUN            // EIP-4844: Blobs, EIP-1153: TLOAD/TSTORE
+ * Hardfork.PRAGUE            // EIP-2537: BLS12-381
+ * ```
+ *
+ * ## Pure Functions
  *
- * ## Usage
+ * ```typescript
+ * // Parsing
+ * Hardfork.fromString(name)           // HardforkType | undefined
+ * Hardfork.toString(fork)             // string
+ * Hardfork.isValidName(name)          // boolean
+ *
+ * // Listing
+ * Hardfork.allIds()                   // HardforkType[]
+ * Hardfork.allNames()                 // string[]
+ * Hardfork.range(start, end)          // HardforkType[]
+ *
+ * // Comparison
+ * Hardfork.compare(a, b)              // -1 | 0 | 1
+ * Hardfork.equals(a, b)               // boolean
+ * Hardfork.gt(a, b)                   // boolean
+ * Hardfork.gte(a, b)                  // boolean
+ * Hardfork.lt(a, b)                   // boolean
+ * Hardfork.lte(a, b)                  // boolean
+ * Hardfork.isAfter(fork, min)         // boolean
+ * Hardfork.isAtLeast(fork, min)       // boolean
+ * Hardfork.isBefore(fork, max)        // boolean
+ * Hardfork.min(forks)                 // HardforkType
+ * Hardfork.max(forks)                 // HardforkType
+ *
+ * // Feature checks
+ * Hardfork.hasEIP1153(fork)           // boolean (transient storage)
+ * Hardfork.hasEIP1559(fork)           // boolean (fee market)
+ * Hardfork.hasEIP3855(fork)           // boolean (PUSH0)
+ * Hardfork.hasEIP4844(fork)           // boolean (blobs)
+ * Hardfork.supportsBlobs(fork)        // boolean
+ * Hardfork.supportsEIP1559(fork)      // boolean
+ * Hardfork.supportsPUSH0(fork)        // boolean
+ * Hardfork.supportsTransientStorage(fork) // boolean
+ * Hardfork.isPoS(fork)                // boolean
+ * Hardfork.isPostMerge(fork)          // boolean
+ * ```
  *
+ * @example
  * ```typescript
  * import * as Hardfork from 'voltaire-effect/primitives/Hardfork'
  *
- * const hardfork = Hardfork.CANCUN
+ * const fork = Hardfork.CANCUN
+ *
+ * if (Hardfork.supportsBlobs(fork)) {
+ *   console.log('Blob transactions supported!')
+ * }
+ *
+ * if (Hardfork.isAtLeast(fork, Hardfork.SHANGHAI)) {
+ *   console.log('PUSH0 available')
+ * }
  * ```
  *
  * @since 0.1.0
  */
+
+// Re-export type
+export type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+// Schema
+export { HardforkSchema } from "./HardforkSchema.js";
+
+// Parsing
+export { fromString } from "./fromString.js";
+export { toString } from "./toString.js";
+export { isValidName } from "./isValidName.js";
+
+// Listing
+export { allIds } from "./allIds.js";
+export { allNames } from "./allNames.js";
+export { range } from "./range.js";
+
+// Comparison
+export { compare } from "./compare.js";
+export { equals } from "./equals.js";
+export { gt, gte, lt, lte, isAfter, isAtLeast, isBefore } from "./comparisons.js";
+export { min, max } from "./minMax.js";
+
+// Feature checks
+export {
+	hasEIP1153,
+	hasEIP1559,
+	hasEIP3855,
+	hasEIP4844,
+	supportsBlobs,
+	supportsEIP1559,
+	supportsPUSH0,
+	supportsTransientStorage,
+	isPoS,
+	isPostMerge,
+} from "./features.js";
+
+// Constants
 export {
-	ARROW_GLACIER,
-	BERLIN,
-	BYZANTIUM,
-	CANCUN,
-	CONSTANTINOPLE,
 	FRONTIER,
-	GRAY_GLACIER,
 	HOMESTEAD,
+	DAO,
+	TANGERINE_WHISTLE,
+	SPURIOUS_DRAGON,
+	BYZANTIUM,
+	CONSTANTINOPLE,
+	PETERSBURG,
 	ISTANBUL,
-	LONDON,
 	MUIR_GLACIER,
-	PETERSBURG,
-	PRAGUE,
+	BERLIN,
+	LONDON,
+	ARROW_GLACIER,
+	GRAY_GLACIER,
+	MERGE,
 	SHANGHAI,
-	SPURIOUS_DRAGON,
-	TANGERINE_WHISTLE,
+	CANCUN,
+	PRAGUE,
+	OSAKA,
+	DEFAULT,
 } from "@tevm/voltaire/Hardfork";

package/src/primitives/Hardfork/isValidName.ts

@@ -0,0 +1,14 @@
+/**
+ * @module isValidName
+ * @description Validate hardfork name (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+
+/**
+ * Check if a string is a valid hardfork name
+ *
+ * @param name - Name to validate
+ * @returns true if name is a valid hardfork
+ */
+export const isValidName: (name: string) => boolean = Hardfork.isValidName;

package/src/primitives/Hardfork/minMax.ts

@@ -0,0 +1,23 @@
+/**
+ * @module minMax
+ * @description Min/max hardfork functions (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+import type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+/**
+ * Get the minimum (earliest) hardfork from an array
+ *
+ * @param forks - Array of hardforks
+ * @returns Earliest hardfork
+ */
+export const min: (forks: HardforkType[]) => HardforkType = Hardfork.min;
+
+/**
+ * Get the maximum (latest) hardfork from an array
+ *
+ * @param forks - Array of hardforks
+ * @returns Latest hardfork
+ */
+export const max: (forks: HardforkType[]) => HardforkType = Hardfork.max;

package/src/primitives/Hardfork/range.ts

@@ -0,0 +1,19 @@
+/**
+ * @module range
+ * @description Get range of hardforks (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+import type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+/**
+ * Get a range of hardforks between start and end (inclusive)
+ *
+ * @param start - Start hardfork
+ * @param end - End hardfork
+ * @returns Array of hardforks in range
+ */
+export const range: (
+	start: HardforkType,
+	end: HardforkType,
+) => HardforkType[] = Hardfork.range;

package/src/primitives/Hardfork/toString.ts

@@ -0,0 +1,16 @@
+/**
+ * @module toString
+ * @description Convert hardfork to string (pure)
+ * @since 0.1.0
+ */
+import * as Hardfork from "@tevm/voltaire/Hardfork";
+import type { HardforkType } from "@tevm/voltaire/Hardfork";
+
+/**
+ * Convert hardfork to string name
+ *
+ * @param fork - Hardfork to convert
+ * @returns Hardfork name string
+ */
+// biome-ignore lint/suspicious/noShadowRestrictedNames: toString is the function name in our API
+export const toString: (fork: HardforkType) => string = Hardfork.toString;

package/src/primitives/Hash/Hash.test.ts

@@ -564,6 +564,110 @@ describe("error cases", () => {
 	});
 });
 
+describe("from functions", () => {
+	describe("from", () => {
+		it("parses valid hex string", () => {
+			const hash = Effect.runSync(Hash.from(`0x${"ab".repeat(32)}`));
+			expect(hash.length).toBe(32);
+		});
+
+		it("parses valid Uint8Array", () => {
+			const hash = Effect.runSync(Hash.from(new Uint8Array(32).fill(0xab)));
+			expect(hash.length).toBe(32);
+		});
+
+		it("fails on invalid hex", () => {
+			expect(() => Effect.runSync(Hash.from("invalid"))).toThrow();
+		});
+
+		it("fails on wrong length bytes", () => {
+			expect(() => Effect.runSync(Hash.from(new Uint8Array(16)))).toThrow();
+		});
+	});
+
+	describe("fromHex", () => {
+		it("parses valid hex", () => {
+			const hash = Effect.runSync(Hash.fromHex(`0x${"ab".repeat(32)}`));
+			expect(hash.length).toBe(32);
+		});
+
+		it("parses hex without 0x prefix", () => {
+			const hash = Effect.runSync(Hash.fromHex("ab".repeat(32)));
+			expect(hash.length).toBe(32);
+		});
+
+		it("fails on invalid characters", () => {
+			expect(() =>
+				Effect.runSync(Hash.fromHex(`0x${"gg".repeat(32)}`)),
+			).toThrow();
+		});
+
+		it("fails on wrong length", () => {
+			expect(() => Effect.runSync(Hash.fromHex(`0x${"ab".repeat(16)}`))).toThrow();
+		});
+	});
+
+	describe("fromBytes", () => {
+		it("parses valid 32-byte array", () => {
+			const hash = Effect.runSync(Hash.fromBytes(new Uint8Array(32)));
+			expect(hash.length).toBe(32);
+		});
+
+		it("fails on wrong length (too short)", () => {
+			expect(() => Effect.runSync(Hash.fromBytes(new Uint8Array(31)))).toThrow();
+		});
+
+		it("fails on wrong length (too long)", () => {
+			expect(() => Effect.runSync(Hash.fromBytes(new Uint8Array(33)))).toThrow();
+		});
+	});
+});
+
+describe("isHash", () => {
+	it("returns true for valid hash", () => {
+		const hash = S.decodeSync(Hash.Hex)(`0x${"ab".repeat(32)}`);
+		expect(Hash.isHash(hash)).toBe(true);
+	});
+
+	it("returns false for wrong length", () => {
+		expect(Hash.isHash(new Uint8Array(16))).toBe(false);
+	});
+
+	it("returns false for non-Uint8Array", () => {
+		expect(Hash.isHash("0x" + "ab".repeat(32))).toBe(false);
+	});
+
+	it("returns false for null", () => {
+		expect(Hash.isHash(null)).toBe(false);
+	});
+
+	it("returns false for undefined", () => {
+		expect(Hash.isHash(undefined)).toBe(false);
+	});
+});
+
+describe("toHex", () => {
+	it("converts hash to hex string", () => {
+		const hash = S.decodeSync(Hash.Hex)(`0x${"ab".repeat(32)}`);
+		expect(Hash.toHex(hash)).toBe(`0x${"ab".repeat(32)}`);
+	});
+
+	it("returns lowercase hex", () => {
+		const hash = S.decodeSync(Hash.Hex)(`0x${"AB".repeat(32)}`);
+		expect(Hash.toHex(hash)).toBe(`0x${"ab".repeat(32)}`);
+	});
+
+	it("produces 66-character string", () => {
+		const hash = S.decodeSync(Hash.Hex)(`0x${"00".repeat(32)}`);
+		expect(Hash.toHex(hash).length).toBe(66);
+	});
+
+	it("starts with 0x", () => {
+		const hash = S.decodeSync(Hash.Hex)(`0x${"ab".repeat(32)}`);
+		expect(Hash.toHex(hash).startsWith("0x")).toBe(true);
+	});
+});
+
 describe("additional edge cases", () => {
 	it("isValidHex with missing 0x prefix accepts raw hex", () => {
 		const result = Effect.runSync(Hash.isValidHex("ab".repeat(32)));

package/src/primitives/Hash/from.ts

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Create Hash from string or bytes.
+ *
+ * @module Hash/from
+ * @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 string or bytes.
+ *
+ * @description Parses hex string or Uint8Array into a 32-byte hash.
+ * Can fail if input is invalid format or wrong length.
+ *
+ * @param {string | Uint8Array} value - Hex string or Uint8Array
+ * @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.from('0x' + 'ab'.repeat(32)))
+ * const hash2 = Effect.runSync(Hash.from(new Uint8Array(32)))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const from = (
+	value: string | Uint8Array,
+): Effect.Effect<HashType, ValidationError> =>
+	Effect.try({
+		try: () => Hash.from(value),
+		catch: (error) =>
+			new ValidationError(
+				error instanceof Error ? error.message : "Invalid hash input",
+				{
+					value,
+					expected: "32-byte hash",
+					cause: error instanceof Error ? error : undefined,
+				},
+			),
+	});