@hybrd/xmtp 1.3.2 → 1.4.0

package/src/resolver/address-resolver.ts

@@ -1,221 +1,227 @@
 import type { XmtpClient } from "../types"
+import { logger } from "@hybrd/utils"
 
 interface AddressResolverOptions {
-  /**
-   * Maximum number of addresses to cache
-   * @default 1000
-   */
-  maxCacheSize?: number
-  /**
-   * Cache TTL in milliseconds
-   * @default 86400000 (24 hours)
-   */
-  cacheTtl?: number
+	/**
+	 * Maximum number of addresses to cache
+	 * @default 1000
+	 */
+	maxCacheSize?: number
+	/**
+	 * Cache TTL in milliseconds
+	 * @default 86400000 (24 hours)
+	 */
+	cacheTtl?: number
 }
 
 interface CacheEntry {
-  address: string
-  timestamp: number
+	address: string
+	timestamp: number
 }
 
 export class AddressResolver {
-  private cache = new Map<string, CacheEntry>()
-  private readonly maxCacheSize: number
-  private readonly cacheTtl: number
-
-  constructor(
-    private client: XmtpClient,
-    options: AddressResolverOptions = {}
-  ) {
-    this.maxCacheSize = options.maxCacheSize ?? 1000
-    this.cacheTtl = options.cacheTtl ?? 86400000 // 24 hours
-  }
-
-  /**
-   * Resolve user address from inbox ID with caching
-   */
-  async resolveAddress(
-    inboxId: string,
-    conversationId?: string
-  ): Promise<`0x${string}` | null> {
-    // Check cache first (fastest)
-    const cached = this.getCachedAddress(inboxId)
-    if (cached) {
-      console.log(`✅ Resolved user address from cache: ${cached}`)
-      return cached
-    }
-
-    let userAddress = undefined
-
-    try {
-      // Try conversation members lookup first (faster than network call)
-      if (conversationId) {
-        const conversation =
-          await this.client.conversations.getConversationById(conversationId)
-        if (conversation) {
-          userAddress = await this.resolveFromConversation(
-            conversation,
-            inboxId
-          )
-          if (userAddress) {
-            this.setCachedAddress(inboxId, userAddress)
-            console.log(`✅ Resolved user address: ${userAddress}`)
-            return userAddress
-          }
-        }
-      }
-
-      // Fallback to inboxStateFromInboxIds
-      userAddress = await this.resolveFromInboxState(inboxId)
-      if (userAddress) {
-        this.setCachedAddress(inboxId, userAddress)
-        console.log(`✅ Resolved user address via fallback: ${userAddress}`)
-        return userAddress
-      }
-
-      console.log(`⚠️ No identifiers found for inbox ${inboxId}`)
-      return null
-    } catch (error) {
-      console.error(`❌ Error resolving user address for ${inboxId}:`, error)
-      return null
-    }
-  }
-
-  /**
-   * Resolve address from conversation members
-   */
-  private async resolveFromConversation(
-    conversation: any,
-    inboxId: string
-  ): Promise<`0x${string}` | null> {
-    try {
-      const members = await conversation.members()
-      const sender = members.find(
-        (member: any) => member.inboxId.toLowerCase() === inboxId.toLowerCase()
-      )
-
-      if (sender) {
-        const ethIdentifier = sender.accountIdentifiers.find(
-          (id: any) => id.identifierKind === 0 // IdentifierKind.Ethereum
-        )
-        if (ethIdentifier) {
-          return ethIdentifier.identifier
-        } else {
-          console.log(`⚠️ No Ethereum identifier found for inbox ${inboxId}`)
-        }
-      } else {
-        console.log(
-          `⚠️ Sender not found in conversation members for inbox ${inboxId}`
-        )
-      }
-    } catch (error) {
-      console.error(`❌ Error resolving from conversation members:`, error)
-    }
-
-    return null
-  }
-
-  /**
-   * Resolve address from inbox state (network fallback)
-   */
-  private async resolveFromInboxState(inboxId: string): Promise<`0x${string}` | null> {
-    try {
-      const inboxState = await this.client.preferences.inboxStateFromInboxIds([
-        inboxId
-      ])
-      const firstState = inboxState?.[0]
-      if (firstState?.identifiers && firstState.identifiers.length > 0) {
-        const firstIdentifier = firstState.identifiers[0]
-        return firstIdentifier?.identifier as `0x${string}`
-      }
-    } catch (error) {
-      console.error(`❌ Error resolving from inbox state:`, error)
-    }
-
-    return null
-  }
-
-  /**
-   * Get cached address if not expired
-   */
-  private getCachedAddress(inboxId: string): `0x${string}` | null {
-    const entry = this.cache.get(inboxId)
-    if (!entry) return null
-
-    const now = Date.now()
-    if (now - entry.timestamp > this.cacheTtl) {
-      this.cache.delete(inboxId)
-      return null
-    }
-
-    return entry.address as `0x${string}`
-  }
-
-  /**
-   * Cache address with LRU eviction
-   */
-  private setCachedAddress(inboxId: string, address: `0x${string}`): void {
-    // Simple LRU: if cache is full, remove oldest entry
-    if (this.cache.size >= this.maxCacheSize) {
-      const firstKey = this.cache.keys().next().value
-      if (firstKey) {
-        this.cache.delete(firstKey)
-      }
-    }
-
-    this.cache.set(inboxId, {
-      address,
-      timestamp: Date.now()
-    })
-  }
-
-  /**
-   * Pre-populate cache from existing conversations
-   */
-  async prePopulateCache(): Promise<void> {
-    console.log("🔄 Pre-populating address cache...")
-    try {
-      const conversations = await this.client.conversations.list()
-      let cachedCount = 0
-
-      for (const conversation of conversations) {
-        try {
-          const members = await conversation.members()
-          for (const member of members) {
-            const ethIdentifier = member.accountIdentifiers.find(
-              (id: any) => id.identifierKind === 0 // IdentifierKind.Ethereum
-            )
-            if (ethIdentifier) {
-              this.setCachedAddress(member.inboxId, ethIdentifier.identifier as `0x${string}`)
-              cachedCount++
-            }
-          }
-        } catch (error) {
-          console.error("Error pre-caching conversation members:", error)
-        }
-      }
-
-      console.log(`✅ Pre-cached ${cachedCount} address mappings`)
-    } catch (error) {
-      console.error("Error pre-populating cache:", error)
-    }
-  }
-
-  /**
-   * Clear the cache
-   */
-  clearCache(): void {
-    this.cache.clear()
-    console.log("🗑️ Address cache cleared")
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getCacheStats(): { size: number; maxSize: number; hitRate?: number } {
-    return {
-      size: this.cache.size,
-      maxSize: this.maxCacheSize
-    }
-  }
+	private cache = new Map<string, CacheEntry>()
+	private readonly maxCacheSize: number
+	private readonly cacheTtl: number
+
+	constructor(
+		private client: XmtpClient,
+		options: AddressResolverOptions = {}
+	) {
+		this.maxCacheSize = options.maxCacheSize ?? 1000
+		this.cacheTtl = options.cacheTtl ?? 86400000 // 24 hours
+	}
+
+	/**
+	 * Resolve user address from inbox ID with caching
+	 */
+	async resolveAddress(
+		inboxId: string,
+		conversationId?: string
+	): Promise<`0x${string}` | null> {
+		// Check cache first (fastest)
+		const cached = this.getCachedAddress(inboxId)
+		if (cached) {
+			logger.debug(`✅ Resolved user address from cache: ${cached}`)
+			return cached
+		}
+
+		let userAddress = undefined
+
+		try {
+			// Try conversation members lookup first (faster than network call)
+			if (conversationId) {
+				const conversation =
+					await this.client.conversations.getConversationById(conversationId)
+				if (conversation) {
+					userAddress = await this.resolveFromConversation(
+						conversation,
+						inboxId
+					)
+					if (userAddress) {
+						this.setCachedAddress(inboxId, userAddress)
+						logger.debug(`✅ Resolved user address: ${userAddress}`)
+						return userAddress
+					}
+				}
+			}
+
+			// Fallback to inboxStateFromInboxIds
+			userAddress = await this.resolveFromInboxState(inboxId)
+			if (userAddress) {
+				this.setCachedAddress(inboxId, userAddress)
+				logger.debug(`✅ Resolved user address via fallback: ${userAddress}`)
+				return userAddress
+			}
+
+			logger.debug(`⚠️ No identifiers found for inbox ${inboxId}`)
+			return null
+		} catch (error) {
+			console.error(`❌ Error resolving user address for ${inboxId}:`, error)
+			return null
+		}
+	}
+
+	/**
+	 * Resolve address from conversation members
+	 */
+	private async resolveFromConversation(
+		conversation: any,
+		inboxId: string
+	): Promise<`0x${string}` | null> {
+		try {
+			const members = await conversation.members()
+			const sender = members.find(
+				(member: any) => member.inboxId.toLowerCase() === inboxId.toLowerCase()
+			)
+
+			if (sender) {
+				const ethIdentifier = sender.accountIdentifiers.find(
+					(id: any) => id.identifierKind === 0 // IdentifierKind.Ethereum
+				)
+				if (ethIdentifier) {
+					return ethIdentifier.identifier
+				} else {
+					logger.debug(`⚠️ No Ethereum identifier found for inbox ${inboxId}`)
+				}
+			} else {
+				logger.debug(
+					`⚠️ Sender not found in conversation members for inbox ${inboxId}`
+				)
+			}
+		} catch (error) {
+			console.error(`❌ Error resolving from conversation members:`, error)
+		}
+
+		return null
+	}
+
+	/**
+	 * Resolve address from inbox state (network fallback)
+	 */
+	private async resolveFromInboxState(
+		inboxId: string
+	): Promise<`0x${string}` | null> {
+		try {
+			const inboxState = await this.client.preferences.inboxStateFromInboxIds([
+				inboxId
+			])
+			const firstState = inboxState?.[0]
+			if (firstState?.identifiers && firstState.identifiers.length > 0) {
+				const firstIdentifier = firstState.identifiers[0]
+				return firstIdentifier?.identifier as `0x${string}`
+			}
+		} catch (error) {
+			console.error(`❌ Error resolving from inbox state:`, error)
+		}
+
+		return null
+	}
+
+	/**
+	 * Get cached address if not expired
+	 */
+	private getCachedAddress(inboxId: string): `0x${string}` | null {
+		const entry = this.cache.get(inboxId)
+		if (!entry) return null
+
+		const now = Date.now()
+		if (now - entry.timestamp > this.cacheTtl) {
+			this.cache.delete(inboxId)
+			return null
+		}
+
+		return entry.address as `0x${string}`
+	}
+
+	/**
+	 * Cache address with LRU eviction
+	 */
+	private setCachedAddress(inboxId: string, address: `0x${string}`): void {
+		// Simple LRU: if cache is full, remove oldest entry
+		if (this.cache.size >= this.maxCacheSize) {
+			const firstKey = this.cache.keys().next().value
+			if (firstKey) {
+				this.cache.delete(firstKey)
+			}
+		}
+
+		this.cache.set(inboxId, {
+			address,
+			timestamp: Date.now()
+		})
+	}
+
+	/**
+	 * Pre-populate cache from existing conversations
+	 */
+	async prePopulateCache(): Promise<void> {
+		logger.debug("🔄 Pre-populating address cache...")
+		try {
+			const conversations = await this.client.conversations.list()
+			let cachedCount = 0
+
+			for (const conversation of conversations) {
+				try {
+					const members = await conversation.members()
+					for (const member of members) {
+						const ethIdentifier = member.accountIdentifiers.find(
+							(id: any) => id.identifierKind === 0 // IdentifierKind.Ethereum
+						)
+						if (ethIdentifier) {
+							this.setCachedAddress(
+								member.inboxId,
+								ethIdentifier.identifier as `0x${string}`
+							)
+							cachedCount++
+						}
+					}
+				} catch (error) {
+					console.error("Error pre-caching conversation members:", error)
+				}
+			}
+
+			logger.debug(`✅ Pre-cached ${cachedCount} address mappings`)
+		} catch (error) {
+			console.error("Error pre-populating cache:", error)
+		}
+	}
+
+	/**
+	 * Clear the cache
+	 */
+	clearCache(): void {
+		this.cache.clear()
+		logger.debug("🗑️ Address cache cleared")
+	}
+
+	/**
+	 * Get cache statistics
+	 */
+	getCacheStats(): { size: number; maxSize: number; hitRate?: number } {
+		return {
+			size: this.cache.size,
+			maxSize: this.maxCacheSize
+		}
+	}
 }

package/src/resolver/basename-resolver.ts

@@ -7,6 +7,7 @@ import {
 } from "viem"
 import { mainnet } from "viem/chains"
 import { L2ResolverAbi } from "../abi/l2_resolver"
+import { logger } from "@hybrd/utils"
 
 // Base L2 Resolver Address mapping by chain ID
 // const BASENAME_L2_RESOLVER_ADDRESSES: Record<number, Address> = {
@@ -139,23 +140,23 @@ export class BasenameResolver {
 	 */
 	private async initializeResolver(): Promise<void> {
 		if (this.resolverAddress && this.chainId) {
-			console.log(
+			logger.debug(
 				`🔄 BasenameResolver already initialized for chain ${this.chainId} with resolver ${this.resolverAddress}`
 			)
 			return
 		}
 
 		try {
-			console.log("🔄 Initializing BasenameResolver...")
+			logger.debug("🔄 Initializing BasenameResolver...")
 			this.chainId = await this.baseClient.getChainId()
-			console.log(`🔗 Chain ID detected: ${this.chainId}`)
+			logger.debug(`🔗 Chain ID detected: ${this.chainId}`)
 
 			this.resolverAddress = getResolverAddress()
-			console.log(
+			logger.debug(
 				`📍 Resolver address for chain ${this.chainId}: ${this.resolverAddress}`
 			)
 
-			console.log(
+			logger.debug(
 				`✅ Initialized BasenameResolver for chain ${this.chainId} with resolver ${this.resolverAddress}`
 			)
 		} catch (error) {

package/src/resolver/ens-resolver.ts

@@ -1,4 +1,5 @@
 import { type Address, PublicClient } from "viem"
+import { logger } from "@hybrd/utils"
 
 interface ENSResolverOptions {
 	/**
@@ -48,33 +49,33 @@ export class ENSResolver {
 	 * Resolve an ENS name to an Ethereum address
 	 */
 	async resolveENSName(ensName: string): Promise<Address | null> {
-		console.log(`🔍 Resolving ENS name: ${ensName}`)
+		logger.debug(`🔍 Resolving ENS name: ${ensName}`)
 
 		try {
 			// Check cache first
 			const cached = this.getCachedAddress(ensName)
 			if (cached) {
-				console.log(`✅ Resolved ENS from cache: ${ensName} → ${cached}`)
+				logger.debug(`✅ Resolved ENS from cache: ${ensName} → ${cached}`)
 				return cached as Address
 			}
 
-			console.log(`📭 No cached address found for ENS: ${ensName}`)
+			logger.debug(`📭 No cached address found for ENS: ${ensName}`)
 
 			// Resolve using mainnet ENS
-			console.log("🔄 Reading ENS contract...")
+			logger.debug("🔄 Reading ENS contract...")
 			const address = await this.mainnetClient.getEnsAddress({
 				name: ensName
 			})
 
-			console.log(`📋 ENS contract returned address: "${address}"`)
+			logger.debug(`📋 ENS contract returned address: "${address}"`)
 
 			if (address && address !== "0x0000000000000000000000000000000000000000") {
 				this.setCachedAddress(ensName, address)
-				console.log(`✅ Resolved ENS: ${ensName} → ${address}`)
+				logger.debug(`✅ Resolved ENS: ${ensName} → ${address}`)
 				return address
 			}
 
-			console.log(`❌ No address found for ENS: ${ensName}`)
+			logger.debug(`❌ No address found for ENS: ${ensName}`)
 			return null
 		} catch (error) {
 			console.error(`❌ Error resolving ENS name ${ensName}:`, error)
@@ -89,35 +90,35 @@ export class ENSResolver {
 	 * 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}`)
+		logger.debug(`🔍 Reverse resolving address to ENS: ${address}`)
 
 		try {
 			// Check cache first
 			const cached = this.getCachedENSName(address)
 			if (cached) {
-				console.log(
+				logger.debug(
 					`✅ Resolved ENS from reverse cache: ${address} → ${cached}`
 				)
 				return cached
 			}
 
-			console.log(`📭 No cached ENS name found for address: ${address}`)
+			logger.debug(`📭 No cached ENS name found for address: ${address}`)
 
 			// Reverse resolve using mainnet ENS
-			console.log("🔄 Reading ENS reverse resolver...")
+			logger.debug("🔄 Reading ENS reverse resolver...")
 			const ensName = await this.mainnetClient.getEnsName({
 				address: address
 			})
 
-			console.log(`📋 ENS reverse resolver returned: "${ensName}"`)
+			logger.debug(`📋 ENS reverse resolver returned: "${ensName}"`)
 
 			if (ensName && ensName.length > 0) {
 				this.setCachedENSName(address, ensName)
-				console.log(`✅ Reverse resolved: ${address} → ${ensName}`)
+				logger.debug(`✅ Reverse resolved: ${address} → ${ensName}`)
 				return ensName
 			}
 
-			console.log(`❌ No ENS name found for address: ${address}`)
+			logger.debug(`❌ No ENS name found for address: ${address}`)
 			return null
 		} catch (error) {
 			console.error(`❌ Error reverse resolving address ${address}:`, error)

package/src/resolver/resolver.ts

@@ -8,6 +8,7 @@ import {
 } from "./basename-resolver"
 import { ENSResolver } from "./ens-resolver"
 import { XmtpResolver } from "./xmtp-resolver"
+import { logger } from "@hybrd/utils"
 
 interface ResolverOptions {
 	/**
@@ -293,14 +294,14 @@ export class Resolver {
 		if (address) {
 			// Try basename first since that's what we expect for this address
 			const basenameResult = await this.getBasename(address)
-			console.log(
+			logger.debug(
 				`🔍 [RESOLVER] Direct basename lookup for ${address}:`,
 				basenameResult
 			)
 
 			// Try to get a human-readable name
 			const resolvedName = await this.resolveAddressToName(address)
-			console.log(
+			logger.debug(
 				`🔍 [RESOLVER] Universal name resolution for ${address}:`,
 				resolvedName
 			)

package/src/resolver/xmtp-resolver.ts

@@ -1,4 +1,5 @@
 import type { XmtpClient, XmtpMessage } from "../types"
+import { logger } from "@hybrd/utils"
 
 interface XmtpResolverOptions {
 	/**
@@ -61,7 +62,7 @@ export class XmtpResolver {
 		// Check cache first (fastest)
 		const cached = this.getCachedAddress(inboxId)
 		if (cached) {
-			console.log(
+			logger.debug(
 				`✅ [XmtpResolver] Resolved user address from cache: ${cached}`
 			)
 			return cached
@@ -81,7 +82,7 @@ export class XmtpResolver {
 					)
 					if (userAddress) {
 						this.setCachedAddress(inboxId, userAddress)
-						console.log(
+						logger.debug(
 							`✅ [XmtpResolver] Resolved user address: ${userAddress}`
 						)
 						return userAddress
@@ -93,13 +94,13 @@ export class XmtpResolver {
 			userAddress = await this.resolveFromInboxState(inboxId)
 			if (userAddress) {
 				this.setCachedAddress(inboxId, userAddress)
-				console.log(
+				logger.debug(
 					`✅ [XmtpResolver] Resolved user address via fallback: ${userAddress}`
 				)
 				return userAddress
 			}
 
-			console.log(`⚠️ [XmtpResolver] No identifiers found for inbox ${inboxId}`)
+			logger.debug(`⚠️ [XmtpResolver] No identifiers found for inbox ${inboxId}`)
 			return null
 		} catch (error) {
 			console.error(
@@ -117,7 +118,7 @@ export class XmtpResolver {
 		// Check cache first
 		const cached = this.getCachedMessage(messageId)
 		if (cached !== undefined) {
-			console.log(
+			logger.debug(
 				cached
 					? `✅ [XmtpResolver] Found message from cache: ${cached.id}`
 					: `✅ [XmtpResolver] Found cached null message for: ${messageId}`
@@ -126,16 +127,16 @@ export class XmtpResolver {
 		}
 
 		try {
-			console.log(`🔍 [XmtpResolver] Finding message: ${messageId}`)
+			logger.debug(`🔍 [XmtpResolver] Finding message: ${messageId}`)
 			const message = await this.client.conversations.getMessageById(messageId)
 
 			if (message) {
 				this.setCachedMessage(messageId, message)
-				console.log(`✅ [XmtpResolver] Found and cached message: ${message.id}`)
+				logger.debug(`✅ [XmtpResolver] Found and cached message: ${message.id}`)
 				return message
 			}
 
-			console.log(`⚠️ [XmtpResolver] Message not found: ${messageId}`)
+			logger.debug(`⚠️ [XmtpResolver] Message not found: ${messageId}`)
 			this.setCachedMessage(messageId, null)
 			return null
 		} catch (error) {
@@ -156,7 +157,7 @@ export class XmtpResolver {
 		const rootCacheKey = `root:${messageId}`
 		const cached = this.getCachedMessage(rootCacheKey)
 		if (cached !== undefined) {
-			console.log(
+			logger.debug(
 				cached
 					? `✅ [XmtpResolver] Found root message from cache: ${cached.id}`
 					: `✅ [XmtpResolver] Found cached null root for: ${messageId}`