tessl/npm-wagmi--core

VanillaJS library for Ethereum blockchain interactions with reactive primitives and utilities for building Ethereum applications

—

Pending

Overview

Eval results

Files

ENS Operations

Name: tessl/npm-wagmi--core
Author: tessl

Ethereum Name Service resolution, reverse resolution, and metadata retrieval. Complete ENS integration.

Capabilities

Resolve ENS Name to Address

Resolves ENS names to Ethereum addresses.

/**
 * Resolves ENS name to address
 * @param config - Wagmi configuration
 * @param parameters - ENS address resolution parameters
 * @returns Resolved address or null
 */
function getEnsAddress<config extends Config>(
  config: config,
  parameters: GetEnsAddressParameters<config>
): Promise<GetEnsAddressReturnType>;

interface GetEnsAddressParameters<config extends Config> {
  /** ENS name to resolve */
  name: string;
  /** Chain ID (defaults to mainnet) */
  chainId?: config['chains'][number]['id'];
  /** Block number to query at */
  blockNumber?: bigint;
  /** Block tag */
  blockTag?: 'latest' | 'earliest' | 'pending' | 'safe' | 'finalized';
  /** Universal resolver address */
  universalResolverAddress?: Address;
}

type GetEnsAddressReturnType = Address | null;

type GetEnsAddressErrorType = BaseErrorType;

/** @deprecated Use getEnsAddress instead */
const fetchEnsAddress = getEnsAddress;

Usage Example:

import { getEnsAddress } from '@wagmi/core'

const address = await getEnsAddress(config, {
  name: 'vitalik.eth',
})
console.log('vitalik.eth resolves to:', address)

// Handle null result
if (address) {
  console.log('Resolved address:', address)
} else {
  console.log('ENS name not found')
}

Reverse Resolve Address to ENS Name

Performs reverse ENS resolution to get name from address.

/**
 * Reverse resolves address to ENS name
 * @param config - Wagmi configuration
 * @param parameters - ENS name resolution parameters
 * @returns ENS name or null
 */
function getEnsName<config extends Config>(
  config: config,
  parameters: GetEnsNameParameters<config>
): Promise<GetEnsNameReturnType>;

interface GetEnsNameParameters<config extends Config> {
  /** Address to reverse resolve */
  address: Address;
  /** Chain ID (defaults to mainnet) */
  chainId?: config['chains'][number]['id'];
  /** Block number to query at */
  blockNumber?: bigint;
  /** Block tag */
  blockTag?: 'latest' | 'earliest' | 'pending' | 'safe' | 'finalized';
  /** Universal resolver address */
  universalResolverAddress?: Address;
}

type GetEnsNameReturnType = string | null;

type GetEnsNameErrorType = BaseErrorType;

/** @deprecated Use getEnsName instead */
const fetchEnsName = getEnsName;

Usage Example:

import { getEnsName } from '@wagmi/core'

const name = await getEnsName(config, {
  address: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
})
console.log('Address resolves to:', name) // "vitalik.eth"

Get ENS Avatar

Retrieves avatar image for ENS name.

/**
 * Gets ENS avatar image
 * @param config - Wagmi configuration
 * @param parameters - ENS avatar parameters
 * @returns Avatar URI or null
 */
function getEnsAvatar<config extends Config>(
  config: config,
  parameters: GetEnsAvatarParameters<config>
): Promise<GetEnsAvatarReturnType>;

interface GetEnsAvatarParameters<config extends Config> {
  /** ENS name */
  name: string;
  /** Chain ID */
  chainId?: config['chains'][number]['id'];
  /** Block number to query at */
  blockNumber?: bigint;
  /** Block tag */
  blockTag?: 'latest' | 'earliest' | 'pending' | 'safe' | 'finalized';
  /** Universal resolver address */
  universalResolverAddress?: Address;
  /** Avatar gateway URLs */
  gatewayUrls?: {
    ipfs?: string;
    arweave?: string;
  };
}

type GetEnsAvatarReturnType = string | null;

type GetEnsAvatarErrorType = BaseErrorType;

/** @deprecated Use getEnsAvatar instead */
const fetchEnsAvatar = getEnsAvatar;

Usage Example:

import { getEnsAvatar } from '@wagmi/core'

const avatar = await getEnsAvatar(config, {
  name: 'vitalik.eth',
})

if (avatar) {
  console.log('Avatar URL:', avatar)
  // Use avatar in UI
  // <img src={avatar} alt="vitalik.eth avatar" />
}

Get ENS Resolver

Gets the resolver contract for an ENS name.

/**
 * Gets ENS resolver contract address
 * @param config - Wagmi configuration
 * @param parameters - ENS resolver parameters
 * @returns Resolver address or null
 */
function getEnsResolver<config extends Config>(
  config: config,
  parameters: GetEnsResolverParameters<config>
): Promise<GetEnsResolverReturnType>;

interface GetEnsResolverParameters<config extends Config> {
  /** ENS name */
  name: string;
  /** Chain ID */
  chainId?: config['chains'][number]['id'];
  /** Block number to query at */
  blockNumber?: bigint;
  /** Block tag */
  blockTag?: 'latest' | 'earliest' | 'pending' | 'safe' | 'finalized';
  /** Universal resolver address */
  universalResolverAddress?: Address;
}

type GetEnsResolverReturnType = Address | null;

type GetEnsResolverErrorType = BaseErrorType;

/** @deprecated Use getEnsResolver instead */
const fetchEnsResolver = getEnsResolver;

Get ENS Text Records

Retrieves text records for ENS names.

/**
 * Gets ENS text record
 * @param config - Wagmi configuration
 * @param parameters - ENS text parameters
 * @returns Text record value or null
 */
function getEnsText<config extends Config>(
  config: config,
  parameters: GetEnsTextParameters<config>
): Promise<GetEnsTextReturnType>;

interface GetEnsTextParameters<config extends Config> {
  /** ENS name */
  name: string;
  /** Text record key */
  key: string;
  /** Chain ID */
  chainId?: config['chains'][number]['id'];
  /** Block number to query at */
  blockNumber?: bigint;
  /** Block tag */
  blockTag?: 'latest' | 'earliest' | 'pending' | 'safe' | 'finalized';
  /** Universal resolver address */
  universalResolverAddress?: Address;
}

type GetEnsTextReturnType = string | null;

type GetEnsTextErrorType = BaseErrorType;

Usage Example:

import { getEnsText, getEnsResolver } from '@wagmi/core'

// Get common text records
const email = await getEnsText(config, {
  name: 'vitalik.eth',
  key: 'email',
})

const twitter = await getEnsText(config, {
  name: 'vitalik.eth',
  key: 'com.twitter',
})

const github = await getEnsText(config, {
  name: 'vitalik.eth',
  key: 'com.github',
})

const url = await getEnsText(config, {
  name: 'vitalik.eth',
  key: 'url',
})

console.log('ENS records:', {
  email,
  twitter,
  github,
  url,
})

// Get resolver for advanced usage
const resolver = await getEnsResolver(config, {
  name: 'vitalik.eth',
})
console.log('Resolver contract:', resolver)

Complete ENS Profile Example

Here's a comprehensive example showing how to build a complete ENS profile:

import { 
  getEnsAddress, 
  getEnsName, 
  getEnsAvatar, 
  getEnsText 
} from '@wagmi/core'

async function getEnsProfile(nameOrAddress: string) {
  let ensName: string | null = null
  let address: Address | null = null
  
  // Determine if input is name or address
  if (nameOrAddress.endsWith('.eth')) {
    ensName = nameOrAddress
    address = await getEnsAddress(config, { name: nameOrAddress })
  } else {
    address = nameOrAddress as Address
    ensName = await getEnsName(config, { address })
  }
  
  if (!ensName || !address) {
    return null
  }
  
  // Get all profile data in parallel
  const [avatar, email, twitter, github, url, description] = await Promise.all([
    getEnsAvatar(config, { name: ensName }),
    getEnsText(config, { name: ensName, key: 'email' }),
    getEnsText(config, { name: ensName, key: 'com.twitter' }),
    getEnsText(config, { name: ensName, key: 'com.github' }),
    getEnsText(config, { name: ensName, key: 'url' }),
    getEnsText(config, { name: ensName, key: 'description' }),
  ])
  
  return {
    name: ensName,
    address,
    avatar,
    email,
    twitter,
    github,
    url,
    description,
  }
}

// Usage
const profile = await getEnsProfile('vitalik.eth')
if (profile) {
  console.log('ENS Profile:', profile)
}

const profileByAddress = await getEnsProfile('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')
if (profileByAddress) {
  console.log('Profile from address:', profileByAddress)
}

Install with Tessl CLI