Web3 ENS

import { ENS, registryAddresses } from "web3-eth-ens";

const { ENS, registryAddresses } = require("web3-eth-ens");

import { ENS } from "web3-eth-ens";

// Create ENS instance with default mainnet registry
const ens = new ENS(undefined, "https://mainnet.infura.io/v3/your-key");

// Resolve ENS name to address
const address = await ens.getAddress("ethereum.eth");
console.log(address); // "0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359"

// Get ENS record owner
const owner = await ens.getOwner("ethereum.eth");
console.log(owner);

// Check if record exists
const exists = await ens.recordExists("ethereum.eth");
console.log(exists); // true

// Get public key
const pubkey = await ens.getPubkey("ethereum.eth");
console.log(pubkey.x, pubkey.y);

/**
 * Create an ENS instance
 * @param registryAddr - Optional custom ENS registry address
 * @param provider - Web3 provider or provider URL
 */
class ENS {
  constructor(
    registryAddr?: string,
    provider?: SupportedProviders<EthExecutionAPI & Web3NetAPI> | Web3ContextObject<EthExecutionAPI & Web3NetAPI> | string
  );
  
  /** The ENS registry address being used */
  registryAddress: string;
}

import { ENS } from "web3-eth-ens";

// Use default mainnet registry
const ens = new ENS(undefined, "https://mainnet.infura.io/v3/your-key");

// Use custom registry address
const customEns = new ENS(
  "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
  "https://goerli.infura.io/v3/your-key"
);

/**
 * Resolves an ENS name to an Ethereum address
 * @param ENSName - The ENS name to resolve
 * @param coinType - The coin type (defaults to 60 for ETH)
 * @returns The cryptocurrency address
 */
getAddress(ENSName: string, coinType = 60): Promise<Address>;

// Resolve to Ethereum address (default)
const ethAddress = await ens.getAddress("ethereum.eth");

// Resolve to Bitcoin address  
const btcAddress = await ens.getAddress("ethereum.eth", 0);

/**
 * Returns true if the record exists
 * @param name - The ENS name to check
 * @returns True if record exists in registry
 */
recordExists(name: string): Promise<boolean>;

/**
 * Returns the owner of an ENS name
 * @param name - The ENS name
 * @returns The address of the owner
 */
getOwner(name: string): Promise<Address>;

/**
 * Returns the caching TTL of an ENS name
 * @param name - The ENS name
 * @returns The TTL in seconds
 */
getTTL(name: string): Promise<string>;

/**
 * Returns the X and Y coordinates of the curve point for the public key
 * @param ENSName - The ENS name
 * @returns Object with x and y coordinates
 */
getPubkey(ENSName: string): Promise<PubkeyResult>;

const pubkey = await ens.getPubkey("ethereum.eth");
console.log(pubkey.x); // X coordinate
console.log(pubkey.y); // Y coordinate

/**
 * Returns the content hash object associated with an ENS node
 * @param ENSName - The ENS name
 * @returns The content hash (typically IPFS hash)
 */
getContenthash(ENSName: string): Promise<string>;

/**
 * Returns the Resolver contract for the given ENS name
 * @param name - The ENS name
 * @returns Contract instance of the resolver
 */
getResolver(name: string): Promise<Contract<typeof PublicResolverAbi>>;

/**
 * Returns true if the resolver supports the given signature or interface ID
 * @param ENSName - The ENS name
 * @param interfaceId - The function signature or interface ID
 * @returns True if interface is supported
 */
supportsInterface(ENSName: string, interfaceId: string): Promise<boolean>;

// Check if resolver supports address resolution
const supportsAddr = await ens.supportsInterface("ethereum.eth", "addr(bytes32)");

// Check using interface ID
const supportsAddrById = await ens.supportsInterface("ethereum.eth", "0x3b3b57de");

/**
 * Checks if current network is synced and supports ENS
 * @returns The ENS registry address for the detected network
 * @throws ENSNetworkNotSyncedError if network is not synced
 * @throws ENSUnsupportedNetworkError if network doesn't support ENS
 */
checkNetwork(): Promise<string>;

/**
 * Returns all events that can be emitted by the ENS registry
 */
get events(): any;

interface RegistryAddresses {
  main: string;    // "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
  goerli: string;  // "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
}

const registryAddresses: RegistryAddresses;

// Core ENS result types
interface PubkeyResult {
  "0": string; // X coordinate
  "1": string; // Y coordinate  
  x: string;   // X coordinate
  y: string;   // Y coordinate
}

// Web3 context types from web3-core
interface Web3ContextObject<T = unknown> {
  provider?: SupportedProviders<T>;
  config?: Partial<Web3Config>;
}

// Provider types from web3-types
type SupportedProviders<T = unknown> = 
  | HttpProvider<T>
  | WebSocketProvider<T>
  | IpcProvider<T>
  | string;

// Execution API types from web3-types
interface EthExecutionAPI {
  eth_call: (transaction: TransactionCall, blockNumber?: BlockNumberOrTag) => string;
  eth_getCode: (address: Address, blockNumber?: BlockNumberOrTag) => string;
  // Additional methods...
}

interface Web3NetAPI {
  net_version: () => string;
  net_peerCount: () => string;
  net_listening: () => boolean;
}

// Contract type from web3-eth-contract
interface Contract<T> {
  options: {
    address?: Address;
    from?: Address;
    gas?: string;
    gasPrice?: string;
  };
  methods: ContractMethods<T>;
  events: ContractEvents<T>;
}

// Address type
type Address = string;

// Block identifier types
type BlockNumberOrTag = string | number | "latest" | "earliest" | "pending";

// Transaction call type
interface TransactionCall {
  to?: Address;
  from?: Address;
  gas?: string;
  gasPrice?: string;
  data?: string;
  value?: string;
}

// Contract method and event types
type ContractMethods<T> = any;
type ContractEvents<T> = any;

// Provider types
interface HttpProvider<T> {
  host: string;
  timeout?: number;
}

interface WebSocketProvider<T> {
  url: string;
  timeout?: number;
}

interface IpcProvider<T> {
  path: string;
  timeout?: number;
}

// Web3 configuration
interface Web3Config {
  defaultAccount?: Address;
  defaultBlock?: BlockNumberOrTag;
  transactionBlockTimeout?: number;
  // Additional config options...
}

// ABI types for ENS contracts
const ENSRegistryAbi: readonly any[];
const PublicResolverAbi: readonly any[];