voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Address/Address.test.ts

@@ -364,3 +364,149 @@ describe("edge cases", () => {
 		expect(short.includes("...")).toBe(true);
 	});
 });
+
+describe("Effect-wrapped constructors", () => {
+	it("from succeeds with valid hex", async () => {
+		const program = Address.from("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+	});
+
+	it("from succeeds with bytes", async () => {
+		const bytes = new Uint8Array(20).fill(0xab);
+		const program = Address.from(bytes);
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+	});
+
+	it("from fails with invalid hex", async () => {
+		const program = Address.from("invalid");
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+
+	it("fromHex succeeds with valid hex", async () => {
+		const program = Address.fromHex("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+	});
+
+	it("fromHex fails on wrong length", async () => {
+		const program = Address.fromHex("0x742d35");
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+
+	it("fromBytes succeeds with 20 bytes", async () => {
+		const program = Address.fromBytes(new Uint8Array(20));
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+	});
+
+	it("fromBytes fails on wrong length", async () => {
+		const program = Address.fromBytes(new Uint8Array(19));
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+
+	it("fromNumber creates address from bigint", async () => {
+		const program = Address.fromNumber(1n);
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+		expect(addr[19]).toBe(1);
+	});
+
+	it("zero creates zero address", () => {
+		const addr = Address.zero();
+		expect(addr.length).toBe(20);
+		expect(Address.isZero(addr)).toBe(true);
+	});
+
+	it("toHex converts address to hex", () => {
+		const addr = S.decodeSync(Address.Hex)("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		const hex = Address.toHex(addr);
+		expect(hex).toBe("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+	});
+
+	it("is type guard works", () => {
+		const addr = S.decodeSync(Address.Hex)("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		expect(Address.is(addr)).toBe(true);
+		expect(Address.is("not an address")).toBe(false);
+		expect(Address.is(new Uint8Array(20))).toBe(true);
+		expect(Address.is(new Uint8Array(19))).toBe(false);
+	});
+
+	it("isAddress validates address format", () => {
+		expect(Address.isAddress("0x742d35cc6634c0532925a3b844bc9e7595f251e3")).toBe(true);
+		expect(Address.isAddress("invalid")).toBe(false);
+	});
+});
+
+describe("utility functions", () => {
+	it("sortAddresses sorts lexicographically", () => {
+		const addr1 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000001");
+		const addr2 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000002");
+		const addr3 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000003");
+
+		const sorted = Address.sortAddresses([addr3, addr1, addr2]);
+		expect(Address.equals(sorted[0], addr1)).toBe(true);
+		expect(Address.equals(sorted[1], addr2)).toBe(true);
+		expect(Address.equals(sorted[2], addr3)).toBe(true);
+	});
+
+	it("deduplicateAddresses removes duplicates", () => {
+		const addr1 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000001");
+		const addr2 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000002");
+
+		const deduped = Address.deduplicateAddresses([addr1, addr1, addr2, addr2]);
+		expect(deduped.length).toBe(2);
+	});
+});
+
+describe("assert functions", () => {
+	it("assert succeeds on valid address", async () => {
+		const program = Address.assert("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		await Effect.runPromise(program);
+	});
+
+	it("assert fails on invalid address", async () => {
+		const program = Address.assert("invalid");
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+
+	it("assert with strict mode validates checksum", async () => {
+		const program = Address.assert("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", { strict: true });
+		await Effect.runPromise(program);
+	});
+
+	it("assertBasic succeeds on valid format", async () => {
+		const program = Address.assertBasic("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		await Effect.runPromise(program);
+	});
+});
+
+describe("toChecksummed", () => {
+	it("converts to checksummed format", async () => {
+		const addr = S.decodeSync(Address.Hex)("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed");
+		const program = Address.toChecksummed(addr).pipe(Effect.provide(KeccakLive));
+		const result = await Effect.runPromise(program);
+		expect(result).toBe("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed");
+	});
+});
+
+describe("calculateCreateAddress", () => {
+	it("calculates CREATE address", async () => {
+		const deployer = S.decodeSync(Address.Hex)("0x6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0");
+		const program = Address.calculateCreateAddress(deployer, 0n);
+		const result = await Effect.runPromise(program);
+		expect(result.length).toBe(20);
+	});
+
+	it("fails on negative nonce", async () => {
+		const deployer = S.decodeSync(Address.Hex)("0x6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0");
+		const program = Address.calculateCreateAddress(deployer, -1n);
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+});

package/src/primitives/Address/assert.ts

@@ -0,0 +1,51 @@
+/**
+ * @module assert
+ * @description Assert value is valid address with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type InvalidAddressError, type InvalidChecksumError } from "@tevm/voltaire/Address";
+
+type AssertError =
+  | InvalidAddressError
+  | InvalidChecksumError;
+
+/**
+ * Assert value is valid address
+ *
+ * @param value - Value to validate
+ * @param options - Validation options
+ * @param options.strict - If true, validates EIP-55 checksum
+ * @returns Effect yielding void or failing with AssertError
+ * @example
+ * ```typescript
+ * // Basic validation
+ * const program = Address.assert('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ *
+ * // Strict checksum validation
+ * const strictProgram = Address.assert('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3', { strict: true })
+ * await Effect.runPromise(strictProgram)
+ * ```
+ */
+export const assert = (
+  value: string | Uint8Array,
+  options?: { strict?: boolean },
+): Effect.Effect<void, AssertError> =>
+  Effect.try({
+    try: () => { Address.assert(value, options); },
+    catch: (e) => e as AssertError,
+  });
+
+/**
+ * Assert value is valid address (non-strict, no checksum validation)
+ *
+ * @param value - Value to validate
+ * @returns Effect yielding void or failing with InvalidAddressError
+ */
+export const assertBasic = (
+  value: string | Uint8Array,
+): Effect.Effect<void, InvalidAddressError> =>
+  Effect.try({
+    try: () => { Address.assert(value, { strict: false }); },
+    catch: (e) => e as InvalidAddressError,
+  });

package/src/primitives/Address/calculateCreate2Address.ts

@@ -0,0 +1,33 @@
+/**
+ * @module calculateCreate2Address
+ * @description Calculate CREATE2 contract deployment address with Effect
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type { HashType } from "@tevm/voltaire/Hash";
+
+/**
+ * Calculate CREATE2 contract deployment address
+ *
+ * Formula: keccak256(0xff ++ sender ++ salt ++ keccak256(initCode))[12:32]
+ *
+ * @param address - Deployer address
+ * @param salt - 32-byte salt value
+ * @param initCode - Contract initialization bytecode (Uint8Array)
+ * @returns Effect yielding the contract address that would be created
+ * @example
+ * ```typescript
+ * const program = Address.calculateCreate2Address(deployerAddr, salt, initCode)
+ * const contractAddr = await Effect.runPromise(program)
+ * ```
+ */
+export const calculateCreate2Address = (
+  address: AddressType,
+  salt: HashType,
+  initCode: Uint8Array,
+): Effect.Effect<AddressType, Error> =>
+  Effect.try({
+    try: () => Address.calculateCreate2Address(address, salt, initCode as Parameters<typeof Address.calculateCreate2Address>[2]),
+    catch: (e) => e as Error,
+  });

package/src/primitives/Address/calculateCreateAddress.ts

@@ -0,0 +1,30 @@
+/**
+ * @module calculateCreateAddress
+ * @description Calculate CREATE contract deployment address with Effect
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType, type InvalidValueError } from "@tevm/voltaire/Address";
+
+/**
+ * Calculate CREATE contract deployment address
+ *
+ * Formula: keccak256(rlp([sender, nonce]))[12:32]
+ *
+ * @param address - Deployer address
+ * @param nonce - Transaction nonce
+ * @returns Effect yielding the contract address that would be created
+ * @example
+ * ```typescript
+ * const program = Address.calculateCreateAddress(deployerAddr, 0n)
+ * const contractAddr = await Effect.runPromise(program)
+ * ```
+ */
+export const calculateCreateAddress = (
+  address: AddressType,
+  nonce: bigint,
+): Effect.Effect<AddressType, InvalidValueError> =>
+  Effect.try({
+    try: () => Address.calculateCreateAddress(address, nonce),
+    catch: (e) => e as InvalidValueError,
+  });

package/src/primitives/Address/deduplicateAddresses.ts

@@ -0,0 +1,20 @@
+/**
+ * @module deduplicateAddresses
+ * @description Remove duplicate addresses from array
+ * @since 0.1.0
+ */
+import { deduplicateAddresses as voltaireDeduplicateAddresses, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Remove duplicate addresses from array
+ *
+ * @param addresses - Array with potential duplicates
+ * @returns New array with duplicates removed
+ * @example
+ * ```typescript
+ * const unique = Address.deduplicateAddresses([addr1, addr1, addr2])
+ * // [addr1, addr2]
+ * ```
+ */
+export const deduplicateAddresses = (addresses: AddressType[]): AddressType[] =>
+  voltaireDeduplicateAddresses(addresses);

package/src/primitives/Address/from.ts

@@ -0,0 +1,41 @@
+/**
+ * @module from
+ * @description Create Address from various input types with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type {
+  InvalidAddressError,
+  InvalidHexFormatError,
+  InvalidAddressLengthError,
+  InvalidValueError,
+} from "@tevm/voltaire/Address";
+
+type AddressError =
+  | InvalidAddressError
+  | InvalidHexFormatError
+  | InvalidAddressLengthError
+  | InvalidValueError;
+
+/**
+ * Create Address from hex string, bytes, or number
+ *
+ * @param value - Hex string, Uint8Array, number, or bigint
+ * @returns Effect yielding AddressType or failing with AddressError
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Address.from('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ * const addr = await Effect.runPromise(program)
+ * ```
+ */
+export const from = (
+  value: string | Uint8Array | number | bigint,
+): Effect.Effect<AddressType, AddressError> =>
+  Effect.try({
+    try: () => Address.from(value),
+    catch: (e) => e as AddressError,
+  });

package/src/primitives/Address/fromAbiEncoded.ts

@@ -0,0 +1,35 @@
+/**
+ * @module fromAbiEncoded
+ * @description Create Address from ABI-encoded bytes with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type {
+  InvalidAddressLengthError,
+  InvalidAbiEncodedPaddingError,
+} from "@tevm/voltaire/Address";
+
+type AbiEncodedError =
+  | InvalidAddressLengthError
+  | InvalidAbiEncodedPaddingError;
+
+/**
+ * Create Address from ABI-encoded bytes (32 bytes, left-padded)
+ *
+ * @param value - 32-byte ABI-encoded address
+ * @returns Effect yielding AddressType or failing with error
+ * @example
+ * ```typescript
+ * const abiEncoded = new Uint8Array(32)
+ * abiEncoded.set(addressBytes, 12) // left-pad with 12 zeros
+ * const program = Address.fromAbiEncoded(abiEncoded)
+ * ```
+ */
+export const fromAbiEncoded = (
+  value: Uint8Array,
+): Effect.Effect<AddressType, AbiEncodedError> =>
+  Effect.try({
+    try: () => Address.fromAbiEncoded(value),
+    catch: (e) => e as AbiEncodedError,
+  });

package/src/primitives/Address/fromBase64.ts

@@ -0,0 +1,25 @@
+/**
+ * @module fromBase64
+ * @description Create Address from base64 string with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType, type InvalidAddressLengthError } from "@tevm/voltaire/Address";
+
+/**
+ * Create Address from base64 encoded string
+ *
+ * @param value - Base64 string (must decode to 20 bytes)
+ * @returns Effect yielding AddressType or failing with InvalidAddressLengthError
+ * @example
+ * ```typescript
+ * const program = Address.fromBase64('dC01zGY0wFMpJaO4RLyeZV8lHuM=')
+ * ```
+ */
+export const fromBase64 = (
+  value: string,
+): Effect.Effect<AddressType, InvalidAddressLengthError> =>
+  Effect.try({
+    try: () => Address.fromBase64(value),
+    catch: (e) => e as InvalidAddressLengthError,
+  });

package/src/primitives/Address/fromBytes.ts

@@ -0,0 +1,25 @@
+/**
+ * @module fromBytes
+ * @description Create Address from Uint8Array with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType, type InvalidAddressLengthError } from "@tevm/voltaire/Address";
+
+/**
+ * Create Address from 20-byte Uint8Array
+ *
+ * @param value - 20-byte Uint8Array
+ * @returns Effect yielding AddressType or failing with InvalidAddressLengthError
+ * @example
+ * ```typescript
+ * const program = Address.fromBytes(new Uint8Array(20))
+ * ```
+ */
+export const fromBytes = (
+  value: Uint8Array,
+): Effect.Effect<AddressType, InvalidAddressLengthError> =>
+  Effect.try({
+    try: () => Address.fromBytes(value),
+    catch: (e) => e as InvalidAddressLengthError,
+  });

package/src/primitives/Address/fromHex.ts

@@ -0,0 +1,31 @@
+/**
+ * @module fromHex
+ * @description Create Address from hex string with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type {
+  InvalidHexFormatError,
+  InvalidAddressLengthError,
+} from "@tevm/voltaire/Address";
+
+type AddressError =
+  | InvalidHexFormatError
+  | InvalidAddressLengthError;
+
+/**
+ * Create Address from hex string
+ *
+ * @param value - Hex string with 0x prefix
+ * @returns Effect yielding AddressType or failing with AddressError
+ * @example
+ * ```typescript
+ * const program = Address.fromHex('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ * ```
+ */
+export const fromHex = (value: string): Effect.Effect<AddressType, AddressError> =>
+  Effect.try({
+    try: () => Address.fromHex(value),
+    catch: (e) => e as AddressError,
+  });

package/src/primitives/Address/fromNumber.ts

@@ -0,0 +1,25 @@
+/**
+ * @module fromNumber
+ * @description Create Address from number or bigint with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType, type InvalidValueError } from "@tevm/voltaire/Address";
+
+/**
+ * Create Address from number or bigint
+ *
+ * @param value - Number or bigint (will be left-padded to 20 bytes)
+ * @returns Effect yielding AddressType or failing with InvalidValueError
+ * @example
+ * ```typescript
+ * const program = Address.fromNumber(1n) // 0x0000...0001
+ * ```
+ */
+export const fromNumber = (
+  value: number | bigint,
+): Effect.Effect<AddressType, InvalidValueError> =>
+  Effect.try({
+    try: () => Address.fromNumber(value),
+    catch: (e) => e as InvalidValueError,
+  });

package/src/primitives/Address/fromPrivateKey.ts

@@ -0,0 +1,25 @@
+/**
+ * @module fromPrivateKey
+ * @description Derive Address from secp256k1 private key with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType, type InvalidValueError } from "@tevm/voltaire/Address";
+
+/**
+ * Create Address from secp256k1 private key
+ *
+ * @param value - 32-byte private key
+ * @returns Effect yielding AddressType or failing with InvalidValueError
+ * @example
+ * ```typescript
+ * const program = Address.fromPrivateKey(privateKeyBytes)
+ * ```
+ */
+export const fromPrivateKey = (
+  value: Uint8Array,
+): Effect.Effect<AddressType, InvalidValueError> =>
+  Effect.try({
+    try: () => Address.fromPrivateKey(value),
+    catch: (e) => e as InvalidValueError,
+  });

package/src/primitives/Address/fromPublicKey.ts

@@ -0,0 +1,56 @@
+/**
+ * @module fromPublicKey
+ * @description Derive Address from secp256k1 public key with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type {
+  InvalidAddressLengthError,
+  InvalidValueError,
+} from "@tevm/voltaire/Address";
+
+type PublicKeyError =
+  | InvalidAddressLengthError
+  | InvalidValueError;
+
+/**
+ * Create Address from secp256k1 public key
+ *
+ * @param publicKey - 64-byte uncompressed public key
+ * @returns Effect yielding AddressType or failing with error
+ * @example
+ * ```typescript
+ * const program = Address.fromPublicKey(publicKeyBytes)
+ * ```
+ */
+export function fromPublicKey(
+  publicKey: Uint8Array,
+): Effect.Effect<AddressType, PublicKeyError>;
+
+/**
+ * Create Address from secp256k1 public key coordinates
+ *
+ * @param x - x coordinate (bigint)
+ * @param y - y coordinate (bigint)
+ * @returns Effect yielding AddressType or failing with error
+ */
+export function fromPublicKey(
+  x: bigint,
+  y: bigint,
+): Effect.Effect<AddressType, PublicKeyError>;
+
+export function fromPublicKey(
+  xOrPublicKey: bigint | Uint8Array,
+  y?: bigint,
+): Effect.Effect<AddressType, PublicKeyError> {
+  return Effect.try({
+    try: () => {
+      if (typeof xOrPublicKey === "bigint") {
+        return Address.fromPublicKey(xOrPublicKey, y!);
+      }
+      return Address.fromPublicKey(xOrPublicKey);
+    },
+    catch: (e) => e as PublicKeyError,
+  });
+}