ODude SDK

A comprehensive, developer-friendly npm package for interacting with the ODude smart contracts ecosystem across multiple blockchain networks. This SDK provides easy-to-use wrappers for Registry, Resolver, TLD, and RWAirdrop contracts with seamless multi-network support.

Features

- 🚀 Simple and intuitive API - Easy to use for both beginners and experts
- 🌐 Multi-network support - Base Sepolia, Filecoin, BNB Chain, Localhost
- 🔄 Automatic TLD-based network routing - Smart routing based on domain TLD
- 📦 Full TypeScript support - Complete type definitions and IntelliSense
- 🔧 Built on ethers.js v6 - Modern, secure, and well-maintained foundation
- 🧪 Comprehensive test coverage - Thoroughly tested with 50+ test cases
- 📚 Well-documented with examples - Extensive documentation and examples
- 🎯 Helper utilities - Name parsing, formatting, and validation utilities
- 🔍 Batch operations - Efficient bulk queries and operations
- 📡 Event monitoring - Real-time event listening across networks
- ⚡ Retry logic - Configurable retry limits for network resilience
- 🌳 Tree-shakeable - Import only what you need for optimal bundle size
- 🔀 Dual module support - Works with both CommonJS and ES Modules
- 🌍 Universal compatibility - Node.js, browsers, Next.js, and modern bundlers

Installation

$3

``bash
npm install @odude/odude-sdk
`

$3

`bash
yarn add @odude/odude-sdk
`

$3

`bash
pnpm add @odude/odude-sdk
`

$3

- Node.js 16+ (for Node.js environments)
- Modern browser with ES2020 support (for browser environments)
- TypeScript 4.5+ (for TypeScript projects)

Table of Contents

1. Quick Start
2. TypeScript Usage
3. Configuration
4. Core Concepts
5. Import Patterns
6. API Reference
7. Extended Functions
8. Usage Examples
9. Testing
10. Browser Usage
11. Next.js Integration
12. Troubleshooting

Quick Start

$3

The ODude SDK supports multiple networks with automatic TLD-based routing:

`javascript
const ODudeSDK = require('@odude/odude-sdk');

// Initialize SDK with multiple network RPC URLs
const sdk = new ODudeSDK({
rpcUrl_filecoin: 'https://api.node.glif.io',
rpcUrl_bnb: 'https://bsc-dataseed1.binance.org',
rpcUrl_sepolia: 'https://sepolia.base.org'
});

// Connect to all networks
sdk.connectAllNetworks();

// The SDK automatically routes based on TLD:
// - @fil, @fvm domains → Filecoin network
// - @bnb, @binance domains → BNB Smart Chain
// - Other domains → Base Sepolia (default)

// Resolve names automatically routes to correct network
const address = await sdk.resolve('alice@fil'); // Uses Filecoin network
const bnbAddress = await sdk.resolve('bob@bnb'); // Uses BNB network
`

Note: Currently, only Base Sepolia network has deployed contracts and is fully functional.

TypeScript Usage

The ODude SDK is built with TypeScript and provides comprehensive type definitions for all functions, interfaces, and classes.

$3

`typescript
import ODudeSDK, {
ODudeSDKConfig,
NameInfo,
NetworkInfo,
NameNotFoundError
} from '@odude/odude-sdk';

// Type-safe configuration
const config: ODudeSDKConfig = {
rpcUrl_sepolia: 'https://sepolia.base.org',
rpcUrl_filecoin: 'https://api.node.glif.io',
privateKey: process.env.PRIVATE_KEY
};

// Create SDK instance with full type support
const sdk = new ODudeSDK(config);

// Connect to networks
await sdk.connectAllNetworks();

// Type-safe method calls with IntelliSense
try {
const address: string = await sdk.resolve('alice@crypto');
const nameInfo: NameInfo = await sdk.getNameInfo('alice@crypto');
const networkInfo: NetworkInfo = sdk.NetworkList();

console.log('Resolved address:', address);
console.log('Name info:', nameInfo);
} catch (error) {
if (error instanceof NameNotFoundError) {
console.log('Name not found:', error.domainName);
}
}
`

$3

`typescript
import {
ODudeSDK,
Registry,
Resolver,
TLD,
RWAirdrop,
AirdropInfo,
MintEligibility,
TransferCallback,
NameResolvedCallback
} from '@odude/odude-sdk';
import { BigNumberish, ContractTransactionResponse } from 'ethers';

class ODudeManager {
private sdk: ODudeSDK;

constructor(config: ODudeSDKConfig) {
this.sdk = new ODudeSDK(config);
}

async initialize(): Promise {
await this.sdk.connectAllNetworks();
this.setupEventListeners();
}

private setupEventListeners(): void {
// Type-safe event callbacks
const transferCallback: TransferCallback = (from, to, tokenId) => {
console.log(Transfer: ${from} → ${to} (Token: ${tokenId}));
};

const nameResolvedCallback: NameResolvedCallback = (name, address) => {
console.log(Name resolved: ${name} → ${address});
};

this.sdk.onTransfer(transferCallback);
this.sdk.onNameResolved(nameResolvedCallback);
}

async mintDomain(
domainName: string,
recipient: string
): Promise {
const tld: TLD = this.sdk.tld();

// Check eligibility with full type safety
const eligibility: MintEligibility = await tld.checkMintEligibility(domainName);

if (!eligibility.eligible) {
throw new Error(Cannot mint ${domainName}: ${eligibility.reason});
}

// Mint with proper typing
return await tld.mintDomain(domainName, recipient, {
value: eligibility.cost
});
}

async getAirdropStatus(address: string): Promise {
const rwairdrop: RWAirdrop = this.sdk.rwairdrop();
return await rwairdrop.getAirdropInfo(address);
}
}

// Usage
const manager = new ODudeManager({
rpcUrl_sepolia: 'https://sepolia.base.org',
privateKey: process.env.PRIVATE_KEY
});

await manager.initialize();
`

$3

The SDK exports comprehensive TypeScript types:

`typescript
// Configuration types
import type {
ODudeSDKConfig,
ContractAddresses,
NetworkConfig,
NetworkInfo
} from '@odude/odude-sdk';

// Data types
import type {
NameInfo,
NFTMetadata,
ResolutionRecord,
ReverseRecord,
AirdropInfo,
MintEligibility,
ParsedName
} from '@odude/odude-sdk';

// Error types
import type {
ODudeSDKError,
NameNotFoundError,
NetworkError,
UnsupportedTLDError
} from '@odude/odude-sdk';

// Callback types
import type {
TransferCallback,
NameResolvedCallback,
DomainMintedCallback
} from '@odude/odude-sdk';
`

Configuration

$3

You can also configure RPC URLs using environment variables:

`bash


Set environment variables


export FILECOIN_RPC_URL="https://your-filecoin-rpc.com"
export BNB_RPC_URL="https://your-bnb-rpc.com"
export BASE_SEPOLIA_RPC_URL="https://your-base-sepolia-rpc.com"
`

`javascript
// SDK will automatically use environment variables
const sdk = new ODudeSDK();
sdk.connectAllNetworks();
`

$3

`javascript
const ODudeSDK = require('odude-sdk');

// Initialize SDK with localhost
const sdk = new ODudeSDK({
rpcUrl: 'http://127.0.0.1:8545'
});

// Connect to deployed contracts
sdk.connectLocalhost();

// Now you can use all contracts
const totalSupply = await sdk.registry().totalSupply();
console.log('Total names registered:', totalSupply.toString());
`

$3

`javascript
const ODudeSDK = require('odude-sdk');

// Connect to a specific network
const sdk = new ODudeSDK();
sdk.connectNetwork('basesepolia'); // or 'filecoin', 'bnb', 'localhost'

// Access contracts for the connected network
const registry = sdk.registry;
const resolver = sdk.resolver;
`

$3

`javascript
const { Wallet } = require('ethers');
const ODudeSDK = require('odude-sdk');

const sdk = new ODudeSDK({
rpcUrl: 'http://127.0.0.1:8545',
privateKey: 'YOUR_PRIVATE_KEY'
});

sdk.connectLocalhost();

// Now you can perform write operations
const tx = await sdk.registry().setReverse(tokenId);
await tx.wait();
`

Core Concepts

$3

The ODude SDK is designed to work seamlessly across multiple blockchain networks:

- Base Sepolia (default): Primary testnet with full contract deployment
- Filecoin: For FIL/FVM ecosystem domains
- BNB Chain: For BNB/Binance ecosystem domains
- Localhost: For local development and testing

$3

The SDK automatically routes operations to the correct network based on the TLD (Top-Level Domain):

`javascript
// These automatically route to the correct network
await sdk.resolve('alice@fil'); // → Filecoin network
await sdk.resolve('bob@bnb'); // → BNB Chain
await sdk.resolve('charlie@crypto'); // → Base Sepolia (default)
`

TLD Mappings:
- @fil, @fvm → Filecoin network
- @bnb, @binance → BNB Chain
- All other TLDs → Base Sepolia (default network)

$3

The SDK provides access to four main contracts:

1. Registry: NFT-based name ownership and management
2. Resolver: Name-to-address resolution and reverse resolution
3. TLD: Top-level domain management and pricing
4. RWAirdrop: Token airdrop functionality for domain holders

$3

ODude uses the @ symbol for domain separation (not .):

`javascript
// ✅ Correct format
'alice@crypto'
'subdomain@alice@crypto'
'test@fil'

// ❌ Incorrect format
'alice.crypto'
'test.fil'
`

$3

The SDK includes intelligent network detection with automatic retry:

- Maximum 3 retry attempts for network detection
- Graceful fallback for failed connections
- Detailed error logging for debugging
- Skip network detection for external RPCs to avoid timeouts

$3

The SDK manages providers and signers for each network:

`javascript
// Get provider for specific network
const provider = sdk.getProvider('basesepolia');

// Get signer for write operations
const signer = sdk.getSigner('basesepolia');

// Connect custom signer
sdk.connectSigner(customSigner, 'basesepolia');
`

Import Patterns

The ODude SDK supports multiple import patterns for maximum compatibility:

$3

`javascript
// Default import
const ODudeSDK = require('@odude/odude-sdk');
const sdk = new ODudeSDK();

// Named imports
const { ODudeSDK, Registry, Resolver, utils } = require('@odude/odude-sdk');

// Error imports
const { NameNotFoundError, NetworkError } = require('@odude/odude-sdk');
`

$3

`javascript
// Default import
import ODudeSDK from '@odude/odude-sdk';
const sdk = new ODudeSDK();

// Named imports
import { ODudeSDK, Registry, Resolver, utils } from '@odude/odude-sdk';

// Mixed imports
import ODudeSDK, { NameNotFoundError, NetworkError } from '@odude/odude-sdk';

// Tree-shaking friendly imports
import { utils } from '@odude/odude-sdk';
const normalized = utils.normalizeName('TEST@CRYPTO');
`

$3

`typescript
// Default import with types
import ODudeSDK, { ODudeSDKConfig } from '@odude/odude-sdk';

// Named imports with types
import {
ODudeSDK,
Registry,
NameInfo,
NetworkError
} from '@odude/odude-sdk';

// Type-only imports
import type {
ODudeSDKConfig,
NameInfo,
AirdropInfo
} from '@odude/odude-sdk';
`

$3

`html


`

$3

`javascript
// Lazy loading
const loadSDK = async () => {
const { ODudeSDK } = await import('@odude/odude-sdk');
return new ODudeSDK();
};

// Conditional loading
if (typeof window !== 'undefined') {
const { ODudeSDK } = await import('@odude/odude-sdk');
// Browser-specific code
}
`

Usage Examples

$3

`javascript
// Get name information
const tokenId = await sdk.registry().getTokenId('alice@crypto');
const owner = await sdk.registry().ownerOf(tokenId);
const metadata = await sdk.registry().getNFTMetadata(tokenId);

console.log('Token ID:', tokenId.toString());
console.log('Owner:', owner);
console.log('Metadata:', metadata);

// Get owner by name
const ownerAddress = await sdk.registry().getOwnerByName('alice@crypto');

// Get name by token ID
const name = await sdk.registry().nameOf(tokenId);

// Get total supply
const totalSupply = await sdk.registry().totalSupply();

// mintDomain a name (requires signer)
const tx = await sdk.registry().mintDomain(
tokenId,
'myname@crypto',
'ipfs://...',
recipientAddress,
{ value: ethers.parseEther('0.1') }
);
await tx.wait();

// Set reverse resolution
const reverseTx = await sdk.registry().setReverse(tokenId);
await reverseTx.wait();

// Listen to events
sdk.registry().onTLDMinted((tokenId, name, owner) => {
console.log('New TLD minted:', name, 'by', owner);
});
`

$3

`javascript
// Resolve name to address
const address = await sdk.resolver().resolve('alice@crypto');
console.log('Resolved address:', address);

// Reverse resolve address to name
const name = await sdk.resolver().reverse('0x...');
console.log('Primary name:', name);

// Check if name exists
const exists = await sdk.resolver().nameExists('alice@crypto');

// Get resolution record
const record = await sdk.resolver().getResolutionRecord('alice@crypto');
console.log('Resolution record:', record);
// {
// resolvedAddress: '0x...',
// name: 'alice@crypto',
// tokenId: 123n,
// exists: true
// }

// Get reverse record
const reverseRecord = await sdk.resolver().getReverseRecord('0x...');
console.log('Reverse record:', reverseRecord);
// {
// primaryName: 'alice@crypto',
// primaryTokenId: 123n,
// exists: true
// }

// Check if address has reverse
const hasReverse = await sdk.resolver().hasReverse('0x...');
`

$3

`javascript
// Get base TLD price
const basePrice = await sdk.tld().getBaseTLDPrice();
console.log('Base TLD price:', ethers.formatEther(basePrice), 'ETH');

// Get TLD-specific price
const tldPrice = await sdk.tld().getTLDPrice(tldTokenId);

// Get commission rate
const commission = await sdk.tld().getCommission(tldTokenId);
console.log('Commission:', commission.toString(), '%');

// Get TLD owner
const tldOwner = await sdk.tld().getTLDOwner(tldTokenId);

// Check if TLD is active
const isActive = await sdk.tld().isTLDActive(tldTokenId);

// Get TLD name
const tldName = await sdk.tld().getTLDName(tldTokenId);

// Set TLD price (requires signer and ownership)
const tx = await sdk.tld().setTLDPrice(tldTokenId, ethers.parseEther('0.05'));
await tx.wait();

// Set commission (requires signer and ownership)
const commissionTx = await sdk.tld().setCommission(tldTokenId, 15);
await commissionTx.wait();

// New TLD Management Functions
// Set ERC token for a TLD
const setErcTx = await sdk.tld().setErcToken(tldTokenId, '0x...');
await setErcTx.wait();

// Get ERC token for a TLD
const ercToken = await sdk.tld().getErcToken(tldTokenId);

// Get token price for a TLD (same as TLD price)
const tokenPrice = await sdk.tld().getTokenPrice(tldTokenId);

// Domain Minting Functions
// Check if domain is eligible for minting
const eligibility = await sdk.tld().checkMintEligibility('alice@fil');
console.log('Eligibility:', eligibility);
// {
// eligible: true,
// available: true,
// tldActive: true,
// cost: 500000000000000000n,
// reason: 'Eligible for minting'
// }

// Estimate minting cost
const cost = await sdk.tld().estimateMintCost('alice@fil');
console.log('Minting cost:', ethers.formatEther(cost), 'ETH');

// Mint domain
const mintTx = await sdk.tld().mintDomain(
'alice@fil',
'0x...',
{ value: cost }
);
await mintTx.wait();

// TLD Minting Functions
// Check TLD minting eligibility (no @ symbol for TLD names)
const tldEligibility = await sdk.tld().checkMintEligibility('mycompany');
console.log('TLD Eligibility:', tldEligibility);
// {
// eligible: true,
// available: true,
// tldActive: true, // Not applicable for TLD minting
// cost: 1000000000000000000n, // Base TLD price
// reason: 'Eligible for TLD minting'
// }

// Mint a TLD (Top-Level Domain)
const tldMintTx = await sdk.mintTLD('mycompany', '0x...', {
value: tldEligibility.cost
});
await tldMintTx.wait();
`

$3

`javascript
// Get claimable airdrops for a user
const claimableAirdrops = await sdk.rwairdrop().getClaimableAirdrops('0x...');
console.log('Claimable airdrops:', claimableAirdrops.length);

// Get airdrop information for a specific TLD and airdrop ID
const airdropInfo = await sdk.rwairdrop().getAirdropInfoByTLD('crypto', 0);
console.log('Airdrop info:', airdropInfo);
// {
// tokenAddress: '0x...',
// totalAmount: 1000000000000000000n,
// perUserShare: 100000000000000000n,
// remainingBalance: 900000000000000000n,
// granter: '0x...',
// tldOwner: '0x...',
// isActive: true,
// isWithdrawn: false,
// createdAt: 1234567890n,
// airdropId: 0n
// }

// Check if a domain has claimed from an airdrop
const hasClaimed = await sdk.rwairdrop().hasDomainClaimed('alice@crypto', 0);

// Get user domains in a specific TLD
const userDomains = await sdk.rwairdrop().getUserDomainsInTLD('0x...', 'crypto');

// Claim airdrop share (requires signer)
const claimTx = await sdk.rwairdrop().claimShare('crypto', 0, 'alice@crypto');
await claimTx.wait();
console.log('Airdrop claimed!');

// Create an airdrop (requires signer and TLD ownership)
const createTx = await sdk.rwairdrop().createAirdrop(
'crypto',
'0x...', // token address
ethers.parseEther('100'), // total amount
ethers.parseEther('1') // per user share
);
await createTx.wait();

// Sync your domains (new method - replaces old syncDomainOwnership)
const domains = ['alice@crypto', 'bob@crypto'];
const syncTx = await sdk.rwairdrop().syncMyDomains(domains);
await syncTx.wait();
console.log('Domains synced!');

// Admin-only: Emergency sync for data recovery
// (Only contract owner can call this)
const adminSyncTx = await sdk.rwairdrop().syncDomainOwnershipsAdmin(
['alice@crypto', 'bob@crypto'],
['0x...', '0x...'] // corresponding owners
);
await adminSyncTx.wait();
`

$3

`javascript
const { utils } = sdk;

// Normalize name
const normalized = utils.normalizeName('ALICE@CRYPTO');
// 'alice@crypto'

// Extract TLD
const tld = utils.extractTLD('alice@crypto');
// 'crypto'

// Extract subdomain
const subdomain = utils.extractSubdomain('alice@crypto');
// 'alice'

// Check if TLD
const isTLD = utils.isTLD('crypto');
// true

// Check if subdomain
const isSubdomain = utils.isSubdomain('alice@crypto');
// true

// Parse name
const parsed = utils.parseName('demo@alice@crypto');
// {
// full: 'demo@alice@crypto',
// tld: 'crypto',
// subdomain: 'demo@alice',
// parts: ['demo', 'alice', 'crypto'],
// isTLD: false,
// isSubdomain: true
// }

// Validate address
const isValid = utils.isValidAddress('0x...');

// Format token ID
const formatted = utils.formatTokenId(123n);
// '123'

// Parse and format ether
const wei = utils.parseEther('1.0');
const ether = utils.formatEther(wei);

// Generate random token ID
const tokenId = utils.randomTokenId();
// 1234567890 (random 10-digit number)

// Validate sub-name format
const isValidName = utils.isValidSubName('test@sepolia');
// true
const isInvalidName = utils.isValidSubName('test@@sepolia');
// false
`

$3

`javascript
// Quick resolve
const address = await sdk.resolve('alice@crypto');

// Quick reverse
const name = await sdk.reverse('0x...');

// Get owner (throws error if not found)
const owner = await sdk.getOwner('alice@crypto');

// Get owner safely (returns null if not found)
const ownerSafe = await sdk.getOwnerSafe('alice@crypto');

// Check if domain exists
const exists = await sdk.domainExists('alice@crypto');

// Get comprehensive domain status
const status = await sdk.getDomainStatus('alice@crypto');
console.log(status);
// {
// name: 'alice@crypto',
// exists: true,
// owner: '0x...',
// canMint: false,
// mintEligibility: null,
// inAirdropContract: true,
// claimableAirdrops: 3,
// airdropDetails: [...]
// }

// Get comprehensive name info
const nameInfo = await sdk.getNameInfo('alice@crypto');
console.log(nameInfo);
// {
// name: 'alice@crypto',
// tokenId: 123n,
// owner: '0x...',
// metadata: { ... },
// tokenURI: 'ipfs://...',
// resolvedAddress: '0x...',
// exists: true
// }

// Get user domains from RWAirdrop contract
const domains = await sdk.rwairdrop().getUserDomainsInTLD('0x...', 'crypto');

// Get airdrop info
const airdropInfo = await sdk.getAirdropInfo('0x...');

// Mint a domain (requires signer)
const mintTx = await sdk.mintDomain('alice@crypto', recipientAddress, {
value: ethers.parseEther('0.1')
});
await mintTx.wait();

// Mint a TLD (requires signer and more ETH)
const tldMintTx = await sdk.mintTLD('mycompany', recipientAddress, {
value: ethers.parseEther('1.0') // TLD minting typically costs more
});
await tldMintTx.wait();
`

TLD vs Subdomain Minting

The ODude SDK supports two types of domain minting:

$3


- Format: Single name without @ symbol (e.g., crypto, sepolia, mycompany)
- Cost: Higher cost (typically 1+ ETH)
- Benefits:
- Own the entire TLD namespace
- Set pricing for subdomains under your TLD
- Earn commission from subdomain sales
- Control TLD policies and settings
- Method: sdk.mintTLD(tldName, toAddress, options)
- Example: node examples/TLDMint.js

$3

- Format: Name with @ symbol (e.g., alice@crypto, bob@sepolia)
- Cost: Lower cost (set by TLD owner)
- Benefits:
- Get a unique name under an existing TLD
- Use for identity, websites, or applications
- Transfer ownership like any NFT
- Method: sdk.mintDomain(domainName, toAddress, options)
- Example: node examples/SubNameMint.js

$3

- Eligibility Checking: TLD minting checks if TLD already exists; subdomain minting checks if TLD is active and subdomain is available
- Pricing: TLD uses base TLD price; subdomain uses TLD-specific pricing
- Registration: TLD minting includes automatic TLD registration; subdomain minting only creates the NFT

Enhanced Domain Management

The ODude SDK v2.0+ includes enhanced domain management features with improved error handling, automatic synchronization, and comprehensive status checking.

$3

#### domainExists(name)
Check if a domain exists without throwing errors.

`javascript
const exists = await sdk.domainExists('test@crypto');
console.log('Domain exists:', exists); // true or false
`

#### getOwnerSafe(name)
Get domain owner with safe error handling (returns null instead of throwing).

`javascript
const owner = await sdk.getOwnerSafe('test@crypto');
console.log('Owner:', owner); // address or null
`

#### getDomainStatus(name)
Get comprehensive domain information including existence, ownership, and airdrop status.

`javascript
const status = await sdk.getDomainStatus('test@crypto');
console.log(status);
// {
// name: 'test@crypto',
// exists: true,
// owner: '0x...',
// canMint: false,
// mintEligibility: null,
// inAirdropContract: true,
// claimableAirdrops: 3,
// airdropDetails: [...]
// }
`

$3

The RWAirdrop contract provides synchronization functions to keep domain ownership data in sync:

#### Available Functions
- ✅ syncMyDomains(domainNames[]) - Domain holders sync all their domains at once
- ✅ syncDomainOwnershipsAdmin(domainNames[], owners[]) - Emergency/admin-only function for data recovery

#### Usage Examples

`javascript
// User syncs their own domains
const myDomains = ['alice@crypto', 'bob@crypto'];
await sdk.rwairdrop().syncMyDomains(myDomains);

// Admin emergency sync (admin only)
await sdk.rwairdrop().syncDomainOwnershipsAdmin(
['alice@crypto', 'bob@crypto'],
['0x...', '0x...']
);
`

$3

- Fixed Domain Format Parsing: All methods now correctly use @ separator instead of .
- Better Error Handling: Safe methods return null instead of throwing errors
- Automatic Synchronization: Airdrop operations automatically sync with Registry contract
- Comprehensive Status: Single method to get complete domain information

Extended Functions

The SDK provides additional extended functions for comprehensive name management and querying.

$3

Get the total number of names owned by a specific address.

`javascript
const totalNames = await sdk.getTotalNames('0x...');
console.log('Total names owned:', totalNames.toString());
`

Parameters:
- address (string): Wallet address to check

Returns: Promise - Total number of names owned

Use Case: Check how many domains a wallet owns before fetching the full list.

$3

Get a list of all names owned by a specific address with their token IDs.

`javascript
const namesList = await sdk.getNamesList('0x...');
console.log('Names owned:');
namesList.forEach(item => {
console.log( ${item.name} (Token ID: ${item.tokenId}));
});
`

Parameters:
- address (string): Wallet address to query

Returns: Promise> - Array of name objects

Use Case: Display all domains owned by a user in a portfolio view.

$3

Get comprehensive details about a specific name including metadata, ownership, and resolution status.

`javascript
const details = await sdk.getNameDetails('alice@crypto');
console.log('Name Details:', {
name: details.name,
tokenId: details.tokenId,
owner: details.owner,
exists: details.exists,
resolvedAddress: details.resolvedAddress,
tokenURI: details.tokenURI,
metadata: details.metadata
});
`

Parameters:
- name (string): ODude name to query (format: name@tld)

Returns: Promise