voltaire-effect 0.2.23 → 0.2.25

package/src/primitives/Bytecode/isValidJumpDest.ts

@@ -0,0 +1,12 @@
+/**
+ * @module isValidJumpDest
+ * @description Check if offset is a valid jump destination (pure)
+ * @since 0.1.0
+ */
+import { isValidJumpDest as _isValidJumpDest } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode } from "./types.js";
+
+export const isValidJumpDest = (
+	code: BrandedBytecode,
+	offset: number,
+): boolean => _isValidJumpDest(code, offset);

package/src/primitives/Bytecode/parseInstructions.ts

@@ -0,0 +1,10 @@
+/**
+ * @module parseInstructions
+ * @description Parse bytecode into instructions (pure)
+ * @since 0.1.0
+ */
+import { parseInstructions as _parseInstructions } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, Instruction } from "./types.js";
+
+export const parseInstructions = (code: BrandedBytecode): Instruction[] =>
+	_parseInstructions(code);

package/src/primitives/Bytecode/prettyPrint.ts

@@ -0,0 +1,12 @@
+/**
+ * @module prettyPrint
+ * @description Pretty print bytecode disassembly (pure)
+ * @since 0.1.0
+ */
+import { prettyPrint as _prettyPrint } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, PrettyPrintOptions } from "./types.js";
+
+export const prettyPrint = (
+	bytecode: BrandedBytecode,
+	options?: PrettyPrintOptions,
+): string => _prettyPrint(bytecode, options);

package/src/primitives/Bytecode/scan.ts

@@ -0,0 +1,20 @@
+/**
+ * @module scan
+ * @description Iterator over bytecode instructions (pure)
+ * @since 0.1.0
+ */
+import { scan as _scan } from "@tevm/voltaire/Bytecode";
+import type { BrandedBytecode, ScanOptions } from "./types.js";
+
+export const scan = (
+	bytecode: BrandedBytecode,
+	options?: ScanOptions,
+): Generator<{
+	pc: number;
+	opcode: number;
+	type: "push" | "regular";
+	size: number;
+	value?: bigint;
+	gas?: number;
+	stackEffect?: { pop: number; push: number };
+}> => _scan(bytecode, options);

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/ContractSignature/ContractSignature.test.ts

@@ -44,19 +44,7 @@ describe("checkReturnData", () => {
 
 describe("verifySignature", () => {
 	const mockProvider = {
-		call: vi.fn(),
-		getLogs: vi.fn(),
-		getBlockNumber: vi.fn(),
-		getBalance: vi.fn(),
-		getBlock: vi.fn(),
-		getTransaction: vi.fn(),
-		getTransactionReceipt: vi.fn(),
-		getTransactionCount: vi.fn(),
-		getCode: vi.fn(),
-		getStorageAt: vi.fn(),
-		estimateGas: vi.fn(),
-		getChainId: vi.fn(),
-		getGasPrice: vi.fn(),
+		request: vi.fn(),
 	};
 
 	const _MockProviderLayer = Layer.succeed(

package/src/primitives/ContractSignature/verifySignature.ts

@@ -16,7 +16,7 @@ import {
 } from "@tevm/voltaire";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
-import * as Runtime from "effect/Runtime";
+import { getCode, call } from "../../services/Provider/functions/index.js";
 import { ProviderService } from "../../services/Provider/index.js";
 
 type AddressType = BrandedAddress.AddressType;
@@ -122,6 +122,9 @@ const isEmptyCode = (code: unknown): code is string =>
 	typeof code === "string" &&
 	(code === "0x" || code === "0x0" || code === "0x00");
 
+// EIP-1271 magic value
+const EIP1271_MAGIC_VALUE = "0x1626ba7e";
+
 /**
  * Verify a signature for both EOA and contract accounts (EIP-1271).
  *
@@ -167,44 +170,29 @@ export const verifySignature = (
 	ProviderService
 > =>
 	Effect.gen(function* () {
-		const provider = yield* ProviderService;
-		const runtime = yield* Effect.runtime();
-		const runPromise = Runtime.runPromise(runtime);
-
 		const addressStr =
 			typeof address === "string" ? address : Address.toHex(address);
+		const addressHex = addressStr as `0x${string}`;
 
-		return yield* Effect.tryPromise({
-			try: async () => {
-				const providerAdapter = {
-					request: async (method: string, params: unknown[]) => {
-						if (method === "eth_getCode") {
-							const [addr, block] = params as [string, string];
-							return runPromise(
-								provider.getCode(addr as `0x${string}`, block as any),
-							);
-						}
-						if (method === "eth_call") {
-							const [callObj] = params as [{ to: string; data: string }];
-							return runPromise(
-								provider.call({
-									to: callObj.to as `0x${string}`,
-									data: callObj.data as `0x${string}`,
-								}),
-							);
-						}
-						throw new Error(`Unsupported method: ${method}`);
-					},
-				};
-
-				const addressHex =
-					typeof address === "string" ? address : Address.toHex(address);
-				const code = await providerAdapter.request("eth_getCode", [
-					addressHex,
-					"latest",
-				]);
-
-				if (isEmptyCode(code)) {
+		// Get code to determine if EOA or contract
+		const code = yield* getCode(addressHex, "latest").pipe(
+			Effect.mapError(
+				(e) =>
+					new SignatureVerificationError({
+						input: {
+							address: addressStr,
+							hash: hash instanceof Uint8Array ? hash : new Uint8Array(hash),
+						},
+						message: `Failed to get code: ${e.message}`,
+						cause: e,
+					}),
+			),
+		);
+
+		// EOA verification
+		if (isEmptyCode(code)) {
+			return yield* Effect.try({
+				try: () => {
 					const sigComponents = toSignatureComponents(signature);
 					const publicKey = Secp256k1.recoverPublicKey(
 						sigComponents,
@@ -216,39 +204,77 @@ export const verifySignature = (
 					const expectedAddress =
 						typeof address === "string" ? Address(address) : address;
 					return Address.equals(recoveredAddress, expectedAddress);
-				}
+				},
+				catch: (e) => {
+					if (e instanceof InvalidSignatureFormatError) {
+						return e;
+					}
+					if (
+						e instanceof Error &&
+						(e.name === "InvalidSignatureFormatError" ||
+							e.name === "InvalidSignatureError")
+					) {
+						return new InvalidSignatureFormatError({
+							message: e.message,
+							cause: e,
+						});
+					}
+					return new SignatureVerificationError({
+						input: {
+							address: addressStr,
+							hash: hash instanceof Uint8Array ? hash : new Uint8Array(hash),
+						},
+						message:
+							e instanceof Error ? e.message : "Signature verification failed",
+						cause: e,
+					});
+				},
+			});
+		}
 
-				const signatureBytes = toSignatureBytes(signature);
-				return await ContractSignature.isValidSignature(
-					providerAdapter,
-					address as any,
-					hash as any,
-					signatureBytes,
-				);
-			},
+		// Contract (EIP-1271) verification
+		const signatureBytes = yield* Effect.try({
+			try: () => toSignatureBytes(signature),
 			catch: (e) => {
 				if (e instanceof InvalidSignatureFormatError) {
 					return e;
 				}
-				if (
-					e instanceof Error &&
-					(e.name === "InvalidSignatureFormatError" ||
-						e.name === "InvalidSignatureError")
-				) {
-					return new InvalidSignatureFormatError({
-						message: e.message,
-						cause: e,
-					});
-				}
-				return new SignatureVerificationError({
-					input: {
-						address: addressStr,
-						hash: hash instanceof Uint8Array ? hash : new Uint8Array(hash),
-					},
-					message:
-						e instanceof Error ? e.message : "Signature verification failed",
+				return new InvalidSignatureFormatError({
+					message: e instanceof Error ? e.message : "Invalid signature format",
 					cause: e,
 				});
 			},
 		});
+
+		// Build EIP-1271 isValidSignature call data
+		const hashHex =
+			hash instanceof Uint8Array
+				? `0x${Buffer.from(hash).toString("hex")}`
+				: `0x${Buffer.from(hash).toString("hex")}`;
+		const sigHex = `0x${Buffer.from(signatureBytes).toString("hex")}`;
+
+		// isValidSignature(bytes32 hash, bytes signature) selector: 0x1626ba7e
+		// ABI encode: selector + hash (32 bytes) + offset to signature (32) + signature length (32) + signature data
+		const hashPadded = hashHex.slice(2).padStart(64, "0");
+		const sigOffset = "0000000000000000000000000000000000000000000000000000000000000040"; // 64 in hex
+		const sigLength = signatureBytes.length.toString(16).padStart(64, "0");
+		const sigPadded = sigHex.slice(2).padEnd(Math.ceil(signatureBytes.length / 32) * 64, "0");
+		const callData = `0x1626ba7e${hashPadded}${sigOffset}${sigLength}${sigPadded}` as `0x${string}`;
+
+		const result = yield* call({ to: addressHex, data: callData }).pipe(
+			Effect.mapError(
+				(e) =>
+					new SignatureVerificationError({
+						input: {
+							address: addressStr,
+							hash: hash instanceof Uint8Array ? hash : new Uint8Array(hash),
+						},
+						message: `EIP-1271 call failed: ${e.message}`,
+						cause: e,
+					}),
+			),
+		);
+
+		// Check if result matches EIP-1271 magic value
+		return result.toLowerCase().startsWith(EIP1271_MAGIC_VALUE);
 	});

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,
+  });