voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Bytecode/size.ts

@@ -0,0 +1,9 @@
+/**
+ * @module size
+ * @description Get bytecode size (pure)
+ * @since 0.1.0
+ */
+import { size as _size } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const size = (code: BrandedBytecode): number => _size(code);

package/src/primitives/Bytecode/stripMetadata.ts

@@ -0,0 +1,10 @@
+/**
+ * @module stripMetadata
+ * @description Strip CBOR metadata from bytecode (pure)
+ * @since 0.1.0
+ */
+import { stripMetadata as _stripMetadata } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const stripMetadata = (code: BrandedBytecode): BrandedBytecode =>
+	_stripMetadata(code);

package/src/primitives/Bytecode/toAbi.ts

@@ -0,0 +1,10 @@
+/**
+ * @module toAbi
+ * @description Extract ABI from bytecode (pure)
+ * @since 0.1.0
+ */
+import { toAbi as _toAbi } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, BrandedAbi } from "./types.js";
+
+export const toAbi = (bytecode: BrandedBytecode): BrandedAbi =>
+	_toAbi(bytecode);

package/src/primitives/Bytecode/toHex.ts

@@ -0,0 +1,10 @@
+/**
+ * @module toHex
+ * @description Convert bytecode to hex string (pure)
+ * @since 0.1.0
+ */
+import { toHex as _toHex } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const toHex = (code: BrandedBytecode, prefix?: boolean): string =>
+	_toHex(code, prefix);

package/src/primitives/Bytecode/types.ts

@@ -0,0 +1,23 @@
+/**
+ * @module types
+ * @description Bytecode type re-exports
+ * @since 0.1.0
+ */
+
+export type {
+	Analysis,
+	BasicBlock,
+	BlockAnalysisOptions,
+	GasAnalysis,
+	GasAnalysisOptions,
+	Instruction,
+	PrettyPrintOptions,
+	ScanOptions,
+	StackAnalysis,
+	StackAnalysisOptions,
+	BrandedAbi,
+} from "@tevm/voltaire/Bytecode";
+
+// Use loose type to avoid brand symbol issues
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type BrandedBytecode = any;

package/src/primitives/Bytecode/validate.ts

@@ -0,0 +1,9 @@
+/**
+ * @module validate
+ * @description Validate bytecode structure (pure)
+ * @since 0.1.0
+ */
+import { validate as _validate } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const validate = (code: BrandedBytecode): boolean => _validate(code);

package/src/primitives/Ens/Ens.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Effect, Exit } from "effect";
+import * as Schema from "effect/Schema";
+import * as Ens from "./index.js";
+
+describe("Ens.EnsSchema", () => {
+  it("validates ENS name", () => {
+    const name = Schema.decodeSync(Ens.EnsSchema)("vitalik.eth");
+    expect(typeof name).toBe("string");
+  });
+});
+
+describe("Ens.from", () => {
+  it("creates EnsType from string", async () => {
+    const name = await Effect.runPromise(Ens.from("vitalik.eth"));
+    expect(typeof name).toBe("string");
+  });
+});
+
+describe("Ens.normalize", () => {
+  it("normalizes ENS name", async () => {
+    const normalized = await Effect.runPromise(Ens.normalize("VITALIK.ETH"));
+    expect(normalized.toLowerCase()).toBe("vitalik.eth");
+  });
+});
+
+describe("Ens.beautify", () => {
+  it("beautifies ENS name", async () => {
+    const beautified = await Effect.runPromise(Ens.beautify("vitalik.eth"));
+    expect(typeof beautified).toBe("string");
+  });
+});
+
+describe("Ens.namehash", () => {
+  it("computes namehash", async () => {
+    const hash = await Effect.runPromise(Ens.namehash("eth"));
+    expect(hash).toBeInstanceOf(Uint8Array);
+    expect(hash.length).toBe(32);
+  });
+});
+
+describe("Ens.labelhash", () => {
+  it("computes labelhash", async () => {
+    const hash = await Effect.runPromise(Ens.labelhash("vitalik"));
+    expect(hash).toBeInstanceOf(Uint8Array);
+    expect(hash.length).toBe(32);
+  });
+});
+
+describe("Ens.validation", () => {
+  it("isValid returns true for valid names", () => {
+    expect(Ens.isValid("vitalik.eth")).toBe(true);
+  });
+
+  it("isValid returns false for invalid names", () => {
+    expect(Ens.isValid("")).toBe(false);
+  });
+
+  it("validate succeeds for valid names", async () => {
+    const result = await Effect.runPromiseExit(Ens.validate("vitalik.eth"));
+    expect(Exit.isSuccess(result)).toBe(true);
+  });
+});
+
+describe("Ens.toString", () => {
+  it("converts to string", async () => {
+    const name = await Effect.runPromise(Ens.from("vitalik.eth"));
+    const str = Ens.toString(name);
+    expect(str).toBe("vitalik.eth");
+  });
+});

package/src/primitives/Ens/convert.ts

@@ -0,0 +1,13 @@
+/**
+ * @module convert
+ * @description Pure ENS conversion functions
+ * @since 0.1.0
+ */
+import { Ens } from "@tevm/voltaire";
+import type { EnsType } from "./String.js";
+
+/**
+ * Convert ENS name to string
+ */
+// biome-ignore lint/suspicious/noShadowRestrictedNames: intentional API name
+export const toString = (name: EnsType): string => Ens.toString(name);

package/src/primitives/Ens/from.ts

@@ -0,0 +1,32 @@
+/**
+ * @module from
+ * @description Effect-wrapped ENS constructor
+ * @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;
+
+/**
+ * Create ENS name from string
+ *
+ * @param name - ENS name string
+ * @returns Effect yielding EnsType or failing with EnsError
+ * @example
+ * ```typescript
+ * const ens = await Effect.runPromise(Ens.from('vitalik.eth'))
+ * ```
+ */
+export const from = (name: string): Effect.Effect<EnsType, EnsError> =>
+  Effect.try({
+    try: () => Ens.from(name),
+    catch: (e) => e as EnsError,
+  });

package/src/primitives/Ens/hash.ts

@@ -0,0 +1,46 @@
+/**
+ * @module hash
+ * @description Effect-wrapped ENS hash operations
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Ens } from "@tevm/voltaire";
+
+type EnsError =
+  | Ens.DisallowedCharacterError
+  | Ens.EmptyLabelError
+  | Ens.IllegalMixtureError
+  | Ens.InvalidLabelExtensionError
+  | Ens.InvalidUtf8Error
+  | Ens.WholeConfusableError;
+
+/**
+ * Compute namehash of ENS name (32-byte hash for contracts)
+ *
+ * @param name - ENS name to hash
+ * @returns Effect yielding 32-byte hash
+ * @example
+ * ```typescript
+ * const hash = await Effect.runPromise(Ens.namehash('vitalik.eth'))
+ * ```
+ */
+export const namehash = (name: string): Effect.Effect<Uint8Array, EnsError> =>
+  Effect.try({
+    try: () => Ens.namehash(name),
+    catch: (e) => e as EnsError,
+  });
+
+/**
+ * Compute labelhash of single ENS label
+ *
+ * @param label - Single ENS label to hash
+ * @returns Effect yielding 32-byte hash
+ */
+export const labelhash = (label: string): Effect.Effect<Uint8Array, EnsError> =>
+  Effect.try({
+    try: () => Ens.labelhash(label),
+    catch: (e) => e as EnsError,
+  });
+
+// Re-export factories for advanced usage
+export { Labelhash, Namehash } from "@tevm/voltaire/Ens";

package/src/primitives/Ens/index.ts

@@ -1,6 +1,6 @@
 /**
- * Ens module for working with Ethereum Name Service names.
- * Provides Effect-based operations for validating, normalizing, and hashing ENS names.
+ * @module Ens
+ * @description Effect-based operations for Ethereum Name Service names.
  *
  * ## Type Declarations
  *
@@ -12,7 +12,89 @@
  * }
  * ```
  *
- * @module
+ * ## Schemas
+ *
+ * | Schema | Input | Output |
+ * |--------|-------|--------|
+ * | `Ens.EnsSchema` | string | EnsType |
+ *
+ * ## Constructors (Effect-wrapped)
+ *
+ * ```typescript
+ * Ens.from(name)    // Effect<EnsType, EnsError>
+ * ```
+ *
+ * ## Normalization (Effect-wrapped)
+ *
+ * ```typescript
+ * Ens.normalize(name) // Effect<EnsType, EnsError>
+ * Ens.beautify(name)  // Effect<EnsType, EnsError>
+ * ```
+ *
+ * ## Hashing (Effect-wrapped)
+ *
+ * ```typescript
+ * Ens.namehash(name)  // Effect<Uint8Array, EnsError>
+ * Ens.labelhash(label) // Effect<Uint8Array, EnsError>
+ * ```
+ *
+ * ## Validation
+ *
+ * ```typescript
+ * Ens.isValid(name)   // boolean (pure)
+ * Ens.is(value)       // type guard (pure)
+ * Ens.validate(name)  // Effect<void, EnsError>
+ * ```
+ *
+ * ## Conversion (Pure)
+ *
+ * ```typescript
+ * Ens.toString(ens)   // string
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import * as Ens from 'voltaire-effect/primitives/Ens'
+ * import { Effect } from 'effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   yield* Ens.validate('vitalik.eth')
+ *   const normalized = yield* Ens.normalize('VITALIK.eth')
+ *   const hash = yield* Ens.namehash(normalized)
+ *   return { name: normalized, hash }
+ * })
+ * ```
+ *
  * @since 0.0.1
  */
-export { EnsSchema, type EnsType } from "./String.js";
+
+// Types
+export type { EnsType } from "./String.js";
+
+// Errors (re-export from voltaire)
+export {
+  DisallowedCharacterError,
+  EmptyLabelError,
+  IllegalMixtureError,
+  InvalidLabelExtensionError,
+  InvalidUtf8Error,
+  WholeConfusableError,
+} from "@tevm/voltaire/Ens";
+
+// Schemas
+export { EnsSchema } from "./String.js";
+
+// Constructors (Effect-wrapped)
+export { from } from "./from.js";
+
+// Normalization (Effect-wrapped)
+export { normalize, beautify } from "./normalize.js";
+
+// Hashing (Effect-wrapped)
+export { namehash, labelhash, Labelhash, Namehash } from "./hash.js";
+
+// Validation
+export { isValid, is, validate } from "./validation.js";
+
+// Conversion (Pure)
+export { toString } from "./convert.js";

package/src/primitives/Ens/normalize.ts

@@ -0,0 +1,45 @@
+/**
+ * @module normalize
+ * @description Effect-wrapped ENS normalization
+ * @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;
+
+/**
+ * Normalize ENS name per ENSIP-15
+ *
+ * @param name - ENS name to normalize
+ * @returns Effect yielding normalized EnsType
+ * @example
+ * ```typescript
+ * const normalized = await Effect.runPromise(Ens.normalize('Vitalik.ETH'))
+ * // 'vitalik.eth'
+ * ```
+ */
+export const normalize = (name: string): Effect.Effect<EnsType, EnsError> =>
+  Effect.try({
+    try: () => Ens.normalize(name),
+    catch: (e) => e as EnsError,
+  });
+
+/**
+ * Beautify ENS name for display
+ *
+ * @param name - ENS name to beautify
+ * @returns Effect yielding beautified EnsType
+ */
+export const beautify = (name: string): Effect.Effect<EnsType, EnsError> =>
+  Effect.try({
+    try: () => Ens.beautify(name),
+    catch: (e) => e as EnsError,
+  });

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";