voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Transaction/index.ts

@@ -48,7 +48,7 @@
  *
  * ```typescript
  * Transaction.hash(tx)              // HashType
- * Transaction.signingHash(tx)       // HashType
+ * Transaction.getSigningHash(tx)    // HashType
  * Transaction.getSender(tx)         // AddressType
  * Transaction.getRecipient(tx)      // AddressType | null
  * Transaction.getChainId(tx)        // bigint | null
@@ -58,11 +58,44 @@
  * Transaction.detectType(bytes)     // Type
  * ```
  *
+ * ## Type Guards
+ *
+ * ```typescript
+ * Transaction.isLegacy(tx)          // tx is Legacy
+ * Transaction.isEIP1559(tx)         // tx is EIP1559
+ * Transaction.isEIP2930(tx)         // tx is EIP2930
+ * Transaction.isEIP4844(tx)         // tx is EIP4844
+ * Transaction.isEIP7702(tx)         // tx is EIP7702
+ * ```
+ *
+ * ## Effect-Returning Functions (Validation)
+ *
+ * ```typescript
+ * Transaction.assertSigned(tx)      // Effect<void, UnsignedTransactionError>
+ * Transaction.verifySignature(tx)   // Effect<boolean, InvalidSignatureError>
+ * Transaction.validateChainId(tx)   // Effect<void, InvalidChainIdError>
+ * Transaction.validateGasLimit(tx)  // Effect<void, InvalidGasLimitError>
+ * Transaction.validateGasPrice(tx)  // Effect<void, InvalidGasPriceError>
+ * Transaction.validateNonce(tx)     // Effect<void, InvalidNonceError>
+ * Transaction.validateValue(tx)     // Effect<void, InvalidValueError>
+ * ```
+ *
+ * ## Mutation (returns new transaction)
+ *
+ * ```typescript
+ * Transaction.withNonce(tx, nonce)     // Any
+ * Transaction.withGasLimit(tx, limit)  // Any
+ * Transaction.withGasPrice(tx, price)  // Any
+ * Transaction.withData(tx, data)       // Any
+ * Transaction.replaceWith(tx, opts)    // Any
+ * ```
+ *
  * @since 0.1.0
  */
 import type { AddressType } from "@tevm/voltaire/Address";
 import type { HashType } from "@tevm/voltaire/Hash";
 import * as VoltaireTransaction from "@tevm/voltaire/Transaction";
+import * as Effect from "effect/Effect";
 
 /**
  * Union type of all supported Ethereum transaction types.
@@ -148,6 +181,15 @@ export {
 	Schema,
 } from "./TransactionSchema.js";
 
+// Re-export types from voltaire
+export type {
+	AccessList,
+	AccessListItem,
+	AuthorizationList,
+	ReplaceOptions,
+	VersionedHash,
+} from "@tevm/voltaire/Transaction";
+
 // Pure functions
 
 /**
@@ -168,9 +210,14 @@ export const hash = (tx: Any): HashType => VoltaireTransaction.hash(tx);
  *
  * @since 0.1.0
  */
-export const signingHash = (tx: Any): HashType =>
+export const getSigningHash = (tx: Any): HashType =>
 	VoltaireTransaction.getSigningHash(tx);
 
+/**
+ * @deprecated Use getSigningHash instead
+ */
+export const signingHash = getSigningHash;
+
 /**
  * Recovers the sender address from the transaction signature.
  *
@@ -287,3 +334,421 @@ export const isSigned = (tx: Any): boolean => VoltaireTransaction.isSigned(tx);
  */
 export const detectType = (data: Uint8Array): VoltaireTransaction.Type =>
 	VoltaireTransaction.detectType(data);
+
+/**
+ * Checks if transaction is a contract call.
+ *
+ * @param tx - Transaction object
+ * @returns true if to is set and data is non-empty
+ *
+ * @since 0.1.0
+ */
+export const isContractCall = (tx: Any): boolean =>
+	VoltaireTransaction.isContractCall(tx);
+
+/**
+ * Checks if transaction has an access list.
+ *
+ * @param tx - Transaction object
+ * @returns true if transaction type supports and has access list
+ *
+ * @since 0.1.0
+ */
+export const hasAccessList = (tx: Any): boolean =>
+	VoltaireTransaction.hasAccessList(tx);
+
+/**
+ * Gets the access list from transaction.
+ *
+ * @param tx - Transaction object
+ * @returns Access list (empty array for legacy transactions)
+ *
+ * @since 0.1.0
+ */
+export const getAccessList = (
+	tx: Any,
+): VoltaireTransaction.AccessList => VoltaireTransaction.getAccessList(tx);
+
+/**
+ * Gets blob count for EIP-4844 transactions.
+ *
+ * @param tx - EIP-4844 transaction
+ * @returns Number of blobs
+ *
+ * @since 0.1.0
+ */
+export const getBlobCount = (tx: EIP4844): number =>
+	VoltaireTransaction.getBlobCount(tx);
+
+/**
+ * Gets blob versioned hashes for EIP-4844 transactions.
+ *
+ * @param tx - EIP-4844 transaction
+ * @returns Array of versioned hashes
+ *
+ * @since 0.1.0
+ */
+export const getBlobVersionedHashes = (
+	tx: EIP4844,
+): readonly VoltaireTransaction.VersionedHash[] =>
+	VoltaireTransaction.getBlobVersionedHashes(tx);
+
+/**
+ * Gets authorization count for EIP-7702 transactions.
+ *
+ * @param tx - EIP-7702 transaction
+ * @returns Number of authorizations
+ *
+ * @since 0.1.0
+ */
+export const getAuthorizationCount = (tx: EIP7702): number =>
+	VoltaireTransaction.getAuthorizationCount(tx);
+
+/**
+ * Gets authorization list for EIP-7702 transactions.
+ *
+ * @param tx - EIP-7702 transaction
+ * @returns Authorization list
+ *
+ * @since 0.1.0
+ */
+export const getAuthorizations = (
+	tx: EIP7702,
+): VoltaireTransaction.AuthorizationList =>
+	VoltaireTransaction.getAuthorizations(tx);
+
+// Type Guards
+
+/**
+ * Type guard for Legacy transactions.
+ *
+ * @param tx - Transaction object
+ * @returns true if Legacy type
+ *
+ * @since 0.1.0
+ */
+export const isLegacy = (tx: Any): tx is Legacy =>
+	VoltaireTransaction.isLegacy(tx);
+
+/**
+ * Type guard for EIP-2930 transactions.
+ *
+ * @param tx - Transaction object
+ * @returns true if EIP-2930 type
+ *
+ * @since 0.1.0
+ */
+export const isEIP2930 = (tx: Any): tx is EIP2930 =>
+	VoltaireTransaction.isEIP2930(tx);
+
+/**
+ * Type guard for EIP-1559 transactions.
+ *
+ * @param tx - Transaction object
+ * @returns true if EIP-1559 type
+ *
+ * @since 0.1.0
+ */
+export const isEIP1559 = (tx: Any): tx is EIP1559 =>
+	VoltaireTransaction.isEIP1559(tx);
+
+/**
+ * Type guard for EIP-4844 transactions.
+ *
+ * @param tx - Transaction object
+ * @returns true if EIP-4844 type
+ *
+ * @since 0.1.0
+ */
+export const isEIP4844 = (tx: Any): tx is EIP4844 =>
+	VoltaireTransaction.isEIP4844(tx);
+
+/**
+ * Type guard for EIP-7702 transactions.
+ *
+ * @param tx - Transaction object
+ * @returns true if EIP-7702 type
+ *
+ * @since 0.1.0
+ */
+export const isEIP7702 = (tx: Any): tx is EIP7702 =>
+	VoltaireTransaction.isEIP7702(tx);
+
+// Mutation functions (return new transaction)
+
+/**
+ * Returns new transaction with updated nonce.
+ *
+ * @param tx - Transaction object
+ * @param nonce - New nonce value
+ * @returns New transaction with updated nonce
+ *
+ * @since 0.1.0
+ */
+export const withNonce = (tx: Any, nonce: bigint): Any =>
+	VoltaireTransaction.withNonce(tx, nonce);
+
+/**
+ * Returns new transaction with updated gas limit.
+ *
+ * @param tx - Transaction object
+ * @param gasLimit - New gas limit
+ * @returns New transaction with updated gas limit
+ *
+ * @since 0.1.0
+ */
+export const withGasLimit = (tx: Any, gasLimit: bigint): Any =>
+	VoltaireTransaction.withGasLimit(tx, gasLimit);
+
+/**
+ * Returns new transaction with updated gas price.
+ *
+ * @param tx - Transaction object
+ * @param gasPrice - New gas price
+ * @returns New transaction with updated gas price
+ *
+ * @since 0.1.0
+ */
+export const withGasPrice = (tx: Any, gasPrice: bigint): Any =>
+	VoltaireTransaction.withGasPrice(tx, gasPrice);
+
+/**
+ * Returns new transaction with updated data.
+ *
+ * @param tx - Transaction object
+ * @param data - New data
+ * @returns New transaction with updated data
+ *
+ * @since 0.1.0
+ */
+export const withData = (tx: Any, data: Uint8Array): Any =>
+	VoltaireTransaction.withData(tx, data);
+
+/**
+ * Returns new transaction with fee bump for replacement.
+ *
+ * @param tx - Transaction object
+ * @param options - Replace options (fee bump percentage)
+ * @returns New transaction suitable for replacement
+ *
+ * @since 0.1.0
+ */
+export const replaceWith = (
+	tx: Any,
+	options?: VoltaireTransaction.ReplaceOptions,
+): Any => VoltaireTransaction.replaceWith(tx, options);
+
+/**
+ * Formats transaction to human-readable string.
+ *
+ * @param tx - Transaction object
+ * @returns Formatted string representation
+ *
+ * @since 0.1.0
+ */
+export const format = (tx: Any): string => VoltaireTransaction.format(tx);
+
+// Effect-returning functions (validation)
+
+/**
+ * Error thrown when transaction is not signed.
+ *
+ * @since 0.1.0
+ */
+export class UnsignedTransactionError extends Error {
+	readonly _tag = "UnsignedTransactionError";
+	constructor(message = "Transaction is not signed") {
+		super(message);
+		this.name = "UnsignedTransactionError";
+	}
+}
+
+/**
+ * Error thrown when signature verification fails.
+ *
+ * @since 0.1.0
+ */
+export class InvalidSignatureError extends Error {
+	readonly _tag = "InvalidSignatureError";
+	constructor(message = "Invalid signature") {
+		super(message);
+		this.name = "InvalidSignatureError";
+	}
+}
+
+/**
+ * Error thrown when chain ID validation fails.
+ *
+ * @since 0.1.0
+ */
+export class InvalidChainIdError extends Error {
+	readonly _tag = "InvalidChainIdError";
+	constructor(message = "Invalid chain ID") {
+		super(message);
+		this.name = "InvalidChainIdError";
+	}
+}
+
+/**
+ * Error thrown when gas limit validation fails.
+ *
+ * @since 0.1.0
+ */
+export class InvalidGasLimitError extends Error {
+	readonly _tag = "InvalidGasLimitError";
+	constructor(message = "Invalid gas limit") {
+		super(message);
+		this.name = "InvalidGasLimitError";
+	}
+}
+
+/**
+ * Error thrown when gas price validation fails.
+ *
+ * @since 0.1.0
+ */
+export class InvalidGasPriceError extends Error {
+	readonly _tag = "InvalidGasPriceError";
+	constructor(message = "Invalid gas price") {
+		super(message);
+		this.name = "InvalidGasPriceError";
+	}
+}
+
+/**
+ * Error thrown when nonce validation fails.
+ *
+ * @since 0.1.0
+ */
+export class InvalidNonceError extends Error {
+	readonly _tag = "InvalidNonceError";
+	constructor(message = "Invalid nonce") {
+		super(message);
+		this.name = "InvalidNonceError";
+	}
+}
+
+/**
+ * Error thrown when value validation fails.
+ *
+ * @since 0.1.0
+ */
+export class InvalidValueError extends Error {
+	readonly _tag = "InvalidValueError";
+	constructor(message = "Invalid value") {
+		super(message);
+		this.name = "InvalidValueError";
+	}
+}
+
+/**
+ * Asserts transaction is signed, returning Effect that fails if not.
+ *
+ * @param tx - Transaction object
+ * @returns Effect that succeeds if signed, fails with UnsignedTransactionError otherwise
+ *
+ * @since 0.1.0
+ */
+export const assertSigned = (
+	tx: Any,
+): Effect.Effect<void, UnsignedTransactionError> =>
+	Effect.try({
+		try: () => VoltaireTransaction.assertSigned(tx),
+		catch: (e) => new UnsignedTransactionError((e as Error).message),
+	});
+
+/**
+ * Verifies transaction signature, returning Effect.
+ *
+ * @param tx - Transaction object
+ * @returns Effect with boolean result or InvalidSignatureError
+ *
+ * @since 0.1.0
+ */
+export const verifySignature = (
+	tx: Any,
+): Effect.Effect<boolean, InvalidSignatureError> =>
+	Effect.try({
+		try: () => VoltaireTransaction.verifySignature(tx),
+		catch: (e) => new InvalidSignatureError((e as Error).message),
+	});
+
+/**
+ * Validates chain ID, returning Effect that fails if invalid.
+ *
+ * @param tx - Transaction object
+ * @returns Effect that succeeds if valid, fails with InvalidChainIdError otherwise
+ *
+ * @since 0.1.0
+ */
+export const validateChainId = (
+	tx: Any,
+): Effect.Effect<void, InvalidChainIdError> =>
+	Effect.try({
+		try: () => VoltaireTransaction.validateChainId(tx),
+		catch: (e) => new InvalidChainIdError((e as Error).message),
+	});
+
+/**
+ * Validates gas limit, returning Effect that fails if invalid.
+ *
+ * @param tx - Transaction object
+ * @returns Effect that succeeds if valid, fails with InvalidGasLimitError otherwise
+ *
+ * @since 0.1.0
+ */
+export const validateGasLimit = (
+	tx: Any,
+): Effect.Effect<void, InvalidGasLimitError> =>
+	Effect.try({
+		try: () => VoltaireTransaction.validateGasLimit(tx),
+		catch: (e) => new InvalidGasLimitError((e as Error).message),
+	});
+
+/**
+ * Validates gas price, returning Effect that fails if invalid.
+ *
+ * @param tx - Transaction object
+ * @returns Effect that succeeds if valid, fails with InvalidGasPriceError otherwise
+ *
+ * @since 0.1.0
+ */
+export const validateGasPrice = (
+	tx: Any,
+): Effect.Effect<void, InvalidGasPriceError> =>
+	Effect.try({
+		try: () => VoltaireTransaction.validateGasPrice(tx),
+		catch: (e) => new InvalidGasPriceError((e as Error).message),
+	});
+
+/**
+ * Validates nonce, returning Effect that fails if invalid.
+ *
+ * @param tx - Transaction object
+ * @returns Effect that succeeds if valid, fails with InvalidNonceError otherwise
+ *
+ * @since 0.1.0
+ */
+export const validateNonce = (
+	tx: Any,
+): Effect.Effect<void, InvalidNonceError> =>
+	Effect.try({
+		try: () => VoltaireTransaction.validateNonce(tx),
+		catch: (e) => new InvalidNonceError((e as Error).message),
+	});
+
+/**
+ * Validates value, returning Effect that fails if invalid.
+ *
+ * @param tx - Transaction object
+ * @returns Effect that succeeds if valid, fails with InvalidValueError otherwise
+ *
+ * @since 0.1.0
+ */
+export const validateValue = (
+	tx: Any,
+): Effect.Effect<void, InvalidValueError> =>
+	Effect.try({
+		try: () => VoltaireTransaction.validateValue(tx),
+		catch: (e) => new InvalidValueError((e as Error).message),
+	});

package/src/primitives/Uint/Uint.test.ts

@@ -836,3 +836,203 @@ describe("additional edge cases", () => {
 		});
 	});
 });
+
+describe("constructor functions", () => {
+	describe("from", () => {
+		it("creates from bigint", () => {
+			const result = Effect.runSync(Uint.from(100n));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(100n);
+		});
+
+		it("creates from number", () => {
+			const result = Effect.runSync(Uint.from(42));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(42n);
+		});
+
+		it("creates from hex string", () => {
+			const result = Effect.runSync(Uint.from("0xff"));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(255n);
+		});
+
+		it("creates from decimal string", () => {
+			const result = Effect.runSync(Uint.from("1000"));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(1000n);
+		});
+
+		it("fails on negative", () => {
+			expect(() => Effect.runSync(Uint.from(-1n))).toThrow();
+		});
+
+		it("fails on overflow", () => {
+			expect(() => Effect.runSync(Uint.from(MAX_UINT256 + 1n))).toThrow();
+		});
+	});
+
+	describe("fromBigInt", () => {
+		it("creates from valid bigint", () => {
+			const result = Effect.runSync(Uint.fromBigInt(100n));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(100n);
+		});
+
+		it("fails on negative", () => {
+			expect(() => Effect.runSync(Uint.fromBigInt(-1n))).toThrow();
+		});
+	});
+
+	describe("fromNumber", () => {
+		it("creates from valid number", () => {
+			const result = Effect.runSync(Uint.fromNumber(42));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(42n);
+		});
+
+		it("fails on non-integer", () => {
+			expect(() => Effect.runSync(Uint.fromNumber(1.5))).toThrow();
+		});
+
+		it("fails on negative", () => {
+			expect(() => Effect.runSync(Uint.fromNumber(-1))).toThrow();
+		});
+	});
+
+	describe("fromHex", () => {
+		it("creates from hex with prefix", () => {
+			const result = Effect.runSync(Uint.fromHex("0xde0b6b3a7640000"));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(1000000000000000000n);
+		});
+
+		it("creates from hex without prefix", () => {
+			const result = Effect.runSync(Uint.fromHex("ff"));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(255n);
+		});
+
+		it("fails on invalid hex", () => {
+			expect(() => Effect.runSync(Uint.fromHex("0xGGG"))).toThrow();
+		});
+	});
+
+	describe("fromBytes", () => {
+		it("creates from bytes", () => {
+			const result = Effect.runSync(Uint.fromBytes(new Uint8Array([0xff])));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(255n);
+		});
+
+		it("creates from 32-byte array", () => {
+			const bytes = new Uint8Array(32).fill(0);
+			bytes[31] = 100;
+			const result = Effect.runSync(Uint.fromBytes(bytes));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(100n);
+		});
+	});
+
+	describe("fromAbiEncoded", () => {
+		it("creates from 32-byte ABI-encoded data", () => {
+			const data = new Uint8Array(32).fill(0);
+			data[31] = 42;
+			const result = Effect.runSync(Uint.fromAbiEncoded(data));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(42n);
+		});
+	});
+
+	describe("tryFrom", () => {
+		it("returns Some for valid value", () => {
+			const result = Uint.tryFrom(100n);
+			expect(result._tag).toBe("Some");
+		});
+
+		it("returns None for invalid value", () => {
+			const result = Uint.tryFrom(-1n);
+			expect(result._tag).toBe("None");
+		});
+
+		it("returns None for invalid string", () => {
+			const result = Uint.tryFrom("invalid");
+			expect(result._tag).toBe("None");
+		});
+	});
+});
+
+describe("type guards", () => {
+	describe("isUint256", () => {
+		it("returns true for valid bigint", () => {
+			expect(Uint.isUint256(100n)).toBe(true);
+		});
+
+		it("returns false for negative", () => {
+			expect(Uint.isUint256(-1n)).toBe(false);
+		});
+
+		it("returns false for overflow", () => {
+			expect(Uint.isUint256(MAX_UINT256 + 1n)).toBe(false);
+		});
+
+		it("returns false for non-bigint", () => {
+			expect(Uint.isUint256(100)).toBe(false);
+			expect(Uint.isUint256("100")).toBe(false);
+		});
+	});
+
+	describe("isValid", () => {
+		it("returns true for valid bigint", () => {
+			expect(Uint.isValid(100n)).toBe(true);
+		});
+
+		it("returns false for negative", () => {
+			expect(Uint.isValid(-1n)).toBe(false);
+		});
+
+		it("returns false for non-bigint", () => {
+			expect(Uint.isValid("hello")).toBe(false);
+		});
+	});
+});
+
+describe("division operations", () => {
+	const a = S.decodeSync(Uint.BigInt)(100n);
+	const b = S.decodeSync(Uint.BigInt)(30n);
+	const zero = S.decodeSync(Uint.BigInt)(0n);
+
+	describe("dividedBy", () => {
+		it("divides two values", () => {
+			const result = Effect.runSync(Uint.dividedBy(a, b));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(3n);
+		});
+
+		it("fails on division by zero", () => {
+			expect(() => Effect.runSync(Uint.dividedBy(a, zero))).toThrow();
+		});
+	});
+
+	describe("modulo", () => {
+		it("computes remainder", () => {
+			const result = Effect.runSync(Uint.modulo(a, b));
+			expect(S.encodeSync(Uint.BigInt)(result)).toBe(10n);
+		});
+
+		it("fails on modulo by zero", () => {
+			expect(() => Effect.runSync(Uint.modulo(a, zero))).toThrow();
+		});
+	});
+});
+
+describe("toHex", () => {
+	it("converts to padded hex by default", () => {
+		const val = S.decodeSync(Uint.BigInt)(255n);
+		const result = Effect.runSync(Uint.toHex(val));
+		expect(result).toMatch(/^0x[0-9a-f]{64}$/);
+		expect(result).toBe(
+			"0x00000000000000000000000000000000000000000000000000000000000000ff",
+		);
+	});
+
+	it("converts to unpadded hex when requested", () => {
+		const val = S.decodeSync(Uint.BigInt)(255n);
+		const result = Effect.runSync(Uint.toHex(val, false));
+		expect(result).toBe("0xff");
+	});
+
+	it("converts zero", () => {
+		const val = S.decodeSync(Uint.BigInt)(0n);
+		const result = Effect.runSync(Uint.toHex(val, false));
+		expect(result).toBe("0x0");
+	});
+});