@hybrd/xmtp 1.0.8 → 1.1.0

package/dist/index.js

@@ -0,0 +1,3323 @@
+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/client.ts
+import { ReactionCodec } from "@xmtp/content-type-reaction";
+import { ReplyCodec } from "@xmtp/content-type-reply";
+import { TransactionReferenceCodec } from "@xmtp/content-type-transaction-reference";
+import { WalletSendCallsCodec } from "@xmtp/content-type-wallet-send-calls";
+import { Client as Client2 } from "@xmtp/node-sdk";
+import { getRandomValues } from "crypto";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { fromString, toString as uint8arraysToString } from "uint8arrays";
+import { createWalletClient, http, toBytes } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { sepolia } from "viem/chains";
+
+// scripts/revoke-installations.ts
+async function revokeOldInstallations(signer, inboxId) {
+  console.log("\u{1F527} Attempting to revoke old installations...");
+  try {
+    if (!inboxId) {
+      console.log("\u2139\uFE0F No inboxId provided, cannot revoke installations");
+      return false;
+    }
+    const inboxStates = await Client.inboxStateFromInboxIds(
+      [inboxId],
+      process.env.XMTP_ENV
+    );
+    if (!inboxStates[0]) {
+      console.log("\u274C No inbox state found for the provided inboxId");
+      return false;
+    }
+    const toRevokeInstallationBytes = inboxStates[0].installations.map(
+      (i) => i.bytes
+    );
+    await Client.revokeInstallations(
+      signer,
+      inboxId,
+      toRevokeInstallationBytes,
+      process.env.XMTP_ENV
+    );
+    const resultingStates = await Client.inboxStateFromInboxIds(
+      [inboxId],
+      process.env.XMTP_ENV
+    );
+    console.log(
+      `\u{1F4CB} Revoked installations: ${toRevokeInstallationBytes.length} installations`
+    );
+    console.log(
+      `\u{1F4CB} Resulting state: ${resultingStates[0]?.installations.length || 0} installations`
+    );
+    return true;
+  } catch (error) {
+    console.error("\u274C Error during installation revocation:", error);
+    return false;
+  }
+}
+async function main() {
+  const { XMTP_WALLET_KEY } = process.env;
+  const inboxId = process.argv[2];
+  if (!XMTP_WALLET_KEY) {
+    console.error("\u274C XMTP_WALLET_KEY is required");
+    process.exit(1);
+  }
+  if (!inboxId) {
+    console.error("\u274C InboxID is required as CLI argument");
+    console.error("Usage: tsx revoke-installations.ts <inboxId>");
+    process.exit(1);
+  }
+  const signer = createSigner(XMTP_WALLET_KEY);
+  const identifier = await signer.getIdentifier();
+  const address = identifier.identifier;
+  console.log(`\u{1F511} Wallet Address: ${address}`);
+  console.log(`\u{1F4CB} Inbox ID: ${inboxId}`);
+  const success = await revokeOldInstallations(signer, inboxId);
+  if (success) {
+    console.log("\u2705 Successfully revoked installations");
+  } else {
+    console.log("\u274C Failed to revoke installations");
+    process.exit(1);
+  }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error("\u{1F4A5} Fatal error:", error);
+    process.exit(1);
+  });
+}
+
+// src/client.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var createUser = (key) => {
+  const account = privateKeyToAccount(key);
+  return {
+    key,
+    account,
+    wallet: createWalletClient({
+      account,
+      chain: sepolia,
+      transport: http()
+    })
+  };
+};
+var createSigner = (key) => {
+  if (!key || typeof key !== "string") {
+    throw new Error("XMTP wallet key must be a non-empty string");
+  }
+  const sanitizedKey = key.startsWith("0x") ? key : `0x${key}`;
+  const user = createUser(sanitizedKey);
+  return {
+    type: "EOA",
+    getIdentifier: () => ({
+      identifierKind: 0,
+      // Use numeric value to avoid ambient const enum issue
+      identifier: user.account.address.toLowerCase()
+    }),
+    signMessage: async (message) => {
+      const signature = await user.wallet.signMessage({
+        message,
+        account: user.account
+      });
+      return toBytes(signature);
+    }
+  };
+};
+async function clearXMTPDatabase(address, env) {
+  console.log("\u{1F9F9} Clearing XMTP database to resolve installation limit...");
+  const getStorageDirectory = () => {
+    const customStoragePath = process.env.XMTP_STORAGE_PATH;
+    if (customStoragePath) {
+      return path.isAbsolute(customStoragePath) ? customStoragePath : path.resolve(process.cwd(), customStoragePath);
+    }
+    const projectRoot = process.env.PROJECT_ROOT || path.resolve(__dirname, "../../..");
+    return path.join(projectRoot, ".data/xmtp");
+  };
+  const dbPattern = `${env}-${address}.db3`;
+  const storageDir = getStorageDirectory();
+  const possiblePaths = [
+    storageDir,
+    // Legacy fallback paths for backward compatibility
+    path.join(process.cwd(), ".data", "xmtp"),
+    path.join(process.cwd(), "..", ".data", "xmtp"),
+    path.join(process.cwd(), "..", "..", ".data", "xmtp")
+  ];
+  for (const dir of possiblePaths) {
+    try {
+      if (fs.existsSync(dir)) {
+        const files = fs.readdirSync(dir);
+        const matchingFiles = files.filter(
+          (file) => file.includes(dbPattern) || file.includes(address) || file.includes(`xmtp-${env}-${address}`)
+        );
+        for (const file of matchingFiles) {
+          const fullPath = path.join(dir, file);
+          try {
+            fs.unlinkSync(fullPath);
+            console.log(`\u2705 Removed: ${fullPath}`);
+          } catch (err) {
+            console.log(`\u26A0\uFE0F Could not remove ${fullPath}:`, err);
+          }
+        }
+      }
+    } catch (err) {
+    }
+  }
+}
+async function createXMTPClient(privateKey, opts) {
+  const { persist = true, maxRetries = 3, storagePath } = opts ?? {};
+  let attempt = 0;
+  const signer = createSigner(privateKey);
+  if (!signer) {
+    throw new Error(
+      "No signer provided and XMTP_WALLET_KEY environment variable is not set"
+    );
+  }
+  const { XMTP_ENCRYPTION_KEY, XMTP_ENV } = process.env;
+  const identifier = await signer.getIdentifier();
+  const address = identifier.identifier;
+  while (attempt < maxRetries) {
+    try {
+      console.log(
+        `\u{1F504} Attempt ${attempt + 1}/${maxRetries} to create XMTP client...`
+      );
+      if (!persist) {
+        throw new Error(
+          "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");
+      }
+      const dbEncryptionKey = getEncryptionKeyFromHex(XMTP_ENCRYPTION_KEY);
+      const dbPath = await getDbPath(
+        `${XMTP_ENV || "dev"}-${address}`,
+        storagePath
+      );
+      console.log(`\u{1F4C1} Using database path: ${dbPath}`);
+      const client = await Client2.create(signer, {
+        dbEncryptionKey,
+        env: XMTP_ENV,
+        dbPath,
+        codecs: [
+          new ReplyCodec(),
+          new ReactionCodec(),
+          new WalletSendCallsCodec(),
+          new TransactionReferenceCodec()
+        ]
+      });
+      console.log("\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`);
+      return client;
+    } catch (error) {
+      attempt++;
+      if (error instanceof Error && error.message.includes("5/5 installations")) {
+        console.log(
+          `\u{1F4A5} Installation limit reached (attempt ${attempt}/${maxRetries})`
+        );
+        if (attempt < maxRetries) {
+          const identifier2 = await signer.getIdentifier();
+          const address2 = identifier2.identifier;
+          const inboxIdMatch = error.message.match(/InboxID ([a-f0-9]+)/);
+          const inboxId = inboxIdMatch ? inboxIdMatch[1] : void 0;
+          const revocationSuccess = await revokeOldInstallations(
+            signer,
+            inboxId
+          );
+          if (revocationSuccess) {
+            console.log("\u{1F3AF} Installations revoked, retrying connection...");
+          } else {
+            console.log(
+              "\u26A0\uFE0F Installation revocation failed or not needed, clearing database..."
+            );
+            await clearXMTPDatabase(address2, process.env.XMTP_ENV || "dev");
+          }
+          const delay = Math.pow(2, attempt) * 1e3;
+          console.log(`\u23F3 Waiting ${delay}ms before retry...`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          console.error(
+            "\u274C Failed to resolve installation limit after all retries"
+          );
+          console.error("\u{1F4A1} Possible solutions:");
+          console.error("   1. Use a different wallet (generate new keys)");
+          console.error("   2. Switch XMTP environments (dev <-> production)");
+          console.error("   3. Wait and try again later");
+          console.error("   4. Contact XMTP support for manual intervention");
+          throw error;
+        }
+      } else if (error instanceof Error && error.message.includes("Association error: Missing identity update")) {
+        console.log(
+          `\u{1F504} Identity association error detected (attempt ${attempt}/${maxRetries})`
+        );
+        if (attempt < maxRetries) {
+          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 tempClient = await Client2.create(signer, {
+              dbEncryptionKey: tempEncryptionKey,
+              env: XMTP_ENV,
+              dbPath: await getDbPath(
+                `${XMTP_ENV || "dev"}-${address}`,
+                storagePath
+              ),
+              codecs: [
+                new ReplyCodec(),
+                new ReactionCodec(),
+                new WalletSendCallsCodec(),
+                new TransactionReferenceCodec()
+              ]
+            });
+            console.log("\u{1F4E1} Syncing identity and conversations...");
+            await tempClient.conversations.sync();
+            console.log(
+              "\u2705 Identity refresh successful, retrying original request..."
+            );
+            const delay = Math.pow(2, attempt) * 1e3;
+            console.log(`\u23F3 Waiting ${delay}ms before retry...`);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          } catch (refreshError) {
+            console.log(`\u274C Identity refresh failed:`, refreshError);
+          }
+        } else {
+          console.error(
+            "\u274C Failed to resolve identity association error after all retries"
+          );
+          console.error(
+            "\u{1F4A1} Try running: pnpm with-env pnpm --filter @hybrd/xmtp refresh:identity"
+          );
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  throw new Error("Max retries exceeded");
+}
+var generateEncryptionKeyHex = () => {
+  const uint8Array = getRandomValues(new Uint8Array(32));
+  return uint8arraysToString(uint8Array, "hex");
+};
+var getEncryptionKeyFromHex = (hex) => {
+  return fromString(hex, "hex");
+};
+var getDbPath = async (description = "xmtp", storagePath) => {
+  const customStoragePath = process.env.XMTP_STORAGE_PATH;
+  let volumePath;
+  if (customStoragePath) {
+    volumePath = path.isAbsolute(customStoragePath) ? customStoragePath : path.resolve(process.cwd(), customStoragePath);
+  } else if (storagePath) {
+    volumePath = path.isAbsolute(storagePath) ? storagePath : path.resolve(process.cwd(), storagePath);
+  } else {
+    const projectRoot = process.env.PROJECT_ROOT || path.resolve(__dirname, "../../..");
+    volumePath = path.join(projectRoot, ".data/xmtp");
+  }
+  const dbPath = `${volumePath}/${description}.db3`;
+  if (typeof globalThis !== "undefined" && "XMTP_STORAGE" in globalThis) {
+    try {
+      console.log(`\u{1F4E6} Using Cloudflare R2 storage for: ${dbPath}`);
+      const r2Bucket = globalThis.XMTP_STORAGE;
+      const remotePath = `xmtp-databases/${description}.db3`;
+      try {
+        const existingObject = await r2Bucket.head(remotePath);
+        if (existingObject) {
+          console.log(`\u{1F4E5} Downloading existing database from R2 storage...`);
+          if (!fs.existsSync(volumePath)) {
+            fs.mkdirSync(volumePath, { recursive: true });
+          }
+          const object = await r2Bucket.get(remotePath);
+          if (object) {
+            const fileData = await object.arrayBuffer();
+            fs.writeFileSync(dbPath, new Uint8Array(fileData));
+            console.log(`\u2705 Database downloaded from R2 storage`);
+          }
+        } else {
+          console.log(`\u{1F4DD} No existing database found in R2 storage`);
+        }
+      } catch (error) {
+        console.log(`\u26A0\uFE0F Failed to download database from R2 storage:`, error);
+      }
+    } catch (error) {
+      console.log(`\u26A0\uFE0F R2 storage not available:`, error);
+    }
+  }
+  if (!fs.existsSync(volumePath)) {
+    fs.mkdirSync(volumePath, { recursive: true });
+  }
+  return dbPath;
+};
+var backupDbToPersistentStorage = async (dbPath, description) => {
+  if (typeof globalThis !== "undefined" && "XMTP_STORAGE" in globalThis && fs.existsSync(dbPath)) {
+    try {
+      console.log(`\u{1F4E6} Backing up database to R2 storage: ${dbPath}`);
+      const r2Bucket = globalThis.XMTP_STORAGE;
+      const remotePath = `xmtp-databases/${description}.db3`;
+      const fileData = fs.readFileSync(dbPath);
+      await r2Bucket.put(remotePath, fileData);
+      console.log(`\u2705 Database backed up to R2 storage: ${remotePath}`);
+    } catch (error) {
+      console.log(`\u26A0\uFE0F Failed to backup database to R2 storage:`, error);
+    }
+  }
+};
+var logAgentDetails = async (clients) => {
+  const clientsByAddress = Array.isArray(clients) ? clients.reduce((acc, XmtpClient) => {
+    const address = XmtpClient.accountIdentifier?.identifier ?? "";
+    acc[address] = acc[address] ?? [];
+    acc[address].push(XmtpClient);
+    return acc;
+  }, {}) : {
+    [clients.accountIdentifier?.identifier ?? ""]: [clients]
+  };
+  for (const [address, clientGroup] of Object.entries(clientsByAddress)) {
+    const firstClient = clientGroup[0];
+    const inboxId = firstClient?.inboxId;
+    const environments = clientGroup.map((c) => c.options?.env ?? "dev").join(", ");
+    console.log(`\x1B[38;2;252;76;52m
+        \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 
+        \u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+         \u255A\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+         \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2550\u255D 
+        \u2588\u2588\u2554\u255D \u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551     
+        \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D     
+      \x1B[0m`);
+    const urls = [`http://xmtp.chat/dm/${address}`];
+    const conversations = await firstClient?.conversations.list();
+    console.log(`
+    \u2713 XMTP XmtpClient:
+    \u2022 Address: ${address}
+    \u2022 Conversations: ${conversations?.length}
+    \u2022 InboxId: ${inboxId}
+    \u2022 Networks: ${environments}
+    ${urls.map((url) => `\u2022 URL: ${url}`).join("\n")}`);
+  }
+};
+function validateEnvironment(vars) {
+  const missing = vars.filter((v) => !process.env[v]);
+  if (missing.length) {
+    try {
+      const envPath = path.resolve(process.cwd(), ".env");
+      if (fs.existsSync(envPath)) {
+        const envVars = fs.readFileSync(envPath, "utf-8").split("\n").filter((line) => line.trim() && !line.startsWith("#")).reduce((acc, line) => {
+          const [key, ...val] = line.split("=");
+          if (key && val.length) acc[key.trim()] = val.join("=").trim();
+          return acc;
+        }, {});
+        missing.forEach((v) => {
+          if (envVars[v]) process.env[v] = envVars[v];
+        });
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    const stillMissing = vars.filter((v) => !process.env[v]);
+    if (stillMissing.length) {
+      console.error("Missing env vars:", stillMissing.join(", "));
+      process.exit(1);
+    }
+  }
+  return vars.reduce((acc, key) => {
+    acc[key] = process.env[key];
+    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);
+    __publicField(this, "privateKey");
+    __publicField(this, "config");
+    __publicField(this, "health");
+    __publicField(this, "healthCheckTimer", null);
+    __publicField(this, "isReconnecting", false);
+    this.privateKey = privateKey;
+    this.config = {
+      maxRetries: config.maxRetries ?? 5,
+      retryDelayMs: config.retryDelayMs ?? 1e3,
+      healthCheckIntervalMs: config.healthCheckIntervalMs ?? 3e4,
+      connectionTimeoutMs: config.connectionTimeoutMs ?? 1e4,
+      reconnectOnFailure: config.reconnectOnFailure ?? true
+    };
+    this.health = {
+      isConnected: false,
+      lastHealthCheck: /* @__PURE__ */ new Date(),
+      consecutiveFailures: 0,
+      totalReconnects: 0,
+      avgResponseTime: 0
+    };
+  }
+  async connect(persist = false) {
+    if (this.client && this.health.isConnected) {
+      return this.client;
+    }
+    let attempt = 0;
+    while (attempt < this.config.maxRetries) {
+      try {
+        console.log(
+          `\u{1F504} XMTP connection attempt ${attempt + 1}/${this.config.maxRetries}`
+        );
+        this.client = await createXMTPClient(this.privateKey, { persist });
+        this.health.isConnected = true;
+        this.health.consecutiveFailures = 0;
+        this.startHealthMonitoring();
+        console.log("\u2705 XMTP client connected successfully");
+        return this.client;
+      } catch (error) {
+        attempt++;
+        this.health.consecutiveFailures++;
+        console.error(`\u274C XMTP connection attempt ${attempt} failed:`, error);
+        if (attempt < this.config.maxRetries) {
+          const delay = this.config.retryDelayMs * Math.pow(2, attempt - 1);
+          console.log(`\u23F3 Retrying in ${delay}ms...`);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw new Error(
+      `Failed to connect to XMTP after ${this.config.maxRetries} attempts`
+    );
+  }
+  // private async createClientWithTimeout(persist: boolean): Promise<XmtpClient> {
+  //   const timeoutPromise = new Promise<never>((_, reject) => {
+  //     setTimeout(
+  //       () => reject(new Error("Connection timeout")),
+  //       this.config.connectionTimeoutMs
+  //     )
+  //   })
+  //   const clientPromise = createXMTPClient(this.signer, { persist })
+  //   return Promise.race([clientPromise, timeoutPromise])
+  // }
+  startHealthMonitoring() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+    }
+    this.healthCheckTimer = setInterval(() => {
+      this.performHealthCheck();
+    }, this.config.healthCheckIntervalMs);
+  }
+  async performHealthCheck() {
+    if (!this.client) return;
+    const startTime = Date.now();
+    try {
+      await this.client.conversations.list();
+      const responseTime = Date.now() - startTime;
+      this.health.avgResponseTime = (this.health.avgResponseTime + responseTime) / 2;
+      this.health.lastHealthCheck = /* @__PURE__ */ new Date();
+      this.health.consecutiveFailures = 0;
+      this.health.isConnected = true;
+      console.log(`\u{1F493} XMTP health check passed (${responseTime}ms)`);
+    } catch (error) {
+      this.health.consecutiveFailures++;
+      this.health.isConnected = false;
+      console.error(`\u{1F494} XMTP health check failed:`, error);
+      if (this.config.reconnectOnFailure && !this.isReconnecting) {
+        this.handleConnectionFailure();
+      }
+    }
+  }
+  async handleConnectionFailure() {
+    if (this.isReconnecting) return;
+    this.isReconnecting = true;
+    this.health.totalReconnects++;
+    console.log("\u{1F504} XMTP connection lost, attempting to reconnect...");
+    try {
+      this.client = null;
+      await this.connect();
+      console.log("\u2705 XMTP reconnection successful");
+    } catch (error) {
+      console.error("\u274C XMTP reconnection failed:", error);
+    } finally {
+      this.isReconnecting = false;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  getHealth() {
+    return { ...this.health };
+  }
+  getClient() {
+    return this.client;
+  }
+  async disconnect() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+    this.client = null;
+    this.health.isConnected = false;
+    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})...`
+      );
+      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";
+      }
+    }
+  }
+  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;
+          }
+        }
+      }
+      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()
+      );
+      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) {
+        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("Error pre-caching conversation members:", error);
+        }
+      }
+      console.log(`\u2705 Pre-cached ${cachedCount} address mappings`);
+    } catch (error) {
+      console.error("Error pre-populating cache:", error);
+    }
+  }
+  /**
+   * 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/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";
+  }
+  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);
+}
+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/index.ts
+import {
+  Client,
+  IdentifierKind as IdentifierKind2
+} from "@xmtp/node-sdk";
+import {
+  ContentTypeTransactionReference
+} from "@xmtp/content-type-transaction-reference";
+import { ContentTypeText } from "@xmtp/content-type-text";
+import {
+  ContentTypeReaction
+} from "@xmtp/content-type-reaction";
+import {
+  ContentTypeReply,
+  ReplyCodec as ReplyCodec2
+} from "@xmtp/content-type-reply";
+import {
+  ContentTypeGroupUpdated,
+  GroupUpdatedCodec
+} from "@xmtp/content-type-group-updated";
+import {
+  ContentTypeWalletSendCalls
+} from "@xmtp/content-type-wallet-send-calls";
+export {
+  BasenameResolver,
+  BasenameTextRecordKeys,
+  Client,
+  ContentTypeGroupUpdated,
+  ContentTypeReaction,
+  ContentTypeReply,
+  ContentTypeText,
+  ContentTypeTransactionReference,
+  ContentTypeWalletSendCalls,
+  DEFAULT_AMOUNT,
+  DEFAULT_OPTIONS,
+  ENSResolver,
+  GroupUpdatedCodec,
+  IdentifierKind2 as IdentifierKind,
+  MAX_USDC_AMOUNT,
+  MessageListener,
+  ReplyCodec2 as ReplyCodec,
+  Resolver,
+  XMTPConnectionManager,
+  XmtpResolver,
+  XmtpServiceClient,
+  backupDbToPersistentStorage,
+  convertChainIdToCoinType,
+  convertReverseNodeToBytes,
+  createAuthenticatedXmtpClient,
+  createMessageListener,
+  createSigner,
+  createUser,
+  createXMTPClient,
+  createXMTPConnectionManager,
+  createXmtpServiceClient,
+  diagnoseXMTPIdentityIssue,
+  extractMentionedNames,
+  extractSubjects,
+  generateEncryptionKeyHex,
+  getDbPath,
+  getEncryptionKeyFromHex,
+  getXMTPToolsUrl,
+  getXmtpAuthConfig,
+  logAgentDetails,
+  resolveSubjects,
+  resolveUserAddress,
+  startMessageListener,
+  startPeriodicBackup,
+  validateEnvironment
+};
+//# sourceMappingURL=index.js.map