@hybrd/xmtp 1.3.2 → 1.4.0

package/dist/index.js

@@ -2,7 +2,22 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/index.ts
+import {
+  Agent,
+  createSigner as createSigner3,
+  createUser as createUser3,
+  filter,
+  getTestUrl
+} from "@xmtp/agent-sdk";
+
+// src/constants.ts
+var DEFAULT_OPTIONS = ["yes", "no"];
+var DEFAULT_AMOUNT = "0.1";
+var MAX_USDC_AMOUNT = 10;
+
 // src/client.ts
+import { logger } from "@hybrd/utils";
 import { ReactionCodec } from "@xmtp/content-type-reaction";
 import { ReplyCodec } from "@xmtp/content-type-reply";
 import { TransactionReferenceCodec } from "@xmtp/content-type-transaction-reference";
@@ -18,6 +33,7 @@ import { privateKeyToAccount } from "viem/accounts";
 import { sepolia } from "viem/chains";
 
 // scripts/revoke-installations.ts
+import { Client } from "@xmtp/node-sdk";
 async function revokeOldInstallations(signer, inboxId) {
   console.log("\u{1F527} Attempting to revoke old installations...");
   try {
@@ -128,7 +144,7 @@ var createSigner = (key) => {
   };
 };
 async function clearXMTPDatabase(address, env) {
-  console.log("\u{1F9F9} Clearing XMTP database to resolve installation limit...");
+  logger.debug("\u{1F9F9} Clearing XMTP database to resolve installation limit...");
   const getStorageDirectory = () => {
     const customStoragePath = process.env.XMTP_STORAGE_PATH;
     if (customStoragePath) {
@@ -157,9 +173,9 @@ async function clearXMTPDatabase(address, env) {
           const fullPath = path.join(dir, file);
           try {
             fs.unlinkSync(fullPath);
-            console.log(`\u2705 Removed: ${fullPath}`);
+            logger.debug(`\u2705 Removed: ${fullPath}`);
           } catch (err) {
-            console.log(`\u26A0\uFE0F Could not remove ${fullPath}:`, err);
+            logger.debug(`\u26A0\uFE0F Could not remove ${fullPath}:`, err);
           }
         }
       }
@@ -176,12 +192,12 @@ async function createXMTPClient(privateKey, opts) {
       "No signer provided and XMTP_WALLET_KEY environment variable is not set"
     );
   }
-  const { XMTP_ENCRYPTION_KEY, XMTP_ENV } = process.env;
+  const { XMTP_DB_ENCRYPTION_KEY, XMTP_ENV } = process.env;
   const identifier = await signer.getIdentifier();
   const address = identifier.identifier;
   while (attempt < maxRetries) {
     try {
-      console.log(
+      logger.debug(
         `\u{1F504} Attempt ${attempt + 1}/${maxRetries} to create XMTP client...`
       );
       if (!persist) {
@@ -189,15 +205,17 @@ async function createXMTPClient(privateKey, opts) {
           "Stateless mode is not supported. XMTP client must run in persistent mode to properly receive and process messages. Set persist: true or remove the persist option to use the default persistent mode."
         );
       }
-      if (!XMTP_ENCRYPTION_KEY) {
-        throw new Error("XMTP_ENCRYPTION_KEY must be set for persistent mode");
+      if (!XMTP_DB_ENCRYPTION_KEY) {
+        throw new Error(
+          "XMTP_DB_ENCRYPTION_KEY must be set for persistent mode"
+        );
       }
-      const dbEncryptionKey = getEncryptionKeyFromHex(XMTP_ENCRYPTION_KEY);
+      const dbEncryptionKey = getEncryptionKeyFromHex(XMTP_DB_ENCRYPTION_KEY);
       const dbPath = await getDbPath(
         `${XMTP_ENV || "dev"}-${address}`,
         storagePath
       );
-      console.log(`\u{1F4C1} Using database path: ${dbPath}`);
+      logger.debug(`\u{1F4C1} Using database path: ${dbPath}`);
       const client = await Client2.create(signer, {
         dbEncryptionKey,
         env: XMTP_ENV,
@@ -209,16 +227,15 @@ async function createXMTPClient(privateKey, opts) {
           new TransactionReferenceCodec()
         ]
       });
-      console.log("\u{1F4E1} Syncing conversations to ensure latest state...");
+      logger.debug("\u{1F4E1} Syncing conversations to ensure latest state...");
       await client.conversations.sync();
       await backupDbToPersistentStorage(
         dbPath,
         `${XMTP_ENV || "dev"}-${address}`
       );
-      console.log("\u2705 XMTP XmtpClient created");
-      console.log(`\u{1F511} Wallet address: ${address}`);
-      console.log(`\u{1F310} Environment: ${XMTP_ENV || "dev"}`);
-      console.log(`\u{1F4BE} Storage mode: persistent`);
+      console.log(`Wallet: ${address}`);
+      console.log(`Env: ${XMTP_ENV || "dev"}`);
+      console.log(`Storage: persistent`);
       return client;
     } catch (error) {
       attempt++;
@@ -265,7 +282,7 @@ async function createXMTPClient(privateKey, opts) {
           console.log("\u{1F527} Attempting automatic identity refresh...");
           try {
             console.log("\u{1F4DD} Creating persistent client to refresh identity...");
-            const tempEncryptionKey = XMTP_ENCRYPTION_KEY ? getEncryptionKeyFromHex(XMTP_ENCRYPTION_KEY) : getEncryptionKeyFromHex(generateEncryptionKeyHex());
+            const tempEncryptionKey = XMTP_DB_ENCRYPTION_KEY ? getEncryptionKeyFromHex(XMTP_DB_ENCRYPTION_KEY) : getEncryptionKeyFromHex(generateEncryptionKeyHex());
             const tempClient = await Client2.create(signer, {
               dbEncryptionKey: tempEncryptionKey,
               env: XMTP_ENV,
@@ -434,78 +451,6 @@ function validateEnvironment(vars) {
     return acc;
   }, {});
 }
-async function diagnoseXMTPIdentityIssue(client, inboxId, environment) {
-  const suggestions = [];
-  const details = {
-    environment,
-    inboxId,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  try {
-    const inboxState = await client.preferences.inboxStateFromInboxIds([
-      inboxId
-    ]);
-    if (inboxState.length === 0) {
-      suggestions.push(
-        `Inbox ID ${inboxId} not found in ${environment} environment`
-      );
-      suggestions.push(
-        "Try switching XMTP_ENV to 'dev' if currently 'production' or vice versa"
-      );
-      suggestions.push(
-        "Verify the user has created an identity on this XMTP network"
-      );
-      details.inboxStateFound = false;
-      return { canResolve: false, suggestions, details };
-    }
-    const inbox = inboxState[0];
-    if (!inbox) {
-      suggestions.push("Inbox state returned empty data");
-      details.inboxStateFound = false;
-      return { canResolve: false, suggestions, details };
-    }
-    details.inboxStateFound = true;
-    details.identifierCount = inbox.identifiers?.length || 0;
-    if (!inbox.identifiers || inbox.identifiers.length === 0) {
-      suggestions.push("Inbox found but has no identifiers");
-      suggestions.push("This indicates incomplete identity registration");
-      suggestions.push("User may need to re-register their identity on XMTP");
-      details.hasIdentifiers = false;
-      return { canResolve: false, suggestions, details };
-    }
-    details.hasIdentifiers = true;
-    details.resolvedAddress = inbox.identifiers[0]?.identifier;
-    return {
-      canResolve: true,
-      suggestions: ["Identity resolved successfully"],
-      details
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    details.error = errorMessage;
-    if (errorMessage.includes("Association error")) {
-      suggestions.push("XMTP identity association error detected");
-      suggestions.push(
-        "Check if user exists on the correct XMTP environment (dev vs production)"
-      );
-      suggestions.push(
-        "Identity may need to be recreated on the current environment"
-      );
-    }
-    if (errorMessage.includes("Missing identity update")) {
-      suggestions.push("Missing identity updates in XMTP network");
-      suggestions.push("This can indicate network sync issues");
-      suggestions.push("Wait a few minutes and retry, or recreate identity");
-    }
-    if (errorMessage.includes("database") || errorMessage.includes("storage")) {
-      suggestions.push("XMTP local database/storage issue");
-      suggestions.push("Try clearing XMTP database and resyncing");
-      suggestions.push("Check .data/xmtp directory permissions");
-    }
-    suggestions.push("Consider testing with a fresh XMTP identity");
-    return { canResolve: false, suggestions, details };
-  }
-}
 var XMTPConnectionManager = class {
   constructor(privateKey, config = {}) {
     __publicField(this, "client", null);
@@ -633,2972 +578,409 @@ var XMTPConnectionManager = class {
     console.log("\u{1F50C} XMTP client disconnected");
   }
 };
-async function createXMTPConnectionManager(privateKey, config) {
-  const manager = new XMTPConnectionManager(privateKey, config);
-  await manager.connect();
-  return manager;
-}
-async function resolveUserAddress(client, senderInboxId, maxRetries = 2) {
-  let attempt = 0;
-  while (attempt < maxRetries) {
-    try {
-      console.log(
-        `\u{1F50D} Resolving user address (attempt ${attempt + 1}/${maxRetries})...`
+
+// src/plugin.ts
+import {
+  Agent as XmtpAgent,
+  createSigner as createSigner2,
+  createUser as createUser2
+} from "@xmtp/agent-sdk";
+import { logger as logger2 } from "@hybrd/utils";
+import { randomUUID } from "crypto";
+async function sendResponse(conversation, text, originalMessageId, behaviorContext) {
+  const shouldThread = behaviorContext?.sendOptions?.threaded ?? false;
+  if (shouldThread) {
+    try {
+      const reply = {
+        reference: originalMessageId,
+        contentType: ContentTypeText,
+        content: text
+      };
+      await conversation.send(reply, ContentTypeReply);
+      logger2.debug(
+        `\u2705 [sendResponse] Threaded reply sent successfully to message ${originalMessageId}`
       );
-      const inboxState = await client.preferences.inboxStateFromInboxIds([
-        senderInboxId
-      ]);
-      const firstInbox = inboxState[0];
-      if (inboxState.length > 0 && firstInbox?.identifiers && firstInbox.identifiers.length > 0) {
-        const userAddress = firstInbox.identifiers[0]?.identifier;
-        if (userAddress) {
-          console.log("\u2705 Resolved user address:", userAddress);
-          return userAddress;
-        }
-      }
-      console.log("\u26A0\uFE0F No identifiers found in inbox state");
-      return "unknown";
     } catch (error) {
-      attempt++;
-      if (error instanceof Error && error.message.includes("Association error: Missing identity update")) {
-        console.log(
-          `\u{1F504} Identity association error during address resolution (attempt ${attempt}/${maxRetries})`
-        );
-        if (attempt < maxRetries) {
-          console.log(
-            "\u{1F527} Attempting automatic identity refresh for address resolution..."
-          );
-          try {
-            console.log("\u{1F4E1} Syncing conversations to refresh identity...");
-            await client.conversations.sync();
-            console.log("\u23F3 Waiting 2s before retry...");
-            await new Promise((resolve) => setTimeout(resolve, 2e3));
-            console.log(
-              "\u2705 Identity sync completed, retrying address resolution..."
-            );
-          } catch (refreshError) {
-            console.log(`\u274C Identity refresh failed:`, refreshError);
-          }
-        } else {
-          console.error("\u274C Failed to resolve user address after all retries");
-          console.error("\u{1F4A1} Identity association issue persists");
-          try {
-            const diagnosis = await diagnoseXMTPIdentityIssue(
-              client,
-              senderInboxId,
-              process.env.XMTP_ENV || "dev"
-            );
-            console.log("\u{1F50D} XMTP Identity Diagnosis:");
-            diagnosis.suggestions.forEach((suggestion) => {
-              console.error(`\u{1F4A1} ${suggestion}`);
-            });
-          } catch (diagError) {
-            console.warn("\u26A0\uFE0F Could not run XMTP identity diagnosis:", diagError);
-          }
-          return "unknown";
-        }
-      } else {
-        console.error("\u274C Error resolving user address:", error);
-        return "unknown";
-      }
+      logger2.error(
+        `\u274C [sendResponse] Failed to send threaded reply to message ${originalMessageId}:`,
+        error
+      );
+      logger2.debug(`\u{1F504} [sendResponse] Falling back to regular message`);
+      await conversation.send(text);
     }
+  } else {
+    await conversation.send(text);
   }
-  return "unknown";
 }
-var startPeriodicBackup = (dbPath, description, intervalMs = 3e5) => {
-  return setInterval(async () => {
-    try {
-      await backupDbToPersistentStorage(dbPath, description);
-    } catch (error) {
-      console.log(`\u26A0\uFE0F Periodic backup failed:`, error);
-    }
-  }, intervalMs);
-};
-
-// src/constants.ts
-var DEFAULT_OPTIONS = ["yes", "no"];
-var DEFAULT_AMOUNT = "0.1";
-var MAX_USDC_AMOUNT = 10;
-
-// src/lib/message-listener.ts
-import { EventEmitter } from "events";
-import { http as http2, createPublicClient } from "viem";
-import { mainnet as mainnet2 } from "viem/chains";
-
-// src/resolver/address-resolver.ts
-var AddressResolver = class {
-  constructor(client, options = {}) {
-    this.client = client;
-    __publicField(this, "cache", /* @__PURE__ */ new Map());
-    __publicField(this, "maxCacheSize");
-    __publicField(this, "cacheTtl");
-    this.maxCacheSize = options.maxCacheSize ?? 1e3;
-    this.cacheTtl = options.cacheTtl ?? 864e5;
-  }
-  /**
-   * Resolve user address from inbox ID with caching
-   */
-  async resolveAddress(inboxId, conversationId) {
-    const cached = this.getCachedAddress(inboxId);
-    if (cached) {
-      console.log(`\u2705 Resolved user address from cache: ${cached}`);
-      return cached;
-    }
-    let userAddress = void 0;
-    try {
-      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(`\u2705 Resolved user address: ${userAddress}`);
-            return userAddress;
+function XMTPPlugin() {
+  return {
+    name: "xmtp",
+    description: "Provides XMTP messaging functionality",
+    apply: async (app, context) => {
+      const {
+        XMTP_WALLET_KEY,
+        XMTP_DB_ENCRYPTION_KEY,
+        XMTP_ENV = "production"
+      } = process.env;
+      const { agent } = context;
+      const pluginContext = context;
+      if (!XMTP_WALLET_KEY) {
+        throw new Error("XMTP_WALLET_KEY must be set");
+      }
+      if (!XMTP_DB_ENCRYPTION_KEY) {
+        throw new Error("XMTP_DB_ENCRYPTION_KEY must be set");
+      }
+      const user = createUser2(XMTP_WALLET_KEY);
+      const signer = createSigner2(user);
+      const xmtpClient = await createXMTPClient(
+        XMTP_WALLET_KEY
+      );
+      async function startNodeStream() {
+        try {
+          logger2.debug("\u{1F3A7} XMTP node client stream initializing");
+          const stream = await xmtpClient.conversations.streamAllMessages();
+          logger2.debug("\u{1F3A7} XMTP node client stream started");
+          for await (const msg of stream) {
+            try {
+              if (msg.senderInboxId === xmtpClient.inboxId) continue;
+              const content = typeof msg.content === "string" ? msg.content : (() => {
+                try {
+                  return JSON.stringify(msg.content);
+                } catch {
+                  return String(msg.content);
+                }
+              })();
+              const conversation = await xmtpClient.conversations.getConversationById(
+                msg.conversationId
+              );
+              if (!conversation) {
+                logger2.warn(
+                  `\u26A0\uFE0F XMTP conversation not found: ${msg.conversationId}`
+                );
+                continue;
+              }
+              const messages = [
+                {
+                  id: randomUUID(),
+                  role: "user",
+                  parts: [{ type: "text", text: content }]
+                }
+              ];
+              const baseRuntime = {
+                conversation,
+                message: msg,
+                xmtpClient
+              };
+              const runtime = await agent.createRuntimeContext(baseRuntime);
+              if (pluginContext.behaviors) {
+                const behaviorContext2 = {
+                  runtime,
+                  client: xmtpClient,
+                  conversation,
+                  message: msg
+                };
+                await pluginContext.behaviors.executeBefore(behaviorContext2);
+                if (behaviorContext2.sendOptions?.filtered) {
+                  continue;
+                }
+              }
+              const { text } = await agent.generate(messages, { runtime });
+              const behaviorContext = {
+                runtime,
+                client: xmtpClient,
+                conversation,
+                message: msg,
+                response: text
+              };
+              if (pluginContext.behaviors) {
+                await pluginContext.behaviors.executeAfter(behaviorContext);
+              }
+              if (behaviorContext?.sendOptions?.filtered) {
+                logger2.debug(
+                  `\u{1F507} [XMTP Plugin] Skipping response due to message being filtered`
+                );
+                return;
+              }
+              await sendResponse(conversation, text, msg.id, behaviorContext);
+            } catch (err) {
+              logger2.error("\u274C Error processing XMTP message:", err);
+            }
           }
+        } catch (err) {
+          logger2.error("\u274C XMTP node client stream failed:", err);
         }
       }
-      userAddress = await this.resolveFromInboxState(inboxId);
-      if (userAddress) {
-        this.setCachedAddress(inboxId, userAddress);
-        console.log(`\u2705 Resolved user address via fallback: ${userAddress}`);
-        return userAddress;
-      }
-      console.log(`\u26A0\uFE0F No identifiers found for inbox ${inboxId}`);
-      return null;
-    } catch (error) {
-      console.error(`\u274C Error resolving user address for ${inboxId}:`, error);
-      return null;
-    }
-  }
-  /**
-   * Resolve address from conversation members
-   */
-  async resolveFromConversation(conversation, inboxId) {
-    try {
-      const members = await conversation.members();
-      const sender = members.find(
-        (member) => member.inboxId.toLowerCase() === inboxId.toLowerCase()
+      const enabledFromEnv = process.env.XMTP_ENABLE_NODE_STREAM;
+      const isNodeStreamEnabled = enabledFromEnv === void 0 ? true : !/^(false|0|off|no)$/i.test(String(enabledFromEnv));
+      if (isNodeStreamEnabled) void startNodeStream();
+      const address = user.account.address.toLowerCase();
+      const agentDbPath = await getDbPath(
+        `agent-${XMTP_ENV || "dev"}-${address}`
       );
-      if (sender) {
-        const ethIdentifier = sender.accountIdentifiers.find(
-          (id) => id.identifierKind === 0
-          // IdentifierKind.Ethereum
-        );
-        if (ethIdentifier) {
-          return ethIdentifier.identifier;
-        } else {
-          console.log(`\u26A0\uFE0F No Ethereum identifier found for inbox ${inboxId}`);
-        }
-      } else {
-        console.log(
-          `\u26A0\uFE0F Sender not found in conversation members for inbox ${inboxId}`
-        );
-      }
-    } catch (error) {
-      console.error(`\u274C Error resolving from conversation members:`, error);
-    }
-    return null;
-  }
-  /**
-   * Resolve address from inbox state (network fallback)
-   */
-  async resolveFromInboxState(inboxId) {
-    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;
-      }
-    } catch (error) {
-      console.error(`\u274C Error resolving from inbox state:`, error);
-    }
-    return null;
-  }
-  /**
-   * Get cached address if not expired
-   */
-  getCachedAddress(inboxId) {
-    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;
-  }
-  /**
-   * Cache address with LRU eviction
-   */
-  setCachedAddress(inboxId, address) {
-    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() {
-    console.log("\u{1F504} Pre-populating address cache...");
-    try {
-      const conversations = await this.client.conversations.list();
-      let cachedCount = 0;
-      for (const conversation of conversations) {
+      logger2.debug(`\u{1F4C1} Using agent listener database path: ${agentDbPath}`);
+      const xmtp = await XmtpAgent.create(signer, {
+        env: XMTP_ENV,
+        dbPath: agentDbPath
+      });
+      xmtp.on("reaction", async ({ conversation, message }) => {
         try {
-          const members = await conversation.members();
-          for (const member of members) {
-            const ethIdentifier = member.accountIdentifiers.find(
-              (id) => id.identifierKind === 0
-              // IdentifierKind.Ethereum
+          const text = message.content.content;
+          const messages = [
+            {
+              id: randomUUID(),
+              role: "user",
+              parts: [{ type: "text", text }]
+            }
+          ];
+          const baseRuntime = {
+            conversation,
+            message,
+            xmtpClient
+          };
+          const runtime = await agent.createRuntimeContext(baseRuntime);
+          if (context.behaviors) {
+            const behaviorContext2 = {
+              runtime,
+              client: xmtpClient,
+              conversation,
+              message
+            };
+            await context.behaviors.executeBefore(behaviorContext2);
+          }
+          const { text: reply } = await agent.generate(messages, { runtime });
+          let behaviorContext;
+          if (context.behaviors) {
+            behaviorContext = {
+              runtime,
+              client: xmtpClient,
+              conversation,
+              message,
+              response: reply
+            };
+            await context.behaviors.executeAfter(behaviorContext);
+          } else {
+            behaviorContext = {
+              runtime,
+              client: xmtpClient,
+              conversation,
+              message,
+              response: reply
+            };
+          }
+          if (behaviorContext?.sendOptions?.filtered) {
+            logger2.debug(
+              `\u{1F507} [XMTP Plugin] Skipping reaction response due to message being filtered`
             );
-            if (ethIdentifier) {
-              this.setCachedAddress(member.inboxId, ethIdentifier.identifier);
-              cachedCount++;
+            return;
+          }
+          await sendResponse(
+            conversation,
+            reply,
+            message.id,
+            behaviorContext
+          );
+        } catch (err) {
+          logger2.error("\u274C Error handling reaction:", err);
+        }
+      });
+      xmtp.on("reply", async ({ conversation, message }) => {
+        try {
+          const text = message.content.content;
+          const messages = [
+            {
+              id: randomUUID(),
+              role: "user",
+              parts: [{ type: "text", text }]
+            }
+          ];
+          const baseRuntime = {
+            conversation,
+            message,
+            xmtpClient
+          };
+          const runtime = await agent.createRuntimeContext(baseRuntime);
+          let behaviorContext;
+          if (context.behaviors) {
+            behaviorContext = {
+              runtime,
+              client: xmtpClient,
+              conversation,
+              message
+            };
+            await context.behaviors.executeBefore(behaviorContext);
+            if (behaviorContext.stopped) {
+              logger2.debug(
+                `\u{1F507} [XMTP Plugin] Skipping reply response due to behavior chain being stopped`
+              );
+              return;
+            }
+          }
+          const { text: reply } = await agent.generate(messages, { runtime });
+          if (context.behaviors) {
+            if (!behaviorContext) {
+              behaviorContext = {
+                runtime,
+                client: xmtpClient,
+                conversation,
+                message,
+                response: reply
+              };
+            } else {
+              behaviorContext.response = reply;
+            }
+            await context.behaviors.executeAfter(behaviorContext);
+            if (behaviorContext.stopped) {
+              logger2.debug(
+                `\u{1F507} [XMTP Plugin] Skipping reply response due to post-behavior chain being stopped`
+              );
+              return;
             }
+          } else {
+            behaviorContext = {
+              runtime,
+              client: xmtpClient,
+              conversation,
+              message,
+              response: reply
+            };
           }
-        } catch (error) {
-          console.error("Error pre-caching conversation members:", error);
+          await sendResponse(
+            conversation,
+            reply,
+            message.id,
+            behaviorContext
+          );
+        } catch (err) {
+          logger2.error("\u274C Error handling reply:", err);
         }
-      }
-      console.log(`\u2705 Pre-cached ${cachedCount} address mappings`);
-    } catch (error) {
-      console.error("Error pre-populating cache:", error);
+      });
+      xmtp.on("text", async ({ conversation, message }) => {
+        try {
+          const text = message.content;
+          const messages = [
+            { id: randomUUID(), role: "user", parts: [{ type: "text", text }] }
+          ];
+          const baseRuntime = {
+            conversation,
+            message,
+            xmtpClient
+          };
+          const runtime = await agent.createRuntimeContext(baseRuntime);
+          let behaviorContext;
+          if (context.behaviors) {
+            behaviorContext = {
+              runtime,
+              client: xmtpClient,
+              conversation,
+              message
+            };
+            await context.behaviors.executeBefore(behaviorContext);
+            if (behaviorContext.stopped) {
+              logger2.debug(
+                `\u{1F507} [XMTP Plugin] Skipping text response due to behavior chain being stopped`
+              );
+              return;
+            }
+          }
+          const { text: reply } = await agent.generate(messages, { runtime });
+          if (context.behaviors) {
+            if (!behaviorContext) {
+              behaviorContext = {
+                runtime,
+                client: xmtpClient,
+                conversation,
+                message,
+                response: reply
+              };
+            } else {
+              behaviorContext.response = reply;
+            }
+            await context.behaviors.executeAfter(behaviorContext);
+            if (behaviorContext.stopped) {
+              logger2.debug(
+                `\u{1F507} [XMTP Plugin] Skipping text response due to post-behavior chain being stopped`
+              );
+              return;
+            }
+          } else {
+            behaviorContext = {
+              runtime,
+              client: xmtpClient,
+              conversation,
+              message,
+              response: reply
+            };
+          }
+          await sendResponse(
+            conversation,
+            reply,
+            message.id,
+            behaviorContext
+          );
+        } catch (err) {
+          logger2.error("\u274C Error handling text:", err);
+        }
+      });
+      void xmtp.start().then(() => logger2.debug("\u2705 XMTP agent listener started")).catch(
+        (err) => console.error("\u274C XMTP agent listener failed to start:", err)
+      );
     }
-  }
-  /**
-   * Clear the cache
-   */
-  clearCache() {
-    this.cache.clear();
-    console.log("\u{1F5D1}\uFE0F Address cache cleared");
-  }
-  /**
-   * Get cache statistics
-   */
-  getCacheStats() {
-    return {
-      size: this.cache.size,
-      maxSize: this.maxCacheSize
-    };
-  }
-};
-
-// src/resolver/basename-resolver.ts
-import {
-  encodePacked,
-  keccak256,
-  namehash
-} from "viem";
-import { mainnet } from "viem/chains";
+  };
+}
 
-// src/abi/l2_resolver.ts
-var L2ResolverAbi = [
-  {
-    inputs: [
-      { internalType: "contract ENS", name: "ens_", type: "address" },
-      {
-        internalType: "address",
-        name: "registrarController_",
-        type: "address"
-      },
-      { internalType: "address", name: "reverseRegistrar_", type: "address" },
-      { internalType: "address", name: "owner_", type: "address" }
-    ],
-    stateMutability: "nonpayable",
-    type: "constructor"
-  },
-  { inputs: [], name: "AlreadyInitialized", type: "error" },
-  { inputs: [], name: "CantSetSelfAsDelegate", type: "error" },
-  { inputs: [], name: "CantSetSelfAsOperator", type: "error" },
-  { inputs: [], name: "NewOwnerIsZeroAddress", type: "error" },
-  { inputs: [], name: "NoHandoverRequest", type: "error" },
-  { inputs: [], name: "Unauthorized", type: "error" },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      {
-        indexed: true,
-        internalType: "uint256",
-        name: "contentType",
-        type: "uint256"
-      }
-    ],
-    name: "ABIChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      { indexed: false, internalType: "address", name: "a", type: "address" }
-    ],
-    name: "AddrChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "coinType",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "bytes",
-        name: "newAddress",
-        type: "bytes"
-      }
-    ],
-    name: "AddressChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "owner",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "operator",
-        type: "address"
-      },
-      { indexed: false, internalType: "bool", name: "approved", type: "bool" }
-    ],
-    name: "ApprovalForAll",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: false,
-        internalType: "address",
-        name: "owner",
-        type: "address"
-      },
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "delegate",
-        type: "address"
-      },
-      { indexed: true, internalType: "bool", name: "approved", type: "bool" }
-    ],
-    name: "Approved",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      { indexed: false, internalType: "bytes", name: "hash", type: "bytes" }
-    ],
-    name: "ContenthashChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      { indexed: false, internalType: "bytes", name: "name", type: "bytes" },
-      {
-        indexed: false,
-        internalType: "uint16",
-        name: "resource",
-        type: "uint16"
-      },
-      { indexed: false, internalType: "bytes", name: "record", type: "bytes" }
-    ],
-    name: "DNSRecordChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      { indexed: false, internalType: "bytes", name: "name", type: "bytes" },
-      {
-        indexed: false,
-        internalType: "uint16",
-        name: "resource",
-        type: "uint16"
-      }
-    ],
-    name: "DNSRecordDeleted",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      {
-        indexed: false,
-        internalType: "bytes",
-        name: "lastzonehash",
-        type: "bytes"
-      },
-      {
-        indexed: false,
-        internalType: "bytes",
-        name: "zonehash",
-        type: "bytes"
-      }
-    ],
-    name: "DNSZonehashChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      {
-        indexed: true,
-        internalType: "bytes4",
-        name: "interfaceID",
-        type: "bytes4"
-      },
-      {
-        indexed: false,
-        internalType: "address",
-        name: "implementer",
-        type: "address"
-      }
-    ],
-    name: "InterfaceChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      { indexed: false, internalType: "string", name: "name", type: "string" }
-    ],
-    name: "NameChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "pendingOwner",
-        type: "address"
-      }
-    ],
-    name: "OwnershipHandoverCanceled",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "pendingOwner",
-        type: "address"
-      }
-    ],
-    name: "OwnershipHandoverRequested",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "oldOwner",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newOwner",
-        type: "address"
-      }
-    ],
-    name: "OwnershipTransferred",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      { indexed: false, internalType: "bytes32", name: "x", type: "bytes32" },
-      { indexed: false, internalType: "bytes32", name: "y", type: "bytes32" }
-    ],
-    name: "PubkeyChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newRegistrarController",
-        type: "address"
-      }
-    ],
-    name: "RegistrarControllerUpdated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newReverseRegistrar",
-        type: "address"
-      }
-    ],
-    name: "ReverseRegistrarUpdated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      {
-        indexed: true,
-        internalType: "string",
-        name: "indexedKey",
-        type: "string"
-      },
-      { indexed: false, internalType: "string", name: "key", type: "string" },
-      { indexed: false, internalType: "string", name: "value", type: "string" }
-    ],
-    name: "TextChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "bytes32", name: "node", type: "bytes32" },
-      {
-        indexed: false,
-        internalType: "uint64",
-        name: "newVersion",
-        type: "uint64"
-      }
-    ],
-    name: "VersionChanged",
-    type: "event"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "uint256", name: "contentTypes", type: "uint256" }
-    ],
-    name: "ABI",
-    outputs: [
-      { internalType: "uint256", name: "", type: "uint256" },
-      { internalType: "bytes", name: "", type: "bytes" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "node", type: "bytes32" }],
-    name: "addr",
-    outputs: [{ internalType: "address payable", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "uint256", name: "coinType", type: "uint256" }
-    ],
-    name: "addr",
-    outputs: [{ internalType: "bytes", name: "", type: "bytes" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "address", name: "delegate", type: "address" },
-      { internalType: "bool", name: "approved", type: "bool" }
-    ],
-    name: "approve",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "cancelOwnershipHandover",
-    outputs: [],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "node", type: "bytes32" }],
-    name: "clearRecords",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "pendingOwner", type: "address" }
-    ],
-    name: "completeOwnershipHandover",
-    outputs: [],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "node", type: "bytes32" }],
-    name: "contenthash",
-    outputs: [{ internalType: "bytes", name: "", type: "bytes" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "bytes32", name: "name", type: "bytes32" },
-      { internalType: "uint16", name: "resource", type: "uint16" }
-    ],
-    name: "dnsRecord",
-    outputs: [{ internalType: "bytes", name: "", type: "bytes" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "ens",
-    outputs: [{ internalType: "contract ENS", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "bytes32", name: "name", type: "bytes32" }
-    ],
-    name: "hasDNSRecords",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "bytes4", name: "interfaceID", type: "bytes4" }
-    ],
-    name: "interfaceImplementer",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "owner", type: "address" },
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "address", name: "delegate", type: "address" }
-    ],
-    name: "isApprovedFor",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "account", type: "address" },
-      { internalType: "address", name: "operator", type: "address" }
-    ],
-    name: "isApprovedForAll",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes[]", name: "data", type: "bytes[]" }],
-    name: "multicall",
-    outputs: [{ internalType: "bytes[]", name: "results", type: "bytes[]" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "nodehash", type: "bytes32" },
-      { internalType: "bytes[]", name: "data", type: "bytes[]" }
-    ],
-    name: "multicallWithNodeCheck",
-    outputs: [{ internalType: "bytes[]", name: "results", type: "bytes[]" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "node", type: "bytes32" }],
-    name: "name",
-    outputs: [{ internalType: "string", name: "", type: "string" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "owner",
-    outputs: [{ internalType: "address", name: "result", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "pendingOwner", type: "address" }
-    ],
-    name: "ownershipHandoverExpiresAt",
-    outputs: [{ internalType: "uint256", name: "result", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "node", type: "bytes32" }],
-    name: "pubkey",
-    outputs: [
-      { internalType: "bytes32", name: "x", type: "bytes32" },
-      { internalType: "bytes32", name: "y", type: "bytes32" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
-    name: "recordVersions",
-    outputs: [{ internalType: "uint64", name: "", type: "uint64" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "registrarController",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "renounceOwnership",
-    outputs: [],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "requestOwnershipHandover",
-    outputs: [],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes", name: "", type: "bytes" },
-      { internalType: "bytes", name: "data", type: "bytes" }
-    ],
-    name: "resolve",
-    outputs: [{ internalType: "bytes", name: "", type: "bytes" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "reverseRegistrar",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "uint256", name: "contentType", type: "uint256" },
-      { internalType: "bytes", name: "data", type: "bytes" }
-    ],
-    name: "setABI",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "uint256", name: "coinType", type: "uint256" },
-      { internalType: "bytes", name: "a", type: "bytes" }
-    ],
-    name: "setAddr",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "address", name: "a", type: "address" }
-    ],
-    name: "setAddr",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "operator", type: "address" },
-      { internalType: "bool", name: "approved", type: "bool" }
-    ],
-    name: "setApprovalForAll",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "bytes", name: "hash", type: "bytes" }
-    ],
-    name: "setContenthash",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "bytes", name: "data", type: "bytes" }
-    ],
-    name: "setDNSRecords",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "bytes4", name: "interfaceID", type: "bytes4" },
-      { internalType: "address", name: "implementer", type: "address" }
-    ],
-    name: "setInterface",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "string", name: "newName", type: "string" }
-    ],
-    name: "setName",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "bytes32", name: "x", type: "bytes32" },
-      { internalType: "bytes32", name: "y", type: "bytes32" }
-    ],
-    name: "setPubkey",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "registrarController_",
-        type: "address"
-      }
-    ],
-    name: "setRegistrarController",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "reverseRegistrar_", type: "address" }
-    ],
-    name: "setReverseRegistrar",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "string", name: "key", type: "string" },
-      { internalType: "string", name: "value", type: "string" }
-    ],
-    name: "setText",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "bytes", name: "hash", type: "bytes" }
-    ],
-    name: "setZonehash",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes4", name: "interfaceID", type: "bytes4" }],
-    name: "supportsInterface",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32", name: "node", type: "bytes32" },
-      { internalType: "string", name: "key", type: "string" }
-    ],
-    name: "text",
-    outputs: [{ internalType: "string", name: "", type: "string" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
-    name: "transferOwnership",
-    outputs: [],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "node", type: "bytes32" }],
-    name: "zonehash",
-    outputs: [{ internalType: "bytes", name: "", type: "bytes" }],
-    stateMutability: "view",
-    type: "function"
+// src/lib/jwt.ts
+import jwt from "jsonwebtoken";
+import { logger as logger3 } from "@hybrd/utils";
+function getJwtSecret() {
+  const secret = process.env.XMTP_DB_ENCRYPTION_KEY;
+  const nodeEnv = process.env.NODE_ENV || "development";
+  if (nodeEnv === "production" && !secret) {
+    throw new Error(
+      "XMTP_DB_ENCRYPTION_KEY environment variable is required in production. Generate a secure random secret for JWT token signing."
+    );
   }
-];
-
-// src/resolver/basename-resolver.ts
-var BASENAME_L2_RESOLVER_ADDRESS = "0xC6d566A56A1aFf6508b41f6c90ff131615583BCD";
-var BasenameTextRecordKeys = {
-  Email: "email",
-  Url: "url",
-  Avatar: "avatar",
-  Description: "description",
-  Notice: "notice",
-  Keywords: "keywords",
-  Twitter: "com.twitter",
-  Github: "com.github",
-  Discord: "com.discord",
-  Telegram: "org.telegram",
-  Snapshot: "snapshot",
-  Location: "location"
-};
-var convertChainIdToCoinType = (chainId) => {
-  if (chainId === mainnet.id) {
-    return "addr";
+  if (!secret) {
+    logger3.warn(
+      "\u26A0\uFE0F  [SECURITY] Using fallback JWT secret for development. Set XMTP_DB_ENCRYPTION_KEY environment variable for production."
+    );
+    return "fallback-secret-for-dev-only";
   }
-  const cointype = (2147483648 | chainId) >>> 0;
-  return cointype.toString(16).toLocaleUpperCase();
-};
-var convertReverseNodeToBytes = (address, chainId) => {
-  const addressFormatted = address.toLocaleLowerCase();
-  const addressNode = keccak256(addressFormatted.substring(2));
-  const chainCoinType = convertChainIdToCoinType(chainId);
-  const baseReverseNode = namehash(
-    `${chainCoinType.toLocaleUpperCase()}.reverse`
-  );
-  const addressReverseNode = keccak256(
-    encodePacked(["bytes32", "bytes32"], [baseReverseNode, addressNode])
-  );
-  return addressReverseNode;
-};
-function convertBasenameToNode(basename) {
-  return namehash(basename);
+  return secret;
 }
-function getResolverAddress() {
-  const resolverAddress = BASENAME_L2_RESOLVER_ADDRESS;
-  return resolverAddress;
-}
-var BasenameResolver = class {
-  constructor(options) {
-    __publicField(this, "cache", /* @__PURE__ */ new Map());
-    __publicField(this, "textRecordCache", /* @__PURE__ */ new Map());
-    __publicField(this, "maxCacheSize");
-    __publicField(this, "cacheTtl");
-    __publicField(this, "baseClient");
-    __publicField(this, "resolverAddress", null);
-    __publicField(this, "chainId", null);
-    this.maxCacheSize = options.maxCacheSize ?? 500;
-    this.cacheTtl = options.cacheTtl ?? 36e5;
-    this.baseClient = options.publicClient;
-    this.initializeResolver();
-  }
-  /**
-   * Initialize the resolver address based on the client's chain ID
-   */
-  async initializeResolver() {
-    if (this.resolverAddress && this.chainId) {
-      console.log(
-        `\u{1F504} BasenameResolver already initialized for chain ${this.chainId} with resolver ${this.resolverAddress}`
-      );
-      return;
-    }
-    try {
-      console.log("\u{1F504} Initializing BasenameResolver...");
-      this.chainId = await this.baseClient.getChainId();
-      console.log(`\u{1F517} Chain ID detected: ${this.chainId}`);
-      this.resolverAddress = getResolverAddress();
-      console.log(
-        `\u{1F4CD} Resolver address for chain ${this.chainId}: ${this.resolverAddress}`
-      );
-      console.log(
-        `\u2705 Initialized BasenameResolver for chain ${this.chainId} with resolver ${this.resolverAddress}`
-      );
-    } catch (error) {
-      console.error("\u274C Failed to initialize BasenameResolver:", error);
-      throw error;
-    }
-  }
-  /**
-   * Get the resolver address, initializing if necessary
-   */
-  async getResolverAddress() {
-    await this.initializeResolver();
-    if (!this.resolverAddress) {
-      throw new Error("Failed to initialize resolver address");
-    }
-    return this.resolverAddress;
-  }
-  /**
-   * Resolve a basename from an Ethereum address
-   */
-  async getBasename(address) {
-    console.log(`\u{1F50D} Starting basename resolution for address: ${address}`);
-    try {
-      const cached = this.getCachedBasename(address);
-      if (cached) {
-        console.log(`\u2705 Resolved basename from cache: ${cached}`);
-        return cached;
-      }
-      console.log(`\u{1F4ED} No cached basename found for address: ${address}`);
-      console.log("\u{1F504} Getting resolver address...");
-      const resolverAddress = await this.getResolverAddress();
-      console.log(`\u{1F4CD} Using resolver address: ${resolverAddress}`);
-      console.log("\u{1F504} Getting chain ID...");
-      const chainId = await this.baseClient.getChainId();
-      console.log(`\u{1F517} Chain ID: ${chainId}`);
-      console.log("\u{1F504} Converting address to reverse node...");
-      const addressReverseNode = convertReverseNodeToBytes(
-        // address.toUpperCase() as `0x${string}`,
-        address,
-        chainId
-      );
-      console.log(`\u{1F517} Reverse node: ${addressReverseNode}`);
-      console.log("\u{1F504} Reading contract to resolve basename...");
-      const basename = await this.baseClient.readContract({
-        abi: L2ResolverAbi,
-        address: resolverAddress,
-        functionName: "name",
-        args: [addressReverseNode]
-      });
-      console.log(
-        `\u{1F4CB} Contract returned basename: "${basename}" (length: ${basename?.length || 0})`
-      );
-      if (basename && basename.length > 0) {
-        this.setCachedBasename(address, basename);
-        console.log(`\u2705 Resolved basename: ${basename} for address: ${address}`);
-        return basename;
-      }
-      console.log(
-        `\u274C No basename found for address: ${address} (empty or null response)`
-      );
-      return null;
-    } catch (error) {
-      console.error(
-        `\u274C Error resolving basename for address ${address}:`,
-        error
-      );
-      if (error instanceof Error) {
-        console.error(`\u274C Error details: ${error.message}`);
-        console.error(`\u274C Error stack:`, error.stack);
-      }
-      return null;
-    }
-  }
-  /**
-   * Get the avatar URL for a basename
-   */
-  async getBasenameAvatar(basename) {
-    console.log(`\u{1F5BC}\uFE0F Getting avatar for basename: ${basename}`);
-    return this.getBasenameTextRecord(basename, BasenameTextRecordKeys.Avatar);
-  }
-  /**
-   * Get a text record for a basename
-   */
-  async getBasenameTextRecord(basename, key) {
-    console.log(`\u{1F4DD} Getting text record "${key}" for basename: ${basename}`);
-    try {
-      const cached = this.getCachedTextRecord(basename, key);
-      if (cached) {
-        console.log(`\u2705 Resolved text record from cache: ${key}=${cached}`);
-        return cached;
-      }
-      console.log(`\u{1F4ED} No cached text record found for ${basename}.${key}`);
-      console.log("\u{1F504} Getting resolver address...");
-      const resolverAddress = await this.getResolverAddress();
-      console.log(`\u{1F4CD} Using resolver address: ${resolverAddress}`);
-      console.log("\u{1F504} Converting basename to node...");
-      const node = convertBasenameToNode(basename);
-      console.log(`\u{1F517} Node hash: ${node}`);
-      console.log(`\u{1F504} Reading contract for text record "${key}"...`);
-      const textRecord = await this.baseClient.readContract({
-        abi: L2ResolverAbi,
-        address: resolverAddress,
-        functionName: "text",
-        args: [node, key]
-      });
-      console.log(
-        `\u{1F4CB} Contract returned text record: "${textRecord}" (length: ${textRecord?.length || 0})`
-      );
-      if (textRecord && textRecord.length > 0) {
-        this.setCachedTextRecord(basename, key, textRecord);
-        console.log(`\u2705 Resolved text record: ${key}=${textRecord}`);
-        return textRecord;
-      }
-      console.log(
-        `\u274C No text record found for ${basename}.${key} (empty or null response)`
-      );
-      return null;
-    } catch (error) {
-      console.error(
-        `\u274C Error resolving text record ${key} for ${basename}:`,
-        error
-      );
-      if (error instanceof Error) {
-        console.error(`\u274C Error details: ${error.message}`);
-        console.error(`\u274C Error stack:`, error.stack);
-      }
-      return null;
-    }
-  }
-  /**
-   * Get the Ethereum address that owns a basename
-   */
-  async getBasenameAddress(basename) {
-    console.log(`\u{1F50D} Getting address for basename: ${basename}`);
-    try {
-      console.log("\u{1F504} Getting resolver address...");
-      const resolverAddress = await this.getResolverAddress();
-      console.log(`\u{1F4CD} Using resolver address: ${resolverAddress}`);
-      console.log("\u{1F504} Converting basename to node...");
-      const node = convertBasenameToNode(basename);
-      console.log(`\u{1F517} Node hash: ${node}`);
-      console.log("\u{1F504} Reading contract to resolve address...");
-      const address = await this.baseClient.readContract({
-        abi: L2ResolverAbi,
-        address: resolverAddress,
-        functionName: "addr",
-        args: [node]
-      });
-      console.log(`\u{1F4CB} Contract returned address: "${address}"`);
-      if (address && address !== "0x0000000000000000000000000000000000000000") {
-        console.log(`\u2705 Resolved address: ${address} for basename: ${basename}`);
-        return address;
-      }
-      console.log(
-        `\u274C No address found for basename: ${basename} (zero address or null response)`
-      );
-      return null;
-    } catch (error) {
-      console.error(
-        `\u274C Error resolving address for basename ${basename}:`,
-        error
-      );
-      if (error instanceof Error) {
-        console.error(`\u274C Error details: ${error.message}`);
-        console.error(`\u274C Error stack:`, error.stack);
-      }
-      return null;
-    }
-  }
-  /**
-   * Get all basic metadata for a basename
-   */
-  async getBasenameMetadata(basename) {
-    console.log(`\u{1F4CA} Getting metadata for basename: ${basename}`);
-    try {
-      const [avatar, description, twitter, github, url] = await Promise.all([
-        this.getBasenameTextRecord(basename, BasenameTextRecordKeys.Avatar),
-        this.getBasenameTextRecord(
-          basename,
-          BasenameTextRecordKeys.Description
-        ),
-        this.getBasenameTextRecord(basename, BasenameTextRecordKeys.Twitter),
-        this.getBasenameTextRecord(basename, BasenameTextRecordKeys.Github),
-        this.getBasenameTextRecord(basename, BasenameTextRecordKeys.Url)
-      ]);
-      const metadata = {
-        basename,
-        avatar,
-        description,
-        twitter,
-        github,
-        url
-      };
-      console.log(`\u2705 Resolved metadata for ${basename}:`, metadata);
-      return metadata;
-    } catch (error) {
-      console.error(
-        `\u274C Error resolving metadata for basename ${basename}:`,
-        error
-      );
-      if (error instanceof Error) {
-        console.error(`\u274C Error details: ${error.message}`);
-        console.error(`\u274C Error stack:`, error.stack);
-      }
-      return null;
-    }
-  }
-  /**
-   * Resolve a full basename profile (name + metadata) from an address
-   */
-  async resolveBasenameProfile(address) {
-    console.log(`\u{1F464} Resolving full basename profile for address: ${address}`);
-    try {
-      const basename = await this.getBasename(address);
-      if (!basename) {
-        console.log(`\u274C No basename found for address: ${address}`);
-        return null;
-      }
-      console.log(`\u{1F504} Getting metadata for resolved basename: ${basename}`);
-      const metadata = await this.getBasenameMetadata(basename);
-      const profile = {
-        address,
-        ...metadata
-      };
-      console.log(`\u2705 Resolved full profile for ${address}:`, profile);
-      return profile;
-    } catch (error) {
-      console.error(
-        `\u274C Error resolving basename profile for ${address}:`,
-        error
-      );
-      if (error instanceof Error) {
-        console.error(`\u274C Error details: ${error.message}`);
-        console.error(`\u274C Error stack:`, error.stack);
-      }
-      return null;
-    }
-  }
-  /**
-   * Get cached basename if not expired
-   */
-  getCachedBasename(address) {
-    const entry = this.cache.get(address.toLowerCase());
-    if (!entry) {
-      console.log(
-        `\u{1F4ED} No cache entry found for address: ${address.toLowerCase()}`
-      );
-      return null;
-    }
-    const now = Date.now();
-    const age = now - entry.timestamp;
-    console.log(`\u{1F550} Cache entry age: ${age}ms (TTL: ${this.cacheTtl}ms)`);
-    if (age > this.cacheTtl) {
-      console.log(
-        `\u23F0 Cache entry expired for address: ${address.toLowerCase()}`
-      );
-      this.cache.delete(address.toLowerCase());
-      return null;
-    }
-    console.log(
-      `\u2705 Valid cache entry found for ${address.toLowerCase()}: "${entry.basename}"`
-    );
-    return entry.basename;
-  }
-  /**
-   * Cache basename with LRU eviction
-   */
-  setCachedBasename(address, basename) {
-    if (this.cache.size >= this.maxCacheSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        console.log(`\u{1F5D1}\uFE0F Cache full, removing oldest entry: ${firstKey}`);
-        this.cache.delete(firstKey);
-      }
-    }
-    console.log(
-      `\u{1F4BE} Caching basename "${basename}" for address: ${address.toLowerCase()}`
-    );
-    this.cache.set(address.toLowerCase(), {
-      basename,
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * Get cached text record if not expired
-   */
-  getCachedTextRecord(basename, key) {
-    const basenameCache = this.textRecordCache.get(basename);
-    if (!basenameCache) {
-      console.log(`\u{1F4ED} No text record cache found for basename: ${basename}`);
-      return null;
-    }
-    const entry = basenameCache.get(key);
-    if (!entry) {
-      console.log(`\u{1F4ED} No cached text record found for ${basename}.${key}`);
-      return null;
-    }
-    const now = Date.now();
-    const age = now - entry.timestamp;
-    console.log(
-      `\u{1F550} Text record cache entry age: ${age}ms (TTL: ${this.cacheTtl}ms)`
-    );
-    if (age > this.cacheTtl) {
-      console.log(`\u23F0 Text record cache entry expired for ${basename}.${key}`);
-      basenameCache.delete(key);
-      return null;
-    }
-    console.log(
-      `\u2705 Valid text record cache entry found for ${basename}.${key}: "${entry.value}"`
-    );
-    return entry.value;
-  }
-  /**
-   * Cache text record
-   */
-  setCachedTextRecord(basename, key, value) {
-    let basenameCache = this.textRecordCache.get(basename);
-    if (!basenameCache) {
-      console.log(`\u{1F4DD} Creating new text record cache for basename: ${basename}`);
-      basenameCache = /* @__PURE__ */ new Map();
-      this.textRecordCache.set(basename, basenameCache);
-    }
-    console.log(
-      `\u{1F4BE} Caching text record "${key}" = "${value}" for basename: ${basename}`
-    );
-    basenameCache.set(key, {
-      value,
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * Clear all caches
-   */
-  clearCache() {
-    const basenameCount = this.cache.size;
-    const textRecordCount = this.textRecordCache.size;
-    this.cache.clear();
-    this.textRecordCache.clear();
-    console.log(`\u{1F5D1}\uFE0F Basename cache cleared (${basenameCount} entries removed)`);
-    console.log(
-      `\u{1F5D1}\uFE0F Text record cache cleared (${textRecordCount} basename caches removed)`
-    );
-  }
-  /**
-   * Get cache statistics
-   */
-  getCacheStats() {
-    return {
-      basenameCache: {
-        size: this.cache.size,
-        maxSize: this.maxCacheSize
-      },
-      textRecordCache: {
-        size: this.textRecordCache.size
-      },
-      chainId: this.chainId,
-      resolverAddress: this.resolverAddress
-    };
-  }
-};
-
-// src/resolver/ens-resolver.ts
-var ENSResolver = class {
-  constructor(options) {
-    __publicField(this, "cache", /* @__PURE__ */ new Map());
-    __publicField(this, "reverseCache", /* @__PURE__ */ new Map());
-    __publicField(this, "maxCacheSize");
-    __publicField(this, "cacheTtl");
-    __publicField(this, "mainnetClient");
-    this.maxCacheSize = options.maxCacheSize ?? 500;
-    this.cacheTtl = options.cacheTtl ?? 36e5;
-    this.mainnetClient = options.mainnetClient;
-  }
-  /**
-   * Resolve an ENS name to an Ethereum address
-   */
-  async resolveENSName(ensName) {
-    console.log(`\u{1F50D} Resolving ENS name: ${ensName}`);
-    try {
-      const cached = this.getCachedAddress(ensName);
-      if (cached) {
-        console.log(`\u2705 Resolved ENS from cache: ${ensName} \u2192 ${cached}`);
-        return cached;
-      }
-      console.log(`\u{1F4ED} No cached address found for ENS: ${ensName}`);
-      console.log("\u{1F504} Reading ENS contract...");
-      const address = await this.mainnetClient.getEnsAddress({
-        name: ensName
-      });
-      console.log(`\u{1F4CB} ENS contract returned address: "${address}"`);
-      if (address && address !== "0x0000000000000000000000000000000000000000") {
-        this.setCachedAddress(ensName, address);
-        console.log(`\u2705 Resolved ENS: ${ensName} \u2192 ${address}`);
-        return address;
-      }
-      console.log(`\u274C No address found for ENS: ${ensName}`);
-      return null;
-    } catch (error) {
-      console.error(`\u274C Error resolving ENS name ${ensName}:`, error);
-      if (error instanceof Error) {
-        console.error(`\u274C Error details: ${error.message}`);
-      }
-      return null;
-    }
-  }
-  /**
-   * Resolve an address to its primary ENS name (reverse resolution)
-   */
-  async resolveAddressToENS(address) {
-    console.log(`\u{1F50D} Reverse resolving address to ENS: ${address}`);
-    try {
-      const cached = this.getCachedENSName(address);
-      if (cached) {
-        console.log(
-          `\u2705 Resolved ENS from reverse cache: ${address} \u2192 ${cached}`
-        );
-        return cached;
-      }
-      console.log(`\u{1F4ED} No cached ENS name found for address: ${address}`);
-      console.log("\u{1F504} Reading ENS reverse resolver...");
-      const ensName = await this.mainnetClient.getEnsName({
-        address
-      });
-      console.log(`\u{1F4CB} ENS reverse resolver returned: "${ensName}"`);
-      if (ensName && ensName.length > 0) {
-        this.setCachedENSName(address, ensName);
-        console.log(`\u2705 Reverse resolved: ${address} \u2192 ${ensName}`);
-        return ensName;
-      }
-      console.log(`\u274C No ENS name found for address: ${address}`);
-      return null;
-    } catch (error) {
-      console.error(`\u274C Error reverse resolving address ${address}:`, error);
-      if (error instanceof Error) {
-        console.error(`\u274C Error details: ${error.message}`);
-      }
-      return null;
-    }
-  }
-  /**
-   * Get ENS avatar for a name
-   */
-  async getENSAvatar(ensName) {
-    console.log(`\u{1F5BC}\uFE0F Getting ENS avatar for: ${ensName}`);
-    try {
-      const avatar = await this.mainnetClient.getEnsAvatar({
-        name: ensName
-      });
-      if (avatar) {
-        console.log(`\u2705 Found ENS avatar: ${avatar}`);
-        return avatar;
-      }
-      console.log(`\u274C No avatar found for ENS: ${ensName}`);
-      return null;
-    } catch (error) {
-      console.error(`\u274C Error getting ENS avatar for ${ensName}:`, error);
-      return null;
-    }
-  }
-  /**
-   * Get ENS text record
-   */
-  async getENSTextRecord(ensName, key) {
-    console.log(`\u{1F4DD} Getting ENS text record "${key}" for: ${ensName}`);
-    try {
-      const textRecord = await this.mainnetClient.getEnsText({
-        name: ensName,
-        key
-      });
-      if (textRecord && textRecord.length > 0) {
-        console.log(`\u2705 Found ENS text record: ${key}=${textRecord}`);
-        return textRecord;
-      }
-      console.log(`\u274C No text record "${key}" found for ENS: ${ensName}`);
-      return null;
-    } catch (error) {
-      console.error(
-        `\u274C Error getting ENS text record ${key} for ${ensName}:`,
-        error
-      );
-      return null;
-    }
-  }
-  /**
-   * Get comprehensive ENS profile
-   */
-  async getENSProfile(ensName) {
-    console.log(`\u{1F464} 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(`\u2705 ENS profile for ${ensName}:`, profile);
-      return profile;
-    } catch (error) {
-      console.error(`\u274C 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(`\u{1F5D1}\uFE0F ENS address cache cleared (${addressCount} entries removed)`);
-    console.log(`\u{1F5D1}\uFE0F 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
-      }
-    };
-  }
-};
-
-// src/resolver/xmtp-resolver.ts
-var XmtpResolver = class {
-  constructor(client, options = {}) {
-    this.client = client;
-    __publicField(this, "addressCache", /* @__PURE__ */ new Map());
-    __publicField(this, "messageCache", /* @__PURE__ */ new Map());
-    __publicField(this, "maxCacheSize");
-    __publicField(this, "cacheTtl");
-    __publicField(this, "maxMessageCacheSize");
-    __publicField(this, "messageCacheTtl");
-    this.maxCacheSize = options.maxCacheSize ?? 1e3;
-    this.cacheTtl = options.cacheTtl ?? 864e5;
-    this.maxMessageCacheSize = options.maxMessageCacheSize ?? 1e3;
-    this.messageCacheTtl = options.messageCacheTtl ?? 36e5;
-  }
-  /**
-   * Resolve user address from inbox ID with caching
-   */
-  async resolveAddress(inboxId, conversationId) {
-    const cached = this.getCachedAddress(inboxId);
-    if (cached) {
-      console.log(
-        `\u2705 [XmtpResolver] Resolved user address from cache: ${cached}`
-      );
-      return cached;
-    }
-    let userAddress = void 0;
-    try {
-      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(
-              `\u2705 [XmtpResolver] Resolved user address: ${userAddress}`
-            );
-            return userAddress;
-          }
-        }
-      }
-      userAddress = await this.resolveFromInboxState(inboxId);
-      if (userAddress) {
-        this.setCachedAddress(inboxId, userAddress);
-        console.log(
-          `\u2705 [XmtpResolver] Resolved user address via fallback: ${userAddress}`
-        );
-        return userAddress;
-      }
-      console.log(`\u26A0\uFE0F [XmtpResolver] No identifiers found for inbox ${inboxId}`);
-      return null;
-    } catch (error) {
-      console.error(
-        `\u274C [XmtpResolver] Error resolving user address for ${inboxId}:`,
-        error
-      );
-      return null;
-    }
-  }
-  /**
-   * Find any message by ID with caching
-   */
-  async findMessage(messageId) {
-    const cached = this.getCachedMessage(messageId);
-    if (cached !== void 0) {
-      console.log(
-        cached ? `\u2705 [XmtpResolver] Found message from cache: ${cached.id}` : `\u2705 [XmtpResolver] Found cached null message for: ${messageId}`
-      );
-      return cached;
-    }
-    try {
-      console.log(`\u{1F50D} [XmtpResolver] Finding message: ${messageId}`);
-      const message = await this.client.conversations.getMessageById(messageId);
-      if (message) {
-        this.setCachedMessage(messageId, message);
-        console.log(`\u2705 [XmtpResolver] Found and cached message: ${message.id}`);
-        return message;
-      }
-      console.log(`\u26A0\uFE0F [XmtpResolver] Message not found: ${messageId}`);
-      this.setCachedMessage(messageId, null);
-      return null;
-    } catch (error) {
-      console.error(
-        `\u274C [XmtpResolver] Error finding message ${messageId}:`,
-        error
-      );
-      this.setCachedMessage(messageId, null);
-      return null;
-    }
-  }
-  /**
-   * Find root message with caching
-   */
-  async findRootMessage(messageId) {
-    const rootCacheKey = `root:${messageId}`;
-    const cached = this.getCachedMessage(rootCacheKey);
-    if (cached !== void 0) {
-      console.log(
-        cached ? `\u2705 [XmtpResolver] Found root message from cache: ${cached.id}` : `\u2705 [XmtpResolver] Found cached null root for: ${messageId}`
-      );
-      return cached;
-    }
-    try {
-      console.log(`\u{1F50D} [XmtpResolver] Finding root message for: ${messageId}`);
-      const rootMessage = await this.findRootMessageRecursive(messageId);
-      if (rootMessage) {
-        this.setCachedMessage(rootCacheKey, rootMessage);
-        console.log(
-          `\u2705 [XmtpResolver] Found and cached root message: ${rootMessage.id}`
-        );
-        return rootMessage;
-      }
-      console.log(`\u26A0\uFE0F [XmtpResolver] No root message found for: ${messageId}`);
-      this.setCachedMessage(rootCacheKey, null);
-      return null;
-    } catch (error) {
-      console.error(
-        `\u274C [XmtpResolver] Error finding root message for ${messageId}:`,
-        error
-      );
-      this.setCachedMessage(rootCacheKey, null);
-      return null;
-    }
-  }
-  /**
-   * Recursively finds the root message in a reply chain by following reply references
-   */
-  async findRootMessageRecursive(messageId, visitedIds = /* @__PURE__ */ new Set()) {
-    if (visitedIds.has(messageId)) {
-      console.warn(
-        `\u26A0\uFE0F Circular reference detected in message chain at ${messageId}`
-      );
-      return null;
-    }
-    visitedIds.add(messageId);
-    const message = await this.client.conversations.getMessageById(messageId);
-    if (!message) {
-      console.warn(`\u26A0\uFE0F [findRootMessage] Message not found: ${messageId}`);
-      return null;
-    }
-    console.log(`\u{1F50D} [findRootMessage] Raw message ${messageId}:`, {
-      id: message.id,
-      contentType: message.contentType,
-      content: message.content,
-      sentAt: message.sentAt
-    });
-    if (message.content?.reference) {
-      return this.findRootMessageRecursive(
-        message.content.reference,
-        visitedIds
-      );
-    }
-    return message;
-  }
-  /**
-   * Resolve address from conversation members
-   */
-  async resolveFromConversation(conversation, inboxId) {
-    try {
-      const members = await conversation.members();
-      const sender = members.find(
-        (member) => member.inboxId.toLowerCase() === inboxId.toLowerCase()
-      );
-      if (sender) {
-        const ethIdentifier = sender.accountIdentifiers.find(
-          (id) => id.identifierKind === 0
-          // IdentifierKind.Ethereum
-        );
-        if (ethIdentifier) {
-          return ethIdentifier.identifier;
-        } else {
-          console.log(
-            `\u26A0\uFE0F [XmtpResolver] No Ethereum identifier found for inbox ${inboxId}`
-          );
-        }
-      } else {
-        console.log(
-          `\u26A0\uFE0F [XmtpResolver] Sender not found in conversation members for inbox ${inboxId}`
-        );
-      }
-    } catch (error) {
-      console.error(
-        `\u274C [XmtpResolver] Error resolving from conversation members:`,
-        error
-      );
-    }
-    return null;
-  }
-  /**
-   * Resolve address from inbox state (network fallback)
-   */
-  async resolveFromInboxState(inboxId) {
-    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;
-      }
-    } catch (error) {
-      console.error(
-        `\u274C [XmtpResolver] Error resolving from inbox state:`,
-        error
-      );
-    }
-    return null;
-  }
-  /**
-   * Get cached address if not expired
-   */
-  getCachedAddress(inboxId) {
-    const entry = this.addressCache.get(inboxId);
-    if (!entry) return null;
-    const now = Date.now();
-    if (now - entry.timestamp > this.cacheTtl) {
-      this.addressCache.delete(inboxId);
-      return null;
-    }
-    return entry.address;
-  }
-  /**
-   * Cache address with LRU eviction
-   */
-  setCachedAddress(inboxId, address) {
-    if (this.addressCache.size >= this.maxCacheSize) {
-      const firstKey = this.addressCache.keys().next().value;
-      if (firstKey) {
-        this.addressCache.delete(firstKey);
-      }
-    }
-    this.addressCache.set(inboxId, {
-      address,
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * Get cached message if not expired
-   */
-  getCachedMessage(messageId) {
-    const entry = this.messageCache.get(messageId);
-    if (!entry) return void 0;
-    const now = Date.now();
-    if (now - entry.timestamp > this.messageCacheTtl) {
-      this.messageCache.delete(messageId);
-      return void 0;
-    }
-    return entry.message;
-  }
-  /**
-   * Cache message with LRU eviction
-   */
-  setCachedMessage(messageId, message) {
-    if (this.messageCache.size >= this.maxMessageCacheSize) {
-      const firstKey = this.messageCache.keys().next().value;
-      if (firstKey) {
-        this.messageCache.delete(firstKey);
-      }
-    }
-    this.messageCache.set(messageId, {
-      message,
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * Pre-populate address cache from existing conversations
-   */
-  async prePopulateCache() {
-    console.log("\u{1F504} [XmtpResolver] 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) => id.identifierKind === 0
-              // IdentifierKind.Ethereum
-            );
-            if (ethIdentifier) {
-              this.setCachedAddress(
-                member.inboxId,
-                ethIdentifier.identifier
-              );
-              cachedCount++;
-            }
-          }
-        } catch (error) {
-          console.error(
-            "[XmtpResolver] Error pre-caching conversation members:",
-            error
-          );
-        }
-      }
-      console.log(
-        `\u2705 [XmtpResolver] Pre-cached ${cachedCount} address mappings`
-      );
-    } catch (error) {
-      console.error("[XmtpResolver] Error pre-populating cache:", error);
-    }
-  }
-  /**
-   * Clear all caches
-   */
-  clearCache() {
-    this.addressCache.clear();
-    this.messageCache.clear();
-    console.log("\u{1F5D1}\uFE0F [XmtpResolver] All caches cleared");
-  }
-  /**
-   * Get cache statistics
-   */
-  getCacheStats() {
-    return {
-      address: {
-        size: this.addressCache.size,
-        maxSize: this.maxCacheSize
-      },
-      message: {
-        size: this.messageCache.size,
-        maxSize: this.maxMessageCacheSize
-      }
-    };
-  }
-};
-
-// src/resolver/resolver.ts
-var Resolver = class {
-  constructor(options) {
-    __publicField(this, "addressResolver");
-    __publicField(this, "ensResolver");
-    __publicField(this, "basenameResolver");
-    __publicField(this, "xmtpResolver");
-    const resolverOptions = {
-      maxCacheSize: options.maxCacheSize ?? 1e3,
-      cacheTtl: options.cacheTtl ?? 36e5
-    };
-    this.addressResolver = new AddressResolver(
-      options.xmtpClient,
-      resolverOptions
-    );
-    this.xmtpResolver = new XmtpResolver(options.xmtpClient, resolverOptions);
-    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) {
-    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) {
-    if (name.endsWith(".eth")) {
-      return this.resolveENSName(name);
-    }
-    if (name.endsWith(".base.eth")) {
-      return this.getBasenameAddress(name);
-    }
-    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) {
-    const basename = await this.getBasename(address);
-    if (basename) {
-      return basename;
-    }
-    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;
-    if (addressOrInboxId.startsWith("0x") && addressOrInboxId.length === 42) {
-      address = addressOrInboxId;
-      inboxId = addressOrInboxId;
-    } else {
-      address = await this.resolveAddress(addressOrInboxId, conversationId);
-    }
-    let name = "Unknown";
-    let basename;
-    if (address) {
-      const basenameResult = await this.getBasename(address);
-      console.log(
-        `\u{1F50D} [RESOLVER] Direct basename lookup for ${address}:`,
-        basenameResult
-      );
-      const resolvedName = await this.resolveAddressToName(address);
-      console.log(
-        `\u{1F50D} [RESOLVER] Universal name resolution for ${address}:`,
-        resolvedName
-      );
-      if (resolvedName) {
-        name = resolvedName;
-        if (resolvedName.endsWith(".base.eth")) {
-          basename = resolvedName;
-        }
-      } else {
-        name = `${address.slice(0, 6)}...${address.slice(-4)}`;
-      }
-      if (!basename) {
-        const resolvedBasename = await this.getBasename(address);
-        basename = resolvedBasename || void 0;
-      }
-    } else {
-      name = `${inboxId.slice(0, 8)}...${inboxId.slice(-4)}`;
-    }
-    return {
-      address: address || addressOrInboxId,
-      inboxId,
-      name,
-      basename
-    };
-  }
-};
-
-// src/lib/message-listener.ts
-var MessageListener = class extends EventEmitter {
-  constructor(config) {
-    super();
-    __publicField(this, "xmtpClient");
-    __publicField(this, "resolver");
-    __publicField(this, "filter");
-    __publicField(this, "heartbeatInterval");
-    __publicField(this, "fallbackCheckInterval");
-    __publicField(this, "messageCount", 0);
-    __publicField(this, "conversations", []);
-    __publicField(this, "config");
-    this.xmtpClient = config.xmtpClient;
-    const mainnetClient = createPublicClient({
-      chain: mainnet2,
-      transport: http2()
-    });
-    this.resolver = new Resolver({
-      xmtpClient: this.xmtpClient,
-      mainnetClient,
-      baseClient: config.publicClient,
-      maxCacheSize: 1e3,
-      cacheTtl: 864e5
-      // 24 hours
-    });
-    this.filter = config.filter;
-    this.config = {
-      heartbeatInterval: config.heartbeatInterval ?? 3e5,
-      // 5 minutes
-      conversationCheckInterval: config.conversationCheckInterval ?? 3e4,
-      // 30 seconds
-      envKey: config.envKey ?? "XMTP_ENV"
-    };
-  }
-  // Type-safe event emitter methods
-  on(event, listener) {
-    return super.on(event, listener);
-  }
-  emit(event, ...args) {
-    return super.emit(event, ...args);
-  }
-  async start() {
-    const XMTP_ENV = process.env[this.config.envKey];
-    await this.resolver?.prePopulateAllCaches();
-    console.log("\u{1F4E1} Syncing conversations...");
-    await this.xmtpClient.conversations.sync();
-    const address = this.xmtpClient.accountIdentifier?.identifier;
-    this.conversations = await this.xmtpClient.conversations.list();
-    console.log(`\u{1F916} XMTP[${XMTP_ENV}] Listening on ${address} ...`);
-    this.emit("started");
-    try {
-      const stream = await this.xmtpClient.conversations.streamAllMessages();
-      this.heartbeatInterval = setInterval(() => {
-        this.emit("heartbeat", {
-          messageCount: this.messageCount,
-          conversationCount: this.conversations.length
-        });
-        if (this.messageCount > 0) {
-          console.log(`\u{1F493} Active - processed ${this.messageCount} messages`);
-        }
-      }, this.config.heartbeatInterval);
-      this.fallbackCheckInterval = setInterval(async () => {
-        try {
-          const latestConversations = await this.xmtpClient.conversations.list();
-          if (latestConversations.length > this.conversations.length) {
-            console.log(
-              `\u{1F195} Detected ${latestConversations.length - this.conversations.length} new conversations`
-            );
-            this.conversations.push(
-              ...latestConversations.slice(this.conversations.length)
-            );
-          }
-        } catch (error) {
-          console.error("\u274C Error checking for new conversations:", error);
-          this.emit("error", error);
-        }
-      }, this.config.conversationCheckInterval);
-      try {
-        for await (const message of stream) {
-          this.messageCount++;
-          try {
-            if (!message || message.senderInboxId.toLowerCase() === this.xmtpClient.inboxId.toLowerCase()) {
-              continue;
-            }
-            console.log(
-              `\u{1F4E8} Received message "${JSON.stringify(message)}" in ${message.conversationId}`
-            );
-            const conversation = await this.xmtpClient.conversations.getConversationById(
-              message.conversationId
-            );
-            if (!conversation) {
-              console.log("\u274C Could not find conversation for message");
-              continue;
-            }
-            const contentTypeId = message.contentType?.typeId;
-            let messageContent;
-            if (contentTypeId === "reply") {
-              const replyContent = message.content;
-              messageContent = (replyContent?.content || "").toString();
-            } else if (contentTypeId === "remoteStaticAttachment" || contentTypeId === "attachment") {
-              messageContent = message.fallback || message.content?.filename || "[Attachment]";
-            } else if (contentTypeId === "reaction") {
-              const reactionContent = message.content;
-              messageContent = `[Reaction: ${reactionContent.content || ""}]`;
-            } else {
-              messageContent = message.content ? String(message.content) : "";
-            }
-            let rootMessage = message;
-            let parentMessage = null;
-            if (contentTypeId === "reply") {
-              const { reference } = message.content;
-              rootMessage = await this.resolver.findRootMessage(reference);
-              parentMessage = await this.resolver.findMessage(reference);
-            } else if (contentTypeId === "reaction") {
-              const { reference } = message.content;
-              rootMessage = await this.resolver.findRootMessage(reference);
-              parentMessage = await this.resolver.findMessage(reference);
-            } else {
-              rootMessage = message;
-              parentMessage = null;
-            }
-            if (!rootMessage) {
-              console.warn(
-                `\u26A0\uFE0F [MessageListener] Could not find root message for: ${message.id}`
-              );
-              continue;
-            }
-            if (this.filter) {
-              const shouldProcess = await this.filter({
-                conversation,
-                message,
-                rootMessage
-              });
-              if (!shouldProcess) {
-                console.log("\u{1F504} Skipping message:", message.id);
-                continue;
-              }
-            }
-            const sender = await this.resolver.createXmtpSender(
-              message.senderInboxId,
-              message.conversationId
-            );
-            const subjects = {};
-            const messageEvent = {
-              conversation,
-              message,
-              rootMessage,
-              // We already checked it's not null above
-              parentMessage: parentMessage || void 0,
-              sender,
-              subjects
-            };
-            this.emit("message", messageEvent);
-          } catch (messageError) {
-            console.error("\u274C Error processing message:", messageError);
-            this.emit("error", messageError);
-          }
-        }
-      } catch (streamError) {
-        console.error("\u274C Error in message stream:", streamError);
-        this.cleanup();
-        this.emit("error", streamError);
-        console.log("\u{1F504} Attempting to restart stream...");
-        await new Promise((resolve) => setTimeout(resolve, 5e3));
-        return this.start();
-      }
-    } catch (streamSetupError) {
-      console.error("\u274C Error setting up message stream:", streamSetupError);
-      this.emit("error", streamSetupError);
-      throw streamSetupError;
-    }
-  }
-  cleanup() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-    }
-    if (this.fallbackCheckInterval) {
-      clearInterval(this.fallbackCheckInterval);
-    }
-  }
-  stop() {
-    this.cleanup();
-    this.emit("stopped");
-    console.log("\u{1F6D1} Message listener stopped");
-    this.removeAllListeners();
-  }
-  /**
-   * Get current statistics
-   */
-  getStats() {
-    return {
-      messageCount: this.messageCount,
-      conversationCount: this.conversations.length,
-      isActive: !!this.heartbeatInterval
-    };
-  }
-};
-async function startMessageListener(config) {
-  const listener = new MessageListener(config);
-  await listener.start();
-  return listener;
-}
-function createMessageListener(config) {
-  return new MessageListener(config);
-}
-
-// src/lib/subjects.ts
-function extractMentionedNames(content) {
-  const nameRegex = /@([a-zA-Z0-9-_]+\.(?:base\.)?eth)\b/gi;
-  const matches = content.match(nameRegex);
-  if (!matches) {
-    return [];
-  }
-  const names = matches.map((match) => match.slice(1).toLowerCase());
-  return [...new Set(names)];
-}
-async function resolveSubjects(mentionedNames, basenameResolver, ensResolver) {
-  const subjects = {};
-  if (mentionedNames.length === 0) {
-    return subjects;
-  }
-  console.log(
-    `\u{1F50D} Found ${mentionedNames.length} name mentions:`,
-    mentionedNames
-  );
-  for (const mentionedName of mentionedNames) {
-    try {
-      let resolvedAddress = null;
-      if (ensResolver.isENSName(mentionedName)) {
-        console.log(`\u{1F50D} Resolving ENS name: ${mentionedName}`);
-        resolvedAddress = await ensResolver.resolveENSName(mentionedName);
-      } else {
-        console.log(`\u{1F50D} Resolving basename: ${mentionedName}`);
-        resolvedAddress = await basenameResolver.getBasenameAddress(mentionedName);
-      }
-      if (resolvedAddress) {
-        subjects[mentionedName] = resolvedAddress;
-        console.log(`\u2705 Resolved ${mentionedName} \u2192 ${resolvedAddress}`);
-      } else {
-        console.log(`\u274C Could not resolve address for: ${mentionedName}`);
-      }
-    } catch (error) {
-      console.error(`\u274C Error resolving ${mentionedName}:`, error);
-    }
-  }
-  return subjects;
-}
-async function extractSubjects(content, basenameResolver, ensResolver) {
-  const mentionedNames = extractMentionedNames(content);
-  return await resolveSubjects(mentionedNames, basenameResolver, ensResolver);
-}
-
-// src/service-client.ts
-var XmtpServiceClient = class {
-  constructor(config) {
-    __publicField(this, "config");
-    this.config = config;
-  }
-  async request(endpoint, body, method = "POST") {
-    try {
-      const baseUrl = this.config.serviceUrl.replace(/\/+$/, "");
-      const isXmtpToolsEndpoint = endpoint.startsWith("/xmtp-tools/");
-      const url = `${baseUrl}${endpoint}?token=${this.config.serviceToken}`;
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (isXmtpToolsEndpoint) {
-        headers.Authorization = `Bearer ${this.config.serviceToken}`;
-      }
-      const fetchOptions = {
-        method,
-        headers
-      };
-      if (method === "POST" && body) {
-        fetchOptions.body = JSON.stringify(body);
-      }
-      const response = await fetch(url, fetchOptions);
-      if (!response.ok) {
-        let errorMessage = `HTTP ${response.status}`;
-        try {
-          const responseText = await response.text();
-          try {
-            const errorData = JSON.parse(responseText);
-            errorMessage = errorData.error || errorMessage;
-          } catch {
-            errorMessage = responseText || errorMessage;
-          }
-        } catch {
-        }
-        throw new Error(errorMessage);
-      }
-      return {
-        success: true,
-        data: await response.json()
-      };
-    } catch (error) {
-      console.error(
-        `\u274C [XmtpServiceClient] Request to ${endpoint} failed:`,
-        error
-      );
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  async sendMessage(params) {
-    return this.request("/xmtp-tools/send", {
-      content: params.content
-    });
-  }
-  async sendReply(params) {
-    return this.request("/xmtp-tools/reply", {
-      content: params.content,
-      messageId: params.messageId
-    });
-  }
-  async sendReaction(params) {
-    return this.request("/xmtp-tools/react", {
-      messageId: params.messageId,
-      emoji: params.emoji,
-      action: params.action
-    });
-  }
-  async sendTransaction(params) {
-    return this.request("/xmtp-tools/transaction", {
-      fromAddress: params.fromAddress,
-      chainId: params.chainId,
-      calls: params.calls.map((call) => ({
-        to: call.to,
-        data: call.data,
-        ...call.gas && { gas: call.gas },
-        value: call.value || "0x0",
-        metadata: {
-          ...call.metadata,
-          chainId: params.chainId,
-          from: params.fromAddress,
-          version: "1"
-        }
-      }))
-    });
-  }
-  /**
-   * Get a single message by ID
-   */
-  async getMessage(params) {
-    return this.request(
-      `/xmtp-tools/messages/${params.messageId}`,
-      void 0,
-      "GET"
-    );
-  }
-  // getConversationMessages removed - superseded by thread-based approach
-};
-function createXmtpServiceClient(serviceUrl, serviceToken) {
-  if (!serviceUrl || !serviceToken) {
-    throw new Error("Missing XMTP service URL or token from runtime context");
-  }
-  return new XmtpServiceClient({
-    serviceUrl,
-    serviceToken
-  });
-}
-function getXmtpAuthConfig(callbackUrl, callbackToken) {
-  if (callbackUrl && callbackToken) {
-    console.log("\u{1F511} [XmtpAuth] Using callback-provided credentials");
-    return {
-      serviceUrl: callbackUrl,
-      serviceToken: callbackToken,
-      source: "callback"
-    };
-  }
-  const envUrl = process.env.XMTP_HOST;
-  const envToken = process.env.XMTP_API_KEY;
-  if (envUrl && envToken) {
-    console.log("\u{1F511} [XmtpAuth] Using environment credentials");
-    return {
-      serviceUrl: envUrl,
-      serviceToken: envToken,
-      source: "environment"
-    };
-  }
-  console.error(
-    "\u274C [XmtpAuth] No XMTP credentials found in callback or environment"
-  );
-  console.error(
-    "\u{1F4A1} [XmtpAuth] Expected: XMTP_HOST + XMTP_API_KEY or callback credentials"
-  );
-  return null;
-}
-function createAuthenticatedXmtpClient(callbackUrl, callbackToken) {
-  const authConfig = getXmtpAuthConfig(callbackUrl, callbackToken);
-  if (!authConfig) {
-    throw new Error("No XMTP credentials found");
-  }
-  console.log(
-    `\u{1F517} [XmtpAuth] Creating XMTP client (${authConfig.source} credentials)`
-  );
-  return createXmtpServiceClient(authConfig.serviceUrl, authConfig.serviceToken);
-}
-function getXMTPToolsUrl(baseUrl, action, token) {
-  return `${baseUrl}/xmtp-tools/${action}?token=${token}`;
-}
-
-// src/endpoints.ts
-import { ContentTypeReaction } from "@xmtp/content-type-reaction";
-import { ContentTypeReply } from "@xmtp/content-type-reply";
-import { ContentTypeText } from "@xmtp/content-type-text";
-import { ContentTypeWalletSendCalls } from "@xmtp/content-type-wallet-send-calls";
-import { Hono } from "hono";
-
-// src/lib/jwt.ts
-import jwt from "jsonwebtoken";
-function getValidatedPayload(c) {
-  const authHeader = c.req.header("Authorization");
-  if (authHeader?.startsWith("Bearer ")) {
-    const token2 = authHeader.substring(7);
-    return validateXMTPToolsToken(token2);
-  }
-  const token = c.req.query("token");
-  if (!token) {
-    return null;
-  }
-  return validateXMTPToolsToken(token);
-}
-function getJwtSecret() {
-  const secret = process.env.XMTP_ENCRYPTION_KEY;
-  const nodeEnv = process.env.NODE_ENV || "development";
-  if (nodeEnv === "production" && !secret) {
-    throw new Error(
-      "XMTP_ENCRYPTION_KEY environment variable is required in production. Generate a secure random secret for JWT token signing."
-    );
-  }
-  if (!secret) {
-    console.warn(
-      "\u26A0\uFE0F  [SECURITY] Using fallback JWT secret for development. Set XMTP_ENCRYPTION_KEY environment variable for production."
-    );
-    return "fallback-secret-for-dev-only";
-  }
-  return secret;
-}
-function getApiKey() {
-  const apiKey = process.env.XMTP_API_KEY;
-  const nodeEnv = process.env.NODE_ENV || "development";
-  if (nodeEnv === "production" && !apiKey) {
-    throw new Error(
-      "XMTP_API_KEY environment variable is required in production. Generate a secure random API key for authentication."
-    );
-  }
-  if (!apiKey) {
-    console.warn(
-      "\u26A0\uFE0F  [SECURITY] Using fallback API key for development. Set XMTP_API_KEY environment variable for production."
-    );
-    return "fallback-api-key-for-dev-only";
-  }
-  return apiKey;
-}
-var JWT_EXPIRY = 5 * 60;
-function generateXMTPToolsToken(payload) {
-  const now = Math.floor(Date.now() / 1e3);
-  const fullPayload = {
-    ...payload,
-    issued: now,
-    expires: now + JWT_EXPIRY
-  };
-  return jwt.sign(fullPayload, getJwtSecret(), {
-    expiresIn: JWT_EXPIRY
-  });
-}
-function validateXMTPToolsToken(token) {
-  if (token === getApiKey()) {
-    console.log("\u{1F511} [Auth] Using API key authentication");
-    const now = Math.floor(Date.now() / 1e3);
-    return {
-      action: "send",
-      // Default action
-      conversationId: "",
-      // Will be filled by endpoint
-      issued: now,
-      expires: now + 3600
-      // API keys are valid for 1 hour
-    };
-  }
-  try {
-    const decoded = jwt.verify(token, getJwtSecret());
-    console.log("\u{1F511} [Auth] Using JWT token authentication");
-    const now = Math.floor(Date.now() / 1e3);
-    if (decoded.expires < now) {
-      console.warn("\u{1F512} XMTP tools token has expired");
-      return null;
-    }
-    return decoded;
-  } catch (error) {
-    console.error(
-      "\u{1F512} Invalid XMTP tools token and not matching API key:",
-      error
-    );
-    return null;
-  }
-}
-
-// src/endpoints.ts
-var app = new Hono();
-app.get("/messages/:messageId", async (c) => {
-  const xmtpClient = c.get("xmtpClient");
-  if (!xmtpClient) {
-    return c.json({ error: "XMTP client not initialized" }, 500);
-  }
-  const token = c.req.query("token");
-  if (!token) {
-    return c.json({ error: "Token required" }, 401);
-  }
-  const payload = validateXMTPToolsToken(token);
-  if (!payload) {
-    return c.json({ error: "Invalid or expired token" }, 401);
-  }
-  const messageId = c.req.param("messageId");
-  try {
-    const message = await xmtpClient.conversations.getMessageById(messageId);
-    if (!message) {
-      return c.json({ error: "Message not found" }, 404);
-    }
-    console.log(`\u2705 Retrieved message ${messageId}`);
-    const transformedMessage = {
-      id: message.id,
-      senderInboxId: message.senderInboxId,
-      sentAt: message.sentAt.toISOString(),
-      content: typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
-      contentType: message.contentType?.typeId || "text",
-      conversationId: message.conversationId,
-      parameters: message.contentType?.parameters || {}
-    };
-    return c.json(transformedMessage);
-  } catch (error) {
-    console.error("\u274C Error fetching message:", error);
-    return c.json({ error: "Failed to fetch message" }, 500);
-  }
-});
-app.post("/send", async (c) => {
-  const xmtpClient = c.get("xmtpClient");
-  if (!xmtpClient) {
-    return c.json({ error: "XMTP client not initialized" }, 500);
-  }
-  const payload = getValidatedPayload(c);
-  if (!payload) {
-    return c.json({ error: "Invalid or expired token" }, 401);
-  }
-  const body = await c.req.json();
-  const content = body.content || payload.content;
-  if (!content) {
-    return c.json({ error: "Content required for send action" }, 400);
-  }
-  const conversationId = payload.conversationId;
-  if (!conversationId) {
-    return c.json({ error: "Conversation ID required" }, 400);
-  }
-  try {
-    const conversation = await xmtpClient.conversations.getConversationById(conversationId);
-    if (!conversation) {
-      return c.json({ error: "Conversation not found" }, 404);
-    }
-    await conversation.send(content);
-    console.log(`\u27A1 Sent message to conversation ${conversationId}`);
-    return c.json({
-      success: true,
-      action: "send",
-      conversationId: payload.conversationId
-    });
-  } catch (error) {
-    console.error("\u274C Error sending message:", error);
-    return c.json({ error: "Failed to send message" }, 500);
-  }
-});
-app.post("/reply", async (c) => {
-  const xmtpClient = c.get("xmtpClient");
-  if (!xmtpClient) {
-    return c.json({ error: "XMTP client not initialized" }, 500);
-  }
-  const payload = getValidatedPayload(c);
-  if (!payload) {
-    return c.json({ error: "Invalid or expired token" }, 401);
-  }
-  const body = await c.req.json();
-  const content = body.content || payload.content;
-  if (!content) {
-    return c.json({ error: "Content required for reply action" }, 400);
-  }
-  const messageId = body.messageId;
-  if (!messageId) {
-    return c.json(
-      { error: "Reference message ID required for reply action" },
-      400
-    );
-  }
-  try {
-    const conversation = await xmtpClient.conversations.getConversationById(
-      payload.conversationId
-    );
-    if (!conversation) {
-      return c.json({ error: "Conversation not found" }, 404);
-    }
-    const reply = {
-      reference: messageId,
-      contentType: ContentTypeText,
-      content
-    };
-    await conversation.send(reply, ContentTypeReply);
-    console.log(
-      `\u27A1 Sent reply "${content}" to conversation ${payload.conversationId}`
-    );
-    return c.json({
-      success: true,
-      action: "reply",
-      conversationId: payload.conversationId
-    });
-  } catch (error) {
-    console.error("\u274C Error sending reply:", error);
-    return c.json({ error: "Failed to send reply" }, 500);
-  }
-});
-app.post("/react", async (c) => {
-  const xmtpClient = c.get("xmtpClient");
-  if (!xmtpClient) {
-    return c.json({ error: "XMTP client not initialized" }, 500);
-  }
-  const payload = getValidatedPayload(c);
-  if (!payload) {
-    return c.json({ error: "Invalid or expired token" }, 401);
-  }
-  const body = await c.req.json();
-  if (!body.emoji) {
-    return c.json({ error: "Emoji required for react action" }, 400);
-  }
-  try {
-    const conversation = await xmtpClient.conversations.getConversationById(
-      payload.conversationId
-    );
-    if (!conversation) {
-      return c.json({ error: "Conversation not found" }, 404);
-    }
-    const reaction = {
-      schema: "unicode",
-      reference: body.messageId,
-      action: body.action,
-      contentType: ContentTypeReaction,
-      content: body.emoji
-    };
-    await conversation.send(reaction, ContentTypeReaction);
-    console.log(
-      `\u27A1 Sent reaction ${body.emoji} to message ${body.messageId} in conversation ${payload.conversationId}`
-    );
-    return c.json({
-      success: true,
-      action: "react",
-      conversationId: payload.conversationId
-    });
-  } catch (error) {
-    console.error("\u274C Error sending reaction:", error);
-    return c.json({ error: "Failed to send reaction" }, 500);
-  }
-});
-app.post("/transaction", async (c) => {
-  const xmtpClient = c.get("xmtpClient");
-  if (!xmtpClient) {
-    return c.json({ error: "XMTP client not initialized" }, 500);
-  }
-  const payload = getValidatedPayload(c);
-  if (!payload) {
-    return c.json({ error: "Invalid or expired token" }, 401);
-  }
-  let body = {};
-  try {
-    body = await c.req.json();
-  } catch (error) {
-    body = {};
-  }
-  const fromAddress = payload.fromAddress || body.fromAddress;
-  const chainId = payload.chainId || body.chainId;
-  const calls = payload.calls || body.calls;
-  if (!calls || !fromAddress || !chainId) {
-    return c.json(
-      { error: "Transaction data required for transaction action" },
-      400
-    );
-  }
-  calls.forEach((call, index) => {
-    if (call.data && typeof call.data === "string") {
-      const actualStart = call.data.substring(0, 10);
-      if (actualStart === "0x010f2e2e") {
-        console.error("\u{1F6A8} CRITICAL: Transaction data truncation detected!");
-        console.error("   Function selector corrupted - transaction will fail");
-        console.error(
-          "   This indicates a bug in wallet software or XMTP transmission"
-        );
-      }
-    }
-  });
-  try {
-    const conversation = await xmtpClient.conversations.getConversationById(
-      payload.conversationId
-    );
-    if (!conversation) {
-      return c.json({ error: "Conversation not found" }, 404);
-    }
-    const params = {
-      version: "1",
-      chainId,
-      from: fromAddress,
-      calls
-    };
-    await conversation.send(params, ContentTypeWalletSendCalls);
-    console.log(
-      `\u2705 Sent transaction request to conversation ${payload.conversationId}`
-    );
-    return c.json({
-      success: true,
-      action: "transaction",
-      conversationId: payload.conversationId
-    });
-  } catch (error) {
-    console.error("\u274C Error sending transaction:", error);
-    return c.json({ error: "Failed to send transaction" }, 500);
-  }
-});
-var endpoints_default = app;
-
-// src/plugin.ts
-function XMTPPlugin({
-  filter
-} = {}) {
-  return {
-    name: "xmtp",
-    description: "Provides XMTP messaging functionality",
-    apply: (app2, context) => {
-      app2.route("/xmtp-tools", endpoints_default);
-    }
-  };
+var JWT_EXPIRY = 5 * 60;
+function generateXMTPToolsToken(payload) {
+  const startTime = performance.now();
+  logger3.debug("\u{1F510} [JWT] Starting token generation...");
+  const now = Math.floor(Date.now() / 1e3);
+  const fullPayload = {
+    ...payload,
+    issued: now,
+    expires: now + JWT_EXPIRY
+  };
+  const token = jwt.sign(fullPayload, getJwtSecret(), {
+    expiresIn: JWT_EXPIRY
+  });
+  const endTime = performance.now();
+  logger3.debug(
+    `\u{1F510} [JWT] Token generation completed in ${(endTime - startTime).toFixed(2)}ms`
+  );
+  return token;
 }
 
 // src/index.ts
 import {
-  Client,
+  Client as Client3,
   IdentifierKind as IdentifierKind2
 } from "@xmtp/node-sdk";
 import {
   ContentTypeTransactionReference
 } from "@xmtp/content-type-transaction-reference";
-import { ContentTypeText as ContentTypeText2 } from "@xmtp/content-type-text";
+import { ContentTypeText } from "@xmtp/content-type-text";
 import {
-  ContentTypeReaction as ContentTypeReaction2
+  ContentTypeReaction
 } from "@xmtp/content-type-reaction";
 import {
-  ContentTypeReply as ContentTypeReply2,
+  ContentTypeReply,
   ReplyCodec as ReplyCodec2
 } from "@xmtp/content-type-reply";
 import {
@@ -3606,55 +988,33 @@ import {
   GroupUpdatedCodec
 } from "@xmtp/content-type-group-updated";
 import {
-  ContentTypeWalletSendCalls as ContentTypeWalletSendCalls2
+  ContentTypeWalletSendCalls
 } from "@xmtp/content-type-wallet-send-calls";
 export {
-  BasenameResolver,
-  BasenameTextRecordKeys,
-  Client,
+  Agent,
+  Client3 as Client,
   ContentTypeGroupUpdated,
-  ContentTypeReaction2 as ContentTypeReaction,
-  ContentTypeReply2 as ContentTypeReply,
-  ContentTypeText2 as ContentTypeText,
+  ContentTypeReaction,
+  ContentTypeReply,
+  ContentTypeText,
   ContentTypeTransactionReference,
-  ContentTypeWalletSendCalls2 as ContentTypeWalletSendCalls,
+  ContentTypeWalletSendCalls,
   DEFAULT_AMOUNT,
   DEFAULT_OPTIONS,
-  ENSResolver,
   GroupUpdatedCodec,
   IdentifierKind2 as IdentifierKind,
   MAX_USDC_AMOUNT,
-  MessageListener,
   ReplyCodec2 as ReplyCodec,
-  Resolver,
   XMTPConnectionManager,
   XMTPPlugin,
-  XmtpResolver,
-  XmtpServiceClient,
-  backupDbToPersistentStorage,
-  convertChainIdToCoinType,
-  convertReverseNodeToBytes,
-  createAuthenticatedXmtpClient,
-  createMessageListener,
-  createSigner,
-  createUser,
+  createSigner3 as createSigner,
+  createUser3 as createUser,
   createXMTPClient,
-  createXMTPConnectionManager,
-  createXmtpServiceClient,
-  diagnoseXMTPIdentityIssue,
-  extractMentionedNames,
-  extractSubjects,
-  generateEncryptionKeyHex,
+  createSigner as createXMTPSigner,
+  filter,
   generateXMTPToolsToken,
-  getDbPath,
-  getEncryptionKeyFromHex,
-  getXMTPToolsUrl,
-  getXmtpAuthConfig,
+  getTestUrl,
   logAgentDetails,
-  resolveSubjects,
-  resolveUserAddress,
-  startMessageListener,
-  startPeriodicBackup,
   validateEnvironment
 };
 //# sourceMappingURL=index.js.map