@hybrd/xmtp 1.0.0 → 1.0.3

package/dist/src/resolver/ens-resolver.js

@@ -0,0 +1,249 @@
+/**
+ * ENS Resolver for mainnet .eth names
+ * Handles resolution of ENS names to addresses and reverse resolution
+ */
+export class ENSResolver {
+    constructor(options) {
+        this.cache = new Map();
+        this.reverseCache = new Map();
+        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) {
+        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;
+            }
+            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) {
+        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) {
+        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, key) {
+        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) {
+        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) {
+        return name.endsWith(".eth") && !name.endsWith(".base.eth");
+    }
+    /**
+     * Get cached address if not expired
+     */
+    getCachedAddress(ensName) {
+        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
+     */
+    setCachedAddress(ensName, address) {
+        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
+     */
+    getCachedENSName(address) {
+        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
+     */
+    setCachedENSName(address, ensName) {
+        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() {
+        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/dist/src/resolver/index.d.ts

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

package/dist/src/resolver/index.js

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

package/dist/src/resolver/resolver.d.ts

@@ -0,0 +1,162 @@
+import { type Address, type PublicClient } from "viem";
+import type { XmtpClient, XmtpMessage, XmtpSender } from "../types";
+import { type BaseName, type BasenameTextRecordKey } from "./basename-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 declare class Resolver {
+    private addressResolver;
+    private ensResolver;
+    private basenameResolver;
+    private xmtpResolver;
+    constructor(options: ResolverOptions);
+    /**
+     * Resolve user address from inbox ID with caching
+     * Uses both AddressResolver and XmtpResolver for redundancy
+     */
+    resolveAddress(inboxId: string, conversationId?: string): Promise<`0x${string}` | null>;
+    /**
+     * Resolve an ENS name to an Ethereum address
+     */
+    resolveENSName(ensName: string): Promise<Address | null>;
+    /**
+     * Resolve an address to its primary ENS name (reverse resolution)
+     */
+    resolveAddressToENS(address: Address): Promise<string | null>;
+    /**
+     * Get ENS avatar for a given ENS name
+     */
+    getENSAvatar(ensName: string): Promise<string | null>;
+    /**
+     * Get ENS text record for a given ENS name and key
+     */
+    getENSTextRecord(ensName: string, key: string): Promise<string | null>;
+    /**
+     * Get complete ENS profile for a given ENS name
+     */
+    getENSProfile(ensName: string): Promise<{
+        ensName: string;
+        address: `0x${string}` | null;
+        avatar: string | null;
+        description: string | null;
+        twitter: string | null;
+        github: string | null;
+        url: string | null;
+    } | null>;
+    /**
+     * Get basename from an Ethereum address
+     */
+    getBasename(address: Address): Promise<string | null>;
+    /**
+     * Get basename avatar for a given basename
+     */
+    getBasenameAvatar(basename: BaseName): Promise<string | null>;
+    /**
+     * Get basename text record for a given basename and key
+     */
+    getBasenameTextRecord(basename: BaseName, key: BasenameTextRecordKey): Promise<string | null>;
+    /**
+     * Resolve basename to an Ethereum address
+     */
+    getBasenameAddress(basename: BaseName): Promise<Address | null>;
+    /**
+     * Get basename metadata for a given basename
+     */
+    getBasenameMetadata(basename: BaseName): Promise<{
+        basename: string;
+        avatar: string | null;
+        description: string | null;
+        twitter: string | null;
+        github: string | null;
+        url: string | null;
+    } | null>;
+    /**
+     * Get complete basename profile for a given address
+     */
+    resolveBasenameProfile(address: Address): Promise<{
+        basename?: string | undefined;
+        avatar?: string | null | undefined;
+        description?: string | null | undefined;
+        twitter?: string | null | undefined;
+        github?: string | null | undefined;
+        url?: string | null | undefined;
+        address: `0x${string}`;
+    } | null>;
+    /**
+     * Find any message by ID with caching
+     */
+    findMessage(messageId: string): Promise<XmtpMessage | null>;
+    /**
+     * Find root message by ID (traverses reply chain)
+     */
+    findRootMessage(messageId: string): Promise<XmtpMessage | null>;
+    /**
+     * Universal name resolution - tries to resolve any name (ENS or basename) to an address
+     */
+    resolveName(name: string): Promise<Address | null>;
+    /**
+     * Universal reverse resolution - tries to resolve an address to any name (ENS or basename)
+     */
+    resolveAddressToName(address: Address): Promise<string | null>;
+    /**
+     * Get complete profile for an address (combines ENS and basename data)
+     */
+    getCompleteProfile(address: Address): Promise<{
+        address: `0x${string}`;
+        ensName: string | null;
+        basename: string | null;
+        ensProfile: {
+            ensName: string;
+            address: `0x${string}` | null;
+            avatar: string | null;
+            description: string | null;
+            twitter: string | null;
+            github: string | null;
+            url: string | null;
+        } | null;
+        basenameProfile: {
+            basename?: string | undefined;
+            avatar?: string | null | undefined;
+            description?: string | null | undefined;
+            twitter?: string | null | undefined;
+            github?: string | null | undefined;
+            url?: string | null | undefined;
+            address: `0x${string}`;
+        } | null;
+    }>;
+    /**
+     * Pre-populate all resolver caches
+     */
+    prePopulateAllCaches(): Promise<void>;
+    /**
+     * Create a complete XmtpSender object from an address or inboxId
+     * Uses the resolver to get the best available name and profile information
+     */
+    createXmtpSender(addressOrInboxId: string, conversationId?: string): Promise<XmtpSender>;
+}
+export {};

package/dist/src/resolver/resolver.js

@@ -0,0 +1,238 @@
+import { AddressResolver } from "./address-resolver";
+import { BasenameResolver } from "./basename-resolver";
+import { ENSResolver } from "./ens-resolver";
+import { XmtpResolver } from "./xmtp-resolver";
+/**
+ * Master Resolver that wraps all individual resolvers
+ * Provides a unified interface for basename, ENS, address, and XMTP resolution
+ */
+export class Resolver {
+    constructor(options) {
+        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
+        });
+        this.basenameResolver = new BasenameResolver({
+            ...resolverOptions,
+            publicClient: options.baseClient
+        });
+    }
+    // === Address Resolution Methods ===
+    /**
+     * Resolve user address from inbox ID with caching
+     * Uses both AddressResolver and XmtpResolver for redundancy
+     */
+    async resolveAddress(inboxId, conversationId) {
+        // 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) {
+        return this.ensResolver.resolveENSName(ensName);
+    }
+    /**
+     * Resolve an address to its primary ENS name (reverse resolution)
+     */
+    async resolveAddressToENS(address) {
+        return this.ensResolver.resolveAddressToENS(address);
+    }
+    /**
+     * Get ENS avatar for a given ENS name
+     */
+    async getENSAvatar(ensName) {
+        return this.ensResolver.getENSAvatar(ensName);
+    }
+    /**
+     * Get ENS text record for a given ENS name and key
+     */
+    async getENSTextRecord(ensName, key) {
+        return this.ensResolver.getENSTextRecord(ensName, key);
+    }
+    /**
+     * Get complete ENS profile for a given ENS name
+     */
+    async getENSProfile(ensName) {
+        return this.ensResolver.getENSProfile(ensName);
+    }
+    // === Basename Resolution Methods ===
+    /**
+     * Get basename from an Ethereum address
+     */
+    async getBasename(address) {
+        return this.basenameResolver.getBasename(address);
+    }
+    /**
+     * Get basename avatar for a given basename
+     */
+    async getBasenameAvatar(basename) {
+        return this.basenameResolver.getBasenameAvatar(basename);
+    }
+    /**
+     * Get basename text record for a given basename and key
+     */
+    async getBasenameTextRecord(basename, key) {
+        return this.basenameResolver.getBasenameTextRecord(basename, key);
+    }
+    /**
+     * Resolve basename to an Ethereum address
+     */
+    async getBasenameAddress(basename) {
+        return this.basenameResolver.getBasenameAddress(basename);
+    }
+    /**
+     * Get basename metadata for a given basename
+     */
+    async getBasenameMetadata(basename) {
+        return this.basenameResolver.getBasenameMetadata(basename);
+    }
+    /**
+     * Get complete basename profile for a given address
+     */
+    async resolveBasenameProfile(address) {
+        return this.basenameResolver.resolveBasenameProfile(address);
+    }
+    // === XMTP Message Methods ===
+    /**
+     * Find any message by ID with caching
+     */
+    async findMessage(messageId) {
+        return this.xmtpResolver.findMessage(messageId);
+    }
+    /**
+     * Find root message by ID (traverses reply chain)
+     */
+    async findRootMessage(messageId) {
+        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) {
+        // 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) {
+        // 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) {
+        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() {
+        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, conversationId) {
+        let address = null;
+        let inboxId = addressOrInboxId;
+        // Check if input looks like an Ethereum address
+        if (addressOrInboxId.startsWith("0x") && addressOrInboxId.length === 42) {
+            address = addressOrInboxId;
+            // 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;
+        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
+        };
+    }
+}