voltaire-effect 0.2.23 → 0.2.25

package/src/primitives/Ens/validation.ts

@@ -0,0 +1,38 @@
+/**
+ * @module validation
+ * @description ENS validation functions
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Ens } from "@tevm/voltaire";
+import type { EnsType } from "./String.js";
+
+type EnsError =
+  | Ens.DisallowedCharacterError
+  | Ens.EmptyLabelError
+  | Ens.IllegalMixtureError
+  | Ens.InvalidLabelExtensionError
+  | Ens.InvalidUtf8Error
+  | Ens.WholeConfusableError;
+
+/**
+ * Check if value is valid ENS name (pure)
+ */
+export const isValid = (name: string): boolean => Ens.isValid(name);
+
+/**
+ * Type guard for EnsType
+ */
+export const is = (value: unknown): value is EnsType => Ens.is(value);
+
+/**
+ * Validate ENS name, throwing on error
+ *
+ * @param name - ENS name to validate
+ * @returns Effect that succeeds if valid, fails with EnsError if invalid
+ */
+export const validate = (name: string): Effect.Effect<void, EnsError> =>
+  Effect.try({
+    try: () => Ens.validate(name),
+    catch: (e) => e as EnsError,
+  });

package/src/primitives/EventLog/accessors.ts

@@ -0,0 +1,32 @@
+/**
+ * @module accessors
+ * @description Pure EventLog accessor functions
+ * @since 0.1.0
+ */
+import * as EventLog from "@tevm/voltaire/EventLog";
+import type { EventLogType } from "@tevm/voltaire/EventLog";
+import type { HashType } from "@tevm/voltaire/Hash";
+
+/**
+ * Get topic at index 0 (event signature)
+ */
+export const getTopic0 = (log: EventLogType): HashType | undefined =>
+  EventLog.getTopic0(log);
+
+/**
+ * Get event signature hash
+ */
+export const getSignature = (log: EventLogType): HashType | undefined =>
+  EventLog.getSignature(log);
+
+/**
+ * Get all indexed topics (topics 1-3)
+ */
+export const getIndexedTopics = (log: EventLogType): readonly HashType[] =>
+  EventLog.getIndexedTopics(log);
+
+/**
+ * Get indexed parameters (alias for getIndexedTopics)
+ */
+export const getIndexed = (log: EventLogType): readonly HashType[] =>
+  EventLog.getIndexed(log);

package/src/primitives/EventLog/clone.ts

@@ -0,0 +1,17 @@
+/**
+ * @module clone
+ * @description Pure EventLog clone/copy functions
+ * @since 0.1.0
+ */
+import * as EventLog from "@tevm/voltaire/EventLog";
+import type { EventLogType } from "@tevm/voltaire/EventLog";
+
+/**
+ * Create deep clone of EventLog
+ */
+export const clone = (log: EventLogType): EventLogType => EventLog.clone(log);
+
+/**
+ * Copy EventLog (alias for clone)
+ */
+export const copy = (log: EventLogType): EventLogType => EventLog.copy(log);

package/src/primitives/EventLog/create.ts

@@ -0,0 +1,46 @@
+/**
+ * @module create
+ * @description Effect-wrapped EventLog constructors
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import * as EventLog from "@tevm/voltaire/EventLog";
+import type { EventLogType } from "@tevm/voltaire/EventLog";
+import type { AddressType } from "@tevm/voltaire/Address";
+import type { HashType } from "@tevm/voltaire/Hash";
+
+interface EventLogInput {
+  address: AddressType;
+  topics: HashType[];
+  data: Uint8Array;
+  blockNumber?: bigint;
+  transactionHash?: HashType;
+  transactionIndex?: number;
+  blockHash?: HashType;
+  logIndex?: number;
+  removed?: boolean;
+}
+
+/**
+ * Create EventLog from raw values
+ *
+ * @param input - EventLog data
+ * @returns Effect yielding EventLogType
+ */
+export const create = (input: EventLogInput): Effect.Effect<EventLogType, Error> =>
+  Effect.try({
+    try: () => EventLog.create(input),
+    catch: (e) => e as Error,
+  });
+
+/**
+ * Create EventLog from various input formats
+ *
+ * @param input - EventLog data or compatible object
+ * @returns Effect yielding EventLogType
+ */
+export const from = (input: unknown): Effect.Effect<EventLogType, Error> =>
+  Effect.try({
+    try: () => EventLog.from(input as EventLogInput),
+    catch: (e) => e as Error,
+  });

package/src/primitives/EventLog/filtering.ts

@@ -0,0 +1,48 @@
+/**
+ * @module filtering
+ * @description Pure EventLog filtering functions
+ * @since 0.1.0
+ */
+import * as EventLog from "@tevm/voltaire/EventLog";
+import type { EventLogType } from "@tevm/voltaire/EventLog";
+import type { AddressType } from "@tevm/voltaire/Address";
+import type { HashType } from "@tevm/voltaire/Hash";
+
+interface LogFilter {
+  address?: AddressType | AddressType[];
+  topics?: (HashType | HashType[] | null)[];
+}
+
+/**
+ * Check if log matches given address
+ */
+export const matchesAddress = (
+  log: EventLogType,
+  address: AddressType | AddressType[],
+): boolean => EventLog.matchesAddress(log, address);
+
+/**
+ * Check if log matches topic filter
+ */
+export const matchesTopics = (
+  log: EventLogType,
+  topics: (HashType | HashType[] | null)[],
+): boolean => EventLog.matchesTopics(log, topics);
+
+/**
+ * Check if log matches full filter (address + topics)
+ */
+export const matchesFilter = (log: EventLogType, filter: LogFilter): boolean =>
+  EventLog.matchesFilter(log, filter);
+
+/**
+ * Filter array of logs by filter criteria
+ */
+export const filterLogs = (logs: EventLogType[], filter: LogFilter): EventLogType[] =>
+  EventLog.filterLogs(logs, filter);
+
+/**
+ * Sort logs by block number, transaction index, and log index
+ */
+export const sortLogs = (logs: EventLogType[]): EventLogType[] =>
+  EventLog.sortLogs(logs);

package/src/primitives/EventLog/index.ts

@@ -1,6 +1,6 @@
 /**
  * @module EventLog
- * @description Event logs emitted by smart contracts.
+ * @description Effect-based operations for EVM event logs.
  *
  * ## Type Declarations
  *
@@ -12,12 +12,102 @@
  * }
  * ```
  *
+ * ## Schemas
+ *
+ * | Schema | Input | Output |
+ * |--------|-------|--------|
+ * | `EventLog.Rpc` | RPC log object | EventLogType |
+ * | `EventLog.Schema` | RPC log object | EventLogType |
+ *
+ * ## Constructors (Effect-wrapped)
+ *
+ * ```typescript
+ * EventLog.create(input)  // Effect<EventLogType, Error>
+ * EventLog.from(input)    // Effect<EventLogType, Error>
+ * ```
+ *
+ * ## Accessors (Pure)
+ *
+ * ```typescript
+ * EventLog.getTopic0(log)        // HashType | undefined
+ * EventLog.getSignature(log)     // HashType | undefined
+ * EventLog.getIndexed(log)       // readonly HashType[]
+ * EventLog.getIndexedTopics(log) // readonly HashType[]
+ * ```
+ *
+ * ## Filtering (Pure)
+ *
+ * ```typescript
+ * EventLog.matchesAddress(log, address) // boolean
+ * EventLog.matchesTopics(log, topics)   // boolean
+ * EventLog.matchesFilter(log, filter)   // boolean
+ * EventLog.filterLogs(logs, filter)     // EventLogType[]
+ * EventLog.sortLogs(logs)               // EventLogType[]
+ * ```
+ *
+ * ## Status (Pure)
+ *
+ * ```typescript
+ * EventLog.isRemoved(log)  // boolean
+ * EventLog.wasRemoved(log) // boolean
+ * ```
+ *
+ * ## Clone/Copy (Pure)
+ *
+ * ```typescript
+ * EventLog.clone(log) // EventLogType
+ * EventLog.copy(log)  // EventLogType
+ * ```
+ *
+ * ## Conversion (Pure)
+ *
+ * ```typescript
+ * EventLog.toRpc(log) // RpcLog
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import * as EventLog from 'voltaire-effect/primitives/EventLog'
+ * import * as Schema from 'effect/Schema'
+ *
+ * const log = Schema.decodeSync(EventLog.Rpc)({
+ *   address: '0x...',
+ *   topics: ['0x...'],
+ *   data: new Uint8Array(32),
+ * })
+ *
+ * const signature = EventLog.getSignature(log)
+ * const transfers = EventLog.filterLogs(logs, { topics: [transferTopic] })
+ * ```
+ *
  * @since 0.0.1
  */
+
+// Types
+export type { EventLogType } from "@tevm/voltaire/EventLog";
+
+// Schemas
 export {
-	EventLogSchema,
-	type EventLogType,
-	EventLogTypeSchema,
-	Rpc,
-	Schema,
+  EventLogSchema,
+  EventLogTypeSchema,
+  Rpc,
+  Schema,
 } from "./Rpc.js";
+
+// Constructors (Effect-wrapped)
+export { create, from } from "./create.js";
+
+// Accessors (Pure)
+export { getTopic0, getSignature, getIndexed, getIndexedTopics } from "./accessors.js";
+
+// Filtering (Pure)
+export { matchesAddress, matchesTopics, matchesFilter, filterLogs, sortLogs } from "./filtering.js";
+
+// Status (Pure)
+export { isRemoved, wasRemoved } from "./status.js";
+
+// Clone/Copy (Pure)
+export { clone, copy } from "./clone.js";
+
+// Conversion (Pure)
+export { toRpc } from "./toRpc.js";

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;