voltaire-effect 0.2.23

package/src/services/Contract/index.ts

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Contract factory for type-safe smart contract interactions.
+ *
+ * @module Contract
+ * @since 0.0.1
+ *
+ * @description
+ * This module provides the `Contract` factory function for creating type-safe
+ * bindings to deployed smart contracts based on their ABI.
+ *
+ * **Note:** `Contract()` is a factory function, NOT a `Context.Tag` service.
+ * It returns an Effect that yields a `ContractInstance` with `.read`, `.write`,
+ * `.simulate`, and `.getEvents` methods. The factory depends on `ProviderService`
+ * for read operations, and write operations additionally require `SignerService`.
+ *
+ * Main exports:
+ * - {@link Contract} - Factory function to create contract instances
+ *
+ * Type exports:
+ * - {@link ContractInstance} - Type-safe contract binding
+ * - {@link Abi} - ABI definition type
+ * - {@link AbiItem} - Single ABI entry type
+ * - {@link EventFilter} - Event query parameters
+ * - {@link DecodedEvent} - Decoded event log
+ *
+ * Error exports:
+ * - {@link ContractError} - Base contract error
+ * - {@link ContractCallError} - Read operation error
+ * - {@link ContractWriteError} - Write operation error
+ * - {@link ContractEventError} - Event query error
+ *
+ * @example Creating a contract instance
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { Contract, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const erc20Abi = [...] as const
+ *
+ * const program = Effect.gen(function* () {
+ *   // Contract() is a factory - yields a contract instance, not a service
+ *   const token = yield* Contract(tokenAddress, erc20Abi)
+ *   const balance = yield* token.read.balanceOf(userAddress)
+ *   return balance
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://...'))
+ * )
+ * ```
+ *
+ * @see {@link ProviderService} - Required for all contract operations
+ * @see {@link SignerService} - Required for write operations
+ */
+
+export { Contract } from "./Contract.js";
+export {
+	type Abi,
+	type AbiItem,
+	type BlockTag,
+	ContractCallError,
+	ContractError,
+	ContractEventError,
+	type ContractInstance,
+	ContractWriteError,
+	type DecodedEvent,
+	type EventFilter,
+	type WriteOptions,
+} from "./ContractTypes.js";

package/src/services/Debug/Debug.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Live implementation of DebugService using TransportService.
+ *
+ * @module Debug
+ * @since 0.3.0
+ */
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type {
+	AddressInput,
+	BlockTag,
+	CallRequest,
+	HashInput,
+	TransactionIndexInput,
+} from "../Provider/ProviderService.js";
+import { TransportService } from "../Transport/TransportService.js";
+import { DebugService } from "./DebugService.js";
+
+const bytesToHex = (bytes: Uint8Array): `0x${string}` => {
+	let hex = "0x";
+	for (let i = 0; i < bytes.length; i++) {
+		hex += bytes[i].toString(16).padStart(2, "0");
+	}
+	return hex as `0x${string}`;
+};
+
+const toAddressHex = (input: AddressInput): `0x${string}` => {
+	if (typeof input === "string") return input as `0x${string}`;
+	return bytesToHex(input);
+};
+
+const toHashHex = (input: HashInput): `0x${string}` => {
+	if (typeof input === "string") return input as `0x${string}`;
+	return bytesToHex(input);
+};
+
+const toIndexHex = (index: TransactionIndexInput): `0x${string}` => {
+	if (typeof index === "string") return index as `0x${string}`;
+	const value = typeof index === "number" ? BigInt(index) : index;
+	return `0x${value.toString(16)}` as `0x${string}`;
+};
+
+const toBlockId = (blockId: BlockTag | HashInput | bigint): string => {
+	if (typeof blockId === "bigint") {
+		return `0x${blockId.toString(16)}`;
+	}
+	if (typeof blockId === "string") return blockId;
+	return bytesToHex(blockId);
+};
+
+const formatCallRequest = (tx: CallRequest) => {
+	const formatted: Record<string, unknown> = {};
+	if (tx.from) formatted.from = toAddressHex(tx.from);
+	if (tx.to) formatted.to = toAddressHex(tx.to);
+	if (tx.data) formatted.data = tx.data;
+	if (tx.value !== undefined) formatted.value = `0x${tx.value.toString(16)}`;
+	if (tx.gas !== undefined) formatted.gas = `0x${tx.gas.toString(16)}`;
+	return formatted;
+};
+
+/**
+ * Live implementation of the Debug layer.
+ *
+ * @since 0.3.0
+ */
+export const Debug: Layer.Layer<DebugService, never, TransportService> =
+	Layer.effect(
+		DebugService,
+		Effect.gen(function* () {
+			const transport = yield* TransportService;
+			const request = <T>(method: string, params?: unknown[]) =>
+				transport.request<T>(method, params);
+
+			return {
+				traceTransaction: (hash, config) =>
+					request<unknown>("debug_traceTransaction", [
+						toHashHex(hash),
+						...(config ? [config] : []),
+					]),
+				traceCall: (tx, blockTag = "latest", config) => {
+					const params: unknown[] = [formatCallRequest(tx), blockTag];
+					if (config !== undefined) params.push(config);
+					return request<unknown>("debug_traceCall", params);
+				},
+				traceBlockByNumber: (blockTag, config) => {
+					const blockRef =
+						typeof blockTag === "bigint"
+							? (`0x${blockTag.toString(16)}` as const)
+							: blockTag;
+					const params: unknown[] = [blockRef];
+					if (config !== undefined) params.push(config);
+					return request<unknown>("debug_traceBlockByNumber", params);
+				},
+				traceBlockByHash: (blockHash, config) => {
+					const params: unknown[] = [toHashHex(blockHash)];
+					if (config !== undefined) params.push(config);
+					return request<unknown>("debug_traceBlockByHash", params);
+				},
+				getBadBlocks: () => request<unknown>("debug_getBadBlocks"),
+				getRawBlock: (blockId) =>
+					request<`0x${string}`>("debug_getRawBlock", [toBlockId(blockId)]),
+				getRawHeader: (blockId) =>
+					request<`0x${string}`>("debug_getRawHeader", [toBlockId(blockId)]),
+				getRawReceipts: (blockId) =>
+					request<`0x${string}`[]>("debug_getRawReceipts", [
+						toBlockId(blockId),
+					]),
+				getRawTransaction: (hash) =>
+					request<`0x${string}`>("debug_getRawTransaction", [toHashHex(hash)]),
+				storageRangeAt: (blockHash, txIndex, address, startKey, maxResults) =>
+					request<unknown>("debug_storageRangeAt", [
+						toHashHex(blockHash),
+						toIndexHex(txIndex),
+						toAddressHex(address),
+						typeof startKey === "string" ? startKey : toHashHex(startKey),
+						maxResults,
+					]),
+			};
+		}),
+	);

package/src/services/Debug/DebugService.ts

@@ -0,0 +1,89 @@
+/**
+ * @fileoverview Debug service definition for debug JSON-RPC methods.
+ *
+ * @module DebugService
+ * @since 0.3.0
+ */
+
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type {
+	AddressInput,
+	BlockTag,
+	CallRequest,
+	HashInput,
+	TransactionIndexInput,
+} from "../Provider/ProviderService.js";
+import type { TransportError } from "../Transport/TransportError.js";
+
+/**
+ * Debug trace configuration object.
+ *
+ * @since 0.3.0
+ */
+export type DebugTraceConfig = Record<string, unknown>;
+
+/**
+ * Shape of the Debug service.
+ *
+ * @since 0.3.0
+ */
+export type DebugShape = {
+	/** Traces a transaction by hash */
+	readonly traceTransaction: (
+		hash: HashInput,
+		config?: DebugTraceConfig,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Traces a call without sending a transaction */
+	readonly traceCall: (
+		tx: CallRequest,
+		blockTag?: BlockTag,
+		config?: DebugTraceConfig,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Traces all transactions in a block by number/tag */
+	readonly traceBlockByNumber: (
+		blockTag: BlockTag | bigint,
+		config?: DebugTraceConfig,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Traces all transactions in a block by hash */
+	readonly traceBlockByHash: (
+		blockHash: HashInput,
+		config?: DebugTraceConfig,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Returns blocks that were rejected during block import */
+	readonly getBadBlocks: () => Effect.Effect<unknown, TransportError>;
+	/** Returns the raw RLP-encoded block */
+	readonly getRawBlock: (
+		blockId: BlockTag | HashInput | bigint,
+	) => Effect.Effect<`0x${string}`, TransportError>;
+	/** Returns the raw RLP-encoded block header */
+	readonly getRawHeader: (
+		blockId: BlockTag | HashInput | bigint,
+	) => Effect.Effect<`0x${string}`, TransportError>;
+	/** Returns raw receipts for the block */
+	readonly getRawReceipts: (
+		blockId: BlockTag | HashInput | bigint,
+	) => Effect.Effect<`0x${string}`[], TransportError>;
+	/** Returns the raw RLP-encoded transaction */
+	readonly getRawTransaction: (
+		hash: HashInput,
+	) => Effect.Effect<`0x${string}`, TransportError>;
+	/** Returns storage range at a given contract */
+	readonly storageRangeAt: (
+		blockHash: HashInput,
+		txIndex: TransactionIndexInput,
+		address: AddressInput,
+		startKey: HashInput | `0x${string}`,
+		maxResults: number,
+	) => Effect.Effect<unknown, TransportError>;
+};
+
+/**
+ * Debug service for debug JSON-RPC operations.
+ *
+ * @since 0.3.0
+ */
+export class DebugService extends Context.Tag("DebugService")<
+	DebugService,
+	DebugShape
+>() {}

package/src/services/Debug/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Debug service exports.
+ *
+ * @module Debug
+ * @since 0.3.0
+ */
+
+export { Debug } from "./Debug.js";
+export {
+	DebugService,
+	type DebugShape,
+	type DebugTraceConfig,
+} from "./DebugService.js";

package/src/services/EngineApi/EngineApi.ts

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Live implementation of EngineApiService using TransportService.
+ *
+ * @module EngineApi
+ * @since 0.3.0
+ */
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { TransportService } from "../Transport/TransportService.js";
+import { EngineApiService } from "./EngineApiService.js";
+
+const toQuantity = (value: `0x${string}` | number | bigint): `0x${string}` => {
+	if (typeof value === "string") return value;
+	const asBigInt = typeof value === "number" ? BigInt(value) : value;
+	return `0x${asBigInt.toString(16)}` as `0x${string}`;
+};
+
+/**
+ * Live implementation of the Engine API layer.
+ *
+ * @since 0.3.0
+ */
+export const EngineApi: Layer.Layer<EngineApiService, never, TransportService> =
+	Layer.effect(
+		EngineApiService,
+		Effect.gen(function* () {
+			const transport = yield* TransportService;
+			const request = <T>(method: string, params?: unknown[]) =>
+				transport.request<T>(method, params);
+
+			return {
+				exchangeCapabilities: (capabilities) =>
+					request<readonly string[]>("engine_exchangeCapabilities", [
+						capabilities,
+					]),
+				exchangeTransitionConfigurationV1: (config) =>
+					request<unknown>("engine_exchangeTransitionConfigurationV1", [
+						config,
+					]),
+				forkchoiceUpdatedV1: (forkchoiceState, payloadAttributes) =>
+					request<unknown>("engine_forkchoiceUpdatedV1", [
+						forkchoiceState,
+						payloadAttributes ?? null,
+					]),
+				forkchoiceUpdatedV2: (forkchoiceState, payloadAttributes) =>
+					request<unknown>("engine_forkchoiceUpdatedV2", [
+						forkchoiceState,
+						payloadAttributes ?? null,
+					]),
+				forkchoiceUpdatedV3: (forkchoiceState, payloadAttributes) =>
+					request<unknown>("engine_forkchoiceUpdatedV3", [
+						forkchoiceState,
+						payloadAttributes ?? null,
+					]),
+				getPayloadV1: (payloadId) =>
+					request<unknown>("engine_getPayloadV1", [payloadId]),
+				getPayloadV2: (payloadId) =>
+					request<unknown>("engine_getPayloadV2", [payloadId]),
+				getPayloadV3: (payloadId) =>
+					request<unknown>("engine_getPayloadV3", [payloadId]),
+				getPayloadV4: (payloadId) =>
+					request<unknown>("engine_getPayloadV4", [payloadId]),
+				newPayloadV1: (payload) =>
+					request<unknown>("engine_newPayloadV1", [payload]),
+				newPayloadV2: (payload) =>
+					request<unknown>("engine_newPayloadV2", [payload]),
+				newPayloadV3: (
+					payload,
+					expectedBlobVersionedHashes,
+					parentBeaconBlockRoot,
+				) => {
+					const params: unknown[] = [payload];
+					if (expectedBlobVersionedHashes !== undefined) {
+						params.push(expectedBlobVersionedHashes);
+						if (parentBeaconBlockRoot !== undefined) {
+							params.push(parentBeaconBlockRoot);
+						}
+					}
+					return request<unknown>("engine_newPayloadV3", params);
+				},
+				newPayloadV4: (payload, ...extra) =>
+					request<unknown>("engine_newPayloadV4", [payload, ...extra]),
+				getPayloadBodiesByHashV1: (blockHashes) =>
+					request<unknown>("engine_getPayloadBodiesByHashV1", [blockHashes]),
+				getPayloadBodiesByRangeV1: (start, count) =>
+					request<unknown>("engine_getPayloadBodiesByRangeV1", [
+						toQuantity(start),
+						toQuantity(count),
+					]),
+				getBlobsV1: (versionedHashes) =>
+					request<unknown>("engine_getBlobsV1", [versionedHashes]),
+			};
+		}),
+	);

package/src/services/EngineApi/EngineApiService.ts

@@ -0,0 +1,99 @@
+/**
+ * @fileoverview Engine API service definition for consensus/execution JSON-RPC methods.
+ *
+ * @module EngineApiService
+ * @since 0.3.0
+ */
+
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type { TransportError } from "../Transport/TransportError.js";
+
+/**
+ * Shape of the Engine API service.
+ *
+ * @since 0.3.0
+ */
+export type EngineApiShape = {
+	/** Exchanges supported Engine API capabilities */
+	readonly exchangeCapabilities: (
+		capabilities: readonly string[],
+	) => Effect.Effect<readonly string[], TransportError>;
+	/** Exchanges transition configuration (V1) */
+	readonly exchangeTransitionConfigurationV1: (
+		config: unknown,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Updates forkchoice (V1) */
+	readonly forkchoiceUpdatedV1: (
+		forkchoiceState: unknown,
+		payloadAttributes?: unknown,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Updates forkchoice (V2) */
+	readonly forkchoiceUpdatedV2: (
+		forkchoiceState: unknown,
+		payloadAttributes?: unknown,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Updates forkchoice (V3) */
+	readonly forkchoiceUpdatedV3: (
+		forkchoiceState: unknown,
+		payloadAttributes?: unknown,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Gets a payload by id (V1) */
+	readonly getPayloadV1: (
+		payloadId: `0x${string}`,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Gets a payload by id (V2) */
+	readonly getPayloadV2: (
+		payloadId: `0x${string}`,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Gets a payload by id (V3) */
+	readonly getPayloadV3: (
+		payloadId: `0x${string}`,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Gets a payload by id (V4) */
+	readonly getPayloadV4: (
+		payloadId: `0x${string}`,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Submits a new execution payload (V1) */
+	readonly newPayloadV1: (
+		payload: unknown,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Submits a new execution payload (V2) */
+	readonly newPayloadV2: (
+		payload: unknown,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Submits a new execution payload (V3) */
+	readonly newPayloadV3: (
+		payload: unknown,
+		expectedBlobVersionedHashes?: readonly `0x${string}`[],
+		parentBeaconBlockRoot?: `0x${string}`,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Submits a new execution payload (V4) */
+	readonly newPayloadV4: (
+		payload: unknown,
+		...extra: readonly unknown[]
+	) => Effect.Effect<unknown, TransportError>;
+	/** Gets payload bodies by block hash (V1) */
+	readonly getPayloadBodiesByHashV1: (
+		blockHashes: readonly `0x${string}`[],
+	) => Effect.Effect<unknown, TransportError>;
+	/** Gets payload bodies by range (V1) */
+	readonly getPayloadBodiesByRangeV1: (
+		start: `0x${string}` | number | bigint,
+		count: `0x${string}` | number | bigint,
+	) => Effect.Effect<unknown, TransportError>;
+	/** Gets blobs by versioned hashes (V1) */
+	readonly getBlobsV1: (
+		versionedHashes: readonly `0x${string}`[],
+	) => Effect.Effect<unknown, TransportError>;
+};
+
+/**
+ * Engine API service for consensus/execution JSON-RPC operations.
+ *
+ * @since 0.3.0
+ */
+export class EngineApiService extends Context.Tag("EngineApiService")<
+	EngineApiService,
+	EngineApiShape
+>() {}

package/src/services/EngineApi/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Engine API service exports.
+ *
+ * @module EngineApi
+ * @since 0.3.0
+ */
+
+export { EngineApi } from "./EngineApi.js";
+export { EngineApiService, type EngineApiShape } from "./EngineApiService.js";

package/src/services/Ens/DefaultEns.ts

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Live implementation of EnsService using ProviderService.
+ *
+ * @module DefaultEns
+ * @since 0.0.1
+ *
+ * @description
+ * Provides the live implementation layer for EnsService. This layer
+ * delegates to the ENS helper functions and requires ProviderService
+ * to be provided for RPC access.
+ *
+ * @see {@link EnsService} - The service interface
+ * @see {@link ProviderService} - Required provider dependency
+ */
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { getEnsAddress } from "../Provider/ens/getEnsAddress.js";
+import { getEnsAvatar } from "../Provider/ens/getEnsAvatar.js";
+import { getEnsName } from "../Provider/ens/getEnsName.js";
+import { getEnsResolver } from "../Provider/ens/getEnsResolver.js";
+import { getEnsText } from "../Provider/ens/getEnsText.js";
+import { ProviderService } from "../Provider/ProviderService.js";
+import { EnsService } from "./EnsService.js";
+
+/**
+ * Live implementation of the ENS layer.
+ *
+ * @since 0.0.1
+ */
+export const DefaultEns: Layer.Layer<EnsService, never, ProviderService> =
+	Layer.effect(
+		EnsService,
+		Effect.gen(function* () {
+			const provider = yield* ProviderService;
+
+			return {
+				getEnsAddress: (params) =>
+					getEnsAddress(params).pipe(
+						Effect.provideService(ProviderService, provider),
+					),
+				getEnsName: (params) =>
+					getEnsName(params).pipe(
+						Effect.provideService(ProviderService, provider),
+					),
+				getEnsResolver: (params) =>
+					getEnsResolver(params).pipe(
+						Effect.provideService(ProviderService, provider),
+					),
+				getEnsAvatar: (params) =>
+					getEnsAvatar(params).pipe(
+						Effect.provideService(ProviderService, provider),
+					),
+				getEnsText: (params) =>
+					getEnsText(params).pipe(
+						Effect.provideService(ProviderService, provider),
+					),
+			};
+		}),
+	);

package/src/services/Ens/EnsService.ts

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview ENS service definition for ENS resolution.
+ *
+ * @module EnsService
+ * @since 0.0.1
+ *
+ * @description
+ * The EnsService provides a high-level interface for resolving Ethereum Name
+ * Service (ENS) records such as addresses, reverse names, resolver contracts,
+ * avatars, and text records.
+ *
+ * Requires ProviderService to be provided via the live layer.
+ *
+ * @see {@link DefaultEns} - The live implementation layer
+ * @see {@link ProviderService} - Required provider dependency
+ */
+
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type { EnsError } from "../Provider/ens/EnsError.js";
+import type { GetEnsAddressParams } from "../Provider/ens/getEnsAddress.js";
+import type { GetEnsAvatarParams } from "../Provider/ens/getEnsAvatar.js";
+import type { GetEnsNameParams } from "../Provider/ens/getEnsName.js";
+import type { GetEnsResolverParams } from "../Provider/ens/getEnsResolver.js";
+import type { GetEnsTextParams } from "../Provider/ens/getEnsText.js";
+
+/**
+ * Shape of the ENS service.
+ *
+ * @since 0.0.1
+ */
+export type EnsShape = {
+	/** Resolves an ENS name to an address */
+	readonly getEnsAddress: (
+		params: GetEnsAddressParams,
+	) => Effect.Effect<`0x${string}` | null, EnsError>;
+	/** Reverse-resolves an address to its ENS name */
+	readonly getEnsName: (
+		params: GetEnsNameParams,
+	) => Effect.Effect<string | null, EnsError>;
+	/** Gets the resolver address for an ENS name */
+	readonly getEnsResolver: (
+		params: GetEnsResolverParams,
+	) => Effect.Effect<`0x${string}` | null, EnsError>;
+	/** Gets the avatar URL/URI for an ENS name */
+	readonly getEnsAvatar: (
+		params: GetEnsAvatarParams,
+	) => Effect.Effect<string | null, EnsError>;
+	/** Gets a text record for an ENS name */
+	readonly getEnsText: (
+		params: GetEnsTextParams,
+	) => Effect.Effect<string | null, EnsError>;
+};
+
+/**
+ * ENS service for name resolution.
+ *
+ * @description
+ * Provides methods for resolving ENS names, reverse lookups, and records.
+ *
+ * @since 0.0.1
+ */
+export class EnsService extends Context.Tag("EnsService")<
+	EnsService,
+	EnsShape
+>() {}

package/src/services/Ens/index.ts

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview ENS module exports for ENS resolution utilities.
+ *
+ * @module Ens
+ * @since 0.0.1
+ *
+ * @description
+ * This module provides the ENS service for resolving names and records.
+ * It includes the service definition, live implementation layer, and
+ * helper utilities for direct ENS resolution.
+ *
+ * Main exports:
+ * - {@link EnsService} - The service tag/interface
+ * - {@link DefaultEns} - The live implementation layer
+ * - {@link EnsError} - Error type for ENS operations
+ *
+ * @example Typical usage
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { EnsService, DefaultEns, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const ens = yield* EnsService
+ *   return yield* ens.getEnsAddress({ name: 'vitalik.eth' })
+ * }).pipe(
+ *   Effect.provide(DefaultEns),
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://...'))
+ * )
+ * ```
+ *
+ * @see {@link ProviderService} - Required dependency for RPC communication
+ */
+
+export {
+	ENS_REGISTRY_ADDRESS,
+	ENS_UNIVERSAL_RESOLVER_ADDRESS,
+} from "../Provider/ens/constants.js";
+export { EnsError } from "../Provider/ens/EnsError.js";
+export {
+	type GetEnsAddressParams,
+	getEnsAddress,
+} from "../Provider/ens/getEnsAddress.js";
+export {
+	type GetEnsAvatarParams,
+	getEnsAvatar,
+} from "../Provider/ens/getEnsAvatar.js";
+export {
+	type GetEnsNameParams,
+	getEnsName,
+} from "../Provider/ens/getEnsName.js";
+export {
+	type GetEnsResolverParams,
+	getEnsResolver,
+} from "../Provider/ens/getEnsResolver.js";
+export {
+	type GetEnsTextParams,
+	getEnsText,
+} from "../Provider/ens/getEnsText.js";
+export { DefaultEns } from "./DefaultEns.js";
+export { EnsService, type EnsShape } from "./EnsService.js";