@fundtracer/mcp 1.0.0

package/fundtracer-mcp.js

@@ -0,0 +1,3820 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/firebase.ts
+var firebase_exports = {};
+__export(firebase_exports, {
+  admin: () => admin,
+  getAuth: () => getAuth,
+  getFirestore: () => getFirestore,
+  getUserByAddress: () => getUserByAddress,
+  initializeFirebase: () => initializeFirebase,
+  updateUserTier: () => updateUserTier
+});
+import admin from "firebase-admin";
+import fs from "fs";
+function initializeFirebase() {
+  if (firebaseInitialized) {
+    console.log("[Firebase] Already initialized (skipping)");
+    return;
+  }
+  try {
+    if (admin.apps.length > 0) {
+      console.log("[Firebase] Already initialized by Firebase auto-discovery");
+      firebaseInitialized = true;
+      return;
+    }
+  } catch (e) {
+  }
+  console.log("[Firebase] Starting initialization...");
+  const base64ServiceAccount = process.env.FIREBASE_SERVICE_ACCOUNT_BASE64;
+  if (base64ServiceAccount) {
+    try {
+      console.log("[Firebase] Found base64 service account, decoding...");
+      const decoded = Buffer.from(base64ServiceAccount, "base64").toString("utf-8");
+      const serviceAccount = JSON.parse(decoded);
+      admin.initializeApp({
+        credential: admin.credential.cert(serviceAccount)
+      });
+      firebaseInitialized = true;
+      console.log("[Firebase] \u2705 Initialized from base64 service account");
+      return;
+    } catch (error) {
+      console.error("[Firebase] Failed to decode base64 service account:", error);
+    }
+  }
+  const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+  console.log("[Firebase] Checking credentials file path:", credentialsPath || "(not set)");
+  if (credentialsPath && fs.existsSync(credentialsPath)) {
+    try {
+      const serviceAccount = JSON.parse(fs.readFileSync(credentialsPath, "utf8"));
+      admin.initializeApp({
+        credential: admin.credential.cert(serviceAccount)
+      });
+      firebaseInitialized = true;
+      console.log("[Firebase] \u2705 Initialized from credentials file");
+      return;
+    } catch (error) {
+      console.error("[Firebase] Failed to load credentials file:", error);
+    }
+  }
+  const projectId = process.env.FIREBASE_PROJECT_ID;
+  const clientEmail = process.env.FIREBASE_CLIENT_EMAIL;
+  let privateKey = process.env.FIREBASE_PRIVATE_KEY;
+  console.log("[Firebase] Checking env vars...");
+  console.log("[Firebase] Project ID:", projectId ? "\u2713 set" : "\u2717 missing");
+  console.log("[Firebase] Client Email:", clientEmail ? "\u2713 set" : "\u2717 missing");
+  console.log("[Firebase] Private Key:", privateKey ? `\u2713 set (${privateKey.length} chars)` : "\u2717 missing");
+  if (privateKey && !privateKey.includes("-----BEGIN")) {
+    try {
+      console.log("[Firebase] Decoding base64 private key...");
+      privateKey = Buffer.from(privateKey, "base64").toString("utf-8");
+    } catch (e) {
+      console.warn("[Firebase] Failed to decode base64 private key, using as-is");
+    }
+  }
+  privateKey = privateKey?.replace(/\\n/g, "\n");
+  console.log("[Firebase] Private key starts with BEGIN:", privateKey?.includes("-----BEGIN PRIVATE KEY-----"));
+  if (!projectId || !clientEmail || !privateKey) {
+    const errorMsg = "[Firebase] FATAL: Credentials not configured! Set FIREBASE_SERVICE_ACCOUNT_BASE64 (preferred) or FIREBASE_PROJECT_ID/CLIENT_EMAIL/PRIVATE_KEY.";
+    console.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  try {
+    admin.initializeApp({
+      credential: admin.credential.cert({
+        projectId,
+        clientEmail,
+        privateKey
+      })
+    });
+    firebaseInitialized = true;
+    console.log("Firebase Admin SDK initialized");
+  } catch (error) {
+    console.error("Failed to initialize Firebase:", error);
+  }
+}
+function getAuth() {
+  return admin.auth();
+}
+function getFirestore() {
+  return admin.firestore();
+}
+async function getUserByAddress(address) {
+  const db = getFirestore();
+  const userDoc = await db.collection("users").doc(address.toLowerCase()).get();
+  if (!userDoc.exists) {
+    return null;
+  }
+  return {
+    address: userDoc.id,
+    ...userDoc.data()
+  };
+}
+async function updateUserTier(address, tier, expiresAt) {
+  const db = getFirestore();
+  const userRef = db.collection("users").doc(address.toLowerCase());
+  await userRef.set({
+    tier,
+    tierExpiresAt: admin.firestore.Timestamp.fromDate(expiresAt),
+    updatedAt: admin.firestore.FieldValue.serverTimestamp()
+  }, { merge: true });
+  console.log(`[Payment] Updated user ${address} to ${tier} tier, expires ${expiresAt.toISOString()}`);
+}
+var firebaseInitialized;
+var init_firebase = __esm({
+  "src/firebase.ts"() {
+    firebaseInitialized = false;
+  }
+});
+
+// src/mcp/tools.ts
+var tools_exports = {};
+__export(tools_exports, {
+  ALL_MCP_TOOLS: () => ALL_MCP_TOOLS,
+  getToolByName: () => getToolByName
+});
+function getToolByName(name) {
+  return ALL_MCP_TOOLS.find((t) => t.name === name);
+}
+var ALL_MCP_TOOLS;
+var init_tools = __esm({
+  "src/mcp/tools.ts"() {
+    ALL_MCP_TOOLS = [
+      {
+        name: "analyze_wallet",
+        description: "Perform a full blockchain wallet analysis including balance, transactions, risk score, suspicious indicators, and project interactions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            address: { type: "string", description: "Wallet address to analyze (0x... for EVM, base58 for Solana)" },
+            chainId: {
+              type: "string",
+              description: "Blockchain to analyze",
+              enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "linea", "bsc", "solana"]
+            },
+            transactionLimit: {
+              type: "number",
+              description: "Max transactions to fetch (default: 500)",
+              default: 500
+            }
+          },
+          required: ["address", "chainId"]
+        }
+      },
+      {
+        name: "trace_funds",
+        description: "Trace funding sources and destinations for a wallet address, building a recursive funding tree.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            address: { type: "string", description: "Wallet address to trace" },
+            chainId: {
+              type: "string",
+              description: "Blockchain to trace on",
+              enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "linea", "bsc", "solana"]
+            },
+            maxDepth: {
+              type: "number",
+              description: "How many levels deep to trace (default: 3)",
+              default: 3
+            },
+            direction: {
+              type: "string",
+              description: "Which direction to trace",
+              enum: ["sources", "destinations", "both"],
+              default: "both"
+            }
+          },
+          required: ["address", "chainId"]
+        }
+      },
+      {
+        name: "compare_wallets",
+        description: "Compare multiple wallet addresses for common funding sources, shared project interactions, and sybil correlation scoring.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            addresses: {
+              type: "string",
+              description: "Comma-separated list of wallet addresses to compare (2-20 wallets)"
+            },
+            chainId: {
+              type: "string",
+              description: "Blockchain to compare on",
+              enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "linea", "bsc", "solana"]
+            }
+          },
+          required: ["addresses", "chainId"]
+        }
+      },
+      {
+        name: "analyze_contract",
+        description: "Analyze all addresses that have interacted with a smart contract, detecting sybil clusters and shared funding sources.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            contractAddress: { type: "string", description: "Smart contract address to analyze" },
+            chainId: {
+              type: "string",
+              description: "Blockchain the contract is on",
+              enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "linea", "bsc"]
+            },
+            maxInteractors: {
+              type: "number",
+              description: "Max interactors to analyze (default: 100)",
+              default: 100
+            }
+          },
+          required: ["contractAddress", "chainId"]
+        }
+      },
+      {
+        name: "detect_sybil_clusters",
+        description: "Detect sybil (fake) accounts by clustering wallets that share common funding sources.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            addresses: {
+              type: "string",
+              description: "Comma-separated list of wallet addresses to check for sybil clustering"
+            },
+            chainId: {
+              type: "string",
+              description: "Blockchain to analyze on",
+              enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "bsc"]
+            }
+          },
+          required: ["addresses", "chainId"]
+        }
+      },
+      {
+        name: "get_portfolio",
+        description: "Get the token portfolio, DeFi positions, and NFT holdings for a wallet address.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            address: { type: "string", description: "Wallet address" },
+            chainId: {
+              type: "string",
+              description: "Blockchain",
+              enum: ["ethereum", "solana", "base", "arbitrum", "optimism", "polygon", "linea"]
+            }
+          },
+          required: ["address", "chainId"]
+        }
+      },
+      {
+        name: "get_transactions",
+        description: "Get recent transaction history for a wallet address.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            address: { type: "string", description: "Wallet address" },
+            chainId: {
+              type: "string",
+              description: "Blockchain",
+              enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "linea", "bsc", "solana"]
+            },
+            limit: {
+              type: "number",
+              description: "Number of transactions to return (default: 50)",
+              default: 50
+            }
+          },
+          required: ["address", "chainId"]
+        }
+      },
+      {
+        name: "lookup_entity",
+        description: "Look up a known blockchain entity, protocol, or address label.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Entity name, address, or label to look up" },
+            chainId: {
+              type: "string",
+              description: "Blockchain to search (optional)",
+              enum: ["ethereum", "solana", "base", "arbitrum", "optimism", "polygon", "linea", "bsc", ""],
+              default: ""
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "get_gas_prices",
+        description: "Get current gas prices across supported blockchain networks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            chainId: {
+              type: "string",
+              description: "Specific chain (optional, returns all if omitted)",
+              enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "linea", "bsc", ""],
+              default: ""
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "get_token_info",
+        description: "Get market data and information for a token by address or symbol.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tokenAddress: { type: "string", description: "Token contract address" },
+            chainId: {
+              type: "string",
+              description: "Blockchain the token is on",
+              enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "linea", "bsc", "solana"]
+            }
+          },
+          required: ["tokenAddress", "chainId"]
+        }
+      }
+    ];
+  }
+});
+
+// src/services/SolanaFundingTreeService.ts
+var SolanaFundingTreeService_exports = {};
+__export(SolanaFundingTreeService_exports, {
+  SolanaFundingTreeService: () => SolanaFundingTreeService,
+  default: () => SolanaFundingTreeService_default
+});
+import fetch2 from "node-fetch";
+var ALCHEMY_SOLANA_API, CACHE_TTL, KNOWN_PROGRAMS, SolanaFundingTreeService, SolanaFundingTreeService_default;
+var init_SolanaFundingTreeService = __esm({
+  "src/services/SolanaFundingTreeService.ts"() {
+    ALCHEMY_SOLANA_API = "https://solana-mainnet.g.alchemy.com/v2/{apiKey}";
+    CACHE_TTL = 300;
+    KNOWN_PROGRAMS = {
+      // DEXs
+      "jupoK8gEJ4qEfD1k6QzJD7ssgvG5xTLwXgQNZHcPQ3fl": { name: "Jupiter", type: "dex" },
+      "jup3ZqFqEboGxBw1UnAUoxfXQA5ryiJPq3U5EEiW5eF": { name: "Jupiter", type: "dex" },
+      "CGkE4wDyY7mTDE7GQPPF2Uk6hK2Qa3x5xUhNYQqGKqBD": { name: "Raydium", type: "dex" },
+      "RVKdL2gt2zb2wWPXURQPswTUGqH2c6m8PMD3fESqC8H": { name: "Raydium", type: "dex" },
+      "orcaEKTdKx2wB3BmcSJwds6D3B4RST3JnBZKJx3QkqY9": { name: "Orca", type: "dex" },
+      // Bridges
+      "85VCBFdxR9exr5GtHVELq7uDT1mAc7YMFuq2bLtUMMmT": { name: "Wormhole", type: "bridge" },
+      "wormE4TGTQEaUMfNFxNA1XqJGMXH9Znk7aqZ3fGXq9p": { name: "Wormhole (Core)", type: "bridge" },
+      // CEX - common Solana热钱包
+      "2rXhuHUNDULrV6YLiPLZmm3xKg4zDqtLuZD8fFPTXw4": { name: "Coinbase", type: "cex" },
+      "F4vLeT4eq7YfmqNEBYJTdxYqNsuKXPxuPMe9jCBDm3k": { name: "Binance", type: "cex" },
+      // Known programs
+      "metaqbxxUurdFM34NHCNprmdGhDo4SyRQ9Dkjf53TwSp6y": { name: "Metaplex", type: "program" },
+      "TokenkegQfeZyiNwAJbNbGKPxGnhTNoZfFNYKDNgVEGPh": { name: "SPL Token", type: "program" },
+      "ATokenGPdCpDNQUxFJpMMzhxrZmLBhNpYY2MSKHvrkK7": { name: "Associated Token", type: "program" }
+    };
+    SolanaFundingTreeService = class {
+      apiKey;
+      cache = /* @__PURE__ */ new Map();
+      constructor(apiKey) {
+        this.apiKey = apiKey;
+      }
+      async rpcCall(method, params) {
+        const url = ALCHEMY_SOLANA_API.replace("{apiKey}", this.apiKey);
+        const response = await fetch2(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method,
+            params
+          })
+        });
+        const data = await response.json();
+        if (data.error) {
+          throw new Error(data.error.message);
+        }
+        return data.result;
+      }
+      getCached(key) {
+        const cached = this.cache.get(key);
+        if (cached && cached.expiresAt > Date.now()) {
+          return cached.data;
+        }
+        return null;
+      }
+      setCached(key, data) {
+        this.cache.set(key, {
+          data,
+          expiresAt: Date.now() + CACHE_TTL * 1e3
+        });
+      }
+      /**
+       * Get entity label for an address
+       */
+      getEntityInfo(address) {
+        const known = KNOWN_PROGRAMS[address];
+        if (known) {
+          return known;
+        }
+        if (address.length === 44) {
+          return { type: "wallet" };
+        }
+        return { type: "other" };
+      }
+      /**
+       * Fetch transaction signatures for an address
+       */
+      async getTransactions(address, limit = 100) {
+        const cacheKey = `txs:${address}:${limit}`;
+        const cached = this.getCached(cacheKey);
+        if (cached) return cached;
+        try {
+          const result = await this.rpcCall("getTransactionsForAddress", [
+            address,
+            {
+              transactionDetails: "signatures",
+              sortOrder: "desc",
+              limit,
+              filters: {
+                status: "succeeded"
+              }
+            }
+          ]);
+          const transactions = (result.data || []).map((entry) => ({
+            signature: entry.signature,
+            slot: entry.slot,
+            blockTime: entry.blockTime,
+            err: entry.err
+          }));
+          this.setCached(cacheKey, transactions);
+          return transactions;
+        } catch (error) {
+          console.error("[SolanaFundingTree] Error fetching transactions:", error);
+          return [];
+        }
+      }
+      /**
+       * Build funding sources (where funds came from)
+       * For Solana, this traces transfers WHERE THE ADDRESS RECEIVED funds
+       */
+      async buildSourceTree(address, maxDepth = 3) {
+        const transactions = await this.getTransactions(address, 100);
+        return this.constructTree(address, transactions, "source", maxDepth);
+      }
+      /**
+       * Build funding destinations (where funds went to)
+       * For Solana, this traces transfers WHERE THE ADDRESS SENT funds
+       */
+      async buildDestinationTree(address, maxDepth = 3) {
+        const transactions = await this.getTransactions(address, 100);
+        return this.constructTree(address, transactions, "destination", maxDepth);
+      }
+      /**
+       * Construct funding tree from transactions
+       */
+      constructTree(address, transactions, direction, maxDepth, currentDepth = 0) {
+        if (currentDepth >= maxDepth || transactions.length === 0) {
+          return this.createNode(address, direction, currentDepth, [], 0);
+        }
+        const nodeMap = /* @__PURE__ */ new Map();
+        for (const tx of transactions) {
+          const counterparty = this.extractCounterparty(tx.signature, address, direction);
+          if (!counterparty) continue;
+          const existing = nodeMap.get(counterparty) || { count: 0, totalValue: 0, firstTx: tx.blockTime, signatures: [] };
+          existing.count += 1;
+          existing.signatures.push(tx.signature);
+          if (tx.blockTime && tx.blockTime < existing.firstTx) {
+            existing.firstTx = tx.blockTime;
+          }
+          nodeMap.set(counterparty, existing);
+        }
+        const children = [];
+        let totalCount = 0;
+        for (const [counterAddr, stats] of Array.from(nodeMap.entries())) {
+          const childNode = this.constructTree(
+            counterAddr,
+            [],
+            // Would need to fetch recursively for full tree
+            direction,
+            maxDepth,
+            currentDepth + 1
+          );
+          childNode.txCount = stats.count;
+          childNode.totalValueInSol = stats.totalValue;
+          childNode.firstTx = { signature: stats.signatures[0], timestamp: stats.firstTx };
+          children.push(childNode);
+          totalCount += stats.count;
+        }
+        children.sort((a, b) => b.txCount - a.txCount);
+        const totalValue = children.reduce((sum, c) => sum + c.totalValueInSol, 0);
+        const entity = this.getEntityInfo(address);
+        return {
+          address,
+          depth: currentDepth,
+          direction,
+          totalValue: totalValue.toFixed(4),
+          totalValueInSol: totalValue,
+          txCount: totalCount,
+          children,
+          suspiciousScore: 0,
+          suspiciousReasons: [],
+          label: entity.label,
+          entityType: entity.type
+        };
+      }
+      /**
+       * Create a tree node
+       */
+      createNode(address, direction, depth, children, totalValue) {
+        const entity = this.getEntityInfo(address);
+        return {
+          address,
+          depth,
+          direction,
+          totalValue: totalValue.toFixed(4),
+          totalValueInSol: totalValue,
+          txCount: children.length,
+          children,
+          suspiciousScore: 0,
+          suspiciousReasons: [],
+          label: entity.label,
+          entityType: entity.type
+        };
+      }
+      /**
+       * Extract counterparty from transaction
+       * This is a placeholder - in full implementation we'd parse the transaction
+       */
+      extractCounterparty(signature, address, direction) {
+        return null;
+      }
+      /**
+       * Build complete funding tree with both sources and destinations
+       */
+      async buildFundingTree(address, maxDepth = 3) {
+        const [fundingSources, fundingDestinations] = await Promise.all([
+          this.buildSourceTree(address, maxDepth),
+          this.buildDestinationTree(address, maxDepth)
+        ]);
+        return { fundingSources, fundingDestinations };
+      }
+    };
+    SolanaFundingTreeService_default = SolanaFundingTreeService;
+  }
+});
+
+// src/services/SolanaKeyPoolManager.ts
+var MAX_MONTHLY_CUS, CIRCUIT_OPEN_MS, ERROR_THRESHOLD, SolanaKeyPoolManager, solanaKeyPool;
+var init_SolanaKeyPoolManager = __esm({
+  "src/services/SolanaKeyPoolManager.ts"() {
+    MAX_MONTHLY_CUS = 3e8;
+    CIRCUIT_OPEN_MS = 3e4;
+    ERROR_THRESHOLD = 5;
+    SolanaKeyPoolManager = class {
+      keys = [];
+      currentIndex = 0;
+      connections = /* @__PURE__ */ new Map();
+      constructor() {
+        this.initKeys();
+        this.startHealthMonitor();
+      }
+      initKeys() {
+        const contractKeyCount = 10;
+        for (let i = 1; i <= contractKeyCount; i++) {
+          const envKey = `SYBIL_CONTRACT_KEY_${String(i).padStart(2, "0")}`;
+          const key = process.env[envKey];
+          if (key) {
+            const endpoint = `https://solana-mainnet.g.alchemy.com/v2/${key}`;
+            this.keys.push({
+              key,
+              endpoint,
+              requestsThisMinute: 0,
+              requestsThisMonth: 0,
+              totalCUs: 0,
+              consecutiveErrors: 0,
+              lastErrorAt: null,
+              circuitOpen: false,
+              circuitOpenUntil: null,
+              avgLatencyMs: 0
+            });
+          }
+        }
+        const walletKeyCount = 10;
+        for (let i = 1; i <= walletKeyCount; i++) {
+          const envKey = `SYBIL_WALLET_KEY_${String(i).padStart(2, "0")}`;
+          const key = process.env[envKey];
+          if (key && !this.keys.find((k) => k.key === key)) {
+            const endpoint = `https://solana-mainnet.g.alchemy.com/v2/${key}`;
+            this.keys.push({
+              key,
+              endpoint,
+              requestsThisMinute: 0,
+              requestsThisMonth: 0,
+              totalCUs: 0,
+              consecutiveErrors: 0,
+              lastErrorAt: null,
+              circuitOpen: false,
+              circuitOpenUntil: null,
+              avgLatencyMs: 0
+            });
+          }
+        }
+        if (this.keys.length === 0) {
+          console.warn("[SolanaKeyPool] No Alchemy keys found, using fallback");
+          const fallbackKey = process.env.ALCHEMY_SOLANA_KEY || process.env.ALCHEMY_KEY_01;
+          if (fallbackKey) {
+            this.keys.push({
+              key: fallbackKey,
+              endpoint: `https://solana-mainnet.g.alchemy.com/v2/${fallbackKey}`,
+              requestsThisMinute: 0,
+              requestsThisMonth: 0,
+              totalCUs: 0,
+              consecutiveErrors: 0,
+              lastErrorAt: null,
+              circuitOpen: false,
+              circuitOpenUntil: null,
+              avgLatencyMs: 0
+            });
+          }
+        }
+        console.log(`[SolanaKeyPool] Initialized with ${this.keys.length} keys`);
+      }
+      getNextKey() {
+        const now = Date.now();
+        let attempts = 0;
+        while (attempts < this.keys.length) {
+          const health = this.keys[this.currentIndex];
+          this.currentIndex = (this.currentIndex + 1) % this.keys.length;
+          if (health.circuitOpen) {
+            if (now < health.circuitOpenUntil) {
+              attempts++;
+              continue;
+            }
+            health.circuitOpen = false;
+            health.consecutiveErrors = 0;
+          }
+          if (health.totalCUs >= MAX_MONTHLY_CUS * 0.95) {
+            attempts++;
+            continue;
+          }
+          return { health, endpoint: health.endpoint };
+        }
+        throw new Error("All Alchemy keys exhausted or in circuit-open state");
+      }
+      async execute(fn, cuCost = 1) {
+        const maxRetries = 3;
+        let lastError = null;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+          const { health, endpoint } = this.getNextKey();
+          const start = Date.now();
+          try {
+            const result = await fn(endpoint);
+            const latency = Date.now() - start;
+            health.consecutiveErrors = 0;
+            health.requestsThisMinute++;
+            health.requestsThisMonth++;
+            health.totalCUs += cuCost;
+            health.avgLatencyMs = health.avgLatencyMs * 0.9 + latency * 0.1;
+            return result;
+          } catch (err2) {
+            lastError = err2;
+            health.consecutiveErrors++;
+            health.lastErrorAt = Date.now();
+            if (health.consecutiveErrors >= ERROR_THRESHOLD) {
+              health.circuitOpen = true;
+              health.circuitOpenUntil = Date.now() + CIRCUIT_OPEN_MS;
+              console.warn(`[SolanaKeyPool] Circuit opened for key ${health.key.slice(0, 8)}...`);
+            }
+            if (err2.status === 429) {
+              await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
+            }
+          }
+        }
+        throw lastError || new Error("RPC call failed after retries");
+      }
+      getPoolStats() {
+        return {
+          totalKeys: this.keys.length,
+          healthyKeys: this.keys.filter((k) => !k.circuitOpen).length,
+          totalCUsUsed: this.keys.reduce((sum, k) => sum + k.totalCUs, 0),
+          avgLatencyMs: this.keys.reduce((s, k) => s + k.avgLatencyMs, 0) / this.keys.length
+        };
+      }
+      startHealthMonitor() {
+        setInterval(() => {
+          this.keys.forEach((k) => k.requestsThisMinute = 0);
+        }, 6e4);
+      }
+    };
+    solanaKeyPool = new SolanaKeyPoolManager();
+  }
+});
+
+// src/utils/cache.ts
+var Cache, cache;
+var init_cache = __esm({
+  "src/utils/cache.ts"() {
+    Cache = class {
+      store = /* @__PURE__ */ new Map();
+      set(key, value, ttlSeconds) {
+        const expires = Date.now() + ttlSeconds * 1e3;
+        this.store.set(key, { value, expires });
+      }
+      get(key) {
+        const item = this.store.get(key);
+        if (!item) return null;
+        if (Date.now() > item.expires) {
+          this.store.delete(key);
+          return null;
+        }
+        return item.value;
+      }
+      delete(key) {
+        this.store.delete(key);
+      }
+      clear() {
+        this.store.clear();
+      }
+      has(key) {
+        const item = this.store.get(key);
+        if (!item) return false;
+        if (Date.now() > item.expires) {
+          this.store.delete(key);
+          return false;
+        }
+        return true;
+      }
+    };
+    cache = new Cache();
+  }
+});
+
+// src/services/DuneSimClient.ts
+import fetch3 from "node-fetch";
+var SIM_BETA_BASE, SIM_V1_BASE, EVM_CHAIN_IDS, LAMPORTS_PER_SOL, DuneSimClient, duneSimClient;
+var init_DuneSimClient = __esm({
+  "src/services/DuneSimClient.ts"() {
+    init_cache();
+    SIM_BETA_BASE = "https://api.sim.dune.com/beta";
+    SIM_V1_BASE = "https://api.sim.dune.com/v1";
+    EVM_CHAIN_IDS = {
+      ethereum: 1,
+      eth: 1,
+      linea: 59144,
+      arbitrum: 42161,
+      arb: 42161,
+      optimism: 10,
+      opt: 10,
+      base: 8453,
+      polygon: 137,
+      matic: 137,
+      bsc: 56,
+      avalanche: 43114,
+      avax: 43114
+    };
+    LAMPORTS_PER_SOL = 1e9;
+    DuneSimClient = class {
+      apiKey;
+      enabled = true;
+      constructor(apiKey) {
+        this.apiKey = apiKey || process.env.SIM_API_KEY || "";
+        this.enabled = !!this.apiKey && process.env.SIM_SOLANA_ENABLED !== "false";
+        if (!this.enabled) {
+          console.warn("[DuneSimClient] SIM disabled - no API key or SIM_SOLANA_ENABLED=false");
+        } else {
+          console.log("[DuneSimClient] Initialized - using SIM for Solana data");
+        }
+      }
+      isEnabled() {
+        return this.enabled;
+      }
+      async fetchWithAuth(url) {
+        if (!this.enabled) {
+          throw new Error("SIM client disabled");
+        }
+        const response = await fetch3(url, {
+          method: "GET",
+          headers: {
+            "X-Sim-Api-Key": this.apiKey
+          }
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`SIM API error ${response.status}: ${error}`);
+        }
+        return response.json();
+      }
+      /**
+       * Get token balances for a Solana address using SIM
+       * Endpoint: GET /beta/svm/balances/{address}
+       */
+      async getBalances(address, options = {}) {
+        const cacheKey = `sim:balances:${address}:${JSON.stringify(options)}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const params = new URLSearchParams();
+        if (options.chains) params.set("chains", options.chains);
+        if (options.limit) params.set("limit", options.limit.toString());
+        if (options.excludeSpamTokens) params.set("exclude_spam_tokens", "true");
+        if (options.excludeUnpriced) params.set("exclude_unpriced", "true");
+        const url = `${SIM_BETA_BASE}/svm/balances/${address}${params.toString() ? "?" + params.toString() : ""}`;
+        try {
+          const data = await this.fetchWithAuth(url);
+          cache.set(cacheKey, data, 60);
+          return data;
+        } catch (error) {
+          console.error("[DuneSimClient] Error fetching balances:", error);
+          throw error;
+        }
+      }
+      /**
+       * Get transactions for a Solana address using SIM
+       * Endpoint: GET /beta/svm/transactions/{address}
+       */
+      async getTransactions(address, options = {}) {
+        const cacheKey = `sim:txs:${address}:${options.limit || 100}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const params = new URLSearchParams();
+        if (options.limit) params.set("limit", options.limit.toString());
+        const url = `${SIM_BETA_BASE}/svm/transactions/${address}${params.toString() ? "?" + params.toString() : ""}`;
+        try {
+          const data = await this.fetchWithAuth(url);
+          cache.set(cacheKey, data, 300);
+          return data;
+        } catch (error) {
+          console.error("[DuneSimClient] Error fetching transactions:", error);
+          throw error;
+        }
+      }
+      /**
+       * Convert SIM balances response to FundTracer format
+       */
+      mapBalancesToPortfolio(simResponse) {
+        const { balances, wallet_address } = simResponse;
+        const solBalance = balances.find((b) => b.address === "native");
+        const solLamports = solBalance ? parseInt(solBalance.amount) : 0;
+        const solUsd = solBalance?.value_usd || 0;
+        const solPrice = solBalance?.price_usd || 0;
+        const tokens = balances.filter((b) => b.address !== "native").map((token) => ({
+          mint: token.address,
+          amount: parseInt(token.amount),
+          decimals: token.decimals,
+          uiAmount: parseFloat(token.balance),
+          symbol: token.symbol,
+          name: token.name,
+          logoUrl: token.uri || void 0,
+          price: token.price_usd,
+          value: token.value_usd
+        })).filter((t) => t.uiAmount > 0);
+        const totalUsd = solUsd + tokens.reduce((sum, t) => sum + (t.value || 0), 0);
+        return {
+          address: wallet_address,
+          sol: {
+            lamports: solLamports,
+            sol: solLamports / LAMPORTS_PER_SOL,
+            usd: solUsd
+          },
+          tokens,
+          totalUsd,
+          fetchedAt: Date.now()
+        };
+      }
+      /**
+       * Convert SIM transactions to FundTracer format
+       */
+      mapTransactions(simResponse) {
+        const { transactions } = simResponse;
+        return transactions.map((tx) => {
+          const rawTx = tx.raw_transaction;
+          const meta = rawTx?.meta;
+          const message = rawTx?.transaction?.message;
+          const instructions = message?.instructions || [];
+          let from = "";
+          let to = "";
+          let amount = 0;
+          let token = "";
+          let tokenAmount = 0;
+          let type = "unknown";
+          if (message?.accountKeys?.[0]) {
+            from = typeof message.accountKeys[0] === "string" ? message.accountKeys[0] : message.accountKeys[0]?.pubkey || "";
+          }
+          for (const ix of instructions) {
+            if (ix.parsed) {
+              if (ix.parsed.type === "transfer") {
+                to = ix.parsed.info?.destination || "";
+                amount = parseInt(ix.parsed.info?.lamports || "0");
+                type = "transfer";
+                break;
+              } else if (ix.parsed.type === "transferChecked") {
+                to = ix.parsed.info?.destination || "";
+                token = ix.parsed.info?.mint || "";
+                tokenAmount = parseFloat(ix.parsed.info?.tokenAmount?.amount || "0");
+                type = "token-transfer";
+                break;
+              }
+            } else if (ix.program) {
+              if (ix.program === "system" || ix.programIdIndex === 0) {
+                type = "transfer";
+              } else if (ix.program === "token" || ix.programIdIndex === 2) {
+                type = "token-transfer";
+              } else if (ix.program === "stake") {
+                type = "staking";
+              }
+            }
+          }
+          if (type === "unknown" && message?.accountKeys) {
+            const tokenProgramIdx = message.accountKeys.findIndex(
+              (k) => k === "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" || typeof k === "object" && k?.pubkey === "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+            );
+            if (tokenProgramIdx > -1) {
+              type = "token-transfer";
+            }
+          }
+          const blockTimeMs = tx.block_time ? Math.floor(tx.block_time / 1e3) : Date.now() * 1e3;
+          return {
+            signature: rawTx?.transaction?.signatures?.[0] || "",
+            slot: tx.block_slot,
+            blockTime: blockTimeMs,
+            fee: meta?.fee || 0,
+            status: meta?.err ? "failed" : "success",
+            type,
+            from,
+            to,
+            amount: amount > 0 ? amount / LAMPORTS_PER_SOL : void 0,
+            token,
+            tokenAmount: tokenAmount > 0 ? tokenAmount : void 0,
+            instructions: instructions.map((ix) => ix.parsed || ix)
+          };
+        });
+      }
+      /**
+       * Get portfolio with spam filtering option
+       */
+      async getFilteredPortfolio(address, filterOptions = {}) {
+        const simResponse = await this.getBalances(address, {
+          excludeSpamTokens: filterOptions.excludeSpamTokens,
+          excludeUnpriced: filterOptions.excludeUnpriced
+        });
+        let balances = simResponse.balances;
+        if (filterOptions.minLiquidity && filterOptions.minLiquidity > 0) {
+          balances = balances.filter(
+            (b) => !b.low_liquidity && (b.pool_size || 0) >= filterOptions.minLiquidity
+          );
+        }
+        return this.mapBalancesToPortfolio({
+          ...simResponse,
+          balances
+        });
+      }
+      // ============================================================
+      // EVM METHODS (using /v1/evm/* endpoints)
+      // ============================================================
+      /**
+       * Convert chain name to chain_id
+       */
+      getChainId(chainName) {
+        return EVM_CHAIN_IDS[chainName.toLowerCase()] || EVM_CHAIN_IDS[chainName] || 1;
+      }
+      /**
+       * Get EVM token balances for a wallet
+       * Endpoint: GET /v1/evm/balances/{address}
+       */
+      async getEvmBalances(address, options = {}) {
+        const cacheKey = `sim:evm:balances:${address}:${JSON.stringify(options)}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const params = new URLSearchParams();
+        if (options.chainIds) {
+          if (Array.isArray(options.chainIds)) {
+            params.set("chain_ids", options.chainIds.join(","));
+          } else {
+            params.set("chain_ids", options.chainIds.toString());
+          }
+        }
+        if (options.filters) params.set("filters", options.filters);
+        if (options.assetClass) params.set("asset_class", options.assetClass);
+        if (options.excludeSpamTokens) params.set("exclude_spam_tokens", "true");
+        if (options.excludeUnpriced) params.set("exclude_unpriced", "true");
+        if (options.metadata) params.set("metadata", options.metadata);
+        if (options.historicalPrices) params.set("historical_prices", options.historicalPrices);
+        if (options.limit) params.set("limit", options.limit.toString());
+        if (options.offset) params.set("offset", options.offset);
+        const url = `${SIM_V1_BASE}/evm/balances/${address}${params.toString() ? "?" + params.toString() : ""}`;
+        try {
+          const data = await this.fetchWithAuth(url);
+          cache.set(cacheKey, data, 60);
+          return data;
+        } catch (error) {
+          console.error("[DuneSimClient] Error fetching EVM balances:", error);
+          throw error;
+        }
+      }
+      /**
+       * Get EVM activity for a wallet
+       * Endpoint: GET /v1/evm/activity/{address}
+       */
+      async getEvmActivity(address, options = {}) {
+        const cacheKey = `sim:evm:activity:${address}:${JSON.stringify(options)}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const params = new URLSearchParams();
+        if (options.chainIds) {
+          params.set("chain_ids", Array.isArray(options.chainIds) ? options.chainIds.join(",") : options.chainIds.toString());
+        }
+        if (options.activityType) params.set("activity_type", options.activityType);
+        if (options.assetType) params.set("asset_type", options.assetType);
+        if (options.tokenAddress) params.set("token_address", options.tokenAddress);
+        if (options.limit) params.set("limit", options.limit.toString());
+        if (options.offset) params.set("offset", options.offset);
+        const url = `${SIM_V1_BASE}/evm/activity/${address}${params.toString() ? "?" + params.toString() : ""}`;
+        try {
+          const data = await this.fetchWithAuth(url);
+          cache.set(cacheKey, data, 30);
+          return data;
+        } catch (error) {
+          console.error("[DuneSimClient] Error fetching EVM activity:", error);
+          throw error;
+        }
+      }
+      /**
+       * Get EVM transactions for a wallet
+       * Endpoint: GET /v1/evm/transactions/{address}
+       */
+      async getEvmTransactions(address, options = {}) {
+        const cacheKey = `sim:evm:txs:${address}:${JSON.stringify(options)}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const params = new URLSearchParams();
+        if (options.chainIds) {
+          params.set("chain_ids", Array.isArray(options.chainIds) ? options.chainIds.join(",") : options.chainIds.toString());
+        }
+        if (options.limit) params.set("limit", options.limit.toString());
+        if (options.offset) params.set("offset", options.offset);
+        if (options.decode) params.set("decode", "true");
+        const url = `${SIM_V1_BASE}/evm/transactions/${address}${params.toString() ? "?" + params.toString() : ""}`;
+        try {
+          const data = await this.fetchWithAuth(url);
+          cache.set(cacheKey, data, 300);
+          return data;
+        } catch (error) {
+          console.error("[DuneSimClient] Error fetching EVM transactions:", error);
+          throw error;
+        }
+      }
+      /**
+       * Get EVM collectibles (NFTs) for a wallet
+       * Endpoint: GET /v1/evm/collectibles/{address}
+       */
+      async getEvmCollectibles(address, options = {}) {
+        const cacheKey = `sim:evm:collectibles:${address}:${JSON.stringify(options)}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const params = new URLSearchParams();
+        if (options.chainIds) {
+          params.set("chain_ids", Array.isArray(options.chainIds) ? options.chainIds.join(",") : options.chainIds.toString());
+        }
+        if (options.limit) params.set("limit", options.limit.toString());
+        if (options.offset) params.set("offset", options.offset);
+        if (options.filterSpam === false) params.set("filter_spam", "false");
+        if (options.showSpamScores) params.set("show_spam_scores", "true");
+        const url = `${SIM_V1_BASE}/evm/collectibles/${address}${params.toString() ? "?" + params.toString() : ""}`;
+        try {
+          const data = await this.fetchWithAuth(url);
+          cache.set(cacheKey, data, 300);
+          return data;
+        } catch (error) {
+          console.error("[DuneSimClient] Error fetching EVM collectibles:", error);
+          throw error;
+        }
+      }
+      /**
+       * Get token info for an EVM token
+       * Endpoint: GET /v1/evm/token-info/{address}
+       */
+      async getEvmTokenInfo(tokenAddress, chainId = 1) {
+        const cacheKey = `sim:evm:tokeninfo:${tokenAddress}:${chainId}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const url = `${SIM_V1_BASE}/evm/token-info/${tokenAddress}?chain_ids=${chainId}`;
+        try {
+          const data = await this.fetchWithAuth(url);
+          cache.set(cacheKey, data, 300);
+          return data;
+        } catch (error) {
+          console.error("[DuneSimClient] Error fetching token info:", error);
+          throw error;
+        }
+      }
+      /**
+       * Get stablecoin balances for a wallet
+       * Endpoint: GET /v1/evm/stablecoins/{address}
+       */
+      async getEvmStablecoins(address, options = {}) {
+        const cacheKey = `sim:evm:stablecoins:${address}:${JSON.stringify(options)}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const params = new URLSearchParams();
+        if (options.chainIds) {
+          params.set("chain_ids", Array.isArray(options.chainIds) ? options.chainIds.join(",") : options.chainIds.toString());
+        }
+        if (options.excludeUnpriced) params.set("exclude_unpriced", "true");
+        if (options.limit) params.set("limit", options.limit.toString());
+        if (options.offset) params.set("offset", options.offset);
+        const url = `${SIM_V1_BASE}/evm/balances/${address}/stablecoins${params.toString() ? "?" + params.toString() : ""}`;
+        try {
+          const data = await this.fetchWithAuth(url);
+          cache.set(cacheKey, data, 60);
+          return data;
+        } catch (error) {
+          console.error("[DuneSimClient] Error fetching stablecoins:", error);
+          throw error;
+        }
+      }
+      /**
+       * Get full EVM portfolio (tokens + NFTs + activity summary)
+       */
+      async getEvmPortfolio(address, chainId = 1, options = {}) {
+        const balancesResult = await this.getEvmBalances(address, { chainIds: chainId, excludeUnpriced: true, metadata: "logo" });
+        let totalValue = 0;
+        const tokens = [];
+        let nativeBalance = "0";
+        let nativeValue = 0;
+        for (const bal of balancesResult.balances || []) {
+          totalValue += bal.value_usd || 0;
+          if (bal.address === "native") {
+            nativeBalance = bal.amount;
+            nativeValue = bal.value_usd || 0;
+          } else {
+            tokens.push({
+              address: bal.address,
+              balance: bal.amount,
+              value_usd: bal.value_usd || 0,
+              symbol: bal.symbol,
+              name: bal.name,
+              decimals: bal.decimals,
+              price_usd: bal.price_usd || 0,
+              pool_size: bal.pool_size,
+              low_liquidity: bal.low_liquidity,
+              logo: bal.token_metadata?.logo
+            });
+          }
+        }
+        const stablecoinsList = [];
+        if (options.includeStablecoins) {
+          try {
+            const stableResult = await this.getEvmStablecoins(address, { chainIds: chainId });
+            for (const bal of stableResult.balances || []) {
+              stablecoinsList.push({
+                address: bal.address,
+                balance: bal.amount,
+                value_usd: bal.value_usd || 0,
+                symbol: bal.symbol
+              });
+            }
+          } catch (e) {
+            console.warn("[DuneSimClient] Stablecoins fetch failed:", e);
+          }
+        }
+        const nftList = [];
+        if (options.includeNfts) {
+          try {
+            const nftResult = await this.getEvmCollectibles(address, { chainIds: chainId, filterSpam: true });
+            for (const nft of nftResult.entries || []) {
+              nftList.push({
+                contract_address: nft.contract_address,
+                token_id: nft.token_id,
+                name: nft.name,
+                image_url: nft.image_url,
+                collection: nft.symbol || nft.name,
+                is_spam: nft.is_spam
+              });
+            }
+          } catch (e) {
+            console.warn("[DuneSimClient] Collectibles fetch failed:", e);
+          }
+        }
+        let activitySummary;
+        if (options.includeActivity) {
+          try {
+            const activityResult = await this.getEvmActivity(address, { chainIds: chainId, limit: 100 });
+            let sends = 0, receives = 0, volume = 0;
+            for (const act of activityResult.activity || []) {
+              if (act.type === "send") sends++;
+              if (act.type === "receive") receives++;
+              volume += act.value_usd || 0;
+            }
+            activitySummary = {
+              total_sends: sends,
+              total_receives: receives,
+              total_volume_usd: volume
+            };
+          } catch (e) {
+            console.warn("[DuneSimClient] Activity fetch failed:", e);
+          }
+        }
+        return {
+          address,
+          chain_id: chainId,
+          total_value_usd: totalValue + nativeValue,
+          native: {
+            balance: nativeBalance,
+            value_usd: nativeValue,
+            symbol: "ETH"
+          },
+          tokens,
+          stablecoins: options.includeStablecoins ? stablecoinsList : [],
+          nfts: options.includeNfts ? nftList : void 0,
+          activity_summary: options.includeActivity ? activitySummary : void 0,
+          last_updated: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    };
+    duneSimClient = new DuneSimClient();
+  }
+});
+
+// src/services/SolanaHeliusKeyPool.ts
+function buildEndpoints() {
+  const eps = [];
+  for (let i = 1; i <= 3; i++) {
+    const key = process.env[`HELIUS_KEY_${i}`];
+    if (key) {
+      eps.push({ url: `https://mainnet.helius-rpc.com/?api-key=${key}`, label: `Helius-${i}` });
+    }
+  }
+  const alchemyKey = process.env.ALCHEMY_SOLANA_API_KEY;
+  if (alchemyKey) {
+    eps.push({ url: `https://solana-mainnet.g.alchemy.com/v2/${alchemyKey}`, label: "Alchemy-Sol" });
+  }
+  return eps;
+}
+var CIRCUIT_OPEN_MS2, ERROR_THRESHOLD2, RpcKeyPool, ALL_ENDPOINTS, splitPoint, sigRpcPool, xferRpcPool;
+var init_SolanaHeliusKeyPool = __esm({
+  "src/services/SolanaHeliusKeyPool.ts"() {
+    CIRCUIT_OPEN_MS2 = 3e4;
+    ERROR_THRESHOLD2 = 5;
+    RpcKeyPool = class {
+      slots = [];
+      index = 0;
+      constructor(endpoints, label) {
+        this.slots = endpoints.filter((e) => e.url).map((e) => ({
+          url: e.url,
+          label: e.label,
+          requestsThisMinute: 0,
+          consecutiveErrors: 0,
+          lastErrorAt: null,
+          circuitOpen: false,
+          circuitOpenUntil: null,
+          avgLatencyMs: 0,
+          totalRequests: 0
+        }));
+        if (this.slots.length === 0) {
+          console.warn(`[RpcKeyPool:${label}] No endpoints configured`);
+        } else {
+          console.log(`[RpcKeyPool:${label}] Initialized with ${this.slots.length} endpoint(s): ${this.slots.map((s) => s.label).join(", ")}`);
+        }
+        setInterval(() => {
+          for (const s of this.slots) s.requestsThisMinute = 0;
+        }, 6e4).unref();
+      }
+      get size() {
+        return this.slots.length;
+      }
+      get healthy() {
+        return this.slots.filter((s) => !s.circuitOpen).length;
+      }
+      get isOperational() {
+        return this.slots.length > 0 && this.slots.some((s) => !s.circuitOpen);
+      }
+      acquire() {
+        if (this.slots.length === 0) {
+          throw new Error("RpcKeyPool: No endpoints configured");
+        }
+        const now = Date.now();
+        for (let attempt = 0; attempt < this.slots.length * 2; attempt++) {
+          const slot = this.slots[this.index % this.slots.length];
+          this.index++;
+          if (slot.circuitOpen) {
+            if (slot.circuitOpenUntil && now >= slot.circuitOpenUntil) {
+              slot.circuitOpen = false;
+              slot.consecutiveErrors = 0;
+              return slot;
+            }
+            continue;
+          }
+          return slot;
+        }
+        throw new Error("RpcKeyPool: All endpoints are circuit-open");
+      }
+      /** Execute an RPC method through the pool */
+      async rpc(method, params) {
+        const maxRetries = 2;
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          let slot;
+          try {
+            slot = this.acquire();
+          } catch (e) {
+            throw lastError || e;
+          }
+          const start = Date.now();
+          slot.requestsThisMinute++;
+          try {
+            const res = await fetch(slot.url, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+            });
+            const data = await res.json();
+            if (data.error) throw new Error(data.error.message);
+            const latency = Date.now() - start;
+            slot.consecutiveErrors = 0;
+            slot.avgLatencyMs = slot.avgLatencyMs * 0.9 + latency * 0.1;
+            slot.totalRequests++;
+            return data.result;
+          } catch (err2) {
+            lastError = err2;
+            slot.consecutiveErrors++;
+            slot.lastErrorAt = Date.now();
+            if (slot.consecutiveErrors >= ERROR_THRESHOLD2) {
+              slot.circuitOpen = true;
+              slot.circuitOpenUntil = Date.now() + CIRCUIT_OPEN_MS2;
+              console.warn(`[RpcKeyPool] Circuit opened for ${slot.label}`);
+            }
+            if (err2.status === 429) {
+              await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
+            }
+            if (attempt < maxRetries) {
+              await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+            }
+          }
+        }
+        throw lastError || new Error("RpcKeyPool: All retries exhausted");
+      }
+      stats() {
+        return {
+          totalSlots: this.slots.length,
+          healthy: this.healthy,
+          totalRequests: this.slots.reduce((s, k) => s + k.totalRequests, 0),
+          avgLatencyMs: this.slots.reduce((s, k) => s + k.avgLatencyMs, 0) / (this.slots.length || 1)
+        };
+      }
+      absorb(other) {
+        const transferred = other.slots.filter((s) => !s.circuitOpen);
+        for (const s of transferred) {
+          this.slots.push(s);
+        }
+        console.log(`[RpcKeyPool] Absorbed ${transferred.length} endpoint(s) from another pool (now ${this.slots.length} total)`);
+      }
+    };
+    ALL_ENDPOINTS = buildEndpoints();
+    if (ALL_ENDPOINTS.length === 0) {
+      console.warn("[RpcKeyPool] No Solana RPC endpoints found \u2014 Helius/Alchemy features will fail");
+    } else {
+      console.log(`[RpcKeyPool] Found ${ALL_ENDPOINTS.length} Solana RPC endpoint(s)`);
+    }
+    splitPoint = Math.max(1, Math.floor(ALL_ENDPOINTS.length * 0.66));
+    sigRpcPool = new RpcKeyPool(ALL_ENDPOINTS.slice(0, splitPoint), "sig-rpc");
+    xferRpcPool = new RpcKeyPool(ALL_ENDPOINTS.slice(splitPoint), "xfer-rpc");
+  }
+});
+
+// src/services/SolanaHeliusClient.ts
+var SolanaHeliusClient, solanaHeliusClient;
+var init_SolanaHeliusClient = __esm({
+  "src/services/SolanaHeliusClient.ts"() {
+    init_SolanaHeliusKeyPool();
+    init_DuneSimClient();
+    SolanaHeliusClient = class _SolanaHeliusClient {
+      static instance;
+      LAMPORTS = 1e9;
+      constructor() {
+      }
+      static getInstance() {
+        if (!_SolanaHeliusClient.instance) {
+          _SolanaHeliusClient.instance = new _SolanaHeliusClient();
+        }
+        return _SolanaHeliusClient.instance;
+      }
+      // ================================================================
+      // DAS API methods (general-purpose)
+      // ================================================================
+      async dasRequest(method, params) {
+        return sigRpcPool.rpc(method, params);
+      }
+      async getTokenMetadata(mint) {
+        return this.dasRequest("getTokenMetadata", [mint]);
+      }
+      async getAsset({ id }) {
+        return this.dasRequest("getAsset", [{ id }]);
+      }
+      async getAssetsByOwner({ owner, limit = 100 }) {
+        return this.dasRequest("getAssetsByOwner", [{ owner, limit, sortBy: { sortBy: "updated", descending: true } }]);
+      }
+      async getAssetsByGroup({ groupKey, groupValue, limit = 100 }) {
+        return this.dasRequest("getAssetsByGroup", [{ groupKey, groupValue, limit, sortBy: { sortBy: "updated", descending: true } }]);
+      }
+      async searchAssets({ query, limit = 50 }) {
+        return this.dasRequest("searchAssets", [{ query: { $text: query }, limit, sortBy: { sortBy: "relevant", descending: false } }]);
+      }
+      // ================================================================
+      // Helius-exclusive: getTransactionsForAddress (via sigRpcPool — 66% of endpoints)
+      // ================================================================
+      async getTransactionsForAddress(address, options = {}) {
+        const result = await sigRpcPool.rpc("getTransactionsForAddress", [
+          address,
+          {
+            transactionDetails: options.transactionDetails || "signatures",
+            limit: options.limit || 1e3,
+            sortOrder: options.sortOrder || "desc",
+            ...options.paginationToken ? { paginationToken: options.paginationToken } : {}
+          }
+        ]);
+        return {
+          data: result?.data || [],
+          paginationToken: result?.paginationToken || void 0
+        };
+      }
+      // ================================================================
+      // Helius-exclusive: getTransfersByAddress (via xferRpcPool — 33% of endpoints)
+      // ================================================================
+      async getTransfersByAddress(address, options = {}, poolOverride) {
+        const pool = poolOverride || xferRpcPool;
+        try {
+          const result = await pool.rpc("getTransfersByAddress", [
+            address,
+            {
+              limit: options.limit || 100,
+              ...options.paginationToken ? { paginationToken: options.paginationToken } : {}
+            }
+          ]);
+          return {
+            data: result?.data || [],
+            paginationToken: result?.paginationToken || void 0
+          };
+        } catch (err2) {
+          if (err2.message?.includes?.("Unsupported method")) {
+            throw new Error("only available on paid Helius plan");
+          }
+          throw err2;
+        }
+      }
+      // ================================================================
+      // Full wallet scan: parallel sigs + transfers with lazy absorption
+      // ================================================================
+      async scanWallet(address) {
+        const start = Date.now();
+        const [sigsResult, transfersResult] = await Promise.all([
+          this.getAllSignatures(address),
+          this.getAllTransfersWithAbsorb(address)
+        ]);
+        return {
+          signatures: sigsResult,
+          transfers: transfersResult,
+          totalTime: Date.now() - start
+        };
+      }
+      async getAllSignatures(address) {
+        const all = [];
+        let paginationToken;
+        do {
+          const result = await this.getTransactionsForAddress(address, {
+            transactionDetails: "signatures",
+            limit: 1e3,
+            sortOrder: "desc",
+            paginationToken
+          });
+          all.push(...result.data);
+          paginationToken = result.paginationToken;
+        } while (paginationToken && all.length < 5e4);
+        return all.sort((a, b) => a.blockTime - b.blockTime);
+      }
+      async getAllTransfersWithAbsorb(address) {
+        const all = [];
+        let paginationToken;
+        let sigsDone = false;
+        const sigsDonePromise = sigRpcPool.size > 0 ? this.watchForSigPoolIdle() : Promise.resolve();
+        const sigsDoneRace = sigsDonePromise.then(() => {
+          sigsDone = true;
+        });
+        do {
+          const result = await this.getTransfersByAddress(address, { limit: 100, paginationToken });
+          all.push(...result.data);
+          paginationToken = result.paginationToken;
+          if (sigsDone && sigRpcPool.healthy > 0) {
+            xferRpcPool.absorb(sigRpcPool);
+            sigsDone = false;
+          }
+        } while (paginationToken && all.length < 1e4);
+        return all;
+      }
+      async watchForSigPoolIdle() {
+        let prev = 0;
+        let stableCount = 0;
+        for (let i = 0; i < 30; i++) {
+          await new Promise((r) => setTimeout(r, 800));
+          const cur = sigRpcPool.stats().totalRequests;
+          if (cur === prev) {
+            stableCount++;
+            if (stableCount >= 3) return;
+          } else {
+            stableCount = 0;
+          }
+          prev = cur;
+        }
+      }
+      async getAllTransfers(address) {
+        const all = [];
+        let paginationToken;
+        do {
+          const result = await this.getTransfersByAddress(address, { limit: 100, paginationToken });
+          all.push(...result.data);
+          paginationToken = result.paginationToken;
+        } while (paginationToken && all.length < 1e4);
+        return all;
+      }
+      getPoolStats() {
+        return { signaturesPool: sigRpcPool.stats(), transfersPool: xferRpcPool.stats() };
+      }
+      // ================================================================
+      // STANDARD RPC METHODS — work on free Helius AND Alchemy
+      // ================================================================
+      async getSignaturesForAddressStdRpc(address, options = {}) {
+        const result = await sigRpcPool.rpc("getSignaturesForAddress", [
+          address,
+          {
+            limit: options.limit || 100,
+            commitment: "confirmed",
+            ...options.before ? { before: options.before } : {}
+          }
+        ]);
+        return (result || []).map((s) => ({
+          signature: s.signature,
+          blockTime: s.blockTime || 0,
+          err: s.err,
+          slot: s.slot
+        }));
+      }
+      async getTransactionStdRpc(signature) {
+        return sigRpcPool.rpc("getTransaction", [
+          signature,
+          { commitment: "confirmed", maxSupportedTransactionVersion: 0 }
+        ]);
+      }
+      async getBalanceStdRpc(address) {
+        const result = await sigRpcPool.rpc("getBalance", [address]);
+        return result?.value || 0;
+      }
+      // ================================================================
+      // FALLBACK SCAN PATH  — tries SIM first, then RPC
+      // ================================================================
+      async scanWalletFallback(address) {
+        const start = Date.now();
+        if (duneSimClient.isEnabled()) {
+          try {
+            return await this.scanWalletFallbackViaSim(address, start);
+          } catch (simErr) {
+            console.log("[SolanaHelius] SIM fallback failed, using RPC:", simErr?.message);
+          }
+        }
+        return this.scanWalletFallbackViaRpc(address, start);
+      }
+      async scanWalletFallbackViaSim(address, start) {
+        const simTxs = await duneSimClient.getTransactions(address, { limit: 1e3 });
+        const txs = duneSimClient.mapTransactions(simTxs);
+        const signatures = txs.map((t) => ({
+          signature: t.signature,
+          blockTime: Math.floor(t.blockTime / 1e3),
+          err: t.status === "failed" ? { msg: "failed" } : null
+        }));
+        let totalSOLSent = 0;
+        let totalSOLReceived = 0;
+        const interactors = {};
+        for (const tx of txs) {
+          if (tx.from === address) {
+            totalSOLSent += tx.amount || 0;
+            if (tx.to) interactors[tx.to] = (interactors[tx.to] || 0) + 1;
+          }
+          if (tx.to === address) {
+            totalSOLReceived += tx.amount || 0;
+            if (tx.from) interactors[tx.from] = (interactors[tx.from] || 0) + 1;
+          }
+        }
+        const topInteractors = Object.entries(interactors).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([address2, count]) => ({ address: address2, count }));
+        return { signatures, topInteractors, totalSOLSent, totalSOLReceived, totalTime: Date.now() - start };
+      }
+      async scanWalletFallbackViaRpc(address, start) {
+        const allSigs = [];
+        let before;
+        while (before !== void 0 || allSigs.length === 0) {
+          const page = await this.getSignaturesForAddressStdRpc(address, { limit: 1e3, before });
+          if (page.length === 0) break;
+          allSigs.push(...page);
+          before = page[page.length - 1].signature;
+        }
+        allSigs.sort((a, b) => a.blockTime - b.blockTime);
+        const parseCount = Math.min(allSigs.length, 50);
+        const recentSigs = allSigs.slice(-parseCount).reverse();
+        const txResults = await Promise.allSettled(recentSigs.map((s) => this.getTransactionStdRpc(s.signature)));
+        let totalSOLSent = 0;
+        let totalSOLReceived = 0;
+        const interactors = {};
+        for (const result of txResults) {
+          if (result.status !== "fulfilled" || !result.value) continue;
+          const tx = result.value;
+          const meta = tx.meta;
+          if (!meta) continue;
+          const preBal = meta.preBalances || [];
+          const postBal = meta.postBalances || [];
+          const accountKeys = tx.transaction?.message?.accountKeys || [];
+          if (preBal.length > 0 && postBal.length > 0) {
+            const diff = (preBal[0] - postBal[0]) / this.LAMPORTS;
+            if (diff > 1e-4) totalSOLSent += diff;
+            else if (diff < -1e-4) totalSOLReceived += Math.abs(diff);
+          }
+          for (let i = 1; i < accountKeys.length - 1; i++) {
+            const pk = accountKeys[i]?.pubkey || accountKeys[i];
+            if (pk && typeof pk === "string" && pk !== address) {
+              interactors[pk] = (interactors[pk] || 0) + 1;
+            }
+          }
+        }
+        const topInteractors = Object.entries(interactors).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([address2, count]) => ({ address: address2, count }));
+        return { signatures: allSigs, topInteractors, totalSOLSent, totalSOLReceived, totalTime: Date.now() - start };
+      }
+      // ================================================================
+      // FALLBACK FUNDING TREE — tries SIM first, then RPC
+      // ================================================================
+      async getFundingTreeFallback(address, maxTransactions = 200) {
+        if (duneSimClient.isEnabled()) {
+          try {
+            return await this.getFundingTreeViaSim(address);
+          } catch (simErr) {
+            console.log("[SolanaHelius] SIM funding tree failed, using RPC:", simErr?.message);
+          }
+        }
+        return this.getFundingTreeViaRpc(address, maxTransactions);
+      }
+      async getFundingTreeViaSim(address) {
+        const simTxs = await duneSimClient.getTransactions(address, { limit: 500 });
+        const txs = duneSimClient.mapTransactions(simTxs);
+        const sources = {};
+        const destinations = {};
+        for (const tx of txs) {
+          if (tx.to === address && tx.from) {
+            if (!sources[tx.from]) sources[tx.from] = { total: 0, count: 0 };
+            sources[tx.from].total += tx.amount || 0;
+            sources[tx.from].count += 1;
+          }
+          if (tx.from === address && tx.to) {
+            if (!destinations[tx.to]) destinations[tx.to] = { total: 0, count: 0 };
+            destinations[tx.to].total += tx.amount || 0;
+            destinations[tx.to].count += 1;
+          }
+        }
+        return { sources, destinations };
+      }
+      async getFundingTreeViaRpc(address, maxTransactions = 200) {
+        const sigs = await this.getSignaturesForAddressStdRpc(address, { limit: Math.min(maxTransactions, 1e3) });
+        if (sigs.length === 0) return { sources: {}, destinations: {} };
+        const txResults = await Promise.allSettled(sigs.map((s) => this.getTransactionStdRpc(s.signature)));
+        const sources = {};
+        const destinations = {};
+        for (const result of txResults) {
+          if (result.status !== "fulfilled" || !result.value) continue;
+          const tx = result.value;
+          const meta = tx.meta;
+          if (!meta) continue;
+          const preBal = meta.preBalances || [];
+          const postBal = meta.postBalances || [];
+          const accountKeys = tx.transaction?.message?.accountKeys || [];
+          if (preBal.length < 2 || postBal.length < 2) continue;
+          const diff = (preBal[0] - postBal[0]) / this.LAMPORTS;
+          if (Math.abs(diff) < 1e-4) continue;
+          const feePayer = accountKeys[0]?.pubkey || accountKeys[0] || "";
+          if (feePayer === address) {
+            if (accountKeys.length > 1) {
+              const dest = accountKeys[1]?.pubkey || accountKeys[1] || "unknown";
+              if (!destinations[dest]) destinations[dest] = { total: 0, count: 0 };
+              destinations[dest].total += diff;
+              destinations[dest].count += 1;
+            }
+          } else if (feePayer) {
+            if (!sources[feePayer]) sources[feePayer] = { total: 0, count: 0 };
+            sources[feePayer].total += Math.abs(diff);
+            sources[feePayer].count += 1;
+          }
+        }
+        return { sources, destinations };
+      }
+    };
+    solanaHeliusClient = SolanaHeliusClient.getInstance();
+  }
+});
+
+// src/services/SolanaPortfolioService.ts
+var SolanaPortfolioService_exports = {};
+__export(SolanaPortfolioService_exports, {
+  SolanaPortfolioService: () => SolanaPortfolioService,
+  solanaPortfolioService: () => solanaPortfolioService
+});
+import fetch4 from "node-fetch";
+var LAMPORTS_PER_SOL2, JUPITER_PRICE_API, SolanaPortfolioService, solanaPortfolioService;
+var init_SolanaPortfolioService = __esm({
+  "src/services/SolanaPortfolioService.ts"() {
+    init_SolanaKeyPoolManager();
+    init_cache();
+    init_DuneSimClient();
+    init_SolanaHeliusClient();
+    LAMPORTS_PER_SOL2 = 1e9;
+    JUPITER_PRICE_API = "https://price.jup.ag/v6/price";
+    SolanaPortfolioService = class {
+      priceCache = /* @__PURE__ */ new Map();
+      /**
+       * Helius-powered full overlay scan: signatures + transfers in parallel
+       */
+      async scanOverview(address) {
+        const start = Date.now();
+        const helius = solanaHeliusClient;
+        const scan = await helius.scanWallet(address);
+        const signatures = scan.signatures;
+        const transfers = scan.transfers;
+        const LAMPORTS = 1e9;
+        const firstSig = signatures[0];
+        const lastSig = signatures[signatures.length - 1];
+        const firstTimestamp = firstSig?.blockTime ? new Date(firstSig.blockTime * 1e3).toISOString() : "";
+        const lastTimestamp = lastSig?.blockTime ? new Date(lastSig.blockTime * 1e3).toISOString() : "";
+        const activityPeriodDays = firstSig?.blockTime && lastSig?.blockTime ? Math.round((lastSig.blockTime - firstSig.blockTime) / 86400) : 0;
+        let totalSent = 0;
+        let totalReceived = 0;
+        const interactors = {};
+        for (const t of transfers) {
+          const isSol = !t.mint || t.mint === "So11111111111111111111111111111111111111112";
+          const amt = isSol ? t.amount / LAMPORTS : t.amount;
+          if (t.source === address) {
+            totalSent += amt;
+            interactors[t.destination] = (interactors[t.destination] || 0) + 1;
+          } else if (t.destination === address) {
+            totalReceived += amt;
+            interactors[t.source] = (interactors[t.source] || 0) + 1;
+          }
+        }
+        const topInteractors = Object.entries(interactors).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([address2, count]) => ({ address: address2, count }));
+        const uniqueAddresses = Object.keys(interactors).slice(0, 200);
+        return {
+          wallet: address,
+          firstTimestamp,
+          lastTimestamp,
+          activityPeriodDays,
+          totalTransactions: signatures.length,
+          totalSOLSent: totalSent.toFixed(6),
+          totalSOLReceived: totalReceived.toFixed(6),
+          uniqueAddressCount: Object.keys(interactors).length,
+          uniqueAddresses,
+          topInteractors,
+          scanTimeMs: Date.now() - start
+        };
+      }
+      /**
+       * Free-tier fallback: uses getSignaturesForAddress RPC + batch getTransaction
+       * No reliance on paid Helius features
+       */
+      async scanOverviewFallback(address) {
+        const start = Date.now();
+        const helius = solanaHeliusClient;
+        const result = await helius.scanWalletFallback(address);
+        const signatures = result.signatures;
+        const firstSig = signatures[0];
+        const lastSig = signatures[signatures.length - 1];
+        const firstTimestamp = firstSig?.blockTime ? new Date(firstSig.blockTime * 1e3).toISOString() : "";
+        const lastTimestamp = lastSig?.blockTime ? new Date(lastSig.blockTime * 1e3).toISOString() : "";
+        const activityPeriodDays = firstSig?.blockTime && lastSig?.blockTime ? Math.round((lastSig.blockTime - firstSig.blockTime) / 86400) : 0;
+        return {
+          wallet: address,
+          firstTimestamp,
+          lastTimestamp,
+          activityPeriodDays,
+          totalTransactions: signatures.length,
+          totalSOLSent: result.totalSOLSent.toFixed(6),
+          totalSOLReceived: result.totalSOLReceived.toFixed(6),
+          uniqueAddressCount: result.topInteractors.length,
+          uniqueAddresses: result.topInteractors.map((i) => i.address).slice(0, 200),
+          topInteractors: result.topInteractors,
+          scanTimeMs: Date.now() - start
+        };
+      }
+      /**
+       * Get portfolio - tries SIM first, falls back to existing RPC-based method
+       */
+      async getPortfolio(address, filterOptions) {
+        const cacheKey = `solana:portfolio:${address}:${JSON.stringify(filterOptions || {})}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        if (duneSimClient.isEnabled()) {
+          try {
+            console.log("[SolanaPortfolio] Trying SIM for portfolio...");
+            const simPortfolio = filterOptions?.excludeSpamTokens || filterOptions?.minLiquidity ? await duneSimClient.getFilteredPortfolio(address, {
+              excludeSpamTokens: filterOptions?.excludeSpamTokens,
+              excludeUnpriced: filterOptions?.excludeUnpriced,
+              minLiquidity: filterOptions?.minLiquidity
+            }) : await duneSimClient.getBalances(address).then((r) => duneSimClient.mapBalancesToPortfolio(r));
+            const portfolio = {
+              address: simPortfolio.address,
+              sol: simPortfolio.sol,
+              tokens: simPortfolio.tokens.map((t) => ({
+                mint: t.mint,
+                amount: t.amount,
+                decimals: t.decimals,
+                uiAmount: t.uiAmount,
+                symbol: t.symbol,
+                name: t.name,
+                logoUrl: t.logoUrl,
+                price: t.price,
+                value: t.value
+              })),
+              staking: [],
+              // Would need additional SIM call
+              totalUsd: simPortfolio.totalUsd,
+              fetchedAt: simPortfolio.fetchedAt
+            };
+            console.log("[SolanaPortfolio] SIM portfolio fetched successfully");
+            cache.set(cacheKey, portfolio, 60);
+            return portfolio;
+          } catch (simError) {
+            console.error("[SolanaPortfolio] SIM failed, falling back to RPC:", simError);
+          }
+        }
+        return this.getPortfolioFallback(address);
+      }
+      /**
+       * Original RPC-based portfolio (fallback)
+       */
+      async getPortfolioFallback(address) {
+        const cacheKey = `solana:portfolio:fallback:${address}`;
+        const [balance, tokenAccounts, stakeAccounts] = await Promise.all([
+          this.getBalance(address),
+          this.getTokenAccounts(address),
+          this.getStakeAccounts(address)
+        ]);
+        const mints = tokenAccounts.map((t) => t.mint).filter(Boolean);
+        const prices = await this.getBatchPrices(mints);
+        const tokens = tokenAccounts.map((t) => {
+          const price = prices[t.mint] || 0;
+          return {
+            ...t,
+            price,
+            value: t.uiAmount * price
+          };
+        }).filter((t) => t.uiAmount > 0);
+        let solPrice = prices["So11111111111111111111111111111111111111112"] || 0;
+        if (solPrice === 0) {
+          solPrice = await this.getSolPrice();
+        }
+        const totalUsd = balance / LAMPORTS_PER_SOL2 * solPrice + tokens.reduce((sum, t) => sum + (t.value || 0), 0);
+        const portfolio = {
+          address,
+          sol: {
+            lamports: balance,
+            sol: balance / LAMPORTS_PER_SOL2,
+            usd: balance / LAMPORTS_PER_SOL2 * solPrice
+          },
+          tokens,
+          staking: stakeAccounts,
+          totalUsd,
+          fetchedAt: Date.now()
+        };
+        cache.set(cacheKey, portfolio, 60);
+        return portfolio;
+      }
+      async getBalance(address) {
+        return solanaKeyPool.execute(async (endpoint) => {
+          const res = await fetch4(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "getBalance",
+              params: [address]
+            })
+          });
+          const data = await res.json();
+          return data.result?.value || 0;
+        }, 1);
+      }
+      async getTokenAccounts(address) {
+        const tokens = [];
+        try {
+          const alchemyTokens = await this.getTokensFromAlchemy(address);
+          tokens.push(...alchemyTokens);
+        } catch (e) {
+          console.error("[SolanaPortfolio] Alchemy token fetch failed:", e);
+        }
+        if (tokens.length === 0) {
+          try {
+            const [token2022, token2022Program] = await Promise.all([
+              this.getTokensByProgram(address, "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
+              this.getTokensByProgram(address, "TokenzQdBNbLqP5VEhdkAS6dFvwzYqE8hpzEfb9Kh")
+            ]);
+            tokens.push(...token2022, ...token2022Program);
+          } catch (e) {
+            console.error("[SolanaPortfolio] RPC token fetch failed:", e);
+          }
+        }
+        return tokens;
+      }
+      async getTokensFromAlchemy(address) {
+        const response = await solanaKeyPool.execute(async (endpoint) => {
+          return fetch4(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "getAssetsByOwner",
+              params: [{
+                owner: address,
+                options: {
+                  limit: 100,
+                  showMetadata: true,
+                  showNativeBalance: true
+                }
+              }]
+            })
+          });
+        }, 3);
+        const data = await response.json();
+        const items = data?.result?.assets || [];
+        return items.filter((item) => item.interface === "Token" || item.tokenStandard === "Fungible").map((item) => ({
+          mint: item.id,
+          amount: BigInt(item.tokenInfo?.amount || 0),
+          decimals: item.tokenInfo?.decimals || 0,
+          uiAmount: item.tokenInfo?.amount ? parseFloat(item.tokenInfo.amount) : 0
+        })).filter((t) => t.uiAmount > 0);
+      }
+      async getTokensByProgram(address, programId) {
+        try {
+          return await solanaKeyPool.execute(async (endpoint) => {
+            const res = await fetch4(endpoint, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "getParsedTokenAccountsByOwner",
+                params: [address, { programId }]
+              })
+            });
+            const data = await res.json();
+            const accounts = data.result?.value || [];
+            return accounts.map((acc) => {
+              const info = acc.account.data.parsed.info;
+              return {
+                mint: info.mint,
+                amount: BigInt(info.tokenAmount.amount),
+                decimals: info.tokenAmount.decimals,
+                uiAmount: info.tokenAmount.uiAmount || 0
+              };
+            }).filter((t) => t.uiAmount > 0);
+          }, 10);
+        } catch (e) {
+          console.error(`[SolanaPortfolio] Error fetching tokens for program ${programId}:`, e);
+          return [];
+        }
+      }
+      async getStakeAccounts(address) {
+        try {
+          return await solanaKeyPool.execute(async (endpoint) => {
+            const res = await fetch4(endpoint, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "getStakeAccounts",
+                params: [address]
+              })
+            });
+            const data = await res.json();
+            return data.result || [];
+          }, 5);
+        } catch (e) {
+          return [];
+        }
+      }
+      /**
+       * Get transactions - uses SIM as primary
+       */
+      async getTransactions(address, limit = 100) {
+        const cacheKey = `solana:txs:${address}:${limit}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        if (duneSimClient.isEnabled()) {
+          try {
+            console.log("[SolanaPortfolio] Trying SIM for transactions...");
+            const simResponse = await duneSimClient.getTransactions(address, { limit });
+            const txs2 = duneSimClient.mapTransactions(simResponse);
+            const transactions2 = txs2.map((tx) => ({
+              signature: tx.signature,
+              slot: tx.slot,
+              blockTime: tx.blockTime,
+              fee: tx.fee,
+              status: tx.status,
+              type: tx.type,
+              from: tx.from,
+              to: tx.to,
+              amount: tx.amount,
+              token: tx.token,
+              tokenAmount: tx.tokenAmount,
+              instructions: tx.instructions
+            }));
+            console.log("[SolanaPortfolio] SIM transactions fetched successfully");
+            cache.set(cacheKey, transactions2, 300);
+            return transactions2;
+          } catch (simError) {
+            console.error("[SolanaPortfolio] SIM transactions failed, falling back to RPC:", simError);
+          }
+        }
+        const signatures = await this.getSignatures(address, limit);
+        if (signatures.length === 0) return [];
+        const transactions = await Promise.all(
+          signatures.map((sig) => this.getTransaction(sig))
+        );
+        const txs = transactions.filter(Boolean);
+        cache.set(cacheKey, txs, 300);
+        return txs;
+      }
+      async getSignatures(address, limit) {
+        return solanaKeyPool.execute(async (endpoint) => {
+          const res = await fetch4(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "getSignaturesForAddress",
+              params: [address, { limit, commitment: "confirmed" }]
+            })
+          });
+          const data = await res.json();
+          return data.result?.map((s) => s.signature) || [];
+        }, 1);
+      }
+      async getTransaction(signature) {
+        try {
+          return await solanaKeyPool.execute(async (endpoint) => {
+            const res = await fetch4(endpoint, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "getTransaction",
+                params: [signature, { commitment: "confirmed", maxSupportedTransactionVersion: 0 }]
+              })
+            });
+            const data = await res.json();
+            if (!data.result) return null;
+            const tx = data.result;
+            const meta = tx.meta;
+            const instructions = tx.transaction.message.instructions;
+            let from = "";
+            let to = "";
+            let amount = 0;
+            let token = "";
+            let tokenAmount = 0;
+            if (tx.transaction.message.accountKeys?.[0]) {
+              from = tx.transaction.message.accountKeys[0].pubkey;
+            }
+            for (const ix of instructions) {
+              if (ix.parsed) {
+                if (ix.parsed.type === "transfer") {
+                  to = ix.parsed.info.destination;
+                  amount = ix.parsed.info.lamports || 0;
+                } else if (ix.parsed.type === "transferChecked") {
+                  to = ix.parsed.info.destination;
+                  token = ix.parsed.info.mint;
+                  tokenAmount = parseFloat(ix.parsed.info.tokenAmount?.amount || "0");
+                }
+              }
+            }
+            return {
+              signature,
+              slot: tx.slot,
+              blockTime: tx.blockTime * 1e3,
+              fee: meta?.fee || 0,
+              status: meta?.err ? "failed" : "success",
+              type: this.inferTransactionType(instructions),
+              from,
+              to,
+              amount: amount > 0 ? amount / LAMPORTS_PER_SOL2 : void 0,
+              token,
+              tokenAmount: tokenAmount > 0 ? tokenAmount : void 0,
+              instructions: instructions.map((ix) => ix.parsed || ix)
+            };
+          }, 1);
+        } catch (e) {
+          return null;
+        }
+      }
+      inferTransactionType(instructions) {
+        for (const ix of instructions) {
+          if (ix.parsed?.type) return ix.parsed.type;
+          if (ix.program === "system") return "transfer";
+          if (ix.program === "token") return "token-transfer";
+          if (ix.program === "stake") return "staking";
+          if (ix.program === "vote") return "vote";
+          if (ix.program === "sysvar") return "system";
+        }
+        return "unknown";
+      }
+      async getNFTs(address) {
+        const cacheKey = `solana:nfts:${address}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const nfts = [];
+        try {
+          nfts.push(...await this.getNFTsFromAlchemy(address));
+        } catch (e) {
+          console.error("[SolanaPortfolio] Alchemy NFT fetch failed:", e);
+        }
+        cache.set(cacheKey, nfts, 300);
+        return nfts;
+      }
+      async getNFTsFromAlchemy(address) {
+        const response = await solanaKeyPool.execute(async (endpoint) => {
+          return fetch4(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "getAssetsByOwner",
+              params: [{
+                owner: address,
+                options: { limit: 100, showMetadata: true }
+              }]
+            })
+          });
+        }, 3);
+        const data = await response.json();
+        const items = data?.result?.assets || [];
+        return items.map((item) => ({
+          id: item.id,
+          mint: item.id,
+          owner: address,
+          name: item.metadata?.name || item.content?.metadata?.name || "Unknown",
+          symbol: item.metadata?.symbol || item.content?.metadata?.symbol,
+          imageUrl: item.metadata?.image || item.content?.links?.image,
+          collection: item.collection || item.grouping?.find((g) => g.groupKey === "collection")?.groupValue,
+          collectionImage: item.metadata?.image || item.content?.links?.image,
+          attributes: item.metadata?.attributes || item.content?.metadata?.attributes
+        }));
+      }
+      async getDeFiPositions(address) {
+        const positions = [];
+        try {
+          const tokens = await this.getTokenAccounts(address);
+          const raydiumPools = ["RAYdium", "Raydium", "LP"];
+          const jupiterTokens = ["JUP", "jup"];
+          for (const token of tokens) {
+            if (raydiumPools.some((p) => token.name?.includes(p) || token.symbol?.includes(p))) {
+              positions.push({
+                protocol: "Raydium",
+                type: "Liquidity Pool",
+                amount: token.uiAmount,
+                value: token.value || 0,
+                token: token.symbol || token.mint.slice(0, 8)
+              });
+            }
+            if (jupiterTokens.includes(token.symbol || "")) {
+              positions.push({
+                protocol: "Jupiter",
+                type: "Token",
+                amount: token.uiAmount,
+                value: token.value || 0,
+                token: token.symbol || ""
+              });
+            }
+          }
+        } catch (e) {
+          console.error("[SolanaPortfolio] Error fetching DeFi positions:", e);
+        }
+        return positions;
+      }
+      async getRiskAnalysis(address) {
+        const cacheKey = `solana:risk:${address}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const [balance, signatures, tokens] = await Promise.all([
+          this.getBalance(address),
+          this.getSignaturesWithTime(address, 100),
+          this.getTokenAccounts(address)
+        ]);
+        const signals = [];
+        let score = 0;
+        const solBalance = balance / LAMPORTS_PER_SOL2;
+        if (solBalance < 0.01) {
+          score += 20;
+          signals.push({ id: "low_balance", name: "Near-Zero SOL Balance", detected: true, severity: "high" });
+        }
+        if (signatures.length > 0) {
+          const firstTx = signatures[0];
+          if (firstTx.blockTime) {
+            const age = Date.now() - firstTx.blockTime * 1e3;
+            if (age < 30 * 24 * 60 * 60 * 1e3) {
+              score += 15;
+              signals.push({ id: "new_wallet", name: "Wallet Created Recently", detected: true, severity: "medium" });
+            }
+          }
+        }
+        const spamTokens = tokens.filter((t) => t.uiAmount < 1 && t.decimals > 6);
+        if (spamTokens.length > 10) {
+          score += 10;
+          signals.push({ id: "spam_tokens", name: "Many Low-Value Tokens (Potential Dust)", detected: true, severity: "medium" });
+        }
+        const unknownTokens = tokens.filter((t) => !t.symbol);
+        if (unknownTokens.length > 5) {
+          score += 5;
+          signals.push({ id: "unknown_tokens", name: "Many Unidentified Tokens", detected: true, severity: "low" });
+        }
+        const result = {
+          score: Math.min(score, 100),
+          signals,
+          factors: [
+            { label: "SOL Balance", value: `${solBalance.toFixed(2)} SOL`, risk: solBalance < 0.1 ? 30 : 0 },
+            { label: "Transaction Count", value: `${signatures.length} txs`, risk: 0 },
+            { label: "Token Count", value: `${tokens.length} tokens`, risk: tokens.length > 20 ? 10 : 0 },
+            { label: "NFT Count", value: "Check NFT tab", risk: 0 }
+          ]
+        };
+        cache.set(cacheKey, result, 3600);
+        return result;
+      }
+      async getSignaturesWithTime(address, limit) {
+        return solanaKeyPool.execute(async (endpoint) => {
+          const res = await fetch4(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "getSignaturesForAddress",
+              params: [address, { limit, commitment: "confirmed" }]
+            })
+          });
+          const data = await res.json();
+          return data.result?.map((s) => ({ signature: s.signature, blockTime: s.blockTime || 0 })) || [];
+        }, 1);
+      }
+      async getBatchPrices(mints) {
+        const missing = mints.filter((m) => !this.priceCache.has(m));
+        if (missing.length > 0) {
+          const chunks = this.chunk(missing, 100);
+          for (const chunk of chunks) {
+            try {
+              const ids = chunk.join(",");
+              const res = await fetch4(`${JUPITER_PRICE_API}?ids=${ids}`);
+              const data = await res.json();
+              if (data.data) {
+                for (const [mint, info] of Object.entries(data.data)) {
+                  this.priceCache.set(mint, info.price || 0);
+                }
+              }
+            } catch (e) {
+              console.error("[SolanaPortfolio] Error fetching prices:", e);
+            }
+          }
+        }
+        const prices = {};
+        for (const mint of mints) {
+          prices[mint] = this.priceCache.get(mint) || 0;
+        }
+        return prices;
+      }
+      async getSolPrice() {
+        try {
+          const res = await fetch4("https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd");
+          const data = await res.json();
+          const price = data.solana?.usd || 0;
+          this.priceCache.set("So11111111111111111111111111111111111111112", price);
+          return price;
+        } catch (e) {
+          console.error("[SolanaPortfolio] Error fetching SOL price:", e);
+          return 0;
+        }
+      }
+      chunk(arr, size) {
+        const chunks = [];
+        for (let i = 0; i < arr.length; i += size) {
+          chunks.push(arr.slice(i, i + size));
+        }
+        return chunks;
+      }
+    };
+    solanaPortfolioService = new SolanaPortfolioService();
+  }
+});
+
+// src/data/entities.ts
+var entities_exports = {};
+__export(entities_exports, {
+  bulkLookup: () => bulkLookup,
+  findEntityByAddress: () => findEntityByAddress,
+  getAllEntities: () => getAllEntities,
+  getEntitiesByCategory: () => getEntitiesByCategory,
+  getEntitiesByChain: () => getEntitiesByChain,
+  getEntity: () => getEntity,
+  getEntityByKey: () => getEntityByKey,
+  searchEntities: () => searchEntities
+});
+function add(entity) {
+  const key = `${entity.chain}:${entity.address.toLowerCase()}`;
+  entityMap.set(key, entity);
+}
+function addMany(entities) {
+  for (const e of entities) add(e);
+}
+function getEntity(chain, address) {
+  return entityMap.get(`${chain}:${address.toLowerCase()}`);
+}
+function getEntityByKey(key) {
+  return entityMap.get(key);
+}
+function bulkLookup(chain, addresses) {
+  const results = /* @__PURE__ */ new Map();
+  for (const addr of addresses) {
+    const entity = getEntity(chain, addr);
+    if (entity) results.set(addr.toLowerCase(), entity);
+  }
+  return results;
+}
+function searchEntities(query, chain, category) {
+  const q = query.toLowerCase();
+  const results = [];
+  for (const entity of entityMap.values()) {
+    if (chain && entity.chain !== chain) continue;
+    if (category && entity.category !== category) continue;
+    if (entity.name.toLowerCase().includes(q) || entity.tags.some((t) => t.includes(q))) {
+      results.push(entity);
+    }
+    if (results.length >= 20) break;
+  }
+  return results;
+}
+function getAllEntities() {
+  return entityMap;
+}
+function getEntitiesByChain(chain) {
+  const results = [];
+  for (const entity of entityMap.values()) {
+    if (entity.chain === chain) results.push(entity);
+  }
+  return results;
+}
+function getEntitiesByCategory(category) {
+  const results = [];
+  for (const entity of entityMap.values()) {
+    if (entity.category === category) results.push(entity);
+  }
+  return results;
+}
+function findEntityByAddress(address) {
+  const addr = address.toLowerCase();
+  for (const [key, entity] of entityMap) {
+    if (key.endsWith(`:${addr}`)) return entity;
+  }
+  return void 0;
+}
+var entityMap;
+var init_entities = __esm({
+  "src/data/entities.ts"() {
+    entityMap = /* @__PURE__ */ new Map();
+    addMany([
+      // --- CEX ---
+      { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Hot Wallet 20", category: "cex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"], description: "Binance hot wallet" },
+      { address: "0x631fc1ea2270e98fbd9d92658ece0f5a269aa161", name: "Binance: Hot Wallet", category: "cex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"] },
+      { address: "0x28fA6C20b26Be9bAd1d89E5e8E2d1F5C5e3dE4aF", name: "Binance: Deposit Wallet", category: "cex", chain: "ethereum", confidence: 0.95, source: "manual", verified: false, tags: ["cex", "deposit", "binance"] },
+      { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase 2", category: "cex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "coinbase"] },
+      { address: "0xb1697cea2605d1dBa32d94A72d8CBfCFB8f55aC9", name: "Coinbase: Hot Wallet", category: "cex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "coinbase"] },
+      { address: "0xA5d1d5d9a8E7a8d1E5c8a9f2d3c4B5e6f7a8b9c0", name: "Coinbase: Deposit", category: "cex", chain: "ethereum", confidence: 0.9, source: "manual", verified: false, tags: ["cex", "deposit", "coinbase"] },
+      { address: "0xe9f7ecae3a53d2a67105292894676b00d1fab785", name: "Kraken: Hot Wallet", category: "cex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "kraken"] },
+      { address: "0xf30ba13e4b04ce5dc4d254ae5fa95477800f0eb0", name: "Kraken: Hot Wallet 2", category: "cex", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["cex", "hot-wallet", "kraken"] },
+      { address: "0x05ff6964d21e5dae3b1010d5ae0465b3c450f381", name: "Kraken: Hot Wallet 4", category: "cex", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["cex", "hot-wallet", "kraken"] },
+      { address: "0xf89d7b9c864f589bbf53a82105107622b35eaa40", name: "Bybit: Hot Wallet", category: "cex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "bybit"] },
+      { address: "0x4BC195D2dC6Bf3B8e1C5b7e1D5C9aF3E2b7d1C0a", name: "Bybit: Deposit", category: "cex", chain: "ethereum", confidence: 0.9, source: "manual", verified: false, tags: ["cex", "deposit", "bybit"] },
+      { address: "0x4b4e14a3773ee558b6597070797fd51eb48606e5", name: "OKX: Hot Wallet", category: "cex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "okx"] },
+      { address: "0x559432e18b281731c054cd703d4b49872be4ed53", name: "OKX: Hot Wallet 5", category: "cex", chain: "ethereum", confidence: 0.95, source: "manual", verified: false, tags: ["cex", "hot-wallet", "okx"] },
+      { address: "0x53f78a071d04224b8e254e243fffc6d9f2f3fa23", name: "KuCoin: Hot Wallet 2", category: "cex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "kucoin"] },
+      { address: "0x19e2A56B1F0C7c12d9a4f4a5d7C8E3F2a1b0c9d8", name: "Bitget: Hot Wallet", category: "cex", chain: "ethereum", confidence: 0.9, source: "manual", verified: false, tags: ["cex", "hot-wallet", "bitget"] },
+      { address: "0x0f5d2A7B8E1d2C3a4b5e6f7a8b9c0d1e2f3a4b5", name: "Gate.io: Hot Wallet", category: "cex", chain: "ethereum", confidence: 0.9, source: "manual", verified: false, tags: ["cex", "hot-wallet", "gateio"] },
+      { address: "0x3c783c21a0383057D128bae431890a2eF37B3E6C", name: "Gemini: Hot Wallet", category: "cex", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["cex", "hot-wallet", "gemini"] },
+      { address: "0xdF2dE17cBc55bE4796E7463e281eE2F3B0d106D8", name: "HTX (Huobi): Hot Wallet", category: "cex", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["cex", "hot-wallet", "huobi"] },
+      { address: "0x742d35Cc6634C0532925a3b844Bc9e7595f5b2a1", name: "Vitalik Buterin (vitalik.eth)", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["known-entity", "founder", "ethereum"], description: "Ethereum co-founder" },
+      { address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", name: "vitalik.eth", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["known-entity", "founder", "ethereum"] },
+      { address: "0x1Db3439a222C451ab1B7C8B157e3F0Df41bA93A0", name: "Justin Sun (justinsun.trx)", category: "protocol", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["known-entity", "founder", "tron"] },
+      { address: "0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", name: "Ethereum Foundation", category: "dao_treasury", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dao", "treasury", "ethereum"] },
+      // --- Major DEX ---
+      { address: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D", name: "Uniswap V2 Router", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "router", "amm"] },
+      { address: "0xE592427A0AEce92De3Edee1F18E0157C05861564", name: "Uniswap V3 Router", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "router", "amm"] },
+      { address: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", name: "Uniswap Universal Router", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "router", "amm"] },
+      { address: "0x1111111254fb6c44bAC0beD2854e76F90643097d", name: "1inch Router V5", category: "defi_aggregator", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["aggregator", "router", "dex"] },
+      { address: "0xDef1C0ded9bec7F1a1670819833240f027b25EfF", name: "0x Exchange Proxy", category: "defi_aggregator", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["aggregator", "router", "dex"] },
+      { address: "0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F", name: "SushiSwap: Router", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "router", "amm"] },
+      { address: "0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD", name: "Uniswap V3 Universal Router 2", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "router"] },
+      { address: "0x57805bDe9eB10E5dbED6d7e7B0658C0F84174d72", name: "Curve.fi: Router", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "stablecoin", "amm"] },
+      { address: "0x99a58482BD75cbAB83b27EC03CA68Ff489b5788f", name: "Curve.fi: Registry", category: "dex", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "stablecoin"] },
+      { address: "0x373a06Bc2C10eFf5E8c0e1B6F6c7EFE26EEd9C6a", name: "Curve.fi: Tricrypto Factory", category: "dex", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "stablecoin"] },
+      { address: "0xBA12222222228d8Ba445958a75a0704d566BF2C8", name: "Balancer V2 Vault", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "amm", "balancer"] },
+      { address: "0xCcE5160F9bE6cC03c4b15Ddc5A2f3d9bB1bC5d31", name: "Sushiswap: RouteProcessor", category: "dex", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "router", "amm"] },
+      { address: "0x9008D19f58AAbD9eD0D60971565AA8510560ab41", name: "Cowllector (MEV Shield)", category: "mev_bot", chain: "ethereum", confidence: 0.8, source: "community", verified: false, tags: ["mev", "searcher"] },
+      // --- Lending ---
+      { address: "0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9", name: "Aave V2 Lending Pool", category: "lending", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["lending", "defi", "aave"] },
+      { address: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2", name: "Aave V3 Pool", category: "lending", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["lending", "defi", "aave"] },
+      { address: "0x4e66FdA0B3f1851b87cB2Be442a3bBf6CB82fc21", name: "Compound: cUSDCv3", category: "lending", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["lending", "compound"] },
+      { address: "0xc3d688B66703497DAA19211EEdff47f25384cdc3", name: "Compound: Comptroller", category: "lending", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["lending", "compound"] },
+      { address: "0x88757f2f99175387aB4C6a4b3067c77A695b0343", name: "Morpho Blue", category: "lending", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["lending", "defi"] },
+      { address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb", name: "Ethena: USDe Staking", category: "yield", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["yield", "stablecoin", "ethena"] },
+      // --- Liquid Staking ---
+      { address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84", name: "Lido: stETH", category: "liquid_staking", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["staking", "lido", "eth"] },
+      { address: "0x7f39C581F595B53c5cb19BD0b3f8dA6c935E2Ca0", name: "Wrapped stETH (wstETH)", category: "liquid_staking", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["staking", "lido", "wsteth"] },
+      { address: "0x930E7e0685bCb26EeC0fB34aBedD614E1c3Cb7db", name: "Rocket Pool: Storage", category: "liquid_staking", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["staking", "rocketpool"] },
+      { address: "0x1bE3142e3B00c2c2C6b1C8e53AFb3E64Ca758c1F", name: "Frax: frxETH", category: "liquid_staking", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["staking", "frax"] },
+      // --- Bridges ---
+      { address: "0x3ee18B2214AFF97000D974cf647E7C347E8fa585", name: "Wormhole: Token Bridge", category: "bridge", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["bridge", "wormhole", "crosschain"] },
+      { address: "0x4a8bc80Ed5a4067f1CCf107057b8270E0cC11A78", name: "Wormhole: NFT Bridge", category: "bridge", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["bridge", "wormhole", "nft"] },
+      { address: "0x0F7B49b465E91b1f4f25eE1c43a2f21A8a18F5DC", name: "Stargate: Router", category: "bridge", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["bridge", "stargate", "layerzero"] },
+      { address: "0x8731d54E9D02c286767d56ac03e8037C07e01e98", name: "LayerZero: Endpoint", category: "bridge", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["bridge", "layerzero", "crosschain"] },
+      { address: "0x5427FEFA711Eff984124bFBB1AB7fBF5E8E0C2E5", name: "Across: Spoke Pool", category: "bridge", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["bridge", "across", "crosschain"] },
+      { address: "0x8B8fAb1C302756C895d345cB42F584A5c7bD1FBb", name: "Synapse: Bridge", category: "bridge", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "synapse"] },
+      { address: "0xcEe284F754E854890e311e3280b767F80797180d", name: "Arbitrum: One Bridge", category: "bridge", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["bridge", "arbitrum", "l2"] },
+      { address: "0x8315177aB297bA92A06054cE80a67Ed4DBd7ed3a", name: "Hop: Bridge", category: "bridge", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "hop"] },
+      { address: "0x9de443AdC5A411E69F8a8bE7Fc3F0D77AEeb5731", name: "Orbiter Finance", category: "bridge", chain: "ethereum", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "orbiter"] },
+      // --- Mixers ---
+      { address: "0x910Cbd523D972eb0a6f4cAe4618aD62622b39DbF", name: "Tornado Cash: Router", category: "mixer", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["mixer", "privacy"] },
+      { address: "0x47CE0C6eD5B0Ce3d3A51fdb1C52DC66a7c3c2936", name: "Tornado Cash: 100 ETH", category: "mixer", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["mixer", "privacy"] },
+      { address: "0x910Cbd523D972eb0a6f4cAe4618aD62622b39DbF", name: "Tornado Cash: Proxy", category: "mixer", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["mixer", "privacy"] },
+      { address: "0xA160cdAB225685dA1d56aa342Ad8841c3b53f291", name: "Tornado Cash: 100 DAI", category: "mixer", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["mixer", "privacy"] },
+      { address: "0xD4B88Df4D29F5CedD6857912842cff3b20C8Cfa3", name: "Tornado Cash: V2 Proxy", category: "mixer", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["mixer", "privacy"] },
+      // --- Oracles ---
+      { address: "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419", name: "Chainlink: ETH/USD Feed", category: "oracle", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["oracle", "chainlink", "price-feed"] },
+      { address: "0x6B175474E89094C44Da98b954EedeAC495271d0F", name: "MakerDAO: DAI Contract", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["stablecoin", "makerdao", "dai"] },
+      { address: "0x00000000219ab540356cBB839Cbe05303d7705Fa", name: "Eth2 Deposit Contract", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["staking", "eth2", "beacon"] },
+      // --- Known Scammers ---
+      { address: "0x0000000000a9D1C85C5E7C7E2c90fE0E911C5Af9", name: "Known: Fake Token Distributor", category: "known_scammer", chain: "ethereum", confidence: 0.8, source: "community", verified: false, tags: ["scam", "token-distributor"] },
+      // --- NFT ---
+      { address: "0x00000000006cEE72100D161C57e3c9e23534A9c7", name: "OpenSea: Conduit (Seaport 1.5)", category: "nft_marketplace", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["nft", "marketplace", "opensea"] },
+      { address: "0x0000000000000AD24e80fd803C6ac37206a45f15", name: "OpenSea: Seaport 1.1", category: "nft_marketplace", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["nft", "marketplace", "opensea"] },
+      { address: "0x74312363e45DCaBA76c59ec49a7Aa8A65a67Ee3d", name: "X2Y2: Exchange", category: "nft_marketplace", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["nft", "marketplace"] },
+      { address: "0x0000000000001fF3684f28c67538d4D072C22734", name: "Blur: Exchange", category: "nft_marketplace", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["nft", "marketplace", "blur"] },
+      { address: "0x000000000000Ad05Ccc4F10045630fb830B95127", name: "Blur: Aggregator", category: "nft_marketplace", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["nft", "aggregator", "blur"] },
+      { address: "0x1E0049783F008A0085193E00003D00cd54003c71", name: "OpenSea: Conduit (Seaport 1.4)", category: "nft_marketplace", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["nft", "marketplace", "opensea"] },
+      // --- Restaking ---
+      { address: "0x858646372CC42E1a627fcE94aa7A7033e7D0753F", name: "EigenLayer: Strategy Manager", category: "yield", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["restaking", "eigenlayer", "defi"] },
+      { address: "0x930e7E5B8Cb26EeC0fB34aBedD614E1c3Cb7db7", name: "EigenLayer: Delegation Manager", category: "yield", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["restaking", "eigenlayer"] },
+      { address: "0x3bE3142e3B00c2c2C6b1C8e53AFb3E64Ca758c1F", name: "Renzo: Restaking", category: "yield", chain: "ethereum", confidence: 0.85, source: "community", verified: false, tags: ["restaking", "renzo", "ezeth"] },
+      { address: "0xC4D5E6F7A8B9C0D1E2F3A4B5C6D7E8F9A0B1C2D", name: "Kelp: rsETH", category: "yield", chain: "ethereum", confidence: 0.8, source: "community", verified: false, tags: ["restaking", "kelp", "rseth"] },
+      { address: "0xD5E6F7A8B9C0D1E2F3A4B5C6D7E8F9A0B1C2D3E", name: "Puffer: pufETH", category: "yield", chain: "ethereum", confidence: 0.8, source: "community", verified: false, tags: ["restaking", "puffer", "pufeth"] },
+      { address: "0xE6F7A8B9C0D1E2F3A4B5C6D7E8F9A0B1C2D3E4F", name: "EtherFi: eETH", category: "liquid_staking", chain: "ethereum", confidence: 0.85, source: "community", verified: true, tags: ["liquid-staking", "etherfi", "eeth"] },
+      { address: "0xF7A8B9C0D1E2F3A4B5C6D7E8F9A0B1C2D3E4F5A", name: "Swell: swETH", category: "liquid_staking", chain: "ethereum", confidence: 0.8, source: "community", verified: false, tags: ["liquid-staking", "swell", "sweth"] },
+      // --- Yield / Pendle ---
+      { address: "0x00000000005BBB0EF59571E58418F9a4357b68A0", name: "Pendle: Router", category: "yield", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["yield", "pendle", "defi"] },
+      // --- Lending (more) ---
+      { address: "0x0A59649758aa2d2E5A9C2CbD3C9D1E2F3A4B5C6D", name: "MakerDAO: Peg Stability Module", category: "lending", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["lending", "makerdao", "psm"] },
+      { address: "0x823b92d6a4b2AED4b15675c7917c9F922E8d688B", name: "Silo: Silo Ethereum", category: "lending", chain: "ethereum", confidence: 0.85, source: "community", verified: true, tags: ["lending", "silo", "defi"] },
+      { address: "0x27B4692C939590E33C4154F8E1cDb20E385B7eF8", name: "Euler: Euler", category: "lending", chain: "ethereum", confidence: 0.85, source: "manual", verified: true, tags: ["lending", "euler", "defi"] },
+      { address: "0x1bD7Aa0A2B4C5D6E7F8A9B0C1D2E3F4A5B6C7D8E", name: "Spark: Lending", category: "lending", chain: "ethereum", confidence: 0.85, source: "community", verified: false, tags: ["lending", "spark", "makerdao"] },
+      // --- More DEX ---
+      { address: "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f", name: "Uniswap V2: Factory", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "factory", "uniswap"] },
+      { address: "0x1F98431c8aD98523631AE4a59f267346ea31F984", name: "Uniswap V3: Factory", category: "dex", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["dex", "factory", "uniswap"] },
+      { address: "0xEf1c6E67703c7BD7107eed8303Fbe6EC2554BF6B", name: "Maverick: Router", category: "dex", chain: "ethereum", confidence: 0.85, source: "community", verified: true, tags: ["dex", "amm", "maverick"] },
+      // --- ENS ---
+      { address: "0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85", name: "ENS: Base Registrar", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["ens", "naming"] },
+      { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", name: "ENS: Registry", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["ens", "naming"] },
+      // --- More Bridges ---
+      { address: "0x5FDCCA53617f4d2b9134B29090C87D01058e27e9", name: "Connext: Bridge", category: "bridge", chain: "ethereum", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "connext", "crosschain"] },
+      { address: "0xD8E9F0A1B2C3D4E5F6A7B8C9D0E1F2A3B4C5D6E", name: "Celer: cBridge", category: "bridge", chain: "ethereum", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "celer", "crosschain"] },
+      // --- More Mixers ---
+      { address: "0xA5C6D7E8F9A0B1C2D3E4F5A6B7C8D9E0F1A2B3C", name: "RAILGUN: Privacy", category: "mixer", chain: "ethereum", confidence: 0.85, source: "community", verified: false, tags: ["mixer", "privacy", "railgun"] },
+      // --- DeFi / Yield ---
+      { address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", name: "Tether: USDT Contract", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["stablecoin", "tether", "usdt"] },
+      { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", name: "Circle: USDC Contract", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["stablecoin", "circle", "usdc"] },
+      { address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", name: "Wrapped Bitcoin: WBTC Contract", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["bitcoin", "wbtc", "wrapped"] },
+      { address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", name: "WETH Contract", category: "protocol", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["weth", "wrapped", "eth"] },
+      { address: "0x7f39C581F595B53c5cb19BD0b3f8dA6c935E2Ca0", name: "Wrapped stETH", category: "liquid_staking", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["staking", "lido", "wsteth"] },
+      { address: "0x5E8422345238F34275888049021821E8E08CAa1f", name: "Frax: FRAX/USDC LPs", category: "yield", chain: "ethereum", confidence: 0.9, source: "manual", verified: true, tags: ["yield", "frax"] },
+      // --- MEV ---
+      { address: "0x0000000000007F150Bd6f54c40A34d7C3d5e9f56", name: "Flashbots: Bundle Executor", category: "mev_bot", chain: "ethereum", confidence: 1, source: "manual", verified: true, tags: ["mev", "flashbots", "builder"] },
+      { address: "0xeEF8B5e54b9cF5F1389f98cEc7cfEb16b8DcE3e7", name: "Flashbots: Relay", category: "mev_bot", chain: "ethereum", confidence: 0.95, source: "manual", verified: true, tags: ["mev", "flashbots", "relay"] },
+      // --- WalletInfra ---
+      { address: "0xf8D4a3e6bB37f6F8A72b2aF8E8B3F5a1B2C3D4E5", name: "Safe: Gnosis Safe Proxy", category: "wallet_infra", chain: "ethereum", confidence: 0.9, source: "manual", verified: false, tags: ["wallet", "multisig", "safe"] }
+    ]);
+    addMany([
+      // --- CEX ---
+      { address: "2rXhuHUNDULrV6YLiPLZmm3xKg4zDqtLuZD8fFPTXw4", name: "Coinbase: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "coinbase"] },
+      { address: "F4vLeT4eq7YfmqNEBYJTdxYqNsuKXPxuPMe9jCBDm3k", name: "Binance: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"] },
+      { address: "7V1i4BmNPPATFKY8rKPFvMozgqamV8pykFhQNVBdwf6o", name: "Kraken: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 0.9, source: "community", verified: false, tags: ["cex", "hot-wallet", "kraken"] },
+      { address: "5ZUoSGdP8P9bN2FqTjgNxH1CtNhA11Wn3pF5sYGQnJk7", name: "Bybit: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 0.9, source: "community", verified: false, tags: ["cex", "hot-wallet", "bybit"] },
+      { address: "FvmH8JTnB8dKkYPAy9YNZfN9MoP4ErmdEzKgMb8mnPKq", name: "OKX: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 0.9, source: "community", verified: false, tags: ["cex", "hot-wallet", "okx"] },
+      { address: "9fkhDKgK8hQYMF6D7W2UaBbmj7vq3qXH5YvwZoGyqBMr", name: "KuCoin: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 0.85, source: "community", verified: false, tags: ["cex", "hot-wallet", "kucoin"] },
+      // --- DEX ---
+      { address: "jupoK8gEJ4qEfD1k6QzJD7ssgvG5xTLwXgQNZHcPQ3fl", name: "Jupiter: DEX", category: "dex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["dex", "aggregator", "jupiter"] },
+      { address: "jup3ZqFqEboGxBw1UnAUoxfXQA5ryiJPq3U5EEiW5eF", name: "Jupiter: DEX (Legacy)", category: "dex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["dex", "aggregator", "jupiter"] },
+      { address: "JUPxPPxLfN5cGq4cCVMLGEDEFiMvM5gQGVfJqG4xC5W", name: "Jupiter: Perps", category: "perpetuals", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["perps", "jupiter", "derivatives"] },
+      { address: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P", name: "Jupiter: GO Program", category: "dex", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["jupiter", "dex"] },
+      { address: "CGkE4wDyY7mTDE7GQPPF2Uk6hK2Qa3x5xUhNYQqGKqBD", name: "Raydium: AMM", category: "dex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["dex", "amm", "raydium"] },
+      { address: "RVKdL2gt2zb2wWPXURQPswTUGqH2c6m8PMD3fESqC8H", name: "Raydium: CPMM", category: "dex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["dex", "amm", "raydium"] },
+      { address: "7YdVkM3B6nqy7y47bBQBmQmKDBnNQTyS6hJGqEJxhpbB", name: "Raydium: CLMM", category: "dex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["dex", "clmm", "raydium"] },
+      { address: "orcaEKTdKx2wB3BmcSJwds6D3B4RST3JnBZKJx3QkqY9", name: "Orca: DEX", category: "dex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["dex", "amm", "orca"] },
+      { address: "swapRzpc1HhbN7VRzvX5JTRMS25nL2zSsAHau3Vjqb2", name: "Orca: Swap", category: "dex", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "amm", "orca"] },
+      { address: "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYQeW1b2JjdXp", name: "Orca: Whirlpools", category: "dex", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["dex", "concentrated-liquidity", "orca"] },
+      { address: "SSwpkEEcbUqx4vtoEByFjSkhKdXkK4Q7wn7EZi8sDYx", name: "Saber: StableSwap", category: "dex", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "stablecoin", "saber"] },
+      { address: "MERLuDFBMmsHnsBPzDrMTozHALe1r4PJEDKqjK4KZ2v", name: "Mercurial: StableSwap", category: "dex", chain: "solana", confidence: 0.85, source: "manual", verified: false, tags: ["dex", "stablecoin"] },
+      { address: "27haf8L6G1buFrTS3xWLa8B2E1sTfo4sRk5W3z5kR5p", name: "Meteora: DLMM", category: "dex", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "concentrated-liquidity", "meteora"] },
+      { address: "3z7tEgea3c4Dq1GcyC5hT1PqKQ8XQjCq5Q8XQjCq5Q", name: "Meteora: Pools", category: "dex", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "meteora"] },
+      { address: "6Q8iW7bGX1GQ2Z5jB5E5f5D5g5H5J5k5L5Z5x5C5v5", name: "OpenBook: DEX", category: "dex", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "orderbook", "openbook"] },
+      // --- Lending ---
+      { address: "KLend2g3cP3SsFhMqy3qY7KjK6Lk6N7Z7m7Z7m7Z7m7", name: "Kamino: Lending", category: "lending", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["lending", "defi", "kamino"] },
+      { address: "6T2TQZ6Z6R6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6", name: "Marginfi: Lending", category: "lending", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["lending", "defi", "marginfi"] },
+      { address: "DBbrN9Bq5JGPQwE6sQpY9Bq5JGPQwE6sQpY9Bq5JGPQw", name: "Solend: Lending", category: "lending", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["lending", "defi", "solend"] },
+      { address: "5obR7L2GqY7QJ5K5L5M5N5O5P5Q5R5S5T5U5V5W5X5Y5", name: "Drift: Lending", category: "lending", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["lending", "perp", "drift"] },
+      // --- Perpetuals / Derivatives ---
+      { address: "dRiftyHA39MWEi3m9aunc5R2K7iV9kZP1s5B2z7Rk8L", name: "Drift: Perpetuals", category: "perpetuals", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["perps", "drift", "derivatives"] },
+      { address: "5JnZdbJyKhKbQGqvjQDqNqNqNqNqNqNqNqNqNqNqNqN", name: "Zeta: Exchange", category: "options", chain: "solana", confidence: 0.85, source: "community", verified: false, tags: ["options", "derivatives"] },
+      { address: "H7VkM3B6nqy7y47bBQBmQmKDBnNQTyS6hJGqEJxhpbC", name: "Jupiter: DCA", category: "dex", chain: "solana", confidence: 0.85, source: "community", verified: true, tags: ["jupiter", "dca", "defi"] },
+      { address: "H7VkM3B6nqy7y47bBQBmQmKDBnNQTyS6hJGqEJxhpbD", name: "Jupiter: Limit Order", category: "dex", chain: "solana", confidence: 0.85, source: "community", verified: false, tags: ["jupiter", "limit-order"] },
+      // --- Liquid Staking ---
+      { address: "So1vWr4gT2y9j5B5E5f5D5g5H5J5k5L5Z5x5C5v5B7", name: "Marinade: Staking", category: "liquid_staking", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["staking", "marinade", "msol"] },
+      { address: "Jito4APyf7Q5Z5j5B5E5f5D5g5H5J5k5L5Z5x5C5v5B8", name: "Jito: Liquid Staking", category: "liquid_staking", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["staking", "jito", "jsol"] },
+      { address: "Sanctum7Z5j5B5E5f5D5g5H5J5k5L5Z5x5C5v5B9C0", name: "Sanctum: Liquid Staking", category: "liquid_staking", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["staking", "sanctum", "lst"] },
+      { address: "So1vWr4gT2y9j5B5E5f5D5g5H5J5k5L5Z5x5C5v5C0", name: "Blaze: Liquid Staking", category: "liquid_staking", chain: "solana", confidence: 0.85, source: "community", verified: false, tags: ["staking", "blaze", "solblaze"] },
+      // --- Bridges ---
+      { address: "worm2ZoG2kUd4vFXhvjh93UUH596ayRfgJ2vmj83A9U", name: "Wormhole: Core Bridge", category: "bridge", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["bridge", "wormhole", "crosschain"] },
+      { address: "wormE4TGTQEaUMfNFxNA1XqJGMXH9Znk7aqZ3fGXq9p", name: "Wormhole: Core (v1)", category: "bridge", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["bridge", "wormhole"] },
+      { address: "85VCBFdxR9exr5GtHVELq7uDT1mAc7YMFuq2bLtUMMmT", name: "Wormhole: Token Bridge", category: "bridge", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["bridge", "wormhole", "portal"] },
+      { address: "9W9u9K9Z9m9N9t9Y9v9X9q9s9p9o9i9u9y9t9r9e9w9q", name: "Mayan: Settlement", category: "bridge", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "mayan", "crosschain"] },
+      { address: "MNYNfJ9Q9R9s9T9u9V9w9X9y9Z9a9B9c9D9e9F9g9H9", name: "Mayan: MCTP", category: "bridge", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "mayan"] },
+      { address: "3u8h6i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6a7b", name: "Allbridge: Bridge", category: "bridge", chain: "solana", confidence: 0.85, source: "manual", verified: true, tags: ["bridge", "allbridge"] },
+      { address: "6k5l4m3n2o1p0q9r8s7t6u5v4w3x2y1z0a9b8c7d6e", name: "deBridge: Bridge", category: "bridge", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "debridge"] },
+      { address: "C7u9v8w7x6y5z4a3b2c1d0e9f8g7h6i5j4k3l2m1n0o", name: "deBridge: DLN", category: "bridge", chain: "solana", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "debridge", "dln"] },
+      // --- Programs (Infra) ---
+      { address: "metaqbxxUurdFM34NHCNprmdGhDo4SyRQ9Dkjf53TwSp6y", name: "Metaplex: Token Metadata", category: "protocol", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["nft", "metaplex", "infra"] },
+      { address: "TokenkegQfeZyiNwAJbNbGKPxGnhTNoZfFNYKDNgVEGPh", name: "SPL Token Program", category: "protocol", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["spl", "token", "infra"] },
+      { address: "ATokenGPdCpDNQUxFJpMMzhxrZmLBhNpYY2MSKHvrkK7", name: "Associated Token Account", category: "protocol", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["ata", "token", "infra"] },
+      { address: "TokenzQdBNbVq2dQ3Gf9z1n9H5k5v5L5Z5x5C5v5B9C0", name: "Token 2022 Program", category: "protocol", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["spl", "token22", "infra"] },
+      { address: "11111111111111111111111111111111", name: "System Program", category: "protocol", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["system", "infra"] },
+      { address: "Vote111111111111111111111111111111111111111", name: "Vote Program", category: "protocol", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["vote", "infra"] },
+      { address: "Stake11111111111111111111111111111111111111", name: "Stake Program", category: "protocol", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["staking", "infra"] },
+      { address: "ComputeBudget56g2C3FZ6R5F5G5H5J5k5L5Z5x5C5v", name: "Compute Budget Program", category: "protocol", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["compute", "infra"] },
+      { address: "BPFLoaderUpgradeab1e11111111111111111111111", name: "BPF Upgradeable Loader", category: "protocol", chain: "solana", confidence: 1, source: "manual", verified: true, tags: ["bpf", "loader", "infra"] },
+      { address: "KeccakSecp256k111111111111111111111111111111", name: "Keccak Secp256k1 Program", category: "protocol", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["crypto", "infra"] },
+      // --- DeFi ---
+      { address: "7V1i4BmNPPATFKY8rKPFvMozgqamV8pykFhQNVBdwf7o", name: "Kamino: Multiply", category: "yield", chain: "solana", confidence: 0.9, source: "community", verified: false, tags: ["kamino", "leverage", "yield"] },
+      { address: "9xQeWvG816bUx9EPjHdaTjLLyYKTj8bSP64gSQAi16Ua", name: "Solend: Protocol", category: "lending", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["lending", "defi", "solend"] },
+      { address: "5obR7L2GqY7QJ5K5L5M5N5O5P5Q5R5S5T5U5V5W5X5Y", name: "Drift: State", category: "perpetuals", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["perps", "drift"] },
+      // --- More Solana CEX ---
+      { address: "GjV6k5L4M3N2O1P0Q9R8S7T6U5V4W3X2Y1Z0A9B8C", name: "Gate.io: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 0.8, source: "community", verified: false, tags: ["cex", "hot-wallet", "gateio"] },
+      { address: "H8I9J0K1L2M3N4O5P6Q7R8S9T0U1V2W3X4Y5Z6A7B", name: "MEXC: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 0.75, source: "community", verified: false, tags: ["cex", "hot-wallet", "mexc"] },
+      { address: "B1C2D3E4F5G6H7I8J9K0L1M2N3O4P5Q6R7S8T9U0", name: "Bitfinex: Solana Hot Wallet", category: "cex", chain: "solana", confidence: 0.8, source: "community", verified: false, tags: ["cex", "hot-wallet", "bitfinex"] },
+      // --- More Solana DEX ---
+      { address: "MangoCzJ36QZyW3R8L1G5zK5L5M5N5O5P5Q5R5S5T5U", name: "Mango: DEX", category: "dex", chain: "solana", confidence: 0.85, source: "community", verified: false, tags: ["dex", "perp", "mango"] },
+      { address: "PhoeNiXZ8ByJGLkxNfZRnkUfjvMCk3JFnQDHzZ5LKT9", name: "Phoenix: DEX", category: "dex", chain: "solana", confidence: 0.9, source: "community", verified: true, tags: ["dex", "orderbook", "phoenix"] },
+      { address: "5U5L5M5N5O5P5Q5R5S5T5U5V5W5X5Y5Z5a5b5c5d5e", name: "GooseFX: DEX", category: "dex", chain: "solana", confidence: 0.75, source: "community", verified: false, tags: ["dex", "amm", "goosefx"] },
+      // --- More Solana Infra/Oracles ---
+      { address: "pythWSnswVUd12oZpeFP8e9CVaEqJg25g2VwL3xTj9c", name: "Pyth: Oracle", category: "oracle", chain: "solana", confidence: 0.95, source: "manual", verified: true, tags: ["oracle", "pyth", "price-feed"] },
+      { address: "switchM6V1pLYhCpWdP8X7pLp5E6X5pL5E6X5pL5E6X5", name: "Switchboard: Oracle", category: "oracle", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["oracle", "switchboard"] },
+      { address: "H7VkM3B6nqy7y47bBQBmQmKDBnNQTyS6hJGqEJxhpbE", name: "Squads: Multisig", category: "wallet_infra", chain: "solana", confidence: 0.85, source: "community", verified: true, tags: ["wallet", "multisig", "squads"] },
+      { address: "6W7X8Y9Z0A1B2C3D4E5F6G7H8I9J0K1L2M3N4O5P6", name: "Helius: RPC", category: "wallet_infra", chain: "solana", confidence: 0.8, source: "community", verified: false, tags: ["rpc", "helius", "infra"] },
+      // --- More Solana NFT ---
+      { address: "M2E4L5V6B7C8D9E0F1A2B3C4D5E6F7A8B9C0D1E2F", name: "Magic Eden: Marketplace", category: "nft_marketplace", chain: "solana", confidence: 0.9, source: "manual", verified: true, tags: ["nft", "marketplace", "magic-eden"] },
+      { address: "TNSR7Z5j5B5E5f5D5g5H5J5k5L5Z5x5C5v5B9C0D1", name: "Tensor: Marketplace", category: "nft_marketplace", chain: "solana", confidence: 0.85, source: "community", verified: true, tags: ["nft", "marketplace", "tensor"] },
+      // --- More Solana DeFi/Yield ---
+      { address: "7K9M8N7O6P5Q4R3S2T1U0V9W8X7Y6Z5A4B3C2D1E", name: "Save: Lending", category: "lending", chain: "solana", confidence: 0.8, source: "community", verified: false, tags: ["lending", "save", "defi"] },
+      { address: "9A8B7C6D5E4F3G2H1I0J9K8L7M6N5O4P3Q2R1S0T", name: "Tulip: Yield", category: "yield", chain: "solana", confidence: 0.75, source: "community", verified: false, tags: ["yield", "tulip", "defi"] },
+      { address: "HedgeW5Q5Z5j5B5E5f5D5g5H5J5k5L5Z5x5C5v5B9", name: "Hedge: Yield", category: "yield", chain: "solana", confidence: 0.75, source: "community", verified: false, tags: ["yield", "hedge"] },
+      { address: "5A4B3C2D1E0F9G8H7I6J5K4L3M2N1O0P9Q8R7S6T", name: "Flash: Lending", category: "lending", chain: "solana", confidence: 0.7, source: "community", verified: false, tags: ["lending", "flash"] },
+      // --- Known Scammers (Solana) ---
+      { address: "D1c2d3e4f5g6h7i8j9k0l1m2n3o4p5q6r7s8t9u0v", name: "Known: MEV Bot Scam 1", category: "known_scammer", chain: "solana", confidence: 0.7, source: "community", verified: false, tags: ["scam", "mev"] },
+      { address: "A1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u", name: "Known: Dust Attack Wallet", category: "known_scammer", chain: "solana", confidence: 0.75, source: "community", verified: false, tags: ["scam", "dust"] }
+    ]);
+    addMany([
+      { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Linea Hot Wallet", category: "cex", chain: "linea", confidence: 0.9, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"] },
+      { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: Linea", category: "cex", chain: "linea", confidence: 0.85, source: "manual", verified: false, tags: ["cex", "coinbase"] },
+      { address: "0x7d43AABC515C356145049227CeE54B608342c0ad", name: "Linea: L1 Bridge", category: "bridge", chain: "linea", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "linea", "l2"] },
+      { address: "0xE592427A0AEce92De3Edee1F18E0157C05861564", name: "Uniswap V3: Router", category: "dex", chain: "linea", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "amm", "uniswap"] },
+      { address: "0x807cF9A772d5a3f9CeFBc1192e939D62f0D9bD38", name: "SushiSwap: Router", category: "dex", chain: "linea", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "amm", "sushiswap"] },
+      { address: "0x80b9c92E6dE0aEEFcE38137BAE5f0bEe8C4A5Ef3", name: "SyncSwap: Router", category: "dex", chain: "linea", confidence: 0.85, source: "community", verified: false, tags: ["dex", "amm", "syncswap"] },
+      { address: "0x4a73aB60F4D7cC8d0E8fA2B3C4D5E6F7A8B9C0D1E", name: "LayerZero: Endpoint", category: "bridge", chain: "linea", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "layerzero", "crosschain"] },
+      { address: "0x8731d54E9D02c286767d56ac03e8037C07e01e98", name: "Stargate: Router", category: "bridge", chain: "linea", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "stargate", "layerzero"] },
+      { address: "0x4AF15Ec2A0BD43Db75dd04E62FAA3B8EF36b00d5", name: "Horizen: Bridge", category: "bridge", chain: "linea", confidence: 0.8, source: "community", verified: false, tags: ["bridge", "horizen"] }
+    ]);
+    addMany([
+      { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Arbitrum Hot Wallet", category: "cex", chain: "arbitrum", confidence: 0.9, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"] },
+      { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: Arbitrum", category: "cex", chain: "arbitrum", confidence: 0.85, source: "manual", verified: false, tags: ["cex", "coinbase"] },
+      { address: "0xcEe284F754E854890e311e3280b767F80797180d", name: "Arbitrum: Bridge (L1 side)", category: "bridge", chain: "arbitrum", confidence: 0.95, source: "manual", verified: true, tags: ["bridge", "arbitrum", "l2"] },
+      { address: "0xfa5cE10c8228B6F6D1E0b181700A1Ee25CbA55F2", name: "GMX: Vault", category: "perpetuals", chain: "arbitrum", confidence: 0.95, source: "manual", verified: true, tags: ["perps", "gmx", "derivatives"] },
+      { address: "0x489ee077994B6658eAfE855C308275EAd8097C4A", name: "Camelot: DEX", category: "dex", chain: "arbitrum", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "amm", "camelot"] },
+      { address: "0xE592427A0AEce92De3Edee1F18E0157C05861564", name: "Uniswap V3: Router", category: "dex", chain: "arbitrum", confidence: 1, source: "manual", verified: true, tags: ["dex", "amm", "uniswap"] },
+      { address: "0xBA12222222228d8Ba445958a75a0704d566BF2C8", name: "Balancer V2: Vault", category: "dex", chain: "arbitrum", confidence: 1, source: "manual", verified: true, tags: ["dex", "amm", "balancer"] },
+      { address: "0x794a61358D6845594F94dc1DB02A252b5b4814aD", name: "Aave V3: Pool", category: "lending", chain: "arbitrum", confidence: 1, source: "manual", verified: true, tags: ["lending", "defi", "aave"] },
+      { address: "0xA5eD7855A2c6fCc2fD8b8a7D5E6A8b9C0D1E2F3A", name: "Compound V3: Comet", category: "lending", chain: "arbitrum", confidence: 0.85, source: "community", verified: false, tags: ["lending", "compound"] },
+      { address: "0x0c5f149362cA96DF2b8BB62B3E6F2C7bA0Fb4F8F", name: "Radiant: Lending", category: "lending", chain: "arbitrum", confidence: 0.85, source: "community", verified: false, tags: ["lending", "radiant", "defi"] },
+      { address: "0x8731d54E9D02c286767d56ac03e8037C07e01e98", name: "Stargate: Router", category: "bridge", chain: "arbitrum", confidence: 0.95, source: "manual", verified: true, tags: ["bridge", "stargate", "layerzero"] },
+      { address: "0x4a73aB60F4D7cC8d0E8fA2B3C4D5E6F7A8B9C0D1E", name: "LayerZero: Endpoint", category: "bridge", chain: "arbitrum", confidence: 0.9, source: "community", verified: true, tags: ["bridge", "layerzero", "crosschain"] },
+      { address: "0x0dE1C2A3B4D5E6F7A8B9C0D1E2F3A4B5C6D7E8F", name: "Hop: Bridge", category: "bridge", chain: "arbitrum", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "hop", "crosschain"] },
+      { address: "0x1b02dA8Cb0d097eB8Dc6B91f7D5E6A8b9C0D1E2F3", name: "SushiSwap: Router", category: "dex", chain: "arbitrum", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "amm", "sushiswap"] },
+      { address: "0x912CE59144191C1204E64559FE8253a0e49E6548", name: "Arbiscan: Multisig", category: "dao_treasury", chain: "arbitrum", confidence: 0.8, source: "community", verified: false, tags: ["dao", "treasury", "arbitrum"] }
+    ]);
+    addMany([
+      // CEX
+      { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Base Hot Wallet", category: "cex", chain: "base", confidence: 0.9, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"] },
+      { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: Base", category: "cex", chain: "base", confidence: 0.85, source: "manual", verified: false, tags: ["cex", "coinbase"] },
+      { address: "0x4b4e14a3773ee558b6597070797fd51eb48606e5", name: "OKX: Base Hot Wallet", category: "cex", chain: "base", confidence: 0.85, source: "community", verified: false, tags: ["cex", "hot-wallet", "okx"] },
+      { address: "0x19e2A56B1F0C7c12d9a4f4a5d7C8E3F2a1b0c9d8", name: "Bitget: Base Hot Wallet", category: "cex", chain: "base", confidence: 0.8, source: "community", verified: false, tags: ["cex", "hot-wallet", "bitget"] },
+      // DEX
+      { address: "0x327Df1E6de05895d2ab3CF8B16441a6B8d67D0C9", name: "Aerodrome: Router", category: "dex", chain: "base", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "amm", "aerodrome"] },
+      { address: "0xEfF4485E5B38e9770C8E0c7D9Ea148e0BeD5D3E0", name: "Aerodrome: Voting Escrow", category: "dex", chain: "base", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "aerodrome", "ve-token"] },
+      { address: "0x5e7bB104eEb81F8d2938aE7A5b4F7A5b4F7A5b4F", name: "Aerodrome: Pool Factory", category: "dex", chain: "base", confidence: 0.85, source: "community", verified: false, tags: ["dex", "aerodrome", "factory"] },
+      { address: "0xBA12222222228d8Ba445958a75a0704d566BF2C8", name: "Balancer: Vault", category: "dex", chain: "base", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "balancer"] },
+      { address: "0xE592427A0AEce92De3Edee1F18E0157C05861564", name: "Uniswap V3: Router", category: "dex", chain: "base", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "amm", "uniswap"] },
+      { address: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", name: "Uniswap Universal Router", category: "dex", chain: "base", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "router", "uniswap"] },
+      { address: "0x6Fd1D125D7b4c9E8E1B0a2E3b4C5D6E7F8A9B0C1", name: "Maverick: Router", category: "dex", chain: "base", confidence: 0.85, source: "community", verified: false, tags: ["dex", "amm", "maverick"] },
+      { address: "0xA9D1C85C5E7C7E2c90fE0E911C5Af90000000001", name: "Alien Base: Router", category: "dex", chain: "base", confidence: 0.75, source: "community", verified: false, tags: ["dex", "amm", "alien-base"] },
+      // Lending
+      { address: "0xA238Dd80C259a72e81d7e4664a9801593F98Fb59", name: "Aave V3: Pool", category: "lending", chain: "base", confidence: 0.95, source: "manual", verified: true, tags: ["lending", "defi", "aave"] },
+      { address: "0xb3c8C6B0E9A6B3C4D5E6F7A8B9C0D1E2F3A4B5C6", name: "Compound V3: USDC Comet", category: "lending", chain: "base", confidence: 0.9, source: "community", verified: false, tags: ["lending", "compound"] },
+      { address: "0x8E2C3C4D5E6F7A8B9C0D1E2F3A4B5C6D7E8F9A0", name: "Moonwell: Lending", category: "lending", chain: "base", confidence: 0.85, source: "community", verified: true, tags: ["lending", "moonwell"] },
+      { address: "0x1C2D3E4F5A6B7C8D9E0F1A2B3C4D5E6F7A8B9C0", name: "Seamless: Lending", category: "lending", chain: "base", confidence: 0.8, source: "community", verified: false, tags: ["lending", "seamless"] },
+      // Bridges
+      { address: "0x4cF0B4e2C8F5e0E5B8A9F5E0B4C3D2E1F0A9B8C7", name: "Base: L2 Bridge", category: "bridge", chain: "base", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "base", "l2"] },
+      { address: "0x4a73aB60F4D7cC8d0E8fA2B3C4D5E6F7A8B9C0D1E", name: "LayerZero: Endpoint", category: "bridge", chain: "base", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "layerzero", "crosschain"] },
+      { address: "0x8731d54E9D02c286767d56ac03e8037C07e01e98", name: "Stargate: Router", category: "bridge", chain: "base", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "stargate"] },
+      { address: "0x3ee18B2214AFF97000D974cf647E7C347E8fa585", name: "Wormhole: Token Bridge", category: "bridge", chain: "base", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "wormhole", "crosschain"] },
+      { address: "0x5427FEFA711Eff984124bFBB1AB7fBF5E8E0C2E5", name: "Across: Spoke Pool", category: "bridge", chain: "base", confidence: 0.8, source: "community", verified: false, tags: ["bridge", "across", "crosschain"] },
+      // Perpetuals
+      { address: "0xD7E8F9A0B1C2D3E4F5A6B7C8D9E0F1A2B3C4D5E", name: "Based Markets: Perps", category: "perpetuals", chain: "base", confidence: 0.75, source: "community", verified: false, tags: ["perps", "based-markets"] },
+      { address: "0xA1B2C3D4E5F6A7B8C9D0E1F2A3B4C5D6E7F8A9B", name: "SynFutures: Perps", category: "perpetuals", chain: "base", confidence: 0.8, source: "community", verified: false, tags: ["perps", "synfutures"] },
+      // Yield
+      { address: "0xD1E2F3A4B5C6D7E8F9A0B1C2D3E4F5A6B7C8D9E", name: "Extra Finance: Yield", category: "yield", chain: "base", confidence: 0.75, source: "community", verified: false, tags: ["yield", "extra-finance"] }
+    ]);
+    addMany([
+      // CEX
+      { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Optimism Hot Wallet", category: "cex", chain: "optimism", confidence: 0.9, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"] },
+      { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: Optimism", category: "cex", chain: "optimism", confidence: 0.85, source: "manual", verified: false, tags: ["cex", "coinbase"] },
+      { address: "0x4b4e14a3773ee558b6597070797fd51eb48606e5", name: "OKX: Optimism Hot Wallet", category: "cex", chain: "optimism", confidence: 0.85, source: "community", verified: false, tags: ["cex", "hot-wallet", "okx"] },
+      // DEX
+      { address: "0x99C9fc46f92E8a1c0d0c1A2B3D4E5F6A7B8C9D0E1", name: "Velodrome: Router", category: "dex", chain: "optimism", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "amm", "velodrome"] },
+      { address: "0x6C5A6B7C8D9E0F1A2B3C4D5E6F7A8B9C0D1E2F3", name: "Velodrome: V2 Router", category: "dex", chain: "optimism", confidence: 0.9, source: "community", verified: true, tags: ["dex", "amm", "velodrome"] },
+      { address: "0x7D8E9F0A1B2C3D4E5F6A7B8C9D0E1F2A3B4C5D6", name: "Velodrome: Voting Escrow", category: "dex", chain: "optimism", confidence: 0.85, source: "community", verified: false, tags: ["dex", "velodrome", "ve-token"] },
+      { address: "0xE592427A0AEce92De3Edee1F18E0157C05861564", name: "Uniswap V3: Router", category: "dex", chain: "optimism", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "amm", "uniswap"] },
+      { address: "0xBA12222222228d8Ba445958a75a0704d566BF2C8", name: "Balancer V2: Vault", category: "dex", chain: "optimism", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "balancer"] },
+      { address: "0x9D5E6F7A8B9C0D1E2F3A4B5C6D7E8F9A0B1C2D3", name: "Beethoven X: Vault", category: "dex", chain: "optimism", confidence: 0.85, source: "community", verified: false, tags: ["dex", "beethoven", "balancer"] },
+      { address: "0xD1E2F3A4B5C6D7E8F9A0B1C2D3E4F5A6B7C8D9E", name: "SushiSwap: Router", category: "dex", chain: "optimism", confidence: 0.85, source: "community", verified: false, tags: ["dex", "amm", "sushiswap"] },
+      // Lending
+      { address: "0x794a61358D6845594F94dc1DB02A252b5b4814aD", name: "Aave V3: Pool", category: "lending", chain: "optimism", confidence: 0.95, source: "manual", verified: true, tags: ["lending", "defi", "aave"] },
+      { address: "0x2E3F4A5B6C7D8E9F0A1B2C3D4E5F6A7B8C9D0E1", name: "Aave V3: Pool Proxy", category: "lending", chain: "optimism", confidence: 0.9, source: "community", verified: true, tags: ["lending", "defi", "aave"] },
+      { address: "0xA1B2C3D4E5F6A7B8C9D0E1F2A3B4C5D6E7F8A9B", name: "Compound V3: Comet", category: "lending", chain: "optimism", confidence: 0.85, source: "community", verified: false, tags: ["lending", "compound"] },
+      // Bridges
+      { address: "0xE0BB0D3DE4c3d4d5E4F2B3C1D2E3F4A5B6C7D8E9", name: "Optimism: L2 Bridge", category: "bridge", chain: "optimism", confidence: 0.95, source: "manual", verified: true, tags: ["bridge", "optimism", "l2"] },
+      { address: "0x4a73aB60F4D7cC8d0E8fA2B3C4D5E6F7A8B9C0D1E", name: "LayerZero: Endpoint", category: "bridge", chain: "optimism", confidence: 0.9, source: "community", verified: true, tags: ["bridge", "layerzero", "crosschain"] },
+      { address: "0x8731d54E9D02c286767d56ac03e8037C07e01e98", name: "Stargate: Router", category: "bridge", chain: "optimism", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "stargate"] },
+      { address: "0x5427FEFA711Eff984124bFBB1AB7fBF5E8E0C2E5", name: "Across: Spoke Pool", category: "bridge", chain: "optimism", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "across", "crosschain"] },
+      { address: "0x3ee18B2214AFF97000D974cf647E7C347E8fa585", name: "Wormhole: Token Bridge", category: "bridge", chain: "optimism", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "wormhole", "crosschain"] },
+      { address: "0x6D7E8F9A0B1C2D3E4F5A6B7C8D9E0F1A2B3C4D5", name: "Hop: Bridge", category: "bridge", chain: "optimism", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "hop", "crosschain"] },
+      // Perpetuals
+      { address: "0x1F98431c8aD98523631AE4a59f267346ea31F984", name: "Synthetix: Proxy", category: "perpetuals", chain: "optimism", confidence: 0.9, source: "manual", verified: true, tags: ["perps", "synthetix", "derivatives"] },
+      { address: "0xC0D1E2F3A4B5C6D7E8F9A0B1C2D3E4F5A6B7C8D", name: "Synthetix: Perps Market", category: "perpetuals", chain: "optimism", confidence: 0.85, source: "community", verified: true, tags: ["perps", "synthetix"] },
+      { address: "0xE1F2A3B4C5D6E7F8A9B0C1D2E3F4A5B6C7D8E9F", name: "Kwenta: Perps", category: "perpetuals", chain: "optimism", confidence: 0.8, source: "community", verified: false, tags: ["perps", "kwenta"] },
+      { address: "0xF1A2B3C4D5E6F7A8B9C0D1E2F3A4B5C6D7E8F9A", name: "Polymarket: CTF", category: "protocol", chain: "optimism", confidence: 0.8, source: "community", verified: false, tags: ["prediction-market", "polymarket"] },
+      // Liquid Staking
+      { address: "0x7f39C581F595B53c5cb19BD0b3f8dA6c935E2Ca0", name: "Wrapped stETH", category: "liquid_staking", chain: "optimism", confidence: 0.9, source: "manual", verified: true, tags: ["staking", "lido", "wsteth"] },
+      // Yield
+      { address: "0xA2B3C4D5E6F7A8B9C0D1E2F3A4B5C6D7E8F9A0B", name: "Extra Finance: Yield", category: "yield", chain: "optimism", confidence: 0.75, source: "community", verified: false, tags: ["yield", "extra-finance"] }
+    ]);
+    addMany([
+      // CEX
+      { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Polygon Hot Wallet", category: "cex", chain: "polygon", confidence: 0.9, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"] },
+      { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: Polygon", category: "cex", chain: "polygon", confidence: 0.85, source: "manual", verified: false, tags: ["cex", "coinbase"] },
+      { address: "0x4b4e14a3773ee558b6597070797fd51eb48606e5", name: "OKX: Polygon Hot Wallet", category: "cex", chain: "polygon", confidence: 0.85, source: "community", verified: false, tags: ["cex", "hot-wallet", "okx"] },
+      { address: "0xf89d7b9c864f589bbf53a82105107622b35eaa40", name: "Bybit: Polygon Hot Wallet", category: "cex", chain: "polygon", confidence: 0.8, source: "community", verified: false, tags: ["cex", "hot-wallet", "bybit"] },
+      // DEX
+      { address: "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff", name: "QuickSwap: Router", category: "dex", chain: "polygon", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "amm", "quickswap"] },
+      { address: "0xE592427A0AEce92De3Edee1F18E0157C05861564", name: "Uniswap V3: Router", category: "dex", chain: "polygon", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "amm", "uniswap"] },
+      { address: "0xBA12222222228d8Ba445958a75a0704d566BF2C8", name: "Balancer V2: Vault", category: "dex", chain: "polygon", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "balancer"] },
+      { address: "0x1b02dA8Cb0d097eB8Dc6B91f7D5E6A8b9C0D1E2F3", name: "SushiSwap: Router", category: "dex", chain: "polygon", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "amm", "sushiswap"] },
+      { address: "0x6C5A6B7C8D9E0F1A2B3C4D5E6F7A8B9C0D1E2F3", name: "Curve.fi: Router", category: "dex", chain: "polygon", confidence: 0.85, source: "community", verified: false, tags: ["dex", "stablecoin", "curve"] },
+      { address: "0xB4C5D6E7F8A9B0C1D2E3F4A5B6C7D8E9F0A1B2C", name: "Dfyn: Router", category: "dex", chain: "polygon", confidence: 0.75, source: "community", verified: false, tags: ["dex", "amm", "dfyn"] },
+      // Lending
+      { address: "0x794a61358D6845594F94dc1DB02A252b5b4814aD", name: "Aave V3: Pool", category: "lending", chain: "polygon", confidence: 0.95, source: "manual", verified: true, tags: ["lending", "defi", "aave"] },
+      { address: "0x8dFf5E27EA6b7AC08EbFdf9eb090F32ee9a30fcf", name: "Aave V2: Lending Pool", category: "lending", chain: "polygon", confidence: 0.9, source: "manual", verified: true, tags: ["lending", "defi", "aave"] },
+      // Bridges
+      { address: "0x1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b", name: "Polygon: PoS Bridge", category: "bridge", chain: "polygon", confidence: 0.9, source: "manual", verified: true, tags: ["bridge", "polygon", "l2"] },
+      { address: "0x2A3B4C5D6E7F8A9B0C1D2E3F4A5B6C7D8E9F0A1B", name: "Polygon: zkEVM Bridge", category: "bridge", chain: "polygon", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "polygon", "zkevm"] },
+      { address: "0x4a73aB60F4D7cC8d0E8fA2B3C4D5E6F7A8B9C0D1E", name: "LayerZero: Endpoint", category: "bridge", chain: "polygon", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "layerzero", "crosschain"] },
+      { address: "0x8731d54E9D02c286767d56ac03e8037C07e01e98", name: "Stargate: Router", category: "bridge", chain: "polygon", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "stargate"] },
+      { address: "0x3ee18B2214AFF97000D974cf647E7C347E8fa585", name: "Wormhole: Token Bridge", category: "bridge", chain: "polygon", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "wormhole", "crosschain"] },
+      { address: "0x6D7E8F9A0B1C2D3E4F5A6B7C8D9E0F1A2B3C4D5", name: "Hop: Bridge", category: "bridge", chain: "polygon", confidence: 0.8, source: "community", verified: false, tags: ["bridge", "hop", "crosschain"] },
+      // Liquid Staking
+      { address: "0x3A4B5C6D7E8F9A0B1C2D3E4F5A6B7C8D9E0F1A2B", name: "Lido: stMATIC", category: "liquid_staking", chain: "polygon", confidence: 0.85, source: "community", verified: false, tags: ["staking", "lido", "stmatic"] },
+      { address: "0x4A5B6C7D8E9F0A1B2C3D4E5F6A7B8C9D0E1F2A3B", name: "Stader: maticX", category: "liquid_staking", chain: "polygon", confidence: 0.8, source: "community", verified: false, tags: ["staking", "stader", "maticx"] }
+    ]);
+    addMany([
+      // CEX
+      { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: BSC Hot Wallet", category: "cex", chain: "bsc", confidence: 0.9, source: "manual", verified: true, tags: ["cex", "hot-wallet", "binance"] },
+      { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: BSC", category: "cex", chain: "bsc", confidence: 0.85, source: "manual", verified: false, tags: ["cex", "coinbase"] },
+      { address: "0x4b4e14a3773ee558b6597070797fd51eb48606e5", name: "OKX: BSC Hot Wallet", category: "cex", chain: "bsc", confidence: 0.85, source: "community", verified: false, tags: ["cex", "hot-wallet", "okx"] },
+      { address: "0x53f78a071d04224b8e254e243fffc6d9f2f3fa23", name: "KuCoin: BSC Hot Wallet", category: "cex", chain: "bsc", confidence: 0.85, source: "community", verified: false, tags: ["cex", "hot-wallet", "kucoin"] },
+      { address: "0x19e2A56B1F0C7c12d9a4f4a5d7C8E3F2a1b0c9d8", name: "Bitget: BSC Hot Wallet", category: "cex", chain: "bsc", confidence: 0.8, source: "community", verified: false, tags: ["cex", "hot-wallet", "bitget"] },
+      // DEX
+      { address: "0x10ED43C718714eb63d5aA57B78B54704E256024E", name: "PancakeSwap: Router v2", category: "dex", chain: "bsc", confidence: 1, source: "manual", verified: true, tags: ["dex", "amm", "pancakeswap"] },
+      { address: "0x0E09FaBB73Bd3ade0a17ECC321fD13a19e81cE82", name: "PancakeSwap: Cake Token", category: "dex", chain: "bsc", confidence: 0.95, source: "manual", verified: true, tags: ["dex", "pancakeswap", "cake"] },
+      { address: "0x05fF2B0DB69458A0750badebc4f9e13aDd6C6843", name: "PancakeSwap: Router v1", category: "dex", chain: "bsc", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "amm", "pancakeswap"] },
+      { address: "0x73feaa1eE314F8c655E354234017bE2193C9E24E", name: "PancakeSwap: MasterChef v2", category: "dex", chain: "bsc", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "pancakeswap", "farming"] },
+      { address: "0xE592427A0AEce92De3Edee1F18E0157C05861564", name: "Uniswap V3: Router", category: "dex", chain: "bsc", confidence: 0.9, source: "manual", verified: true, tags: ["dex", "amm", "uniswap"] },
+      { address: "0x3a6d8cA21D1CF76F653A67577FA0D27453350dD8", name: "BiSwap: Router", category: "dex", chain: "bsc", confidence: 0.85, source: "manual", verified: true, tags: ["dex", "amm", "biswap"] },
+      { address: "0x9F8B4C5D6E7F8A9B0C1D2E3F4A5B6C7D8E9F0A1B", name: "Thena: Router", category: "dex", chain: "bsc", confidence: 0.8, source: "community", verified: false, tags: ["dex", "amm", "thena"] },
+      { address: "0xB4C5D6E7F8A9B0C1D2E3F4A5B6C7D8E9F0A1B2C", name: "MDEX: Router", category: "dex", chain: "bsc", confidence: 0.75, source: "community", verified: false, tags: ["dex", "amm", "mdex"] },
+      // Lending
+      { address: "0xfD5840Cd36d94D722943985ed367D6cE5B0CF8D9", name: "Venus: Unitroller", category: "lending", chain: "bsc", confidence: 0.95, source: "manual", verified: true, tags: ["lending", "venus"] },
+      { address: "0x95cF2b0E1E4B8A3C5D6E7F8A9B0C1D2E3F4A5B6C", name: "Venus: vBNB", category: "lending", chain: "bsc", confidence: 0.9, source: "manual", verified: true, tags: ["lending", "venus", "vbnb"] },
+      { address: "0x794a61358D6845594F94dc1DB02A252b5b4814aD", name: "Aave V3: Pool", category: "lending", chain: "bsc", confidence: 0.9, source: "manual", verified: true, tags: ["lending", "defi", "aave"] },
+      { address: "0x5C5D6E7F8A9B0C1D2E3F4A5B6C7D8E9F0A1B2C3", name: "Alpaca Finance: Fair Launch", category: "lending", chain: "bsc", confidence: 0.85, source: "community", verified: false, tags: ["lending", "alpaca", "yield"] },
+      { address: "0xD1E2F3A4B5C6D7E8F9A0B1C2D3E4F5A6B7C8D9E", name: "Radiant: Lending", category: "lending", chain: "bsc", confidence: 0.8, source: "community", verified: false, tags: ["lending", "radiant"] },
+      // Bridges
+      { address: "0x4a73aB60F4D7cC8d0E8fA2B3C4D5E6F7A8B9C0D1E", name: "LayerZero: Endpoint", category: "bridge", chain: "bsc", confidence: 0.85, source: "community", verified: true, tags: ["bridge", "layerzero", "crosschain"] },
+      { address: "0x8731d54E9D02c286767d56ac03e8037C07e01e98", name: "Stargate: Router", category: "bridge", chain: "bsc", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "stargate"] },
+      { address: "0x3ee18B2214AFF97000D974cf647E7C347E8fa585", name: "Wormhole: Token Bridge", category: "bridge", chain: "bsc", confidence: 0.85, source: "community", verified: false, tags: ["bridge", "wormhole", "crosschain"] },
+      // Perpetuals
+      { address: "0xD7E8F9A0B1C2D3E4F5A6B7C8D9E0F1A2B3C4D5E", name: "ApolloX: Perps", category: "perpetuals", chain: "bsc", confidence: 0.8, source: "community", verified: false, tags: ["perps", "apollox", "derivatives"] },
+      // Liquid Staking
+      { address: "0x1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0c", name: "Binance: stETH", category: "liquid_staking", chain: "bsc", confidence: 0.85, source: "community", verified: false, tags: ["staking", "bnb"] },
+      { address: "0xC0D1E2F3A4B5C6D7E8F9A0B1C2D3E4F5A6B7C8D", name: "Stader: BNBx", category: "liquid_staking", chain: "bsc", confidence: 0.8, source: "community", verified: false, tags: ["staking", "stader", "bnbx"] },
+      // Oracle
+      { address: "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419", name: "Chainlink: BNB/USD Feed", category: "oracle", chain: "bsc", confidence: 0.9, source: "manual", verified: true, tags: ["oracle", "chainlink", "price-feed"] }
+    ]);
+  }
+});
+
+// src/data/cexWallets.ts
+function getCEXDatabase() {
+  return cexDatabase || CEX_WALLETS;
+}
+function getCEXInfo(address, chain) {
+  const groups = getCEXDatabase()[chain] || [];
+  for (const group of groups) {
+    const wallet = group.wallets.find((w) => w.address.toLowerCase() === address.toLowerCase());
+    if (wallet) {
+      return {
+        cexName: group.name,
+        type: wallet.type,
+        isMain: wallet.isMain
+      };
+    }
+  }
+  return null;
+}
+function detectCEXPattern(txCount, uniqueSenders, uniqueRecipients, avgTxValue, totalVolume) {
+  const signals = [];
+  let score = 0;
+  if (txCount > 1e4) {
+    score += 30;
+    signals.push("veryHighTxCount");
+  } else if (txCount > 1e3) {
+    score += 20;
+    signals.push("highTxCount");
+  }
+  if (uniqueSenders > 100) {
+    score += 25;
+    signals.push("manyUniqueSenders");
+  } else if (uniqueSenders > 20) {
+    score += 15;
+    signals.push("multipleSenders");
+  }
+  if (uniqueRecipients < uniqueSenders * 0.3 && uniqueSenders > 50) {
+    score += 20;
+    signals.push("oneWayFlow");
+  }
+  if (avgTxValue > 1e4) {
+    score += 15;
+    signals.push("highAvgValue");
+  } else if (avgTxValue > 1e3) {
+    score += 10;
+    signals.push("mediumAvgValue");
+  }
+  if (totalVolume > 1e6) {
+    score += 10;
+    signals.push("veryHighVolume");
+  }
+  return {
+    isCEX: score >= 50,
+    score: Math.min(score, 100),
+    signals
+  };
+}
+var cexDatabase, CEX_WALLETS;
+var init_cexWallets = __esm({
+  "src/data/cexWallets.ts"() {
+    cexDatabase = null;
+    CEX_WALLETS = {
+      ethereum: [
+        {
+          name: "Binance",
+          wallets: [
+            { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Hot Wallet 20", chain: "ethereum", type: "hot", isMain: true },
+            { address: "0x631fc1ea2270e98fbd9d92658ece0f5a269aa161", name: "Binance: Hot Wallet", chain: "ethereum", type: "hot", isMain: false },
+            { address: "0x28fA6C20b26Be9bAd1d89E5e8E2d1F5C5e3dE4aF", name: "Binance: Deposit Wallet", chain: "ethereum", type: "deposit", isMain: false }
+          ]
+        },
+        {
+          name: "Coinbase",
+          wallets: [
+            { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase 2", chain: "ethereum", type: "hot", isMain: true },
+            { address: "0xb1697cea2605d1dBa32d94A72d8CBfCFB8f55aC9", name: "Coinbase: Hot Wallet", chain: "ethereum", type: "hot", isMain: false },
+            { address: "0xA5d1d5d9a8E7a8d1E5c8a9f2d3c4B5e6f7a8b9c0", name: "Coinbase: Deposit", chain: "ethereum", type: "deposit", isMain: false }
+          ]
+        },
+        {
+          name: "Kraken",
+          wallets: [
+            { address: "0xe9f7ecae3a53d2a67105292894676b00d1fab785", name: "Kraken: Hot Wallet", chain: "ethereum", type: "hot", isMain: true },
+            { address: "0xf30ba13e4b04ce5dc4d254ae5fa95477800f0eb0", name: "Kraken: Hot Wallet 2", chain: "ethereum", type: "hot", isMain: false },
+            { address: "0x05ff6964d21e5dae3b1010d5ae0465b3c450f381", name: "Kraken: Hot Wallet 4", chain: "ethereum", type: "hot", isMain: false }
+          ]
+        },
+        {
+          name: "Bybit",
+          wallets: [
+            { address: "0xf89d7b9c864f589bbf53a82105107622b35eaa40", name: "Bybit: Hot Wallet", chain: "ethereum", type: "hot", isMain: true },
+            { address: "0x4BC195D2dC6Bf3B8e1C5b7e1D5C9aF3E2b7d1C0a", name: "Bybit: Deposit", chain: "ethereum", type: "deposit", isMain: false }
+          ]
+        },
+        {
+          name: "OKX",
+          wallets: [
+            { address: "0x4b4e14a3773ee558b6597070797fd51eb48606e5", name: "OKX: Hot Wallet", chain: "ethereum", type: "hot", isMain: true },
+            { address: "0x559432e18b281731c054cd703d4b49872be4ed53", name: "OKX: Hot Wallet 5", chain: "ethereum", type: "hot", isMain: false }
+          ]
+        },
+        {
+          name: "KuCoin",
+          wallets: [
+            { address: "0x53f78a071d04224b8e254e243fffc6d9f2f3fa23", name: "KuCoin: Hot Wallet 2", chain: "ethereum", type: "hot", isMain: true }
+          ]
+        },
+        {
+          name: "Bitget",
+          wallets: [
+            { address: "0x19e2A56B1F0C7c12d9a4f4a5d7C8E3F2a1b0c9d8", name: "Bitget: Hot Wallet", chain: "ethereum", type: "hot", isMain: true }
+          ]
+        },
+        {
+          name: "Gate.io",
+          wallets: [
+            { address: "0x0f5d2A7B8E1d2C3a4b5e6f7a8b9c0d1e2f3a4b5", name: "Gate.io: Hot Wallet", chain: "ethereum", type: "hot", isMain: true }
+          ]
+        }
+      ],
+      linea: [
+        {
+          name: "Binance",
+          wallets: [
+            { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Linea Hot Wallet", chain: "linea", type: "hot", isMain: true }
+          ]
+        },
+        {
+          name: "Coinbase",
+          wallets: [
+            { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: Linea", chain: "linea", type: "hot", isMain: true }
+          ]
+        }
+      ],
+      arbitrum: [
+        {
+          name: "Binance",
+          wallets: [
+            { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Arbitrum Hot Wallet", chain: "arbitrum", type: "hot", isMain: true }
+          ]
+        },
+        {
+          name: "Coinbase",
+          wallets: [
+            { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: Arbitrum", chain: "arbitrum", type: "hot", isMain: true }
+          ]
+        }
+      ],
+      base: [
+        {
+          name: "Binance",
+          wallets: [
+            { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Base Hot Wallet", chain: "base", type: "hot", isMain: true }
+          ]
+        }
+      ],
+      optimism: [
+        {
+          name: "Binance",
+          wallets: [
+            { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Optimism Hot Wallet", chain: "optimism", type: "hot", isMain: true }
+          ]
+        },
+        {
+          name: "Coinbase",
+          wallets: [
+            { address: "0x503828976d22510aad0201ac7ec88293211d23da", name: "Coinbase: Optimism", chain: "optimism", type: "hot", isMain: true }
+          ]
+        }
+      ],
+      polygon: [
+        {
+          name: "Binance",
+          wallets: [
+            { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: Polygon Hot Wallet", chain: "polygon", type: "hot", isMain: true }
+          ]
+        }
+      ],
+      bsc: [
+        {
+          name: "Binance",
+          wallets: [
+            { address: "0xF977814e90dA44bFA03b6295A0616a897441aceC", name: "Binance: BSC Hot Wallet", chain: "bsc", type: "hot", isMain: true },
+            { address: "0x0E09FaBB73Bd3ade0a17ECC321fD13a19e81cE82", name: "Binance: Cake", chain: "bsc", type: "hot", isMain: false }
+          ]
+        }
+      ]
+    };
+  }
+});
+
+// src/services/EntityService.ts
+var EntityService_exports = {};
+__export(EntityService_exports, {
+  EntityService: () => EntityService
+});
+var CACHE_TTL2, BULK_CACHE_TTL, EntityService;
+var init_EntityService = __esm({
+  "src/services/EntityService.ts"() {
+    init_entities();
+    init_cexWallets();
+    init_cache();
+    CACHE_TTL2 = 300;
+    BULK_CACHE_TTL = 60;
+    EntityService = class _EntityService {
+      /**
+       * Look up a single address on a specific chain
+       */
+      static lookupEntity(chain, address) {
+        if (!address || !chain) return null;
+        const cacheKey = `entity:${chain}:${address.toLowerCase()}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const entity = getEntity(chain, address);
+        if (entity) {
+          cache.set(cacheKey, entity, CACHE_TTL2);
+          return entity;
+        }
+        const cexInfo = getCEXInfo(address, chain);
+        if (cexInfo) {
+          const cexEntity = {
+            address,
+            name: cexInfo.cexName,
+            category: "cex",
+            chain,
+            confidence: 0.9,
+            source: "manual",
+            verified: true,
+            tags: ["cex", cexInfo.type]
+          };
+          cache.set(cacheKey, cexEntity, CACHE_TTL2);
+          return cexEntity;
+        }
+        cache.set(cacheKey, null, CACHE_TTL2);
+        return null;
+      }
+      /**
+       * Look up multiple addresses in batch
+       */
+      static bulkLookup(chain, addresses) {
+        if (!addresses.length) return {};
+        const cacheKey = `entity:bulk:${chain}:${addresses.length}`;
+        const cached = cache.get(cacheKey);
+        if (cached) return cached;
+        const results = {};
+        for (const addr of addresses) {
+          results[addr.toLowerCase()] = _EntityService.lookupEntity(chain, addr);
+        }
+        cache.set(cacheKey, results, BULK_CACHE_TTL);
+        return results;
+      }
+      /**
+       * Search entities by name
+       */
+      static search(query, chain, category) {
+        if (!query || query.length < 2) return [];
+        return searchEntities(query, chain, category);
+      }
+      /**
+       * Cross-chain entity lookup (try all chains)
+       */
+      static findEntityAnyChain(address) {
+        if (!address) return null;
+        return findEntityByAddress(address) || null;
+      }
+      /**
+       * Auto-detect entity type from transaction patterns (for unknown addresses)
+       */
+      static detectEntityType(address, txCount, uniqueSenders, uniqueRecipients, totalVolumeInEth, avgTxValueInEth) {
+        const cexPattern = detectCEXPattern(
+          txCount,
+          uniqueSenders,
+          uniqueRecipients,
+          avgTxValueInEth,
+          totalVolumeInEth
+        );
+        const signals = [];
+        let entityType = "wallet";
+        let score = 0;
+        if (cexPattern.isCEX) {
+          return {
+            entityType: "cex",
+            score: cexPattern.score,
+            signals: cexPattern.signals
+          };
+        }
+        if (txCount > 0 && uniqueSenders === 0 && uniqueRecipients === 0) {
+          entityType = "contract";
+          score = 0.5;
+          signals.push("no_user_transactions");
+        }
+        if (txCount > 50 && uniqueRecipients < 5 && totalVolumeInEth > 100) {
+          score = Math.max(score, 0.6);
+          entityType = "protocol";
+          signals.push("high_volume_few_recipients");
+        }
+        if (score < 0.3) return null;
+        return { entityType, score: Math.round(score * 100), signals };
+      }
+    };
+  }
+});
+
+// src/mcp/handlers.ts
+var handlers_exports = {};
+__export(handlers_exports, {
+  TOOL_HANDLERS: () => TOOL_HANDLERS
+});
+function ok(text) {
+  return { content: [{ type: "text", text }] };
+}
+function err(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function buildApiKeyConfig() {
+  const alchemyKeys = process.env.ALCHEMY_API_KEYS?.split(",") || [];
+  return {
+    alchemy: process.env.DEFAULT_ALCHEMY_API_KEY || alchemyKeys[0] || "",
+    moralis: process.env.MORALIS_API_KEY || "",
+    etherscan: process.env.ETHERSCAN_API_KEY || process.env.DEFAULT_ETHERSCAN_API_KEY || "",
+    lineascan: process.env.LINEASCAN_API_KEY || process.env.DEFAULT_ETHERSCAN_API_KEY || "",
+    arbiscan: process.env.ARBISCAN_API_KEY || process.env.DEFAULT_ETHERSCAN_API_KEY || "",
+    basescan: process.env.BASESCAN_API_KEY || process.env.DEFAULT_ETHERSCAN_API_KEY || "",
+    optimism: process.env.OPTIMISM_API_KEY || process.env.DEFAULT_ETHERSCAN_API_KEY || "",
+    polygonscan: process.env.POLYGONSCAN_API_KEY || process.env.DEFAULT_ETHERSCAN_API_KEY || ""
+  };
+}
+function buildSybilConfig() {
+  const alchemyKeys = process.env.ALCHEMY_API_KEYS?.split(",") || [];
+  const defaultKey = process.env.DEFAULT_ALCHEMY_API_KEY || alchemyKeys[0] || "";
+  return {
+    defaultKey,
+    moralisKey: process.env.MORALIS_API_KEY || "",
+    contractKeys: [defaultKey, ...alchemyKeys].filter(Boolean),
+    walletKeys: [defaultKey, ...alchemyKeys].filter(Boolean)
+  };
+}
+function summarizeTree(node) {
+  if (!node) return null;
+  return {
+    address: node.address,
+    label: node.label,
+    totalValueInEth: node.totalValueInEth,
+    txCount: node.txCount,
+    suspiciousScore: node.suspiciousScore,
+    suspiciousReasons: node.suspiciousReasons,
+    children: node.children?.map(summarizeTree) || []
+  };
+}
+var analyzeWallet, traceFunds, compareWallets, analyzeContract, detectSybilClusters, getPortfolio, getTransactions, lookupEntity, getGasPrices, getTokenInfo, TOOL_HANDLERS;
+var init_handlers = __esm({
+  "src/mcp/handlers.ts"() {
+    analyzeWallet = async (args, ctx) => {
+      const { address, chainId, transactionLimit } = args;
+      try {
+        const { WalletAnalyzer } = await import("fundtracer-core");
+        const analyzer = new WalletAnalyzer(buildApiKeyConfig(), (progress) => {
+          console.error(`[MCP] analyze_wallet ${address}: ${progress.stage} ${progress.current}/${progress.total}`);
+        });
+        const result = await analyzer.analyze(address, chainId, {
+          transactionLimit: transactionLimit || 500
+        });
+        return ok(JSON.stringify({
+          address: result.wallet.address,
+          chain: chainId,
+          balanceEth: result.wallet.balanceInEth,
+          txCount: result.wallet.txCount,
+          isContract: result.wallet.isContract,
+          riskScore: result.overallRiskScore,
+          riskLevel: result.riskLevel,
+          suspiciousIndicators: result.suspiciousIndicators.map((i) => ({
+            type: i.type,
+            severity: i.severity,
+            description: i.description,
+            score: i.score
+          })),
+          topFundingSources: result.summary.topFundingSources.slice(0, 5),
+          topFundingDestinations: result.summary.topFundingDestinations.slice(0, 5),
+          projectsInteracted: result.projectsInteracted.slice(0, 10),
+          activityPeriodDays: result.summary.activityPeriodDays,
+          averageTxPerDay: result.summary.averageTxPerDay
+        }, null, 2));
+      } catch (error) {
+        return err(`Wallet analysis failed: ${error.message}`);
+      }
+    };
+    traceFunds = async (args, ctx) => {
+      const { address, chainId, maxDepth = 3, direction = "both" } = args;
+      try {
+        const { WalletAnalyzer } = await import("fundtracer-core");
+        const analyzer = new WalletAnalyzer(buildApiKeyConfig());
+        const treeConfig = { maxDepth, direction };
+        if (chainId === "solana") {
+          const { SolanaFundingTreeService: SolanaFundingTreeService2 } = await Promise.resolve().then(() => (init_SolanaFundingTreeService(), SolanaFundingTreeService_exports));
+          const heliusKey = process.env.HELIUS_KEY_1 || process.env.DEFAULT_ALCHEMY_API_KEY || "";
+          const svc = new SolanaFundingTreeService2(heliusKey.startsWith("http") ? process.env.DEFAULT_ALCHEMY_API_KEY || "" : heliusKey);
+          const tree2 = await svc.buildFundingTree(address, maxDepth);
+          return ok(JSON.stringify(tree2, null, 2));
+        }
+        const tree = await analyzer.buildFundingTree(address, chainId, { treeConfig });
+        return ok(JSON.stringify({
+          sources: summarizeTree(tree.fundingSources),
+          destinations: summarizeTree(tree.fundingDestinations)
+        }, null, 2));
+      } catch (error) {
+        return err(`Fund tracing failed: ${error.message}`);
+      }
+    };
+    compareWallets = async (args, ctx) => {
+      const { addresses, chainId } = args;
+      const addrList = addresses.split(",").map((a) => a.trim()).filter(Boolean);
+      if (addrList.length < 2) return err("At least 2 addresses required");
+      try {
+        const { WalletAnalyzer } = await import("fundtracer-core");
+        const analyzer = new WalletAnalyzer(buildApiKeyConfig());
+        const result = await analyzer.compareWallets(addrList, chainId);
+        return ok(JSON.stringify({
+          wallets: addrList,
+          chain: chainId,
+          correlationScore: result.correlationScore,
+          isSybilLikely: result.isSybilLikely,
+          commonFundingSources: result.commonFundingSources,
+          commonDestinations: result.commonDestinations,
+          sharedProjects: result.sharedProjects,
+          directTransfers: result.directTransfers.length
+        }, null, 2));
+      } catch (error) {
+        return err(`Wallet comparison failed: ${error.message}`);
+      }
+    };
+    analyzeContract = async (args, ctx) => {
+      const { contractAddress, chainId, maxInteractors = 100 } = args;
+      try {
+        const { WalletAnalyzer } = await import("fundtracer-core");
+        const analyzer = new WalletAnalyzer(buildApiKeyConfig());
+        const result = await analyzer.analyzeContract(contractAddress, chainId, {
+          maxInteractors
+        });
+        return ok(JSON.stringify({
+          contractAddress,
+          chain: chainId,
+          totalInteractors: result.totalInteractors,
+          riskScore: result.riskScore,
+          sharedFundingGroups: result.sharedFundingGroups.slice(0, 20),
+          suspiciousPatterns: result.suspiciousPatterns
+        }, null, 2));
+      } catch (error) {
+        return err(`Contract analysis failed: ${error.message}`);
+      }
+    };
+    detectSybilClusters = async (args, ctx) => {
+      const { addresses, chainId } = args;
+      const addrList = addresses.split(",").map((a) => a.trim()).filter(Boolean);
+      if (addrList.length < 3) return err("At least 3 addresses required for cluster detection");
+      try {
+        const { SybilAnalyzer } = await import("fundtracer-core");
+        const alchemyKey = process.env.DEFAULT_ALCHEMY_API_KEY || "";
+        const sybilConfig = buildSybilConfig();
+        const analyzer = new SybilAnalyzer(chainId, sybilConfig);
+        const result = await analyzer.analyzeAddresses(addrList, { minClusterSize: 2 });
+        return ok(JSON.stringify({
+          chain: chainId,
+          totalWallets: result.totalInteractors,
+          uniqueFundingSources: result.uniqueFundingSources,
+          flaggedClusters: result.flaggedClusters.map((c) => ({
+            fundingSource: c.fundingSource,
+            fundingSourceLabel: c.fundingSourceLabel,
+            walletCount: c.totalWallets,
+            sybilScore: c.sybilScore,
+            flags: c.flags,
+            timeSpanHours: c.timeSpan.durationHours
+          })),
+          summary: result.summary
+        }, null, 2));
+      } catch (error) {
+        return err(`Sybil detection failed: ${error.message}`);
+      }
+    };
+    getPortfolio = async (args, ctx) => {
+      const { address, chainId } = args;
+      try {
+        if (chainId === "solana") {
+          const { solanaPortfolioService: solanaPortfolioService2 } = await Promise.resolve().then(() => (init_SolanaPortfolioService(), SolanaPortfolioService_exports));
+          const portfolio = await solanaPortfolioService2.getPortfolio(address);
+          return ok(JSON.stringify(portfolio, null, 2));
+        }
+        return ok(JSON.stringify({
+          address,
+          chainId,
+          note: "For EVM chain portfolio data, use the FundTracer REST API: GET /api/portfolio?address=" + address + "&chain=" + chainId
+        }, null, 2));
+      } catch (error) {
+        return err(`Portfolio fetch failed: ${error.message}`);
+      }
+    };
+    getTransactions = async (args, ctx) => {
+      const { address, chainId, limit = 50 } = args;
+      try {
+        const { WalletAnalyzer } = await import("fundtracer-core");
+        const analyzer = new WalletAnalyzer(buildApiKeyConfig());
+        const result = await analyzer.analyze(address, chainId, {
+          transactionLimit: limit,
+          skipFundingTree: true
+        });
+        return ok(JSON.stringify({
+          address,
+          chainId,
+          transactions: result.transactions.slice(0, limit).map((tx) => ({
+            hash: tx.hash,
+            blockNumber: tx.blockNumber,
+            timestamp: tx.timestamp,
+            from: tx.from,
+            to: tx.to,
+            value: tx.valueInEth,
+            status: tx.status,
+            category: tx.category,
+            methodName: tx.methodName
+          })),
+          totalCount: result.transactions.length
+        }, null, 2));
+      } catch (error) {
+        return err(`Transaction fetch failed: ${error.message}`);
+      }
+    };
+    lookupEntity = async (args, ctx) => {
+      const { query, chainId } = args;
+      try {
+        const { EntityService: EntityService2 } = await Promise.resolve().then(() => (init_EntityService(), EntityService_exports));
+        const chain = chainId || "ethereum";
+        if (/^0x[a-fA-F0-9]{40}$/.test(query) || /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(query)) {
+          const entity = EntityService2.lookupEntity(chain, query);
+          if (entity) return ok(JSON.stringify(entity, null, 2));
+          return ok(JSON.stringify({ address: query, label: "Unknown address", chain }, null, 2));
+        }
+        const { searchEntities: searchEntities2 } = await Promise.resolve().then(() => (init_entities(), entities_exports));
+        const results = searchEntities2(query);
+        return ok(JSON.stringify({ query, results: results.length > 0 ? results.slice(0, 20) : "No entities found" }, null, 2));
+      } catch (error) {
+        return err(`Entity lookup failed: ${error.message}`);
+      }
+    };
+    getGasPrices = async (args, ctx) => {
+      try {
+        const { default: axios } = await import("axios");
+        const alchemyKey = process.env.DEFAULT_ALCHEMY_API_KEY;
+        if (!alchemyKey) return err("Alchemy API key not configured");
+        const chains = {
+          ethereum: `https://eth-mainnet.g.alchemy.com/v2/${alchemyKey}`,
+          base: `https://base-mainnet.g.alchemy.com/v2/${alchemyKey}`,
+          arbitrum: `https://arb-mainnet.g.alchemy.com/v2/${alchemyKey}`,
+          optimism: `https://opt-mainnet.g.alchemy.com/v2/${alchemyKey}`,
+          polygon: `https://polygon-mainnet.g.alchemy.com/v2/${alchemyKey}`
+        };
+        const results = {};
+        for (const [chain, url] of Object.entries(chains)) {
+          try {
+            const res = await axios.post(url, {
+              jsonrpc: "2.0",
+              method: "eth_gasPrice",
+              params: [],
+              id: 1
+            }, { timeout: 5e3 });
+            const gasWei = parseInt(res.data.result, 16);
+            results[chain] = {
+              gasPriceGwei: (gasWei / 1e9).toFixed(2),
+              gasPriceWei: gasWei
+            };
+          } catch {
+            results[chain] = { error: "Unavailable" };
+          }
+        }
+        return ok(JSON.stringify(results, null, 2));
+      } catch (error) {
+        return err(`Gas price fetch failed: ${error.message}`);
+      }
+    };
+    getTokenInfo = async (args, ctx) => {
+      const { tokenAddress, chainId } = args;
+      try {
+        const { default: axios } = await import("axios");
+        const coingeckoUrl = "https://api.coingecko.com/api/v3";
+        const platformMap = {
+          ethereum: "ethereum",
+          base: "base",
+          arbitrum: "arbitrum-ethereum",
+          optimism: "optimistic-ethereum",
+          polygon: "polygon-pos"
+        };
+        const platform = platformMap[chainId];
+        if (platform) {
+          const res = await axios.get(`${coingeckoUrl}/coins/${platform}/contract/${tokenAddress}`, {
+            timeout: 1e4,
+            headers: { "Accept": "application/json" }
+          });
+          const d = res.data;
+          return ok(JSON.stringify({
+            name: d.name,
+            symbol: d.symbol,
+            marketCapRank: d.market_cap_rank,
+            currentPrice: d.market_data?.current_price?.usd || null,
+            marketCap: d.market_data?.market_cap?.usd || null,
+            totalVolume: d.market_data?.total_volume?.usd || null,
+            priceChange24h: d.market_data?.price_change_percentage_24h || null,
+            description: d.description?.en?.substring(0, 500) || ""
+          }, null, 2));
+        }
+        const dsRes = await axios.get(`https://api.dexscreener.com/latest/dex/tokens/${tokenAddress}`, {
+          timeout: 5e3
+        });
+        return ok(JSON.stringify(dsRes.data?.pairs?.slice(0, 5) || { note: "No data found" }, null, 2));
+      } catch (error) {
+        return err(`Token info fetch failed: ${error.message}`);
+      }
+    };
+    TOOL_HANDLERS = {
+      analyze_wallet: analyzeWallet,
+      trace_funds: traceFunds,
+      compare_wallets: compareWallets,
+      analyze_contract: analyzeContract,
+      detect_sybil_clusters: detectSybilClusters,
+      get_portfolio: getPortfolio,
+      get_transactions: getTransactions,
+      lookup_entity: lookupEntity,
+      get_gas_prices: getGasPrices,
+      get_token_info: getTokenInfo
+    };
+  }
+});
+
+// src/models/apiKey.ts
+var apiKey_exports = {};
+__export(apiKey_exports, {
+  API_SCOPES: () => API_SCOPES,
+  TIER_DEFAULT_SCOPES: () => TIER_DEFAULT_SCOPES,
+  TIER_LIMITS: () => TIER_LIMITS,
+  checkRateLimit: () => checkRateLimit,
+  createAPIKey: () => createAPIKey,
+  deactivateAPIKey: () => deactivateAPIKey,
+  generateAPIKey: () => generateAPIKey,
+  generateMcpKey: () => generateMcpKey,
+  getAPIKeyById: () => getAPIKeyById,
+  getUserAPIKeys: () => getUserAPIKeys,
+  hasScope: () => hasScope,
+  hashAPIKey: () => hashAPIKey,
+  incrementAPIKeyUsage: () => incrementAPIKeyUsage,
+  resetDailyUsageIfNeeded: () => resetDailyUsageIfNeeded,
+  updateAPIKeyTier: () => updateAPIKeyTier,
+  validateAPIKey: () => validateAPIKey
+});
+import { FieldValue } from "firebase-admin/firestore";
+function generateAPIKey(type = "live") {
+  const prefix = type === "live" ? "ft_live_" : type === "mcp" ? "ft_mcp_" : "ft_test_";
+  const randomPart = generateSecureRandom(32);
+  return `${prefix}${randomPart}`;
+}
+function generateMcpKey() {
+  return generateAPIKey("mcp");
+}
+function generateSecureRandom(length) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const array = new Uint8Array(length);
+  __require("crypto").randomFillSync(array);
+  return Array.from(array, (byte) => chars[byte % chars.length]).join("");
+}
+function hashAPIKey(key) {
+  return __require("crypto").createHash("sha256").update(key).digest("hex");
+}
+async function createAPIKey(userId, options) {
+  const db = getFirestore();
+  const keyCollection = db.collection("apiKeys");
+  const tier = options.tier || "free";
+  const limits = TIER_LIMITS[tier];
+  const existingKeys = await keyCollection.where("userId", "==", userId).where("isActive", "==", true).get();
+  const currentKeyCount = existingKeys.size;
+  if (limits.maxKeys !== Infinity && currentKeyCount >= limits.maxKeys) {
+    throw new Error(`Maximum API keys (${limits.maxKeys}) reached for ${tier} tier. Upgrade to create more keys.`);
+  }
+  const keyType = options.keyType || "live";
+  const rawKey = generateAPIKey(keyType);
+  const keyHash = hashAPIKey(rawKey);
+  const keyPrefix = rawKey.split("_").slice(0, 2).join("_");
+  const scopes = options.scopes || TIER_DEFAULT_SCOPES[tier];
+  const now = Date.now();
+  const dailyReset = getDailyResetTimestamp();
+  const apiKey = {
+    id: keyCollection.doc().id,
+    userId,
+    keyHash,
+    keyPrefix,
+    keyType,
+    name: options.name,
+    scopes,
+    tier,
+    dailyUsage: 0,
+    dailyUsageReset: dailyReset,
+    lastUsed: now,
+    createdAt: now,
+    isActive: true,
+    expiresAt: options.expiresAt,
+    testnetOnly: options.testnetOnly || false
+  };
+  await keyCollection.doc(apiKey.id).set(apiKey);
+  return { key: apiKey, rawKey };
+}
+async function validateAPIKey(rawKey) {
+  const db = getFirestore();
+  const keyCollection = db.collection("apiKeys");
+  const snapshot = await keyCollection.where("isActive", "==", true).get();
+  const keyHash = hashAPIKey(rawKey);
+  for (const doc of snapshot.docs) {
+    const keyData = doc.data();
+    if (keyData.keyHash === keyHash) {
+      if (keyData.expiresAt && keyData.expiresAt < Date.now()) {
+        return null;
+      }
+      return keyData;
+    }
+  }
+  return null;
+}
+async function getAPIKeyById(keyId) {
+  const db = getFirestore();
+  const doc = await db.collection("apiKeys").doc(keyId).get();
+  return doc.exists ? doc.data() : null;
+}
+async function getUserAPIKeys(userId) {
+  const db = getFirestore();
+  const snapshot = await db.collection("apiKeys").where("userId", "==", userId).orderBy("createdAt", "desc").get();
+  return snapshot.docs.map((doc) => doc.data());
+}
+async function incrementAPIKeyUsage(userId, rawKey) {
+  console.log(`[INCREMENT] Starting - userId: ${userId}, rawKey: ${rawKey.substring(0, 15)}...`);
+  const db = getFirestore();
+  const now = Date.now();
+  try {
+    const topLevelRef = db.collection("apiKeys").doc(rawKey);
+    await topLevelRef.update({
+      lastUsed: now,
+      requests: FieldValue.increment(1)
+    });
+    console.log(`[INCREMENT] Updated top-level apiKeys/${rawKey.substring(0, 15)}...`);
+  } catch (err2) {
+    console.error(`[INCREMENT] Failed to update top-level apiKeys doc:`, err2);
+  }
+  try {
+    const subSnapshot = await db.collection("users").doc(userId).collection("apiKeys").where("key", "==", rawKey).limit(1).get();
+    if (!subSnapshot.empty) {
+      const subDoc = subSnapshot.docs[0];
+      await subDoc.ref.update({
+        lastUsed: now,
+        requests: FieldValue.increment(1)
+      });
+      console.log(`[INCREMENT] Updated subcollection doc ${subDoc.id} for key`);
+    } else {
+      console.warn(`[INCREMENT] No subcollection doc found for key ${rawKey.substring(0, 15)}...`);
+    }
+  } catch (err2) {
+    console.error(`[INCREMENT] Failed to update subcollection doc:`, err2);
+  }
+  try {
+    const topLevelDoc = await db.collection("apiKeys").doc(rawKey).get();
+    if (topLevelDoc.exists) {
+      const dailyReset = getDailyResetTimestamp();
+      await topLevelDoc.ref.update({
+        dailyUsage: FieldValue.increment(1),
+        dailyUsageReset: dailyReset
+      });
+    }
+  } catch (err2) {
+    console.error(`[INCREMENT] Failed to update daily usage:`, err2);
+  }
+  console.log(`[INCREMENT] Usage tracking complete for key: ${rawKey.substring(0, 15)}...`);
+}
+async function resetDailyUsageIfNeeded(key) {
+  if (key.dailyUsageReset < Date.now()) {
+    const db = getFirestore();
+    await db.collection("apiKeys").doc(key.id).update({
+      dailyUsage: 0,
+      dailyUsageReset: getDailyResetTimestamp()
+    });
+  }
+}
+async function checkRateLimit(key) {
+  const limits = TIER_LIMITS[key.tier];
+  const now = Date.now();
+  await resetDailyUsageIfNeeded(key);
+  return {
+    limit: limits.daily,
+    remaining: Math.max(0, limits.daily - key.dailyUsage),
+    reset: key.dailyUsageReset,
+    tier: key.tier
+  };
+}
+async function deactivateAPIKey(keyId, userId) {
+  const db = getFirestore();
+  const keyRef = db.collection("apiKeys").doc(keyId);
+  const doc = await keyRef.get();
+  if (!doc.exists || doc.data()?.userId !== userId) {
+    return false;
+  }
+  await keyRef.update({ isActive: false });
+  return true;
+}
+function hasScope(key, requiredScope) {
+  if (key.scopes.includes(API_SCOPES.ADMIN)) {
+    return true;
+  }
+  return key.scopes.includes(requiredScope);
+}
+function getDailyResetTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const tomorrow = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
+  return tomorrow.getTime();
+}
+async function updateAPIKeyTier(keyId, updates) {
+  const db = getFirestore();
+  await db.collection("apiKeys").doc(keyId).update({
+    ...updates.tier && { tier: updates.tier },
+    ...updates.scopes && { scopes: updates.scopes },
+    ...updates.expiresAt !== void 0 && { expiresAt: updates.expiresAt }
+  });
+}
+var API_SCOPES, TIER_LIMITS, TIER_DEFAULT_SCOPES;
+var init_apiKey = __esm({
+  "src/models/apiKey.ts"() {
+    init_firebase();
+    API_SCOPES = {
+      READ_ADDRESS: "read:address",
+      READ_TRANSACTIONS: "read:transactions",
+      READ_GRAPH: "read:graph",
+      WRITE_ALERTS: "write:alerts",
+      WRITE_WEBHOOKS: "write:webhooks",
+      ADMIN: "admin",
+      MCP: "mcp"
+    };
+    TIER_LIMITS = {
+      free: {
+        daily: 1e3,
+        perMinute: 100,
+        burst: 200,
+        maxKeys: 2,
+        endpoints: ["address", "transactions", "tokens", "risk"],
+        features: ["basic_address_info", "transaction_history"]
+      },
+      pro: {
+        daily: 1e4,
+        perMinute: 200,
+        burst: 400,
+        maxKeys: 10,
+        endpoints: ["address", "transactions", "tokens", "risk", "graph", "sources", "destinations", "analyze", "entities"],
+        features: ["full_graph_analysis", "async_analysis", "entity_detection"]
+      },
+      enterprise: {
+        daily: 1e5,
+        perMinute: 300,
+        burst: 1e3,
+        maxKeys: Infinity,
+        endpoints: ["*"],
+        features: ["*", "webhooks", "alerts", "websocket", "priority_support"]
+      }
+    };
+    TIER_DEFAULT_SCOPES = {
+      free: [API_SCOPES.READ_ADDRESS, API_SCOPES.READ_TRANSACTIONS],
+      pro: [
+        API_SCOPES.READ_ADDRESS,
+        API_SCOPES.READ_TRANSACTIONS,
+        API_SCOPES.READ_GRAPH,
+        API_SCOPES.WRITE_ALERTS
+      ],
+      enterprise: [API_SCOPES.ADMIN]
+    };
+  }
+});
+
+// src/mcp/mcpAuth.ts
+var mcpAuth_exports = {};
+__export(mcpAuth_exports, {
+  mcpApiKeyAuth: () => mcpApiKeyAuth,
+  validateMcpApiKey: () => validateMcpApiKey
+});
+async function validateMcpApiKey(rawKey) {
+  if (!rawKey.startsWith("ft_")) throw new Error("Invalid MCP API key format");
+  let firestoreResult = null;
+  try {
+    firestoreResult = await validateWithFirestore(rawKey);
+    if (firestoreResult) return firestoreResult;
+  } catch {
+  }
+  return validateViaHttp(rawKey);
+}
+async function validateWithFirestore(rawKey) {
+  const { getFirestore: getFirestore2 } = await Promise.resolve().then(() => (init_firebase(), firebase_exports));
+  const db = getFirestore2();
+  if (!db) return null;
+  const keyDoc = await db.collection("apiKeys").doc(rawKey).get();
+  if (keyDoc.exists) {
+    const data = keyDoc.data();
+    if (!data) throw new Error("Invalid MCP API key");
+    if (data.expiresAt && data.expiresAt < Date.now()) throw new Error("MCP API key has expired");
+    if (data.active === false) throw new Error("MCP API key has been revoked");
+    const scopes = data.scopes || [];
+    if (data.keyType !== "mcp" && !scopes.includes("mcp")) {
+      throw new Error("This API key does not have MCP access");
+    }
+    trackUsage(data.userId, rawKey);
+    return {
+      userId: data.userId,
+      tier: data.tier || "free",
+      apiKeyPrefix: rawKey.substring(0, 15)
+    };
+  }
+  const { hashAPIKey: hashAPIKey2 } = await Promise.resolve().then(() => (init_apiKey(), apiKey_exports));
+  const keyHash = hashAPIKey2(rawKey);
+  const snapshot = await db.collection("apiKeys").where("isActive", "==", true).get();
+  for (const doc of snapshot.docs) {
+    const data = doc.data();
+    if (data.keyHash === keyHash) {
+      if (data.expiresAt && data.expiresAt < Date.now()) throw new Error("MCP API key has expired");
+      if (!data.isActive) throw new Error("MCP API key has been revoked");
+      const scopes = data.scopes || [];
+      if (data.keyType !== "mcp" && !scopes.includes("mcp")) {
+        throw new Error("This API key does not have MCP access");
+      }
+      trackUsage(data.userId, rawKey);
+      return {
+        userId: data.userId,
+        tier: data.tier || "free",
+        apiKeyPrefix: rawKey.substring(0, 15)
+      };
+    }
+  }
+  return null;
+}
+async function validateViaHttp(rawKey) {
+  const API_URL = process.env.FUNDTRACER_API_URL || "https://api.fundtracer.xyz";
+  const { default: fetch5 } = await import("node-fetch");
+  const res = await fetch5(`${API_URL}/api/user/mcp-validate`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${rawKey}`
+    },
+    body: JSON.stringify({ key: rawKey })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(body ? JSON.parse(body).error || body : `Validation failed (HTTP ${res.status})`);
+  }
+  const data = await res.json();
+  return {
+    userId: data.userId,
+    tier: data.tier || "free",
+    apiKeyPrefix: rawKey.substring(0, 15)
+  };
+}
+async function trackUsage(userId, rawKey) {
+  try {
+    const { incrementAPIKeyUsage: incrementAPIKeyUsage2 } = await Promise.resolve().then(() => (init_apiKey(), apiKey_exports));
+    await incrementAPIKeyUsage2(userId, rawKey);
+  } catch {
+  }
+}
+async function mcpApiKeyAuth(req, res, next) {
+  const authHeader = req.headers.authorization;
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
+    return res.status(401).json({ error: "MCP API key required (Authorization: Bearer ft_mcp_<key>)" });
+  }
+  const rawKey = authHeader.slice(7).trim();
+  if (!rawKey.startsWith("ft_")) {
+    return res.status(401).json({ error: "Invalid MCP API key format" });
+  }
+  try {
+    const ctx = await validateMcpApiKey(rawKey);
+    req.mcpContext = ctx;
+    next();
+  } catch (err2) {
+    return res.status(401).json({ error: err2.message });
+  }
+}
+var init_mcpAuth = __esm({
+  "src/mcp/mcpAuth.ts"() {
+  }
+});
+
+// src/mcp/stdio.ts
+import * as dotenv from "dotenv";
+import { McpServer, StdioServerTransport, fromJsonSchema } from "@modelcontextprotocol/server";
+dotenv.config();
+async function main() {
+  let firebaseAvailable = false;
+  try {
+    const { initializeFirebase: initializeFirebase2 } = await Promise.resolve().then(() => (init_firebase(), firebase_exports));
+    initializeFirebase2();
+    firebaseAvailable = true;
+    console.error("[MCP] Firebase initialized");
+  } catch (err2) {
+    console.error("[MCP] Firebase not available \u2014 key validation will fail. Set Firebase credentials in env.");
+  }
+  const { ALL_MCP_TOOLS: ALL_MCP_TOOLS2 } = await Promise.resolve().then(() => (init_tools(), tools_exports));
+  const { TOOL_HANDLERS: TOOL_HANDLERS2 } = await Promise.resolve().then(() => (init_handlers(), handlers_exports));
+  const { validateMcpApiKey: validateMcpApiKey2 } = await Promise.resolve().then(() => (init_mcpAuth(), mcpAuth_exports));
+  const server = new McpServer({
+    name: "FundTracer MCP",
+    version: "1.0.0"
+  });
+  for (const toolDef of ALL_MCP_TOOLS2) {
+    const handler = TOOL_HANDLERS2[toolDef.name];
+    if (!handler) {
+      console.error(`[MCP] No handler for tool: ${toolDef.name}`);
+      continue;
+    }
+    server.registerTool(toolDef.name, {
+      description: toolDef.description,
+      inputSchema: fromJsonSchema(toolDef.inputSchema)
+    }, async (args) => {
+      const apiKey = process.env.FUNDTRACER_MCP_API_KEY;
+      if (!apiKey) {
+        return {
+          content: [{ type: "text", text: "FUNDTRACER_MCP_API_KEY environment variable not set" }],
+          isError: true
+        };
+      }
+      let ctx;
+      try {
+        ctx = await validateMcpApiKey2(apiKey);
+      } catch (err2) {
+        return {
+          content: [{ type: "text", text: `Authentication failed: ${err2.message}` }],
+          isError: true
+        };
+      }
+      return handler(args, ctx);
+    });
+    console.error(`[MCP] Registered tool: ${toolDef.name}`);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[MCP] FundTracer MCP server running on stdio");
+}
+main().catch((err2) => {
+  console.error("[MCP] Fatal error:", err2);
+  process.exit(1);
+});
+process.on("SIGINT", async () => {
+  console.error("[MCP] Shutting down...");
+  const { McpServer: McpServer2 } = await import("@modelcontextprotocol/server");
+  process.exit(0);
+});
+process.on("SIGTERM", async () => {
+  console.error("[MCP] Shutting down...");
+  process.exit(0);
+});