@hybrd/xmtp 1.0.0

package/src/lib/message-listener.ts

@@ -0,0 +1,343 @@
+import { EventEmitter } from "node:events"
+import { Reaction } from "@xmtp/content-type-reaction"
+import { Reply } from "@xmtp/content-type-reply"
+import { http, PublicClient, createPublicClient } from "viem"
+import { mainnet } from "viem/chains"
+import { Resolver } from "../resolver/resolver"
+import type { MessageEvent, XmtpClient, XmtpMessage } from "../types"
+
+// Configuration for the message listener
+export interface MessageListenerConfig {
+	publicClient: PublicClient
+	xmtpClient: XmtpClient
+	/**
+	 * Filter function to determine which messages to process
+	 * Return true to process the message, false to skip
+	 */
+	filter?: (
+		event: Pick<MessageEvent, "conversation" | "message" | "rootMessage">
+	) => Promise<boolean> | boolean
+	/**
+	 * Heartbeat interval in milliseconds (default: 5 minutes)
+	 */
+	heartbeatInterval?: number
+	/**
+	 * Conversation check interval in milliseconds (default: 30 seconds)
+	 */
+	conversationCheckInterval?: number
+	/**
+	 * Environment variable key for XMTP environment (default: "XMTP_ENV")
+	 */
+	envKey?: string
+}
+
+// Enriched message data with resolved address
+
+// Define the event signature for type safety
+export interface MessageListenerEvents {
+	message: [data: MessageEvent]
+	error: [error: Error]
+	started: []
+	stopped: []
+	heartbeat: [stats: { messageCount: number; conversationCount: number }]
+}
+
+/**
+ * A flexible XMTP message listener that can be configured for different applications
+ */
+export class MessageListener extends EventEmitter {
+	private xmtpClient: XmtpClient
+	private resolver: Resolver
+	private filter?: (
+		event: Pick<MessageEvent, "conversation" | "message" | "rootMessage">
+	) => Promise<boolean> | boolean
+	private heartbeatInterval?: NodeJS.Timeout
+	private fallbackCheckInterval?: NodeJS.Timeout
+	private messageCount = 0
+	private conversations: any[] = []
+	private readonly config: Required<
+		Pick<
+			MessageListenerConfig,
+			"heartbeatInterval" | "conversationCheckInterval" | "envKey"
+		>
+	>
+
+	constructor(config: MessageListenerConfig) {
+		super()
+		this.xmtpClient = config.xmtpClient
+
+		// Create mainnet client for ENS resolution
+		const mainnetClient = createPublicClient({
+			chain: mainnet,
+			transport: http()
+		})
+
+		// Create unified resolver with all capabilities
+		this.resolver = new Resolver({
+			xmtpClient: this.xmtpClient,
+			mainnetClient,
+			baseClient: config.publicClient,
+			maxCacheSize: 1000,
+			cacheTtl: 86400000 // 24 hours
+		})
+
+		this.filter = config.filter
+		this.config = {
+			heartbeatInterval: config.heartbeatInterval ?? 300000, // 5 minutes
+			conversationCheckInterval: config.conversationCheckInterval ?? 30000, // 30 seconds
+			envKey: config.envKey ?? "XMTP_ENV"
+		}
+	}
+
+	// Type-safe event emitter methods
+	on<U extends keyof MessageListenerEvents>(
+		event: U,
+		listener: (...args: MessageListenerEvents[U]) => void
+	): this {
+		return super.on(event, listener)
+	}
+
+	emit<U extends keyof MessageListenerEvents>(
+		event: U,
+		...args: MessageListenerEvents[U]
+	): boolean {
+		return super.emit(event, ...args)
+	}
+
+	async start(): Promise<void> {
+		const XMTP_ENV = process.env[this.config.envKey]
+
+		// Pre-populate address cache from existing conversations
+		await this.resolver?.prePopulateAllCaches()
+
+		console.log("📡 Syncing conversations...")
+		await this.xmtpClient.conversations.sync()
+
+		const address = this.xmtpClient.accountIdentifier?.identifier
+
+		// List existing conversations for debugging
+		this.conversations = await this.xmtpClient.conversations.list()
+
+		console.log(`🤖 XMTP[${XMTP_ENV}] Listening on ${address} ...`)
+
+		// Emit started event
+		this.emit("started")
+
+		// Stream all messages and emit events for processing
+		try {
+			const stream = await this.xmtpClient.conversations.streamAllMessages()
+
+			// Add a heartbeat to show the listener is active
+			this.heartbeatInterval = setInterval(() => {
+				this.emit("heartbeat", {
+					messageCount: this.messageCount,
+					conversationCount: this.conversations.length
+				})
+				if (this.messageCount > 0) {
+					console.log(`💓 Active - processed ${this.messageCount} messages`)
+				}
+			}, this.config.heartbeatInterval)
+
+			// Check for new conversations
+			this.fallbackCheckInterval = setInterval(async () => {
+				try {
+					const latestConversations = await this.xmtpClient.conversations.list()
+					if (latestConversations.length > this.conversations.length) {
+						console.log(
+							`🆕 Detected ${latestConversations.length - this.conversations.length} new conversations`
+						)
+						this.conversations.push(
+							...latestConversations.slice(this.conversations.length)
+						)
+					}
+				} catch (error) {
+					console.error("❌ Error checking for new conversations:", error)
+					this.emit("error", error as Error)
+				}
+			}, this.config.conversationCheckInterval)
+
+			try {
+				for await (const message of stream) {
+					this.messageCount++
+
+					try {
+						// Skip messages from self or null messages
+						if (
+							!message ||
+							message.senderInboxId.toLowerCase() ===
+								this.xmtpClient.inboxId.toLowerCase()
+						) {
+							continue
+						}
+
+						console.log(
+							`📨 Received message "${JSON.stringify(message)}" in ${message.conversationId}`
+						)
+
+						// Get conversation details
+						const conversation =
+							await this.xmtpClient.conversations.getConversationById(
+								message.conversationId
+							)
+
+						if (!conversation) {
+							console.log("❌ Could not find conversation for message")
+							continue
+						}
+
+						const contentTypeId = message.contentType?.typeId
+
+						// Extract message content for processing
+						let messageContent: string
+						if (contentTypeId === "reply") {
+							const replyContent = message.content as any
+							messageContent = (replyContent?.content || "").toString()
+						} else if (
+							contentTypeId === "remoteStaticAttachment" ||
+							contentTypeId === "attachment"
+						) {
+							// For attachments, use the fallback message or filename
+							messageContent =
+								(message as any).fallback ||
+								(message.content as any)?.filename ||
+								"[Attachment]"
+						} else if (contentTypeId === "reaction") {
+							// For reactions, use a simple representation
+							const reactionContent = message.content as Reaction
+							messageContent = `[Reaction: ${reactionContent.content || ""}]`
+						} else {
+							// For text and other content types, safely convert to string
+							messageContent = message.content ? String(message.content) : ""
+						}
+
+						// Find root message for replies and reactions
+						let rootMessage: XmtpMessage | null = message
+						let parentMessage: XmtpMessage | null = null
+
+						if (contentTypeId === "reply") {
+							const { reference } = message.content as Reply
+							rootMessage = await this.resolver.findRootMessage(reference)
+							parentMessage = await this.resolver.findMessage(reference)
+						} else if (contentTypeId === "reaction") {
+							const { reference } = message.content as Reaction
+							rootMessage = await this.resolver.findRootMessage(reference)
+							parentMessage = await this.resolver.findMessage(reference)
+						} else {
+							// For text messages and attachments, they are root messages
+							rootMessage = message
+							parentMessage = null
+						}
+
+						// Skip if we couldn't find the root message
+						if (!rootMessage) {
+							console.warn(
+								`⚠️ [MessageListener] Could not find root message for: ${message.id}`
+							)
+							continue
+						}
+
+						// Apply custom message filter if provided
+						if (this.filter) {
+							const shouldProcess = await this.filter({
+								conversation,
+								message,
+								rootMessage
+							})
+							if (!shouldProcess) {
+								console.log("🔄 Skipping message:", message.id)
+								continue
+							}
+						}
+
+						// Create sender using unified resolver
+						const sender = await this.resolver.createXmtpSender(
+							message.senderInboxId,
+							message.conversationId
+						)
+
+						// Extract and resolve subjects (basenames and ENS names mentioned in message)
+						// TODO: Update extractSubjects to work with unified resolver
+						const subjects = {}
+
+						// Create enriched message with resolved address, name, subjects, root message, and parent message
+						const messageEvent: MessageEvent = {
+							conversation,
+							message,
+							rootMessage: rootMessage as XmtpMessage, // We already checked it's not null above
+							parentMessage: parentMessage || undefined,
+							sender,
+							subjects
+						}
+
+						// Emit the enriched message
+						this.emit("message", messageEvent)
+					} catch (messageError) {
+						console.error("❌ Error processing message:", messageError)
+						this.emit("error", messageError as Error)
+						// Continue processing other messages instead of crashing
+					}
+				}
+			} catch (streamError) {
+				console.error("❌ Error in message stream:", streamError)
+				this.cleanup()
+				this.emit("error", streamError as Error)
+				console.log("🔄 Attempting to restart stream...")
+
+				// Wait a bit before restarting to avoid tight restart loops
+				await new Promise((resolve) => setTimeout(resolve, 5000))
+
+				// Recursively restart the message listener
+				return this.start()
+			}
+		} catch (streamSetupError) {
+			console.error("❌ Error setting up message stream:", streamSetupError)
+			this.emit("error", streamSetupError as Error)
+			throw streamSetupError
+		}
+	}
+
+	private cleanup() {
+		if (this.heartbeatInterval) {
+			clearInterval(this.heartbeatInterval)
+		}
+		if (this.fallbackCheckInterval) {
+			clearInterval(this.fallbackCheckInterval)
+		}
+	}
+
+	stop() {
+		this.cleanup()
+		this.emit("stopped")
+		console.log("🛑 Message listener stopped")
+		this.removeAllListeners()
+	}
+
+	/**
+	 * Get current statistics
+	 */
+	getStats() {
+		return {
+			messageCount: this.messageCount,
+			conversationCount: this.conversations.length,
+			isActive: !!this.heartbeatInterval
+		}
+	}
+}
+
+/**
+ * Helper function to start a message listener
+ */
+export async function startMessageListener(
+	config: MessageListenerConfig
+): Promise<MessageListener> {
+	const listener = new MessageListener(config)
+	await listener.start()
+	return listener
+}
+
+/**
+ * Factory function to create a message listener with common filters
+ */
+export function createMessageListener(config: MessageListenerConfig) {
+	return new MessageListener(config)
+}

package/src/lib/subjects.ts

@@ -0,0 +1,89 @@
+import type { BasenameResolver } from "../resolver/basename-resolver"
+import type { ENSResolver } from "../resolver/ens-resolver"
+
+/**
+ * Extract basenames/ENS names from message content using @mention pattern
+ * @param content The message content to parse
+ * @returns Array of unique names found in the message
+ */
+export function extractMentionedNames(content: string): string[] {
+	// Match @basename.eth and @basename.base.eth patterns (case insensitive)
+	const nameRegex = /@([a-zA-Z0-9-_]+\.(?:base\.)?eth)\b/gi
+	const matches = content.match(nameRegex)
+
+	if (!matches) {
+		return []
+	}
+
+	// Remove @ symbol and deduplicate
+	const names = matches.map((match) => match.slice(1).toLowerCase())
+	return [...new Set(names)]
+}
+
+/**
+ * Resolve mentioned names to addresses and return as subjects object
+ * @param mentionedNames Array of names to resolve
+ * @param basenameResolver Basename resolver instance
+ * @param ensResolver ENS resolver instance
+ * @returns Promise that resolves to subjects object mapping names to addresses
+ */
+export async function resolveSubjects(
+	mentionedNames: string[],
+	basenameResolver: BasenameResolver,
+	ensResolver: ENSResolver
+): Promise<Record<string, `0x${string}`>> {
+	const subjects: Record<string, `0x${string}`> = {}
+
+	if (mentionedNames.length === 0) {
+		return subjects
+	}
+
+	console.log(
+		`🔍 Found ${mentionedNames.length} name mentions:`,
+		mentionedNames
+	)
+
+	for (const mentionedName of mentionedNames) {
+		try {
+			let resolvedAddress: string | null = null
+
+			// Check if it's an ENS name (.eth but not .base.eth)
+			if (ensResolver.isENSName(mentionedName)) {
+				console.log(`🔍 Resolving ENS name: ${mentionedName}`)
+				resolvedAddress = await ensResolver.resolveENSName(mentionedName)
+			} else {
+				// It's a basename (.base.eth or other format)
+				console.log(`🔍 Resolving basename: ${mentionedName}`)
+				resolvedAddress =
+					await basenameResolver.getBasenameAddress(mentionedName)
+			}
+
+			if (resolvedAddress) {
+				subjects[mentionedName] = resolvedAddress as `0x${string}`
+				console.log(`✅ Resolved ${mentionedName} → ${resolvedAddress}`)
+			} else {
+				console.log(`❌ Could not resolve address for: ${mentionedName}`)
+			}
+		} catch (error) {
+			console.error(`❌ Error resolving ${mentionedName}:`, error)
+		}
+	}
+
+	return subjects
+}
+
+/**
+ * Extract subjects from message content (combines extraction and resolution)
+ * @param content The message content to parse
+ * @param basenameResolver Basename resolver instance
+ * @param ensResolver ENS resolver instance
+ * @returns Promise that resolves to subjects object mapping names to addresses
+ */
+export async function extractSubjects(
+	content: string,
+	basenameResolver: BasenameResolver,
+	ensResolver: ENSResolver
+): Promise<Record<string, `0x${string}`>> {
+	const mentionedNames = extractMentionedNames(content)
+	return await resolveSubjects(mentionedNames, basenameResolver, ensResolver)
+}

package/src/localStorage.ts.old

@@ -0,0 +1,203 @@
+import { existsSync, mkdirSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { validateEnvironment } from "./client";
+import type { WalletInfo, WalletStorage } from "./walletService";
+
+const { XMTP_NETWORK_ID } = validateEnvironment(["XMTP_NETWORK_ID"]);
+export const STORAGE_DIRS = {
+  WALLET: ".data/wallet_data",
+  XMTP: ".data/xmtp",
+};
+
+/**
+ * Generic file-based storage service
+ */
+export class FileStorage implements WalletStorage {
+  private initialized = false;
+
+  constructor(private baseDirs = STORAGE_DIRS) {
+    this.initialize();
+  }
+
+  /**
+   * Initialize storage directories
+   */
+  public initialize(): void {
+    if (this.initialized) return;
+
+    Object.values(this.baseDirs).forEach((dir) => {
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    });
+
+    this.initialized = true;
+  }
+
+  /**
+   * File operations - save/read/delete
+   */
+  private async saveToFile(
+    directory: string,
+    identifier: string,
+    data: string,
+  ): Promise<boolean> {
+    const key = `${identifier}-${XMTP_NETWORK_ID}`;
+    try {
+      await fs.writeFile(path.join(directory, `${key}.json`), data);
+      return true;
+    } catch (error) {
+      console.error(`Error writing to file ${key}:`, error);
+      return false;
+    }
+  }
+
+  private async readFromFile<T>(
+    directory: string,
+    identifier: string,
+  ): Promise<T | null> {
+    try {
+      const key = `${identifier}-${XMTP_NETWORK_ID}`;
+      const data = await fs.readFile(
+        path.join(directory, `${key}.json`),
+        "utf-8",
+      );
+      return JSON.parse(data) as T;
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        (error.message.includes("ENOENT") ||
+          error.message.includes("no such file or directory"))
+      ) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  public async deleteFile(directory: string, key: string): Promise<boolean> {
+    try {
+      await fs.unlink(path.join(directory, `${key}.json`));
+      return true;
+    } catch (error) {
+      console.error(`Error deleting file ${key}:`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Generic data operations
+   */
+  public async saveData(
+    category: string,
+    id: string,
+    data: unknown,
+  ): Promise<boolean> {
+    if (!this.initialized) this.initialize();
+
+    // Make sure the directory exists
+    const directory = path.join(".data", category);
+    if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
+
+    return await this.saveToFile(directory, id, JSON.stringify(data));
+  }
+
+  public async getData<T>(category: string, id: string): Promise<T | null> {
+    if (!this.initialized) this.initialize();
+
+    const directory = path.join(".data", category);
+    return this.readFromFile<T>(directory, id);
+  }
+
+  public async listData<T>(category: string): Promise<T[]> {
+    if (!this.initialized) this.initialize();
+
+    try {
+      const directory = path.join(".data", category);
+      if (!existsSync(directory)) return [];
+
+      const files = await fs.readdir(directory);
+      const items: T[] = [];
+
+      for (const file of files.filter((f) => f.endsWith(".json"))) {
+        const id = file.replace(`-${XMTP_NETWORK_ID}.json`, "");
+        const data = await this.getData<T>(category, id);
+        if (data) items.push(data);
+      }
+
+      return items;
+    } catch (error) {
+      console.error(`Error listing data in ${category}:`, error);
+      return [];
+    }
+  }
+
+  public async deleteData(category: string, id: string): Promise<boolean> {
+    if (!this.initialized) this.initialize();
+
+    try {
+      const directory = path.join(".data", category);
+      const key = `${id}-${XMTP_NETWORK_ID}`;
+      return await this.deleteFile(directory, key);
+    } catch (error) {
+      console.error(`Error deleting data ${id} from ${category}:`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Wallet Storage implementation
+   */
+  public async saveWallet(userId: string, walletData: string): Promise<void> {
+    if (!this.initialized) this.initialize();
+    await this.saveToFile(this.baseDirs.WALLET, userId, walletData);
+  }
+
+  public async getWallet(userId: string): Promise<WalletInfo | null> {
+    if (!this.initialized) this.initialize();
+    return this.readFromFile(this.baseDirs.WALLET, userId);
+  }
+
+  public async getWalletByAddress(address: string): Promise<WalletInfo | null> {
+    if (!this.initialized) this.initialize();
+    try {
+      const directory = this.baseDirs.WALLET;
+      if (!existsSync(directory)) return null;
+
+      const files = await fs.readdir(directory);
+
+      for (const file of files.filter((f) => f.endsWith(".json"))) {
+        try {
+          const data = await fs.readFile(path.join(directory, file), "utf-8");
+          const walletData = JSON.parse(data) as WalletInfo;
+
+          // Check if this wallet has the target address
+          if (walletData.address.toLowerCase() === address.toLowerCase()) {
+            return walletData;
+          }
+        } catch (err) {
+          console.error(`Error parsing wallet data from ${file}:`, err);
+          // Skip files with parsing errors
+          continue;
+        }
+      }
+
+      return null;
+    } catch (error) {
+      console.error(`Error finding wallet by address ${address}:`, error);
+      return null;
+    }
+  }
+
+  public async getWalletCount(): Promise<number> {
+    try {
+      const files = await fs.readdir(this.baseDirs.WALLET);
+      return files.filter((file) => file.endsWith(".json")).length;
+    } catch (error) {
+      console.error("Error getting wallet count:", error);
+      return 0;
+    }
+  }
+}
+
+// Export a single global instance
+export const storage = new FileStorage();