CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-web3

A Python library for interacting with Ethereum blockchain

Overall
score

88%

Evaluation — 88%

↑ 1.01x

Agent success when using this tile

Overview
Eval results
Files

ens-operations.mddocs/

ENS Operations

Ethereum Name Service integration for human-readable address resolution, reverse lookups, domain management, and decentralized naming system interactions.

Capabilities

ENS Resolution

Core ENS functionality for resolving names to addresses and vice versa.

class ENS:
    def __init__(self, provider: BaseProvider = None):
        """
        Initialize ENS instance.
        
        Parameters:
        - provider: Web3 provider for blockchain access
        """

    def address(self, name: str) -> ChecksumAddress:
        """
        Resolve ENS name to Ethereum address.
        
        Parameters:
        - name: ENS name (e.g., 'ethereum.eth')
        
        Returns:
        Ethereum address
        
        Raises:
        InvalidName: If name format is invalid
        UnownedName: If name is not owned
        """

    def name(self, address: AnyAddress) -> str:
        """
        Reverse resolve Ethereum address to ENS name.
        
        Parameters:
        - address: Ethereum address
        
        Returns:
        ENS name if configured, empty string otherwise
        """

    def resolver(self, name: str) -> ChecksumAddress:
        """
        Get resolver contract address for ENS name.
        
        Parameters:
        - name: ENS name
        
        Returns:
        Resolver contract address
        """

    def owner(self, name: str) -> ChecksumAddress:
        """
        Get owner address for ENS name.
        
        Parameters:
        - name: ENS name
        
        Returns:
        Owner address
        """

Async ENS Operations

Async version of ENS operations with the same interface.

class AsyncENS:
    def __init__(self, provider: AsyncBaseProvider = None):
        """
        Initialize async ENS instance.
        
        Parameters:  
        - provider: Async Web3 provider
        """

    async def address(self, name: str) -> ChecksumAddress:
        """
        Async resolve ENS name to address.
        
        Parameters:
        - name: ENS name
        
        Returns:
        Ethereum address
        """

    async def name(self, address: AnyAddress) -> str:
        """
        Async reverse resolve address to ENS name.
        
        Parameters:
        - address: Ethereum address
        
        Returns:
        ENS name
        """

    async def resolver(self, name: str) -> ChecksumAddress:
        """
        Async get resolver contract address.
        
        Parameters:
        - name: ENS name
        
        Returns:
        Resolver contract address
        """

    async def owner(self, name: str) -> ChecksumAddress:
        """
        Async get owner address.
        
        Parameters:
        - name: ENS name
        
        Returns:
        Owner address
        """

Base ENS

Base class providing common ENS functionality.

class BaseENS:
    def is_valid_name(self, name: str) -> bool:
        """
        Check if ENS name format is valid.
        
        Parameters:
        - name: ENS name to validate
        
        Returns:
        True if valid format
        """

    def namehash(self, name: str) -> HexBytes:
        """
        Calculate namehash for ENS name.
        
        Parameters:
        - name: ENS name
        
        Returns:
        Namehash as bytes
        """

    def label_to_hash(self, label: str) -> HexBytes:
        """
        Convert label to hash for ENS operations.
        
        Parameters:
        - label: ENS label
        
        Returns:
        Label hash
        """

ENS Exceptions

ENS-specific exception classes for error handling.

class AddressMismatch(ValueError):
    """Address does not match expected value."""

class BidTooLow(ValueError):
    """Bid amount is too low for auction."""

class InvalidLabel(ValueError):
    """ENS label format is invalid."""

class InvalidName(ValueError):
    """ENS name format is invalid."""

class UnauthorizedError(ValueError):
    """Unauthorized operation on ENS name."""

class UnderfundedBid(ValueError):
    """Insufficient funds for bid."""

class UnownedName(ValueError):
    """ENS name is not owned/registered."""

Usage Examples

Basic ENS Resolution

from web3 import Web3
from ens import ENS

# Initialize Web3 and ENS
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR-PROJECT-ID'))
ens = ENS.from_web3(w3)

# Resolve ENS name to address
address = ens.address('ethereum.eth')
print(f"ethereum.eth resolves to: {address}")

# Reverse resolve address to ENS name
name = ens.name('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')
print(f"Address resolves to: {name}")

# Check if name is valid
if ens.is_valid_name('test.eth'):
    print("Valid ENS name format")

ENS with Web3 Integration

from web3 import Web3

# ENS middleware is included by default
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR-PROJECT-ID'))

# Use ENS names directly in Web3 operations
balance = w3.eth.get_balance('ethereum.eth')
print(f"Balance for ethereum.eth: {w3.from_wei(balance, 'ether')} ETH")

# Send transaction to ENS name
transaction = {
    'from': w3.eth.accounts[0],
    'to': 'recipient.eth',  # ENS name resolved automatically
    'value': w3.to_wei(1, 'ether'),
    'gas': 21000,
    'gasPrice': w3.to_wei(20, 'gwei')
}

tx_hash = w3.eth.send_transaction(transaction)

Advanced ENS Operations

from web3 import Web3
from ens import ENS

w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR-PROJECT-ID'))
ens = ENS.from_web3(w3)

# Get ENS name owner
owner = ens.owner('example.eth')
print(f"Owner of example.eth: {owner}")

# Get resolver contract
resolver_address = ens.resolver('example.eth')
print(f"Resolver for example.eth: {resolver_address}")

# Calculate namehash
namehash = ens.namehash('subdomain.example.eth')
print(f"Namehash: {namehash.hex()}")

# Validate name format
names_to_check = ['valid.eth', 'invalid..eth', 'toolong.eth']
for name in names_to_check:
    if ens.is_valid_name(name):
        print(f"{name} is valid")
    else:
        print(f"{name} is invalid")

Error Handling

from web3 import Web3
from ens import ENS
from ens.exceptions import InvalidName, UnownedName

w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR-PROJECT-ID'))
ens = ENS.from_web3(w3)

try:
    # Try to resolve unregistered name
    address = ens.address('nonexistent-name-12345.eth')
    print(f"Address: {address}")
except UnownedName:
    print("ENS name is not registered")
except InvalidName:
    print("Invalid ENS name format")

try:
    # Try invalid name format
    address = ens.address('invalid..name.eth')
except InvalidName as e:
    print(f"Invalid name: {e}")

Async ENS Operations

import asyncio
from web3 import AsyncWeb3
from ens import AsyncENS

async def main():
    w3 = AsyncWeb3(AsyncWeb3.AsyncHTTPProvider('https://mainnet.infura.io/v3/YOUR-PROJECT-ID'))
    ens = AsyncENS.from_web3(w3)
    
    # Async ENS resolution
    address = await ens.address('ethereum.eth')
    print(f"ethereum.eth resolves to: {address}")
    
    # Async reverse resolution
    name = await ens.name('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')
    print(f"Address resolves to: {name}")
    
    # Get owner asynchronously
    owner = await ens.owner('ethereum.eth')
    print(f"Owner: {owner}")

asyncio.run(main())

Custom ENS Resolver

from web3 import Web3
from ens import ENS

w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR-PROJECT-ID'))

# Connect to specific ENS registry
custom_ens = ENS(
    provider=w3.provider,
    addr='0x314159265dd8dbb310642f98f50c066173c1259b'  # Custom ENS registry
)

# Use custom ENS instance
try:
    address = custom_ens.address('example.eth')
    print(f"Resolved via custom ENS: {address}")
except Exception as e:
    print(f"Resolution failed: {e}")

Batch ENS Operations

from web3 import Web3
from ens import ENS
from ens.exceptions import UnownedName

w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR-PROJECT-ID'))
ens = ENS.from_web3(w3)

# Batch resolve multiple names
names = ['ethereum.eth', 'ens.eth', 'example.eth']
addresses = {}

for name in names:
    try:
        address = ens.address(name)
        addresses[name] = address
        print(f"{name} -> {address}")
    except UnownedName:
        print(f"{name} is not registered")
    except Exception as e:
        print(f"Error resolving {name}: {e}")

print(f"Successfully resolved {len(addresses)} names")

Install with Tessl CLI

npx tessl i tessl/pypi-web3

docs

account-management.md

ens-operations.md

ethereum-operations.md

index.md

middleware.md

providers.md

smart-contracts.md

utilities.md

web3-client.md

tile.json