@hybrd/xmtp 1.0.0

package/src/resolver/ens-resolver.ts

@@ -0,0 +1,324 @@
+import { type Address, PublicClient } from "viem"
+
+interface ENSResolverOptions {
+	/**
+	 * Maximum number of ENS names to cache
+	 * @default 500
+	 */
+	maxCacheSize?: number
+	/**
+	 * Cache TTL in milliseconds
+	 * @default 3600000 (1 hour)
+	 */
+	cacheTtl?: number
+	/**
+	 * Mainnet public client for ENS resolution
+	 */
+	mainnetClient: PublicClient
+}
+
+interface CacheEntry {
+	address: string
+	timestamp: number
+}
+
+interface ReverseCacheEntry {
+	ensName: string
+	timestamp: number
+}
+
+/**
+ * ENS Resolver for mainnet .eth names
+ * Handles resolution of ENS names to addresses and reverse resolution
+ */
+export class ENSResolver {
+	private cache = new Map<string, CacheEntry>()
+	private reverseCache = new Map<string, ReverseCacheEntry>()
+	private readonly maxCacheSize: number
+	private readonly cacheTtl: number
+	private readonly mainnetClient: PublicClient
+
+	constructor(options: ENSResolverOptions) {
+		this.maxCacheSize = options.maxCacheSize ?? 500
+		this.cacheTtl = options.cacheTtl ?? 3600000 // 1 hour
+		this.mainnetClient = options.mainnetClient
+	}
+
+	/**
+	 * Resolve an ENS name to an Ethereum address
+	 */
+	async resolveENSName(ensName: string): Promise<Address | null> {
+		console.log(`🔍 Resolving ENS name: ${ensName}`)
+
+		try {
+			// Check cache first
+			const cached = this.getCachedAddress(ensName)
+			if (cached) {
+				console.log(`✅ Resolved ENS from cache: ${ensName} → ${cached}`)
+				return cached as Address
+			}
+
+			console.log(`📭 No cached address found for ENS: ${ensName}`)
+
+			// Resolve using mainnet ENS
+			console.log("🔄 Reading ENS contract...")
+			const address = await this.mainnetClient.getEnsAddress({
+				name: ensName
+			})
+
+			console.log(`📋 ENS contract returned address: "${address}"`)
+
+			if (address && address !== "0x0000000000000000000000000000000000000000") {
+				this.setCachedAddress(ensName, address)
+				console.log(`✅ Resolved ENS: ${ensName} → ${address}`)
+				return address
+			}
+
+			console.log(`❌ No address found for ENS: ${ensName}`)
+			return null
+		} catch (error) {
+			console.error(`❌ Error resolving ENS name ${ensName}:`, error)
+			if (error instanceof Error) {
+				console.error(`❌ Error details: ${error.message}`)
+			}
+			return null
+		}
+	}
+
+	/**
+	 * Resolve an address to its primary ENS name (reverse resolution)
+	 */
+	async resolveAddressToENS(address: Address): Promise<string | null> {
+		console.log(`🔍 Reverse resolving address to ENS: ${address}`)
+
+		try {
+			// Check cache first
+			const cached = this.getCachedENSName(address)
+			if (cached) {
+				console.log(
+					`✅ Resolved ENS from reverse cache: ${address} → ${cached}`
+				)
+				return cached
+			}
+
+			console.log(`📭 No cached ENS name found for address: ${address}`)
+
+			// Reverse resolve using mainnet ENS
+			console.log("🔄 Reading ENS reverse resolver...")
+			const ensName = await this.mainnetClient.getEnsName({
+				address: address
+			})
+
+			console.log(`📋 ENS reverse resolver returned: "${ensName}"`)
+
+			if (ensName && ensName.length > 0) {
+				this.setCachedENSName(address, ensName)
+				console.log(`✅ Reverse resolved: ${address} → ${ensName}`)
+				return ensName
+			}
+
+			console.log(`❌ No ENS name found for address: ${address}`)
+			return null
+		} catch (error) {
+			console.error(`❌ Error reverse resolving address ${address}:`, error)
+			if (error instanceof Error) {
+				console.error(`❌ Error details: ${error.message}`)
+			}
+			return null
+		}
+	}
+
+	/**
+	 * Get ENS avatar for a name
+	 */
+	async getENSAvatar(ensName: string): Promise<string | null> {
+		console.log(`🖼️ Getting ENS avatar for: ${ensName}`)
+
+		try {
+			const avatar = await this.mainnetClient.getEnsAvatar({
+				name: ensName
+			})
+
+			if (avatar) {
+				console.log(`✅ Found ENS avatar: ${avatar}`)
+				return avatar
+			}
+
+			console.log(`❌ No avatar found for ENS: ${ensName}`)
+			return null
+		} catch (error) {
+			console.error(`❌ Error getting ENS avatar for ${ensName}:`, error)
+			return null
+		}
+	}
+
+	/**
+	 * Get ENS text record
+	 */
+	async getENSTextRecord(ensName: string, key: string): Promise<string | null> {
+		console.log(`📝 Getting ENS text record "${key}" for: ${ensName}`)
+
+		try {
+			const textRecord = await this.mainnetClient.getEnsText({
+				name: ensName,
+				key: key
+			})
+
+			if (textRecord && textRecord.length > 0) {
+				console.log(`✅ Found ENS text record: ${key}=${textRecord}`)
+				return textRecord
+			}
+
+			console.log(`❌ No text record "${key}" found for ENS: ${ensName}`)
+			return null
+		} catch (error) {
+			console.error(
+				`❌ Error getting ENS text record ${key} for ${ensName}:`,
+				error
+			)
+			return null
+		}
+	}
+
+	/**
+	 * Get comprehensive ENS profile
+	 */
+	async getENSProfile(ensName: string) {
+		console.log(`👤 Getting ENS profile for: ${ensName}`)
+
+		try {
+			const [address, avatar, description, twitter, github, url] =
+				await Promise.all([
+					this.resolveENSName(ensName),
+					this.getENSAvatar(ensName),
+					this.getENSTextRecord(ensName, "description"),
+					this.getENSTextRecord(ensName, "com.twitter"),
+					this.getENSTextRecord(ensName, "com.github"),
+					this.getENSTextRecord(ensName, "url")
+				])
+
+			const profile = {
+				ensName,
+				address,
+				avatar,
+				description,
+				twitter,
+				github,
+				url
+			}
+
+			console.log(`✅ ENS profile for ${ensName}:`, profile)
+			return profile
+		} catch (error) {
+			console.error(`❌ Error getting ENS profile for ${ensName}:`, error)
+			return null
+		}
+	}
+
+	/**
+	 * Check if a name is a valid ENS name (.eth)
+	 */
+	isENSName(name: string): boolean {
+		return name.endsWith(".eth") && !name.endsWith(".base.eth")
+	}
+
+	/**
+	 * Get cached address if not expired
+	 */
+	private getCachedAddress(ensName: string): string | null {
+		const entry = this.cache.get(ensName.toLowerCase())
+		if (!entry) {
+			return null
+		}
+
+		const now = Date.now()
+		if (now - entry.timestamp > this.cacheTtl) {
+			this.cache.delete(ensName.toLowerCase())
+			return null
+		}
+
+		return entry.address
+	}
+
+	/**
+	 * Cache address with LRU eviction
+	 */
+	private setCachedAddress(ensName: string, address: string): void {
+		if (this.cache.size >= this.maxCacheSize) {
+			const firstKey = this.cache.keys().next().value
+			if (firstKey) {
+				this.cache.delete(firstKey)
+			}
+		}
+
+		this.cache.set(ensName.toLowerCase(), {
+			address,
+			timestamp: Date.now()
+		})
+	}
+
+	/**
+	 * Get cached ENS name if not expired
+	 */
+	private getCachedENSName(address: Address): string | null {
+		const entry = this.reverseCache.get(address.toLowerCase())
+		if (!entry) {
+			return null
+		}
+
+		const now = Date.now()
+		if (now - entry.timestamp > this.cacheTtl) {
+			this.reverseCache.delete(address.toLowerCase())
+			return null
+		}
+
+		return entry.ensName
+	}
+
+	/**
+	 * Cache ENS name with LRU eviction
+	 */
+	private setCachedENSName(address: Address, ensName: string): void {
+		if (this.reverseCache.size >= this.maxCacheSize) {
+			const firstKey = this.reverseCache.keys().next().value
+			if (firstKey) {
+				this.reverseCache.delete(firstKey)
+			}
+		}
+
+		this.reverseCache.set(address.toLowerCase(), {
+			ensName,
+			timestamp: Date.now()
+		})
+	}
+
+	/**
+	 * Clear all caches
+	 */
+	clearCache(): void {
+		const addressCount = this.cache.size
+		const ensCount = this.reverseCache.size
+
+		this.cache.clear()
+		this.reverseCache.clear()
+
+		console.log(`🗑️ ENS address cache cleared (${addressCount} entries removed)`)
+		console.log(`🗑️ ENS reverse cache cleared (${ensCount} entries removed)`)
+	}
+
+	/**
+	 * Get cache statistics
+	 */
+	getCacheStats() {
+		return {
+			addressCache: {
+				size: this.cache.size,
+				maxSize: this.maxCacheSize
+			},
+			reverseCache: {
+				size: this.reverseCache.size,
+				maxSize: this.maxCacheSize
+			}
+		}
+	}
+}

package/src/resolver/index.ts

@@ -0,0 +1 @@
+export * from "./resolver"

package/src/resolver/resolver.ts

@@ -0,0 +1,336 @@
+import { type Address, type PublicClient } from "viem"
+import type { XmtpClient, XmtpMessage, XmtpSender } from "../types"
+import { AddressResolver } from "./address-resolver"
+import {
+	type BaseName,
+	BasenameResolver,
+	type BasenameTextRecordKey
+} from "./basename-resolver"
+import { ENSResolver } from "./ens-resolver"
+import { XmtpResolver } from "./xmtp-resolver"
+
+interface ResolverOptions {
+	/**
+	 * XMTP Client for message and address resolution
+	 */
+	xmtpClient: XmtpClient
+	/**
+	 * Mainnet public client for ENS resolution
+	 */
+	mainnetClient: PublicClient
+	/**
+	 * Base network public client for basename resolution
+	 */
+	baseClient: PublicClient
+	/**
+	 * Maximum cache size for each resolver
+	 * @default 1000
+	 */
+	maxCacheSize?: number
+	/**
+	 * Cache TTL in milliseconds
+	 * @default 3600000 (1 hour)
+	 */
+	cacheTtl?: number
+}
+
+/**
+ * Master Resolver that wraps all individual resolvers
+ * Provides a unified interface for basename, ENS, address, and XMTP resolution
+ */
+export class Resolver {
+	private addressResolver: AddressResolver
+	private ensResolver: ENSResolver
+	private basenameResolver: BasenameResolver
+	private xmtpResolver: XmtpResolver
+
+	constructor(options: ResolverOptions) {
+		const resolverOptions = {
+			maxCacheSize: options.maxCacheSize ?? 1000,
+			cacheTtl: options.cacheTtl ?? 3600000
+		}
+
+		this.addressResolver = new AddressResolver(
+			options.xmtpClient,
+			resolverOptions
+		)
+		this.xmtpResolver = new XmtpResolver(options.xmtpClient, resolverOptions)
+
+		// Type assertions needed due to viem version differences across monorepo packages
+		// Both clients are PublicClient-compatible but TypeScript sees them as incompatible types
+		this.ensResolver = new ENSResolver({
+			...resolverOptions,
+			mainnetClient: options.mainnetClient as PublicClient
+		})
+		this.basenameResolver = new BasenameResolver({
+			...resolverOptions,
+			publicClient: options.baseClient as PublicClient
+		})
+	}
+
+	// === Address Resolution Methods ===
+
+	/**
+	 * Resolve user address from inbox ID with caching
+	 * Uses both AddressResolver and XmtpResolver for redundancy
+	 */
+	async resolveAddress(
+		inboxId: string,
+		conversationId?: string
+	): Promise<`0x${string}` | null> {
+		// Try AddressResolver first, fallback to XmtpResolver
+		let result = await this.addressResolver.resolveAddress(
+			inboxId,
+			conversationId
+		)
+		if (!result) {
+			result = await this.xmtpResolver.resolveAddress(inboxId, conversationId)
+		}
+		return result
+	}
+
+	// === ENS Resolution Methods ===
+
+	/**
+	 * Resolve an ENS name to an Ethereum address
+	 */
+	async resolveENSName(ensName: string): Promise<Address | null> {
+		return this.ensResolver.resolveENSName(ensName)
+	}
+
+	/**
+	 * Resolve an address to its primary ENS name (reverse resolution)
+	 */
+	async resolveAddressToENS(address: Address): Promise<string | null> {
+		return this.ensResolver.resolveAddressToENS(address)
+	}
+
+	/**
+	 * Get ENS avatar for a given ENS name
+	 */
+	async getENSAvatar(ensName: string): Promise<string | null> {
+		return this.ensResolver.getENSAvatar(ensName)
+	}
+
+	/**
+	 * Get ENS text record for a given ENS name and key
+	 */
+	async getENSTextRecord(ensName: string, key: string): Promise<string | null> {
+		return this.ensResolver.getENSTextRecord(ensName, key)
+	}
+
+	/**
+	 * Get complete ENS profile for a given ENS name
+	 */
+	async getENSProfile(ensName: string) {
+		return this.ensResolver.getENSProfile(ensName)
+	}
+
+	// === Basename Resolution Methods ===
+
+	/**
+	 * Get basename from an Ethereum address
+	 */
+	async getBasename(address: Address): Promise<string | null> {
+		return this.basenameResolver.getBasename(address)
+	}
+
+	/**
+	 * Get basename avatar for a given basename
+	 */
+	async getBasenameAvatar(basename: BaseName): Promise<string | null> {
+		return this.basenameResolver.getBasenameAvatar(basename)
+	}
+
+	/**
+	 * Get basename text record for a given basename and key
+	 */
+	async getBasenameTextRecord(
+		basename: BaseName,
+		key: BasenameTextRecordKey
+	): Promise<string | null> {
+		return this.basenameResolver.getBasenameTextRecord(basename, key)
+	}
+
+	/**
+	 * Resolve basename to an Ethereum address
+	 */
+	async getBasenameAddress(basename: BaseName): Promise<Address | null> {
+		return this.basenameResolver.getBasenameAddress(basename)
+	}
+
+	/**
+	 * Get basename metadata for a given basename
+	 */
+	async getBasenameMetadata(basename: BaseName) {
+		return this.basenameResolver.getBasenameMetadata(basename)
+	}
+
+	/**
+	 * Get complete basename profile for a given address
+	 */
+	async resolveBasenameProfile(address: Address) {
+		return this.basenameResolver.resolveBasenameProfile(address)
+	}
+
+	// === XMTP Message Methods ===
+
+	/**
+	 * Find any message by ID with caching
+	 */
+	async findMessage(messageId: string): Promise<XmtpMessage | null> {
+		return this.xmtpResolver.findMessage(messageId)
+	}
+
+	/**
+	 * Find root message by ID (traverses reply chain)
+	 */
+	async findRootMessage(messageId: string): Promise<XmtpMessage | null> {
+		return this.xmtpResolver.findRootMessage(messageId)
+	}
+
+	// === Universal Resolution Methods ===
+
+	/**
+	 * Universal name resolution - tries to resolve any name (ENS or basename) to an address
+	 */
+	async resolveName(name: string): Promise<Address | null> {
+		// Try ENS first (more common)
+		if (name.endsWith(".eth")) {
+			return this.resolveENSName(name)
+		}
+
+		// Try basename
+		if (name.endsWith(".base.eth")) {
+			return this.getBasenameAddress(name)
+		}
+
+		// If no TLD, try both
+		const ensResult = await this.resolveENSName(name)
+		if (ensResult) {
+			return ensResult
+		}
+
+		return this.getBasenameAddress(name)
+	}
+
+	/**
+	 * Universal reverse resolution - tries to resolve an address to any name (ENS or basename)
+	 */
+	async resolveAddressToName(address: Address): Promise<string | null> {
+		// Try basename first (more relevant for this project)
+		const basename = await this.getBasename(address)
+		if (basename) {
+			return basename
+		}
+
+		// Try ENS as fallback
+		return this.resolveAddressToENS(address)
+	}
+
+	/**
+	 * Get complete profile for an address (combines ENS and basename data)
+	 */
+	async getCompleteProfile(address: Address) {
+		const [ensName, basename, ensProfile, basenameProfile] =
+			await Promise.allSettled([
+				this.resolveAddressToENS(address),
+				this.getBasename(address),
+				this.resolveAddressToENS(address).then((name) =>
+					name ? this.getENSProfile(name) : null
+				),
+				this.resolveBasenameProfile(address)
+			])
+
+		return {
+			address,
+			ensName: ensName.status === "fulfilled" ? ensName.value : null,
+			basename: basename.status === "fulfilled" ? basename.value : null,
+			ensProfile: ensProfile.status === "fulfilled" ? ensProfile.value : null,
+			basenameProfile:
+				basenameProfile.status === "fulfilled" ? basenameProfile.value : null
+		}
+	}
+
+	// === Cache Management Methods ===
+
+	/**
+	 * Pre-populate all resolver caches
+	 */
+	async prePopulateAllCaches(): Promise<void> {
+		await Promise.allSettled([
+			this.addressResolver.prePopulateCache(),
+			this.xmtpResolver.prePopulateCache()
+		])
+	}
+
+	/**
+	 * Create a complete XmtpSender object from an address or inboxId
+	 * Uses the resolver to get the best available name and profile information
+	 */
+	async createXmtpSender(
+		addressOrInboxId: string,
+		conversationId?: string
+	): Promise<XmtpSender> {
+		let address: `0x${string}` | null = null
+		let inboxId = addressOrInboxId
+
+		// Check if input looks like an Ethereum address
+		if (addressOrInboxId.startsWith("0x") && addressOrInboxId.length === 42) {
+			address = addressOrInboxId as `0x${string}`
+			// When we have an address, we need to find the actual inboxId
+			// For now, use address as fallback but this should be resolved from XMTP
+			inboxId = addressOrInboxId // This will be improved when we have proper address->inboxId resolution
+		} else {
+			// Assume it's an inboxId, try to resolve to address
+			address = await this.resolveAddress(addressOrInboxId, conversationId)
+		}
+
+		// Get the best available name using universal resolution
+		let name = "Unknown"
+		let basename: string | undefined
+
+		if (address) {
+			// Try basename first since that's what we expect for this address
+			const basenameResult = await this.getBasename(address)
+			console.log(
+				`🔍 [RESOLVER] Direct basename lookup for ${address}:`,
+				basenameResult
+			)
+
+			// Try to get a human-readable name
+			const resolvedName = await this.resolveAddressToName(address)
+			console.log(
+				`🔍 [RESOLVER] Universal name resolution for ${address}:`,
+				resolvedName
+			)
+
+			if (resolvedName) {
+				name = resolvedName
+				// Check if it's a basename specifically
+				if (resolvedName.endsWith(".base.eth")) {
+					basename = resolvedName
+				}
+			} else {
+				// Fallback to shortened address
+				name = `${address.slice(0, 6)}...${address.slice(-4)}`
+			}
+
+			// Always try to get basename even if ENS was found
+			if (!basename) {
+				const resolvedBasename = await this.getBasename(address)
+				basename = resolvedBasename || undefined
+			}
+		} else {
+			// No address resolution available, use inboxId
+			name = `${inboxId.slice(0, 8)}...${inboxId.slice(-4)}`
+		}
+
+		return {
+			address: address || addressOrInboxId,
+			inboxId,
+			name,
+			basename
+		}
+	}
+}