voltaire-effect 0.2.23

package/src/primitives/Address/greaterThan.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Address greater-than comparison.
+ * @module greaterThan
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Checks if first address is greater than second.
+ *
+ * @param a - First address
+ * @param b - Second address
+ * @returns true if a > b
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const a = S.decodeSync(Address.Hex)('0x0000000000000000000000000000000000000002')
+ * const b = S.decodeSync(Address.Hex)('0x0000000000000000000000000000000000000001')
+ * Address.greaterThan(a, b) // true
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const greaterThan = (a: AddressType, b: AddressType): boolean =>
+	Address.greaterThan(a, b);

package/src/primitives/Address/index.ts

@@ -0,0 +1,89 @@
+/**
+ * @module Address
+ * @description Effect Schemas for Ethereum addresses with EIP-55 checksum support.
+ *
+ * ## Type Declarations
+ *
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ *
+ * function transfer(to: Address.AddressType, amount: bigint) {
+ *   // ...
+ * }
+ * ```
+ *
+ * ## Schemas
+ *
+ * | Schema | Input | Output | Description |
+ * |--------|-------|--------|-------------|
+ * | `Address.Hex` | hex string | AddressType | Decodes any hex, encodes to lowercase |
+ * | `Address.Checksummed` | checksummed string | AddressType | Validates checksum on decode, requires KeccakService for encode |
+ * | `Address.Bytes` | Uint8Array | AddressType | 20-byte array conversion |
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * // Decode (parse input)
+ * const addr = S.decodeSync(Address.Hex)('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3')
+ *
+ * // Encode (format output)
+ * const hex = S.encodeSync(Address.Hex)(addr)
+ * // "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
+ *
+ * // Checksummed encoding (requires KeccakService)
+ * import * as Effect from 'effect/Effect'
+ * import { KeccakLive } from 'voltaire-effect/crypto/Keccak256'
+ *
+ * const program = S.encode(Address.Checksummed)(addr)
+ * const checksummed = await Effect.runPromise(program.pipe(Effect.provide(KeccakLive)))
+ * // "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"
+ * ```
+ *
+ * ## Pure Functions
+ *
+ * ```typescript
+ * Address.equals(a, b)     // boolean
+ * Address.compare(a, b)    // -1 | 0 | 1
+ * Address.isZero(addr)     // boolean
+ * Address.lessThan(a, b)   // boolean
+ * Address.greaterThan(a, b) // boolean
+ * Address.isValid(value)   // boolean
+ * Address.isValidChecksum(str) // boolean
+ * Address.clone(addr)      // AddressType
+ * Address.toBytes(addr)    // Uint8Array
+ * Address.toU256(addr)     // Uint256Type (U256)
+ * Address.toShortHex(addr) // string (e.g., "0x742d...51e3")
+ * Address.toLowercase(addr) // Lowercase address hex
+ * Address.toUppercase(addr) // Uppercase address hex
+ * Address.toAbiEncoded(addr) // Uint8Array (32 bytes)
+ * ```
+ *
+ * @since 0.1.0
+ */
+
+// Re-export AddressType from voltaire
+export type { AddressType } from "@tevm/voltaire/Address";
+export { AddressTypeSchema } from "./AddressSchema.js";
+// Schemas
+export { Bytes } from "./Bytes.js";
+export { Checksummed } from "./Checksummed.js";
+
+// Pure functions
+export { clone } from "./clone.js";
+export { compare } from "./compare.js";
+export { equals } from "./equals.js";
+export { greaterThan } from "./greaterThan.js";
+export { Hex } from "./Hex.js";
+export { isValid } from "./isValid.js";
+export { isValidChecksum } from "./isValidChecksum.js";
+export { isZero } from "./isZero.js";
+export { lessThan } from "./lessThan.js";
+export { toAbiEncoded } from "./toAbiEncoded.js";
+export { toBytes } from "./toBytes.js";
+export { toLowercase } from "./toLowercase.js";
+export { toShortHex } from "./toShortHex.js";
+export { toU256 } from "./toU256.js";
+export { toUppercase } from "./toUppercase.js";

package/src/primitives/Address/isValid.ts

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Address validity check.
+ * @module isValid
+ * @since 0.1.0
+ */
+
+import { Address } from "@tevm/voltaire/Address";
+
+/**
+ * Checks if a value is a valid Ethereum address string.
+ *
+ * @param value - The value to check
+ * @returns true if the value is a valid address string
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ *
+ * Address.isValid('0x742d35cc6634c0532925a3b844bc9e7595f251e3') // true
+ * Address.isValid('invalid') // false
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const isValid = (value: string | Uint8Array): boolean =>
+	Address.isValid(value);

package/src/primitives/Address/isValidChecksum.ts

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview EIP-55 checksum validation.
+ * @module isValidChecksum
+ * @since 0.1.0
+ */
+
+import { Address } from "@tevm/voltaire/Address";
+
+/**
+ * Checks if a string has valid EIP-55 checksum.
+ *
+ * @param value - Hex string to validate
+ * @returns true if the checksum is valid
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ *
+ * Address.isValidChecksum('0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed') // true
+ * Address.isValidChecksum('0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed') // false
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const isValidChecksum = (value: string): boolean =>
+	Address.isValidChecksum(value);

package/src/primitives/Address/isZero.ts

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Zero address check.
+ * @module isZero
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Checks if an Address is the zero address (0x0000...0000).
+ *
+ * @param addr - The address to check
+ * @returns true if the address is zero
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const zero = S.decodeSync(Address.Hex)('0x0000000000000000000000000000000000000000')
+ * Address.isZero(zero) // true
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const isZero = (addr: AddressType): boolean => Address.isZero(addr);

package/src/primitives/Address/lessThan.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Address less-than comparison.
+ * @module lessThan
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Checks if first address is less than second.
+ *
+ * @param a - First address
+ * @param b - Second address
+ * @returns true if a < b
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const a = S.decodeSync(Address.Hex)('0x0000000000000000000000000000000000000001')
+ * const b = S.decodeSync(Address.Hex)('0x0000000000000000000000000000000000000002')
+ * Address.lessThan(a, b) // true
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const lessThan = (a: AddressType, b: AddressType): boolean =>
+	Address.lessThan(a, b);

package/src/primitives/Address/toAbiEncoded.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Address to ABI-encoded bytes conversion.
+ * @module toAbiEncoded
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Converts an Address to ABI-encoded bytes (32-byte left-padded).
+ *
+ * @param addr - The address to convert
+ * @returns 32-byte Uint8Array with address in last 20 bytes
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const addr = S.decodeSync(Address.Hex)('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ * const encoded = Address.toAbiEncoded(addr)
+ * // Uint8Array(32) with 12 zero bytes + 20 address bytes
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toAbiEncoded = (addr: AddressType): Uint8Array =>
+	Address.toAbiEncoded(addr);

package/src/primitives/Address/toBytes.ts

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Address to bytes conversion.
+ * @module toBytes
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Converts an Address to its 20-byte representation.
+ *
+ * @param addr - The AddressType to convert
+ * @returns A 20-byte Uint8Array
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const addr = S.decodeSync(Address.Hex)('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ * const bytes = Address.toBytes(addr) // Uint8Array(20)
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toBytes = (addr: AddressType): Uint8Array => Address.toBytes(addr);

package/src/primitives/Address/toLowercase.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Address to lowercase hex conversion.
+ * @module toLowercase
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Converts an Address to lowercase hex string.
+ *
+ * @param addr - The address to convert
+ * @returns Lowercase hex string with "0x" prefix
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const addr = S.decodeSync(Address.Hex)('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3')
+ * Address.toLowercase(addr) // "0x742d35cc6634c0532925a3b844bc9e7595f251e3"
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toLowercase = (
+	addr: AddressType,
+): ReturnType<typeof Address.toLowercase> => Address.toLowercase(addr);

package/src/primitives/Address/toShortHex.ts

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Address to short hex conversion.
+ * @module toShortHex
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Converts an Address to shortened hex format (e.g., "0x742d...51e3").
+ *
+ * @param addr - The address to convert
+ * @returns Shortened hex string
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const addr = S.decodeSync(Address.Hex)('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ * Address.toShortHex(addr) // "0x742d...51e3"
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toShortHex = (addr: AddressType): string =>
+	Address.toShortHex(addr);

package/src/primitives/Address/toU256.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Address to U256 conversion.
+ * @module toU256
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import { Uint256, type Type as Uint256Type } from "@tevm/voltaire/Uint";
+
+/**
+ * Converts an Address to a Uint256.
+ *
+ * @param addr - The address to convert
+ * @returns The Uint256 representation of the address
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const addr = S.decodeSync(Address.Hex)('0x0000000000000000000000000000000000000001')
+ * Address.toU256(addr) // 1n
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toU256 = (addr: AddressType): Uint256Type =>
+	Uint256.fromBigInt(Address.toU256(addr));

package/src/primitives/Address/toUppercase.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Address to uppercase hex conversion.
+ * @module toUppercase
+ * @since 0.1.0
+ */
+
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Converts an Address to uppercase hex string.
+ *
+ * @param addr - The address to convert
+ * @returns Uppercase hex string with "0x" prefix
+ *
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as S from 'effect/Schema'
+ *
+ * const addr = S.decodeSync(Address.Hex)('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ * Address.toUppercase(addr) // "0X742D35CC6634C0532925A3B844BC9E7595F251E3"
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toUppercase = (
+	addr: AddressType,
+): ReturnType<typeof Address.toUppercase> => Address.toUppercase(addr);

package/src/primitives/Authorization/Rpc.ts

@@ -0,0 +1,148 @@
+/**
+ * Schema for EIP-7702 Authorization tuples in JSON-RPC format.
+ *
+ * @description
+ * Transforms JSON-compatible authorization input into the branded
+ * `AuthorizationType` with proper bigint and Uint8Array field types.
+ *
+ * @example Decoding
+ * ```typescript
+ * import * as Authorization from 'voltaire-effect/primitives/Authorization'
+ * import * as S from 'effect/Schema'
+ *
+ * const auth = S.decodeSync(Authorization.Rpc)({
+ *   chainId: '1',
+ *   address: '0x742d35Cc6634C0532925a3b844Bc9e7595f251e3',
+ *   nonce: '0',
+ *   yParity: 0,
+ *   r: '0x...',
+ *   s: '0x...'
+ * })
+ * ```
+ *
+ * @example Encoding
+ * ```typescript
+ * const json = S.encodeSync(Authorization.Rpc)(auth)
+ * ```
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-7702
+ * @module Authorization/Rpc
+ * @since 0.1.0
+ */
+
+import {
+	Authorization,
+	type AuthorizationType,
+} from "@tevm/voltaire/Authorization";
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+
+/**
+ * Raw authorization input type (JSON-compatible).
+ * @since 0.1.0
+ */
+export type AuthorizationInput = {
+	chainId: string | number | bigint;
+	address: string;
+	nonce: string | number | bigint;
+	yParity: number;
+	r: string;
+	s: string;
+};
+
+const AuthorizationTypeSchema = S.declare<AuthorizationType>(
+	(u): u is AuthorizationType => {
+		if (typeof u !== "object" || u === null) return false;
+		const auth = u as Record<string, unknown>;
+		return (
+			typeof auth.chainId === "bigint" &&
+			auth.address instanceof Uint8Array &&
+			typeof auth.nonce === "bigint" &&
+			typeof auth.yParity === "number" &&
+			auth.r instanceof Uint8Array &&
+			auth.s instanceof Uint8Array
+		);
+	},
+	{ identifier: "Authorization" },
+);
+
+const AuthorizationInputSchema = S.Struct({
+	chainId: S.Union(S.String, S.Number, S.BigIntFromSelf),
+	address: S.String,
+	nonce: S.Union(S.String, S.Number, S.BigIntFromSelf),
+	yParity: S.Number,
+	r: S.String,
+	s: S.String,
+});
+
+/**
+ * Schema for EIP-7702 Authorization tuples in JSON-RPC format.
+ *
+ * @since 0.1.0
+ */
+export const Rpc: S.Schema<AuthorizationType, AuthorizationInput> =
+	S.transformOrFail(AuthorizationInputSchema, AuthorizationTypeSchema, {
+		strict: true,
+		decode: (input, _options, ast) => {
+			try {
+				const auth: AuthorizationType = {
+					chainId: toBigInt(input.chainId),
+					address: hexToBytes(
+						input.address,
+						20,
+					) as AuthorizationType["address"],
+					nonce: toBigInt(input.nonce),
+					yParity: input.yParity,
+					r: hexToBytes(input.r, 32),
+					s: hexToBytes(input.s, 32),
+				};
+				Authorization.validate(auth);
+				return ParseResult.succeed(auth);
+			} catch (e) {
+				return ParseResult.fail(
+					new ParseResult.Type(ast, input, (e as Error).message),
+				);
+			}
+		},
+		encode: (auth) => {
+			const result: AuthorizationInput = {
+				chainId: auth.chainId.toString(),
+				address: toHexString(auth.address),
+				nonce: auth.nonce.toString(),
+				yParity: auth.yParity,
+				r: toHexString(auth.r),
+				s: toHexString(auth.s),
+			};
+			return ParseResult.succeed(result);
+		},
+	}).annotations({ identifier: "Authorization.Rpc" });
+
+function toBigInt(value: string | number | bigint): bigint {
+	if (typeof value === "bigint") return value;
+	if (typeof value === "number") return BigInt(value);
+	if (value.startsWith("0x")) return BigInt(value);
+	return BigInt(value);
+}
+
+function hexToBytes(hex: string, expectedLength: number): Uint8Array {
+	const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+	if (cleanHex.length !== expectedLength * 2) {
+		throw new Error(
+			`Expected ${expectedLength} bytes, got ${cleanHex.length / 2}`,
+		);
+	}
+	const bytes = new Uint8Array(expectedLength);
+	for (let i = 0; i < expectedLength; i++) {
+		bytes[i] = parseInt(cleanHex.slice(i * 2, i * 2 + 2), 16);
+	}
+	return bytes;
+}
+
+function toHexString(bytes: Uint8Array): string {
+	return (
+		"0x" +
+		Array.from(bytes)
+			.map((b) => b.toString(16).padStart(2, "0"))
+			.join("")
+	);
+}

package/src/primitives/Authorization/index.ts

@@ -0,0 +1,38 @@
+/**
+ * @module Authorization
+ * @description Effect Schemas for EIP-7702 authorization tuples.
+ *
+ * EIP-7702 enables EOAs to delegate execution to smart contracts,
+ * bringing account abstraction features to existing EOAs.
+ *
+ * ## Schemas
+ *
+ * | Schema | Input | Output |
+ * |--------|-------|--------|
+ * | `Authorization.Rpc` | JSON-RPC format | AuthorizationType |
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import * as Authorization from 'voltaire-effect/primitives/Authorization'
+ * import * as S from 'effect/Schema'
+ *
+ * // Decode from JSON-RPC format
+ * const auth = S.decodeSync(Authorization.Rpc)({
+ *   chainId: '1',
+ *   address: '0x742d35Cc6634C0532925a3b844Bc9e7595f251e3',
+ *   nonce: '0',
+ *   yParity: 0,
+ *   r: '0x...',
+ *   s: '0x...'
+ * })
+ *
+ * // Encode back to JSON-RPC format
+ * const json = S.encodeSync(Authorization.Rpc)(auth)
+ * ```
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-7702
+ * @since 0.1.0
+ */
+
+export { type AuthorizationInput, Rpc } from "./Rpc.js";

package/src/primitives/Balance/BigInt.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Schema for Balance from bigint.
+ * @module Balance/BigInt
+ * @since 0.1.0
+ */
+
+import { Uint } from "@tevm/voltaire";
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+
+export type BalanceType = bigint & { readonly __tag: "Balance" };
+
+const BalanceTypeSchema = S.declare<BalanceType>(
+	(u): u is BalanceType => typeof u === "bigint" && u >= 0n,
+	{ identifier: "Balance" },
+);
+
+/**
+ * Schema for Balance from bigint.
+ *
+ * @example
+ * ```typescript
+ * import * as Balance from 'voltaire-effect/primitives/Balance'
+ * import * as S from 'effect/Schema'
+ *
+ * const balance = S.decodeSync(Balance.BigInt)(1000000000000000000n) // 1 ETH
+ * const encoded = S.encodeSync(Balance.BigInt)(balance) // 1000000000000000000n
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const BigInt: S.Schema<BalanceType, bigint> = S.transformOrFail(
+	S.BigIntFromSelf,
+	BalanceTypeSchema,
+	{
+		strict: true,
+		decode: (value, _options, ast) => {
+			try {
+				return ParseResult.succeed(Uint.from(value) as unknown as BalanceType);
+			} catch (e) {
+				return ParseResult.fail(
+					new ParseResult.Type(ast, value, (e as Error).message),
+				);
+			}
+		},
+		encode: (balance) => ParseResult.succeed(balance as bigint),
+	},
+).annotations({ identifier: "Balance.BigInt" });

package/src/primitives/Balance/Number.ts

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Schema for Balance from number.
+ * @module Balance/Number
+ * @since 0.1.0
+ */
+
+import { Uint } from "@tevm/voltaire";
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+import type { BalanceType } from "./BigInt.js";
+
+const BalanceTypeSchema = S.declare<BalanceType>(
+	(u): u is BalanceType => typeof u === "bigint" && u >= 0n,
+	{ identifier: "Balance" },
+);
+
+/**
+ * Schema for Balance from number.
+ *
+ * @example
+ * ```typescript
+ * import * as Balance from 'voltaire-effect/primitives/Balance'
+ * import * as S from 'effect/Schema'
+ *
+ * const balance = S.decodeSync(Balance.Number)(1000000)
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const Number: S.Schema<BalanceType, number> = S.transformOrFail(
+	S.Number,
+	BalanceTypeSchema,
+	{
+		strict: true,
+		decode: (value, _options, ast) => {
+			try {
+				return ParseResult.succeed(Uint.from(value) as unknown as BalanceType);
+			} catch (e) {
+				return ParseResult.fail(
+					new ParseResult.Type(ast, value, (e as Error).message),
+				);
+			}
+		},
+		encode: (balance) => ParseResult.succeed(globalThis.Number(balance)),
+	},
+).annotations({ identifier: "Balance.Number" });