@elizaos/plugin-social-alpha 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/service.js

@@ -0,0 +1,3078 @@
+import {
+  asUUID,
+  ChannelType,
+  logger as coreLogger,
+  createUniqueUuid,
+  ModelType,
+  Service
+} from "@elizaos/core";
+function toJsonRecord(value) {
+  return JSON.parse(JSON.stringify(value ?? {}));
+}
+function logValue(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) return value.stack ?? value.message;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+const logger = {
+  debug: (...args) => coreLogger.debug(args.map(logValue).join(" ")),
+  info: (...args) => coreLogger.info(args.map(logValue).join(" ")),
+  warn: (...args) => coreLogger.warn(args.map(logValue).join(" ")),
+  error: (...args) => coreLogger.error(args.map(logValue).join(" "))
+};
+import { v4 as uuidv4 } from "uuid";
+import { BirdeyeClient, DexscreenerClient, HeliusClient } from "./clients.js";
+import {
+  DEFAULT_TRADING_CONFIG,
+  getConvictionMultiplier,
+  getLiquidityMultiplier,
+  getMarketCapMultiplier,
+  getVolumeMultiplier,
+  TRUST_LEADERBOARD_WORLD_SEED
+} from "./config.js";
+import { formatFullReport } from "./reports.js";
+import { BalancedTrustScoreCalculator } from "./services/balancedTrustScoreCalculator.js";
+import {
+  Conviction,
+  RecommendationType,
+  ServiceType,
+  SupportedChain,
+  TRUST_MARKETPLACE_COMPONENT_TYPE,
+  TransactionType
+} from "./types.js";
+function parseRecommendationExtraction(response) {
+  const parsed = parseJsonObject(
+    response
+  );
+  if (!parsed?.recommendations || !Array.isArray(parsed.recommendations)) {
+    return null;
+  }
+  return {
+    recommendations: parsed.recommendations.map((rec) => ({
+      ...rec,
+      messageIndex: typeof rec.messageIndex === "number" ? rec.messageIndex : Number.parseInt(String(rec.messageIndex ?? "0"), 10),
+      isCall: rec.isCall === true || String(rec.isCall).toLowerCase() === "true"
+    }))
+  };
+}
+function parseJsonObject(value) {
+  try {
+    const parsed = JSON.parse(value.trim());
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function asContentObject(value, requiredStringKeys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  const record = value;
+  for (const key of requiredStringKeys) {
+    if (typeof record[key] !== "string") {
+      return null;
+    }
+  }
+  return value;
+}
+function asTransaction(value) {
+  return asContentObject(value, ["positionId", "tokenAddress"]);
+}
+class CommunityInvestorService extends Service {
+  static serviceType = ServiceType.COMMUNITY_INVESTOR;
+  capabilityDescription = "Manages community-driven investment trust scores and recommendations.";
+  // Client instances
+  birdeyeClient;
+  dexscreenerClient;
+  heliusClient = null;
+  // Configuration
+  tradingConfig;
+  apiKeys = {};
+  balancedTrustCalculator;
+  // Constants can be defined here or loaded from config/settings
+  POSITIVE_TRADE_THRESHOLD = 10;
+  // Trust score above this might trigger a trade
+  NEUTRAL_MARGIN = 5;
+  // Trust scores within +/- this from 0 are neutral
+  RECENCY_WEIGHT_MONTHS = 6;
+  USER_TRADE_COOLDOWN_HOURS = 12;
+  METRIC_REFRESH_INTERVAL = 24 * 60 * 60 * 1e3;
+  // 1 day to re-evaluate metrics
+  // Add this property to the class
+  userRegistry = /* @__PURE__ */ new Set();
+  componentWorldId;
+  componentRoomId;
+  // This will be the same as componentWorldId
+  constructor(runtime) {
+    if (!runtime) {
+      throw new Error("CommunityInvestorService requires an agent runtime");
+    }
+    super(runtime);
+    this.runtime = runtime;
+    this.balancedTrustCalculator = new BalancedTrustScoreCalculator();
+    this.componentWorldId = createUniqueUuid(
+      runtime,
+      TRUST_LEADERBOARD_WORLD_SEED
+    );
+    this.componentRoomId = this.componentWorldId;
+    logger.info(
+      `[CommunityInvestorService] Using Component World/Room ID: ${this.componentWorldId}`
+    );
+    this.ensurePluginComponentContext();
+    this.birdeyeClient = BirdeyeClient.createFromRuntime(runtime);
+    this.dexscreenerClient = DexscreenerClient.createFromRuntime(runtime);
+    try {
+      this.heliusClient = HeliusClient.createFromRuntime(runtime);
+    } catch (error) {
+      logger.warn(
+        "Failed to initialize Helius client, holder data will be limited:",
+        error
+      );
+    }
+    this.tradingConfig = DEFAULT_TRADING_CONFIG;
+    this.initialize(runtime);
+    this.registerTaskWorkers(runtime);
+  }
+  static async start(runtime) {
+    const service = new CommunityInvestorService(runtime);
+    return service;
+  }
+  static async stop(runtime) {
+    const service = runtime.getService("trading");
+    if (service) {
+      await service.stop?.();
+    }
+  }
+  async stop() {
+    return Promise.resolve();
+  }
+  /**
+   * Process a buy signal from an entity
+   */
+  async processBuySignal(buySignal, entity) {
+    logger.debug("processing buy signal", buySignal, entity);
+    try {
+      if (!entity.id) {
+        logger.error("Entity ID is required for processing buy signal");
+        return null;
+      }
+      const tokenPerformance = await this.getOrFetchTokenPerformance(
+        buySignal.tokenAddress,
+        buySignal.chain || this.tradingConfig.defaultChain
+      );
+      if (!tokenPerformance) {
+        logger.error(`Token not found: ${buySignal.tokenAddress}`);
+        return null;
+      }
+      if (!this.validateToken(tokenPerformance)) {
+        logger.error(`Token failed validation: ${buySignal.tokenAddress}`);
+        return null;
+      }
+      const recommendation = await this.createTokenRecommendation(
+        entity.id,
+        tokenPerformance,
+        buySignal.conviction || Conviction.MEDIUM,
+        RecommendationType.BUY
+      );
+      if (!recommendation) {
+        logger.error(
+          `Failed to create recommendation for token: ${buySignal.tokenAddress}`
+        );
+        return null;
+      }
+      const buyAmount = this.calculateBuyAmount(
+        entity,
+        buySignal.conviction || Conviction.MEDIUM,
+        tokenPerformance
+      );
+      const position = await this.createPosition(
+        recommendation.id,
+        entity.id,
+        buySignal.tokenAddress,
+        buySignal.walletAddress || "simulation",
+        buyAmount,
+        tokenPerformance.price?.toString() || "0",
+        buySignal.isSimulation || this.tradingConfig.forceSimulation
+      );
+      if (!position) {
+        logger.error(
+          `Failed to create position for token: ${buySignal.tokenAddress}`
+        );
+        return null;
+      }
+      await this.recordTransaction(
+        position.id,
+        buySignal.tokenAddress,
+        TransactionType.BUY,
+        buyAmount,
+        tokenPerformance.price || 0,
+        position.isSimulation
+      );
+      return position;
+    } catch (error) {
+      logger.error("Error processing buy signal:", error);
+      return null;
+    }
+  }
+  /**
+   * Process a sell signal for an existing position
+   */
+  async processSellSignal(positionId, _sellRecommenderId) {
+    try {
+      logger.debug("processing sell signal", positionId, _sellRecommenderId);
+      const position = await this.getPosition(positionId);
+      if (!position) {
+        logger.error(`Position not found: ${positionId}`);
+        return false;
+      }
+      if (position.closedAt) {
+        logger.error(`Position already closed: ${positionId}`);
+        return false;
+      }
+      const tokenPerformance = await this.getOrFetchTokenPerformance(
+        position.tokenAddress,
+        position.chain
+      );
+      if (!tokenPerformance) {
+        logger.error(`Token not found: ${position.tokenAddress}`);
+        return false;
+      }
+      const initialPrice = Number.parseFloat(position.initialPrice);
+      const currentPrice = tokenPerformance.price || 0;
+      const priceChange = initialPrice > 0 ? (currentPrice - initialPrice) / initialPrice : 0;
+      const updatedPosition = {
+        ...position,
+        currentPrice: currentPrice.toString(),
+        closedAt: /* @__PURE__ */ new Date()
+      };
+      await this.storePosition(updatedPosition);
+      await this.recordTransaction(
+        position.id,
+        position.tokenAddress,
+        TransactionType.SELL,
+        BigInt(position.amount),
+        currentPrice,
+        position.isSimulation
+      );
+      await this.updateRecommenderMetrics(position.entityId, priceChange * 100);
+      return true;
+    } catch (error) {
+      logger.error("Error processing sell signal:", error);
+      return false;
+    }
+  }
+  /**
+   * Handle a recommendation from a entity
+   */
+  async handleRecommendation(entity, recommendation) {
+    try {
+      logger.debug("handling recommendation", entity, recommendation);
+      if (!entity.id) {
+        logger.error("Entity ID is required for handling recommendation");
+        return null;
+      }
+      const tokenPerformance = await this.getOrFetchTokenPerformance(
+        recommendation.tokenAddress,
+        recommendation.chain
+      );
+      if (!tokenPerformance) {
+        logger.error(`Token not found: ${recommendation.tokenAddress}`);
+        return null;
+      }
+      const tokenRecommendation = await this.createTokenRecommendation(
+        entity.id,
+        tokenPerformance,
+        recommendation.conviction,
+        recommendation.type
+      );
+      if (!tokenRecommendation) {
+        logger.error(
+          `Failed to create recommendation for token: ${recommendation.tokenAddress}`
+        );
+        return null;
+      }
+      if (recommendation.type === RecommendationType.BUY) {
+        const buyAmount = this.calculateBuyAmount(
+          entity,
+          recommendation.conviction,
+          tokenPerformance
+        );
+        const position = await this.createPosition(
+          tokenRecommendation.id,
+          entity.id,
+          recommendation.tokenAddress,
+          "simulation",
+          // Use simulation wallet by default
+          buyAmount,
+          tokenPerformance.price?.toString() || "0",
+          true
+          // Simulation by default
+        );
+        if (!position) {
+          logger.error(
+            `Failed to create position for token: ${recommendation.tokenAddress}`
+          );
+          return null;
+        }
+        await this.recordTransaction(
+          position.id,
+          recommendation.tokenAddress,
+          TransactionType.BUY,
+          buyAmount,
+          tokenPerformance.price || 0,
+          true
+          // Simulation by default
+        );
+        return position;
+      }
+      return null;
+    } catch (error) {
+      logger.error("Error handling recommendation:", error);
+      return null;
+    }
+  }
+  /**
+   * Check if a wallet is registered for a chain
+   */
+  hasWallet(chain) {
+    logger.debug("hasWallet", chain);
+    return chain.toLowerCase() === "solana";
+  }
+  // ===================== TOKEN PROVIDER METHODS =====================
+  /**
+   * Get token overview data
+   */
+  async getTokenOverview(chain, tokenAddress, forceRefresh = false) {
+    try {
+      logger.debug("getting token overview", chain, tokenAddress, forceRefresh);
+      if (!forceRefresh) {
+        const cacheKey = `token:${chain}:${tokenAddress}:overview`;
+        const cachedData = await this.runtime.getCache(cacheKey);
+        if (cachedData) {
+          return cachedData;
+        }
+        const tokenPerformance = await this.getTokenPerformance(
+          tokenAddress,
+          chain
+        );
+        if (tokenPerformance) {
+          const tokenData = {
+            chain: tokenPerformance.chain || chain,
+            address: tokenPerformance.address || tokenAddress,
+            name: tokenPerformance.name || "",
+            symbol: tokenPerformance.symbol || "",
+            decimals: tokenPerformance.decimals || 0,
+            metadata: tokenPerformance.metadata || {},
+            price: tokenPerformance.price || 0,
+            priceUsd: tokenPerformance.price?.toString() || "0",
+            price24hChange: tokenPerformance.price24hChange || 0,
+            marketCap: tokenPerformance.currentMarketCap || 0,
+            liquidityUsd: tokenPerformance.liquidity || 0,
+            volume24h: tokenPerformance.volume || 0,
+            volume24hChange: tokenPerformance.volume24hChange || 0,
+            trades: tokenPerformance.trades || 0,
+            trades24hChange: tokenPerformance.trades24hChange || 0,
+            uniqueWallet24h: 0,
+            // Would need to be fetched
+            uniqueWallet24hChange: 0,
+            // Would need to be fetched
+            holders: tokenPerformance.holders || 0
+          };
+          await this.runtime.setCache(
+            cacheKey,
+            tokenData
+          );
+          return tokenData;
+        }
+      }
+      if (chain.toLowerCase() === "solana") {
+        const [dexScreenerData, birdeyeData] = await Promise.all([
+          this.dexscreenerClient.searchForHighestLiquidityPair(
+            tokenAddress,
+            chain,
+            {
+              expires: "5m"
+            }
+          ),
+          this.birdeyeClient.fetchTokenOverview(
+            tokenAddress,
+            { expires: "5m" },
+            forceRefresh
+          )
+        ]);
+        const tokenData = {
+          chain,
+          address: tokenAddress,
+          name: birdeyeData?.name || dexScreenerData?.baseToken?.name || "",
+          symbol: birdeyeData?.symbol || dexScreenerData?.baseToken?.symbol || "",
+          decimals: birdeyeData?.decimals || 9,
+          // Default for Solana tokens
+          metadata: {
+            logoURI: birdeyeData?.logoURI || "",
+            pairAddress: dexScreenerData?.pairAddress || "",
+            dexId: dexScreenerData?.dexId || ""
+          },
+          price: Number.parseFloat(dexScreenerData?.priceUsd || "0"),
+          priceUsd: dexScreenerData?.priceUsd || "0",
+          price24hChange: dexScreenerData?.priceChange?.h24 || 0,
+          marketCap: dexScreenerData?.marketCap || 0,
+          liquidityUsd: dexScreenerData?.liquidity?.usd || 0,
+          volume24h: dexScreenerData?.volume?.h24 || 0,
+          volume24hChange: 0,
+          // Need to calculate from historical data
+          trades: 0,
+          // Would need additional data
+          trades24hChange: 0,
+          // Would need additional data
+          uniqueWallet24h: 0,
+          // Would need additional data
+          uniqueWallet24hChange: 0,
+          // Would need additional data
+          holders: 0
+        };
+        const cacheKey = `token:${chain}:${tokenAddress}:overview`;
+        await this.runtime.setCache(
+          cacheKey,
+          tokenData
+        );
+        return tokenData;
+      }
+      throw new Error(`Chain ${chain} not supported`);
+    } catch (error) {
+      logger.error(`Error fetching token overview for ${tokenAddress}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Resolve a ticker to a token address
+   */
+  async resolveTicker(ticker, chain = SupportedChain.SOLANA, contextMessages) {
+    logger.debug(
+      `[CommunityInvestorService] Attempting to resolve ticker "${ticker}" on chain ${chain}`
+    );
+    const cleanTicker = ticker.startsWith("$") ? ticker.substring(1).toUpperCase() : ticker.toUpperCase();
+    if (contextMessages) {
+      for (const msg of contextMessages.slice().reverse()) {
+        if (msg.content?.text?.includes(ticker) && msg.content.text.length > ticker.length + 5) {
+          const potentialAddressParts = msg.content.text.split(/[\s(),]+/);
+          for (const part of potentialAddressParts) {
+            if (chain === SupportedChain.SOLANA && part.length >= 32 && part.length <= 44 && /^[a-zA-Z0-9]+$/.test(part)) {
+              logger.info(
+                `[CommunityInvestorService] Found potential Solana address ${part} for ticker ${ticker} in context.`
+              );
+              return {
+                address: part,
+                chain: SupportedChain.SOLANA,
+                ticker: cleanTicker
+              };
+            }
+            if ((chain === SupportedChain.ETHEREUM || chain === SupportedChain.BASE) && part.length === 42 && part.toLowerCase().startsWith("0x") && /^0x[a-fA-F0-9]{40}$/.test(part)) {
+              logger.info(
+                `[CommunityInvestorService] Found potential Ethereum/Base address ${part} for ticker ${ticker} in context.`
+              );
+              return {
+                address: part,
+                chain,
+                ticker: cleanTicker
+              };
+            }
+          }
+        }
+      }
+    }
+    if (chain === SupportedChain.SOLANA) {
+      const knownSolanaTokens = {
+        SOL: "So11111111111111111111111111111111111111112",
+        USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+        USDT: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+        WIF: "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzL7WDb43cuQu2",
+        BONK: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
+        JUP: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
+        RAY: "4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R",
+        ORCA: "orcaEKTdK7LKz57vaAYr9QeNsVEPfiu6QeMU1kektZE",
+        SRM: "SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt",
+        FTT: "AGFEad2et2ZJif9jaGpdMixQqvW5i81aBdvKe7PHNfz3"
+      };
+      if (knownSolanaTokens[cleanTicker]) {
+        return {
+          address: knownSolanaTokens[cleanTicker],
+          chain: SupportedChain.SOLANA,
+          ticker: cleanTicker
+        };
+      }
+      try {
+        const searchResults = await this.dexscreenerClient.search(cleanTicker, {
+          expires: "5m"
+        });
+        if (searchResults?.pairs && searchResults.pairs.length > 0) {
+          const bestPair = searchResults.pairs.filter(
+            (pair) => pair.baseToken.symbol.toUpperCase() === cleanTicker
+          ).sort(
+            (a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0)
+          )[0];
+          if (bestPair) {
+            logger.info(
+              `[CommunityInvestorService] Found ${cleanTicker} via DexScreener: ${bestPair.baseToken.address}`
+            );
+            return {
+              address: bestPair.baseToken.address,
+              chain: SupportedChain.SOLANA,
+              ticker: cleanTicker
+            };
+          }
+        }
+      } catch (error) {
+        logger.warn(
+          `[CommunityInvestorService] DexScreener search failed for ${cleanTicker}:`,
+          error
+        );
+      }
+    } else if (chain === SupportedChain.ETHEREUM) {
+      const knownEthereumTokens = {
+        ETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        USDC: "0xA0b86a33E6441c69De69b9A87e20b88dd75B61FC",
+        USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        DAI: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        LINK: "0x514910771AF9Ca656af840dff83E8264EcF986CA",
+        UNI: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
+        WBTC: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+      };
+      if (knownEthereumTokens[cleanTicker]) {
+        return {
+          address: knownEthereumTokens[cleanTicker],
+          chain: SupportedChain.ETHEREUM,
+          ticker: cleanTicker
+        };
+      }
+      try {
+        const searchResults = await this.dexscreenerClient.search(cleanTicker, {
+          expires: "5m"
+        });
+        if (searchResults?.pairs && searchResults.pairs.length > 0) {
+          const bestPair = searchResults.pairs.filter(
+            (pair) => pair.chainId.toLowerCase() === "ethereum" && pair.baseToken.symbol.toUpperCase() === cleanTicker
+          ).sort(
+            (a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0)
+          )[0];
+          if (bestPair) {
+            logger.info(
+              `[CommunityInvestorService] Found ${cleanTicker} via DexScreener on Ethereum: ${bestPair.baseToken.address}`
+            );
+            return {
+              address: bestPair.baseToken.address,
+              chain: SupportedChain.ETHEREUM,
+              ticker: cleanTicker
+            };
+          }
+        }
+      } catch (error) {
+        logger.warn(
+          `[CommunityInvestorService] DexScreener search failed for ${cleanTicker} on Ethereum:`,
+          error
+        );
+      }
+    } else if (chain === SupportedChain.BASE) {
+      const knownBaseTokens = {
+        ETH: "0x4200000000000000000000000000000000000006",
+        // Base ETH
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006"
+      };
+      if (knownBaseTokens[cleanTicker]) {
+        return {
+          address: knownBaseTokens[cleanTicker],
+          chain: SupportedChain.BASE,
+          ticker: cleanTicker
+        };
+      }
+      try {
+        const searchResults = await this.dexscreenerClient.search(cleanTicker, {
+          expires: "5m"
+        });
+        if (searchResults?.pairs && searchResults.pairs.length > 0) {
+          const bestPair = searchResults.pairs.filter(
+            (pair) => pair.chainId.toLowerCase() === "base" && pair.baseToken.symbol.toUpperCase() === cleanTicker
+          ).sort(
+            (a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0)
+          )[0];
+          if (bestPair) {
+            logger.info(
+              `[CommunityInvestorService] Found ${cleanTicker} via DexScreener on Base: ${bestPair.baseToken.address}`
+            );
+            return {
+              address: bestPair.baseToken.address,
+              chain: SupportedChain.BASE,
+              ticker: cleanTicker
+            };
+          }
+        }
+      } catch (error) {
+        logger.warn(
+          `[CommunityInvestorService] DexScreener search failed for ${cleanTicker} on Base:`,
+          error
+        );
+      }
+    }
+    logger.warn(
+      `[CommunityInvestorService] Could not resolve ticker ${ticker} on chain ${chain}`
+    );
+    return null;
+  }
+  /**
+   * Get current price for a token
+   */
+  async getCurrentPrice(chain, tokenAddress) {
+    logger.debug("getting current price", chain, tokenAddress);
+    try {
+      const cacheKey = `token:${chain}:${tokenAddress}:price`;
+      const cachedPrice = await this.runtime.getCache(cacheKey);
+      if (cachedPrice) {
+        return Number.parseFloat(cachedPrice);
+      }
+      const token = await this.getTokenPerformance(tokenAddress, chain);
+      if (token?.price) {
+        await this.runtime.setCache(cacheKey, token.price.toString());
+        return token.price;
+      }
+      if (chain.toLowerCase() === "solana") {
+        const price = await this.birdeyeClient.fetchPrice(tokenAddress, {
+          chain: "solana"
+        });
+        await this.runtime.setCache(cacheKey, price.toString());
+        return price;
+      }
+      throw new Error(`Chain ${chain} not supported for price fetching`);
+    } catch (error) {
+      logger.error(`Error fetching current price for ${tokenAddress}:`, error);
+      return 0;
+    }
+  }
+  /**
+   * Determine if a token should be traded
+   */
+  async shouldTradeToken(chain, tokenAddress) {
+    logger.debug("shouldTradeToken", chain, tokenAddress);
+    try {
+      const tokenData = await this.getProcessedTokenData(chain, tokenAddress);
+      if (!tokenData) return false;
+      const { tradeData, security, dexScreenerData } = tokenData;
+      if (!dexScreenerData?.pairs || dexScreenerData.pairs.length === 0) {
+        return false;
+      }
+      const pair = dexScreenerData.pairs[0];
+      if (!pair.liquidity || pair.liquidity.usd < this.tradingConfig.minLiquidityUsd) {
+        return false;
+      }
+      if (!pair.marketCap || pair.marketCap > this.tradingConfig.maxMarketCapUsd) {
+        return false;
+      }
+      if (security && security.top10HolderPercent > 80) {
+        return false;
+      }
+      if (tradeData && tradeData.volume_24h_usd < 1e3) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.error(
+        `Error checking if token ${tokenAddress} should be traded:`,
+        error
+      );
+      return false;
+    }
+  }
+  /**
+   * Get processed token data with security and trade information
+   */
+  async getProcessedTokenData(chain, tokenAddress) {
+    logger.debug("getting processed token data", chain, tokenAddress);
+    try {
+      const cacheKey = `token:${chain}:${tokenAddress}:processed`;
+      const cachedData = await this.runtime.getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      if (chain.toLowerCase() === "solana") {
+        const dexScreenerData = await this.dexscreenerClient.search(
+          tokenAddress,
+          {
+            expires: "5m"
+          }
+        );
+        let tokenTradeData;
+        let tokenSecurityData;
+        try {
+          tokenTradeData = await this.birdeyeClient.fetchTokenTradeData(
+            tokenAddress,
+            {
+              chain: "solana",
+              expires: "5m"
+            }
+          );
+          tokenSecurityData = await this.birdeyeClient.fetchTokenSecurity(
+            tokenAddress,
+            {
+              chain: "solana",
+              expires: "5m"
+            }
+          );
+        } catch (error) {
+          logger.error(`Error fetching token data for ${tokenAddress}:`, error);
+          return null;
+        }
+        const holderDistributionTrend = await this.analyzeHolderDistribution(tokenTradeData);
+        let highValueHolders = [];
+        let highSupplyHoldersCount = 0;
+        if (this.heliusClient) {
+          try {
+            const holders = await this.heliusClient.fetchHolderList(
+              tokenAddress,
+              {
+                expires: "30m"
+              }
+            );
+            const tokenPrice = Number.parseFloat(
+              tokenTradeData.price.toString()
+            );
+            highValueHolders = holders.filter((holder) => {
+              const balance = Number.parseFloat(holder.balance);
+              const balanceUsd = balance * tokenPrice;
+              return balanceUsd > 5;
+            }).map((holder) => ({
+              holderAddress: holder.address,
+              balanceUsd: (Number.parseFloat(holder.balance) * tokenPrice).toFixed(2)
+            }));
+            const totalSupply = "0";
+            highSupplyHoldersCount = holders.filter((holder) => {
+              const holderRatio = Number.parseFloat(holder.balance) / Number.parseFloat(totalSupply);
+              return holderRatio > 0.02;
+            }).length;
+          } catch (error) {
+            logger.warn(
+              `Error fetching holder data for ${tokenAddress}:`,
+              error
+            );
+          }
+        }
+        const recentTrades = tokenTradeData.volume_24h > 0;
+        const isDexScreenerListed = dexScreenerData.pairs.length > 0;
+        const isDexScreenerPaid = dexScreenerData.pairs.some(
+          (pair) => pair.boosts && pair.boosts.active > 0
+        );
+        const processedData = {
+          token: {
+            address: tokenAddress,
+            name: dexScreenerData.pairs[0]?.baseToken?.name || "",
+            symbol: dexScreenerData.pairs[0]?.baseToken?.symbol || "",
+            decimals: 9,
+            // Default for Solana
+            logoURI: ""
+          },
+          security: tokenSecurityData,
+          tradeData: tokenTradeData,
+          holderDistributionTrend,
+          highValueHolders,
+          recentTrades,
+          highSupplyHoldersCount,
+          dexScreenerData,
+          isDexScreenerListed,
+          isDexScreenerPaid
+        };
+        await this.runtime.setCache(
+          cacheKey,
+          processedData
+        );
+        return processedData;
+      }
+      throw new Error(`Chain ${chain} not supported for processed token data`);
+    } catch (error) {
+      logger.error(
+        `Error fetching processed token data for ${tokenAddress}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Analyze holder distribution trend
+   */
+  async analyzeHolderDistribution(tradeData) {
+    logger.debug("analyzing holder distribution", tradeData);
+    const intervals = [
+      {
+        period: "30m",
+        change: tradeData.unique_wallet_30m_change_percent
+      },
+      { period: "1h", change: tradeData.unique_wallet_1h_change_percent },
+      { period: "2h", change: tradeData.unique_wallet_2h_change_percent },
+      { period: "4h", change: tradeData.unique_wallet_4h_change_percent },
+      { period: "8h", change: tradeData.unique_wallet_8h_change_percent },
+      {
+        period: "24h",
+        change: tradeData.unique_wallet_24h_change_percent
+      }
+    ];
+    const validChanges = intervals.map((interval) => interval.change).filter((change) => change !== null && change !== void 0);
+    if (validChanges.length === 0) {
+      return "stable";
+    }
+    const averageChange = validChanges.reduce((acc, curr) => acc + curr, 0) / validChanges.length;
+    const increaseThreshold = 10;
+    const decreaseThreshold = -10;
+    if (averageChange > increaseThreshold) {
+      return "increasing";
+    }
+    if (averageChange < decreaseThreshold) {
+      return "decreasing";
+    }
+    return "stable";
+  }
+  // ===================== SCORE MANAGER METHODS =====================
+  /**
+   * Update token performance data
+   */
+  async updateTokenPerformance(chain, tokenAddress) {
+    logger.debug("updating token performance", chain, tokenAddress);
+    try {
+      const tokenData = await this.getTokenOverview(chain, tokenAddress, true);
+      const performance = {
+        chain,
+        address: tokenAddress,
+        name: tokenData.name,
+        symbol: tokenData.symbol,
+        decimals: tokenData.decimals,
+        price: Number.parseFloat(tokenData.priceUsd),
+        volume: tokenData.volume24h,
+        liquidity: tokenData.liquidityUsd,
+        currentMarketCap: tokenData.marketCap,
+        holders: tokenData.holders,
+        price24hChange: tokenData.price24hChange,
+        volume24hChange: tokenData.volume24hChange,
+        metadata: tokenData.metadata,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await this.storeTokenPerformance(performance);
+      return performance;
+    } catch (error) {
+      logger.error(
+        `Error updating token performance for ${tokenAddress}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Calculate risk score for a token
+   */
+  calculateRiskScore(token) {
+    logger.debug("calculating risk score", token);
+    let score = 50;
+    const liquidity = token.liquidity || 0;
+    score -= getLiquidityMultiplier(liquidity);
+    const marketCap = token.currentMarketCap || 0;
+    score += getMarketCapMultiplier(marketCap);
+    const volume = token.volume || 0;
+    score -= getVolumeMultiplier(volume);
+    if (token.rugPull) score += 30;
+    if (token.isScam) score += 30;
+    if (token.rapidDump) score += 15;
+    if (token.suspiciousVolume) score += 15;
+    return Math.max(0, Math.min(100, score));
+  }
+  /**
+   * Update entity metrics based on their recommendation performance
+   */
+  async updateRecommenderMetrics(entityId, performance = 0) {
+    logger.debug("updating recommender metrics", entityId, performance);
+    const metrics = await this.getRecommenderMetrics(entityId);
+    if (!metrics) {
+      await this.initializeRecommenderMetrics(entityId, "default");
+      return;
+    }
+    const updatedMetrics = {
+      ...metrics,
+      totalRecommendations: metrics.totalRecommendations + 1,
+      successfulRecs: performance > 0 ? metrics.successfulRecs + 1 : metrics.successfulRecs,
+      avgTokenPerformance: (metrics.avgTokenPerformance * metrics.totalRecommendations + performance) / (metrics.totalRecommendations + 1),
+      trustScore: this.calculateTrustScore(metrics, performance)
+    };
+    await this.storeRecommenderMetrics(updatedMetrics);
+    const historyEntry = {
+      entityId,
+      metrics: updatedMetrics,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    await this.storeRecommenderMetricsHistory(historyEntry);
+  }
+  /**
+   * Calculate trust score based on metrics and new performance
+   */
+  calculateTrustScore(metrics, newPerformance) {
+    logger.debug("calculating trust score", metrics, newPerformance);
+    const HISTORY_WEIGHT = 0.7;
+    const NEW_PERFORMANCE_WEIGHT = 0.3;
+    const newSuccessRate = (metrics.successfulRecs + (newPerformance > 0 ? 1 : 0)) / (metrics.totalRecommendations + 1);
+    const consistencyScore = metrics.consistencyScore || 50;
+    const newTrustScore = metrics.trustScore * HISTORY_WEIGHT + (newPerformance > 0 ? 100 : 0) * NEW_PERFORMANCE_WEIGHT;
+    const successFactor = newSuccessRate * 100;
+    const combinedScore = newTrustScore * 0.6 + successFactor * 0.3 + consistencyScore * 0.1;
+    return Math.max(0, Math.min(100, combinedScore));
+  }
+  // ===================== POSITION METHODS =====================
+  /**
+   * Get or fetch token performance data
+   */
+  async getOrFetchTokenPerformance(tokenAddress, chain) {
+    logger.debug("getting or fetching token performance", tokenAddress, chain);
+    try {
+      let tokenPerformance = await this.getTokenPerformance(
+        tokenAddress,
+        chain
+      );
+      if (!tokenPerformance) {
+        const tokenOverview = await this.getTokenOverview(chain, tokenAddress);
+        tokenPerformance = {
+          chain,
+          address: tokenAddress,
+          name: tokenOverview.name,
+          symbol: tokenOverview.symbol,
+          decimals: tokenOverview.decimals,
+          price: Number.parseFloat(tokenOverview.priceUsd),
+          volume: tokenOverview.volume24h,
+          price24hChange: tokenOverview.price24hChange,
+          liquidity: tokenOverview.liquidityUsd,
+          holders: tokenOverview.holders,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        if (tokenPerformance) {
+          await this.storeTokenPerformance(tokenPerformance);
+        }
+      }
+      return tokenPerformance;
+    } catch (error) {
+      logger.error(
+        `Error fetching token performance for ${tokenAddress}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Validate if a token meets trading criteria
+   */
+  validateToken(token) {
+    if (token.address?.startsWith("sim_")) {
+      return true;
+    }
+    if (token.isScam || token.rugPull) {
+      return false;
+    }
+    const liquidity = token.liquidity || 0;
+    if (liquidity < this.tradingConfig.minLiquidityUsd) {
+      return false;
+    }
+    const marketCap = token.currentMarketCap || 0;
+    if (marketCap > this.tradingConfig.maxMarketCapUsd) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Create a token recommendation
+   */
+  async createTokenRecommendation(entityId, token, conviction = Conviction.MEDIUM, type = RecommendationType.BUY) {
+    logger.debug(
+      "creating token recommendation",
+      entityId,
+      token,
+      conviction,
+      type
+    );
+    try {
+      const recommendation = {
+        id: uuidv4(),
+        entityId,
+        chain: token.chain || this.tradingConfig.defaultChain,
+        tokenAddress: token.address || "",
+        type,
+        conviction,
+        initialMarketCap: (token.initialMarketCap || 0).toString(),
+        initialLiquidity: (token.liquidity || 0).toString(),
+        initialPrice: (token.price || 0).toString(),
+        marketCap: (token.currentMarketCap || 0).toString(),
+        liquidity: (token.liquidity || 0).toString(),
+        price: (token.price || 0).toString(),
+        rugPull: token.rugPull || false,
+        isScam: token.isScam || false,
+        riskScore: this.calculateRiskScore(token),
+        performanceScore: 0,
+        metadata: {},
+        status: "ACTIVE",
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await this.storeTokenRecommendation(recommendation);
+      return recommendation;
+    } catch (error) {
+      logger.error("Error creating token recommendation:", error);
+      return null;
+    }
+  }
+  /**
+   * Calculate buy amount based on entity trust score and conviction
+   */
+  calculateBuyAmount(entity, conviction, token) {
+    logger.debug("calculating buy amount", entity, conviction, token);
+    let trustScore = 50;
+    if (entity.id) {
+      const metricsPromise = this.getRecommenderMetrics(entity.id);
+      metricsPromise.then((metrics) => {
+        if (metrics) {
+          trustScore = metrics.trustScore;
+        }
+      }).catch((error) => {
+        logger.error(`Error getting entity metrics for ${entity.id}:`, error);
+      });
+    }
+    const { baseAmount, minAmount, maxAmount, trustScoreMultiplier } = this.tradingConfig.buyAmountConfig;
+    const trustMultiplier = 1 + trustScore / 100 * trustScoreMultiplier;
+    const convMultiplier = getConvictionMultiplier(conviction);
+    let amount = baseAmount * trustMultiplier * convMultiplier;
+    if (token.liquidity) {
+      amount *= getLiquidityMultiplier(token.liquidity);
+    }
+    amount = Math.max(minAmount, Math.min(maxAmount, amount));
+    return BigInt(Math.floor(amount * 1e9));
+  }
+  /**
+   * Create a new position
+   */
+  async createPosition(recommendationId, entityId, tokenAddress, walletAddress, amount, price, isSimulation) {
+    logger.debug(
+      "creating position",
+      recommendationId,
+      entityId,
+      tokenAddress,
+      walletAddress,
+      amount,
+      price,
+      isSimulation
+    );
+    try {
+      const position = {
+        id: uuidv4(),
+        chain: this.tradingConfig.defaultChain,
+        tokenAddress,
+        walletAddress,
+        isSimulation,
+        entityId,
+        recommendationId,
+        initialPrice: price,
+        balance: "0",
+        status: "OPEN",
+        amount: amount.toString(),
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      await this.storePosition(position);
+      return position;
+    } catch (error) {
+      logger.error("Error creating position:", error);
+      return null;
+    }
+  }
+  /**
+   * Record a transaction
+   */
+  async recordTransaction(positionId, tokenAddress, type, amount, price, isSimulation) {
+    logger.debug(
+      "recording transaction",
+      positionId,
+      tokenAddress,
+      type,
+      amount,
+      price,
+      isSimulation
+    );
+    try {
+      const transaction = {
+        id: uuidv4(),
+        positionId,
+        chain: this.tradingConfig.defaultChain,
+        tokenAddress,
+        type,
+        amount: amount.toString(),
+        price: price.toString(),
+        isSimulation,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await this.storeTransaction(transaction);
+      return true;
+    } catch (error) {
+      logger.error("Error recording transaction:", error);
+      return false;
+    }
+  }
+  /**
+   * Get all positions for an entity
+   */
+  async getPositionsByRecommender(entityId) {
+    logger.debug("getting positions by recommender", entityId);
+    try {
+      const recommendations = await this.getRecommendationsByRecommender(entityId);
+      const positions = [];
+      for (const recommendation of recommendations) {
+        const positionMatches = await this.getPositionsByToken(
+          recommendation.tokenAddress
+        );
+        const entityPositions = positionMatches.filter(
+          (position) => position.entityId === entityId
+        );
+        positions.push(...entityPositions);
+      }
+      return positions;
+    } catch (error) {
+      logger.error("Error getting positions by entity:", error);
+      return [];
+    }
+  }
+  /**
+   * Get all positions for a token
+   */
+  async getPositionsByToken(tokenAddress) {
+    logger.debug("getting positions by token", tokenAddress);
+    try {
+      const positions = await this.getOpenPositionsWithBalance();
+      return positions.filter(
+        (position) => position.tokenAddress === tokenAddress
+      );
+    } catch (error) {
+      logger.error("Error getting positions by token:", error);
+      return [];
+    }
+  }
+  /**
+   * Get all transactions for a position
+   */
+  async getTransactionsByPosition(positionId) {
+    logger.debug("getting transactions by position", positionId);
+    try {
+      const query = `transactions for position ${positionId}`;
+      const embedding = await this.runtime.useModel(
+        ModelType.TEXT_EMBEDDING,
+        query
+      );
+      const memories = await this.runtime.searchMemories({
+        tableName: "transactions",
+        embedding,
+        match_threshold: 0.7,
+        limit: 20
+      });
+      const transactions = [];
+      for (const memory of memories) {
+        const transaction = asTransaction(memory.content.transaction);
+        if (transaction && transaction.positionId === positionId) {
+          transactions.push(transaction);
+        }
+      }
+      return transactions;
+    } catch (error) {
+      logger.error("Error getting transactions by position:", error);
+      return [];
+    }
+  }
+  /**
+   * Get all transactions for a token
+   */
+  async getTransactionsByToken(tokenAddress) {
+    logger.debug("getting transactions by token", tokenAddress);
+    try {
+      const query = `transactions for token ${tokenAddress}`;
+      const embedding = await this.runtime.useModel(
+        ModelType.TEXT_EMBEDDING,
+        query
+      );
+      const memories = await this.runtime.searchMemories({
+        tableName: "transactions",
+        embedding,
+        match_threshold: 0.7,
+        limit: 50
+      });
+      const transactions = [];
+      for (const memory of memories) {
+        const transaction = asTransaction(memory.content.transaction);
+        if (transaction && transaction.tokenAddress === tokenAddress) {
+          transactions.push(transaction);
+        }
+      }
+      return transactions;
+    } catch (error) {
+      logger.error("Error getting transactions by token:", error);
+      return [];
+    }
+  }
+  /**
+   * Get a position by ID
+   */
+  async getPosition(positionId) {
+    logger.debug("getting position", positionId);
+    try {
+      const cacheKey = `position:${positionId}`;
+      const cachedPosition = await this.runtime.getCache(cacheKey);
+      if (cachedPosition) {
+        return cachedPosition;
+      }
+      const query = `position with ID ${positionId}`;
+      const embedding = await this.runtime.useModel(
+        ModelType.TEXT_EMBEDDING,
+        query
+      );
+      const memories = await this.runtime.searchMemories({
+        tableName: "positions",
+        embedding,
+        match_threshold: 0.7,
+        limit: 1
+      });
+      const position = asContentObject(
+        memories[0]?.content.position,
+        ["id", "entityId", "tokenAddress"]
+      );
+      if (position) {
+        await this.runtime.setCache(cacheKey, position);
+        return position;
+      }
+      return null;
+    } catch (error) {
+      logger.error("Error getting position:", error);
+      return null;
+    }
+  }
+  /**
+   * Get all recommendations by a entity
+   */
+  async getRecommendationsByRecommender(entityId) {
+    logger.debug("getting recommendations by recommender", entityId);
+    try {
+      const query = `recommendations by entity ${entityId}`;
+      const embedding = await this.runtime.useModel(
+        ModelType.TEXT_EMBEDDING,
+        query
+      );
+      const memories = await this.runtime.searchMemories({
+        tableName: "recommendations",
+        embedding,
+        match_threshold: 0.7,
+        limit: 50
+      });
+      const recommendations = [];
+      for (const memory of memories) {
+        const meta = memory.metadata;
+        if (meta?.recommendation && meta.recommendation.entityId === entityId) {
+          recommendations.push(meta.recommendation);
+        }
+      }
+      return recommendations;
+    } catch (error) {
+      logger.error("Error getting recommendations by entity:", error);
+      return [];
+    }
+  }
+  /**
+   * Close a position and update metrics
+   */
+  async closePosition(positionId) {
+    logger.debug("closing position", positionId);
+    try {
+      const position = await this.getPosition(positionId);
+      if (!position) {
+        logger.error(`Position ${positionId} not found`);
+        return false;
+      }
+      position.status = "CLOSED";
+      position.closedAt = /* @__PURE__ */ new Date();
+      const transactions = await this.getTransactionsByPosition(positionId);
+      const performance = await this.calculatePositionPerformance(
+        position,
+        transactions
+      );
+      await this.updateRecommenderMetrics(position.entityId, performance);
+      await this.storePosition(position);
+      return true;
+    } catch (error) {
+      logger.error(`Failed to close position ${positionId}:`, error);
+      return false;
+    }
+  }
+  /**
+   * Calculate position performance
+   */
+  async calculatePositionPerformance(position, transactions) {
+    logger.debug("calculating position performance", position, transactions);
+    if (!transactions.length) return 0;
+    const buyTxs = transactions.filter((t) => t.type === TransactionType.BUY);
+    const sellTxs = transactions.filter((t) => t.type === TransactionType.SELL);
+    const totalBuyAmount = buyTxs.reduce(
+      (sum, tx) => sum + BigInt(tx.amount),
+      0n
+    );
+    const _totalSellAmount = sellTxs.reduce(
+      (sum, tx) => sum + BigInt(tx.amount),
+      0n
+    );
+    position.amount = totalBuyAmount.toString();
+    const avgBuyPrice = buyTxs.reduce((sum, tx) => sum + Number(tx.price), 0) / buyTxs.length;
+    const avgSellPrice = sellTxs.length ? sellTxs.reduce((sum, tx) => sum + Number(tx.price), 0) / sellTxs.length : await this.getCurrentPrice(position.chain, position.tokenAddress);
+    position.currentPrice = avgSellPrice.toString();
+    return (avgSellPrice - avgBuyPrice) / avgBuyPrice * 100;
+  }
+  /**
+   * Store token performance data
+   */
+  async storeTokenPerformance(token) {
+    logger.debug("storing token performance", token);
+    try {
+      const text = `Token performance data for ${token.symbol || token.address} on ${token.chain}`;
+      const memory = {
+        id: uuidv4(),
+        entityId: this.runtime.agentId,
+        roomId: "global",
+        content: {
+          text,
+          token: toJsonRecord(token)
+        },
+        createdAt: Date.now()
+      };
+      const embedding = await this.runtime.useModel("TEXT_EMBEDDING", text);
+      const memoryWithEmbedding = { ...memory, embedding };
+      await this.runtime.createMemory(memoryWithEmbedding, "tokens", true);
+      const cacheKey = `token:${token.chain}:${token.address}:performance`;
+      await this.runtime.setCache(cacheKey, token);
+    } catch (error) {
+      logger.error(
+        `Error storing token performance for ${token.address}:`,
+        error
+      );
+    }
+  }
+  /**
+   * Store position data
+   */
+  async storePosition(position) {
+    logger.debug("storing position", position);
+    try {
+      const text = `Position data for token ${position.tokenAddress} by entity ${position.entityId}`;
+      const memory = {
+        id: uuidv4(),
+        entityId: this.runtime.agentId,
+        roomId: "global",
+        content: {
+          text,
+          position: toJsonRecord(position)
+        },
+        createdAt: Date.now()
+      };
+      const embedding = await this.runtime.useModel("TEXT_EMBEDDING", text);
+      const memoryWithEmbedding = { ...memory, embedding };
+      await this.runtime.createMemory(memoryWithEmbedding, "positions", true);
+      const cacheKey = `position:${position.id}`;
+      await this.runtime.setCache(cacheKey, position);
+    } catch (error) {
+      logger.error(
+        `Error storing position for ${position.tokenAddress}:`,
+        error
+      );
+    }
+  }
+  /**
+   * Store transaction data
+   */
+  async storeTransaction(transaction) {
+    logger.debug("storing transaction", transaction);
+    try {
+      const text = `Transaction data for position ${transaction.positionId} token ${transaction.tokenAddress} ${transaction.type}`;
+      const memory = {
+        id: uuidv4(),
+        entityId: this.runtime.agentId,
+        roomId: "global",
+        content: {
+          text,
+          transaction: toJsonRecord(transaction)
+        },
+        createdAt: Date.now()
+      };
+      const embedding = await this.runtime.useModel("TEXT_EMBEDDING", text);
+      const memoryWithEmbedding = { ...memory, embedding };
+      await this.runtime.createMemory(
+        memoryWithEmbedding,
+        "transactions",
+        true
+      );
+      const cacheKey = `position:${transaction.positionId}:transactions`;
+      const cachedTxs = await this.runtime.getCache(cacheKey);
+      if (cachedTxs) {
+        const txs = cachedTxs;
+        txs.push(transaction);
+        await this.runtime.setCache(cacheKey, txs);
+      } else {
+        await this.runtime.setCache(cacheKey, [transaction]);
+      }
+    } catch (error) {
+      logger.error(
+        `Error storing transaction for position ${transaction.positionId}:`,
+        error
+      );
+    }
+  }
+  /**
+   * Store token recommendation data
+   */
+  async storeTokenRecommendation(recommendation) {
+    logger.debug("storing token recommendation", recommendation);
+    try {
+      const text = `Token recommendation for ${recommendation.tokenAddress} by entity ${recommendation.entityId}`;
+      const memory = {
+        id: uuidv4(),
+        entityId: this.runtime.agentId,
+        roomId: "global",
+        content: {
+          text,
+          recommendation: toJsonRecord(recommendation)
+        },
+        createdAt: Date.now()
+      };
+      const embedding = await this.runtime.useModel("TEXT_EMBEDDING", text);
+      const memoryWithEmbedding = { ...memory, embedding };
+      await this.runtime.createMemory(
+        memoryWithEmbedding,
+        "recommendations",
+        true
+      );
+      const cacheKey = `recommendation:${recommendation.id}`;
+      await this.runtime.setCache(
+        cacheKey,
+        recommendation
+      );
+    } catch (error) {
+      logger.error(
+        `Error storing recommendation for ${recommendation.tokenAddress}:`,
+        error
+      );
+    }
+  }
+  /**
+   * Store entity metrics
+   */
+  async storeRecommenderMetrics(metrics) {
+    logger.debug("storing recommender metrics", metrics);
+    try {
+      const text = `Recommender metrics for ${metrics.entityId}`;
+      const memory = {
+        id: uuidv4(),
+        entityId: this.runtime.agentId,
+        roomId: "global",
+        content: {
+          text,
+          metrics: toJsonRecord(metrics)
+        },
+        createdAt: Date.now()
+      };
+      const embedding = await this.runtime.useModel("TEXT_EMBEDDING", text);
+      const memoryWithEmbedding = { ...memory, embedding };
+      await this.runtime.createMemory(
+        memoryWithEmbedding,
+        "recommender_metrics",
+        true
+      );
+      const cacheKey = `entity:${metrics.entityId}:metrics`;
+      await this.runtime.setCache(cacheKey, metrics);
+    } catch (error) {
+      logger.error(
+        `Error storing entity metrics for ${metrics.entityId}:`,
+        error
+      );
+    }
+  }
+  /**
+   * Store entity metrics history
+   */
+  async storeRecommenderMetricsHistory(history) {
+    logger.debug("storing recommender metrics history", history);
+    try {
+      const text = `Recommender metrics history for ${history.entityId}`;
+      const memory = {
+        id: uuidv4(),
+        entityId: this.runtime.agentId,
+        roomId: "global",
+        content: {
+          text,
+          history: toJsonRecord(history)
+        },
+        createdAt: Date.now()
+      };
+      const embedding = await this.runtime.useModel("TEXT_EMBEDDING", text);
+      const memoryWithEmbedding = { ...memory, embedding };
+      await this.runtime.createMemory(
+        memoryWithEmbedding,
+        "recommender_metrics_history",
+        true
+      );
+      const cacheKey = `entity:${history.entityId}:history`;
+      const cachedHistory = await this.runtime.getCache(cacheKey);
+      if (cachedHistory) {
+        const histories = cachedHistory;
+        histories.push(history);
+        const recentHistories = histories.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime()).slice(0, 10);
+        await this.runtime.setCache(
+          cacheKey,
+          recentHistories
+        );
+      } else {
+        await this.runtime.setCache(cacheKey, [
+          history
+        ]);
+      }
+    } catch (error) {
+      logger.error(
+        `Error storing entity metrics history for ${history.entityId}:`,
+        error
+      );
+    }
+  }
+  /**
+   * Get entity metrics
+   */
+  async getRecommenderMetrics(entityId) {
+    logger.debug("getting recommender metrics", entityId);
+    try {
+      const cacheKey = `entity:${entityId}:metrics`;
+      const cachedMetrics = await this.runtime.getCache(cacheKey);
+      if (cachedMetrics) {
+        return cachedMetrics;
+      }
+      const query = `entity metrics for entity ${entityId}`;
+      const embedding = await this.runtime.useModel(
+        ModelType.TEXT_EMBEDDING,
+        query
+      );
+      const memories = await this.runtime.searchMemories({
+        tableName: "recommender_metrics",
+        embedding,
+        match_threshold: 0.7,
+        limit: 1
+      });
+      const metrics = asContentObject(
+        memories[0]?.content.metrics,
+        ["entityId", "platform"]
+      );
+      if (metrics) {
+        await this.runtime.setCache(cacheKey, metrics);
+        return metrics;
+      }
+      return null;
+    } catch (error) {
+      logger.error(`Error getting entity metrics for ${entityId}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Get entity metrics history
+   */
+  async getRecommenderMetricsHistory(entityId) {
+    logger.debug("getting recommender metrics history", entityId);
+    try {
+      const cacheKey = `entity:${entityId}:history`;
+      const cachedHistory = await this.runtime.getCache(cacheKey);
+      if (cachedHistory) {
+        return cachedHistory;
+      }
+      const query = `entity metrics history for entity ${entityId}`;
+      const embedding = await this.runtime.useModel(
+        ModelType.TEXT_EMBEDDING,
+        query
+      );
+      const memories = await this.runtime.searchMemories({
+        tableName: "recommender_metrics_history",
+        embedding,
+        match_threshold: 0.7,
+        limit: 10
+      });
+      const historyEntries = [];
+      for (const memory of memories) {
+        const history = asContentObject(
+          memory.content.history,
+          ["entityId"]
+        );
+        if (history && history.entityId === entityId) {
+          historyEntries.push(history);
+        }
+      }
+      const sortedEntries = historyEntries.sort(
+        (a, b) => b.timestamp.getTime() - a.timestamp.getTime()
+      );
+      await this.runtime.setCache(
+        cacheKey,
+        sortedEntries
+      );
+      return sortedEntries;
+    } catch (error) {
+      logger.error(
+        `Error getting entity metrics history for ${entityId}:`,
+        error
+      );
+      return [];
+    }
+  }
+  /**
+   * Initialize entity metrics
+   */
+  async initializeRecommenderMetrics(entityId, platform) {
+    logger.debug("initializing recommender metrics", entityId, platform);
+    try {
+      const initialMetrics = {
+        entityId,
+        platform,
+        totalRecommendations: 0,
+        successfulRecs: 0,
+        consistencyScore: 50,
+        trustScore: 50,
+        failedTrades: 0,
+        totalProfit: 0,
+        avgTokenPerformance: 0,
+        lastUpdated: /* @__PURE__ */ new Date(),
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      await this.storeRecommenderMetrics(initialMetrics);
+      const historyEntry = {
+        entityId,
+        metrics: initialMetrics,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await this.storeRecommenderMetricsHistory(historyEntry);
+    } catch (error) {
+      logger.error(`Error initializing entity metrics for ${entityId}:`, error);
+    }
+  }
+  /**
+   * Get token performance
+   */
+  async getTokenPerformance(tokenAddress, chain) {
+    logger.debug("getting token performance", tokenAddress, chain);
+    try {
+      const cacheKey = `token:${chain}:${tokenAddress}:performance`;
+      const cachedToken = await this.runtime.getCache(cacheKey);
+      if (cachedToken) {
+        return cachedToken;
+      }
+      const query = `token performance for ${tokenAddress}`;
+      const embedding = await this.runtime.useModel(
+        ModelType.TEXT_EMBEDDING,
+        query
+      );
+      const memories = await this.runtime.searchMemories({
+        tableName: "tokens",
+        embedding,
+        match_threshold: 0.7,
+        limit: 1
+      });
+      if (memories.length > 0 && memories[0].content.token) {
+        const token = memories[0].content.token;
+        await this.runtime.setCache(cacheKey, token);
+        return token;
+      }
+      return null;
+    } catch (error) {
+      logger.error(
+        `Error getting token performance for ${tokenAddress}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get open positions with balance
+   */
+  async getOpenPositionsWithBalance() {
+    logger.debug("getting open positions with balance");
+    try {
+      const cacheKey = "positions:open:with-balance";
+      const cachedPositions = await this.runtime.getCache(cacheKey);
+      if (cachedPositions) {
+        return cachedPositions;
+      }
+      const query = "open positions with balance";
+      const embedding = await this.runtime.useModel(
+        ModelType.TEXT_EMBEDDING,
+        query
+      );
+      const memories = await this.runtime.searchMemories({
+        tableName: "positions",
+        embedding,
+        match_threshold: 0.7,
+        limit: 50
+      });
+      const positions = [];
+      for (const memory of memories) {
+        const position = asContentObject(memory.content.position, [
+          "id",
+          "entityId",
+          "tokenAddress"
+        ]);
+        if (position) {
+          if (position.status === "OPEN") {
+            positions.push({
+              ...position,
+              balance: BigInt(position.balance || "0")
+            });
+          }
+        }
+      }
+      await this.runtime.setCache(cacheKey, positions);
+      return positions;
+    } catch (error) {
+      logger.error("Error getting open positions with balance:", error);
+      return [];
+    }
+  }
+  /**
+   * Get positions transactions
+   */
+  async getPositionsTransactions(positionIds) {
+    logger.debug("getting positions transactions", positionIds);
+    try {
+      const allTransactions = [];
+      for (const positionId of positionIds) {
+        const transactions = await this.getTransactionsByPosition(positionId);
+        allTransactions.push(...transactions);
+      }
+      return allTransactions;
+    } catch (error) {
+      logger.error("Error getting transactions for positions:", error);
+      return [];
+    }
+  }
+  /**
+   * Get formatted portfolio report
+   */
+  async getFormattedPortfolioReport(entityId) {
+    logger.debug("getting formatted portfolio report", entityId);
+    try {
+      const positions = await this.getOpenPositionsWithBalance();
+      const filteredPositions = entityId ? positions.filter((p) => p.entityId === entityId) : positions;
+      if (filteredPositions.length === 0) {
+        return "No open positions found.";
+      }
+      const tokens = [];
+      const tokenSet = /* @__PURE__ */ new Set();
+      for (const position of filteredPositions) {
+        if (tokenSet.has(`${position.chain}:${position.tokenAddress}`))
+          continue;
+        const token = await this.getTokenPerformance(
+          position.tokenAddress,
+          position.chain
+        );
+        if (token) tokens.push(token);
+        tokenSet.add(`${position.chain}:${position.tokenAddress}`);
+      }
+      const transactions = await this.getPositionsTransactions(
+        filteredPositions.map((p) => p.id)
+      );
+      const report = formatFullReport(tokens, filteredPositions, transactions);
+      return `
+Portfolio Summary:
+Total Current Value: ${report.totalCurrentValue}
+Total Realized P&L: ${report.totalRealizedPnL}
+Total Unrealized P&L: ${report.totalUnrealizedPnL}
+Total P&L: ${report.totalPnL}
+
+Positions:
+${report.positionReports.join("\n")}
+
+Tokens:
+${report.tokenReports.join("\n")}
+            `.trim();
+    } catch (error) {
+      logger.error("Error generating portfolio report:", error);
+      return "Error generating portfolio report.";
+    }
+  }
+  async initialize(runtime) {
+    logger.info("[CommunityInvestorService] Initializing...");
+    this.apiKeys.birdeye = runtime.getSetting("BIRDEYE_API_KEY");
+    this.apiKeys.moralis = runtime.getSetting("MORALIS_API_KEY");
+    await this.loadUserRegistry();
+    logger.info("[CommunityInvestorService] Initialized.");
+  }
+  /**
+   * Fetches token data from an external API.
+   * Uses Birdeye and DexScreener for real market data.
+   */
+  async getTokenAPIData(address, chain) {
+    logger.debug(
+      `[CommunityInvestorService] Fetching token API data for ${address} on ${chain}`
+    );
+    try {
+      let tokenData = {};
+      if (chain === SupportedChain.SOLANA) {
+        try {
+          const [tokenOverview, price, security, tradeData, dexScreenerData] = await Promise.all([
+            this.birdeyeClient.fetchTokenOverview(address, {
+              chain: "solana",
+              expires: "5m"
+            }),
+            this.birdeyeClient.fetchPrice(address, {
+              chain: "solana",
+              expires: "1m"
+            }),
+            this.birdeyeClient.fetchTokenSecurity(address, {
+              chain: "solana",
+              expires: "10m"
+            }),
+            this.birdeyeClient.fetchTokenTradeData(address, {
+              chain: "solana",
+              expires: "5m"
+            }),
+            this.dexscreenerClient.search(address, { expires: "5m" })
+          ]);
+          const dexPair = dexScreenerData.pairs?.[0];
+          tokenData = {
+            name: tokenOverview.name || dexPair?.baseToken?.name,
+            symbol: tokenOverview.symbol || dexPair?.baseToken?.symbol,
+            currentPrice: price || parseFloat(dexPair?.priceUsd || "0"),
+            liquidity: dexPair?.liquidity?.usd || 0,
+            marketCap: dexPair?.marketCap || tradeData.market || 0,
+            isKnownScam: false
+            // Would need additional scam detection logic
+          };
+          if (tradeData) {
+            const recent24hPrices = [
+              tradeData.price,
+              tradeData.history_24h_price,
+              tradeData.history_12h_price,
+              tradeData.history_8h_price,
+              tradeData.history_6h_price,
+              tradeData.history_4h_price,
+              tradeData.history_2h_price,
+              tradeData.history_1h_price,
+              tradeData.history_30m_price
+            ].filter((p) => p != null && p > 0);
+            if (recent24hPrices.length > 0) {
+              tokenData.ath = Math.max(...recent24hPrices);
+              tokenData.atl = Math.min(...recent24hPrices);
+            }
+            const now = Date.now();
+            tokenData.priceHistory = [
+              {
+                timestamp: now - 24 * 60 * 60 * 1e3,
+                price: tradeData.history_24h_price || tradeData.price
+              },
+              {
+                timestamp: now - 12 * 60 * 60 * 1e3,
+                price: tradeData.history_12h_price || tradeData.price
+              },
+              {
+                timestamp: now - 8 * 60 * 60 * 1e3,
+                price: tradeData.history_8h_price || tradeData.price
+              },
+              {
+                timestamp: now - 6 * 60 * 60 * 1e3,
+                price: tradeData.history_6h_price || tradeData.price
+              },
+              {
+                timestamp: now - 4 * 60 * 60 * 1e3,
+                price: tradeData.history_4h_price || tradeData.price
+              },
+              {
+                timestamp: now - 2 * 60 * 60 * 1e3,
+                price: tradeData.history_2h_price || tradeData.price
+              },
+              {
+                timestamp: now - 1 * 60 * 60 * 1e3,
+                price: tradeData.history_1h_price || tradeData.price
+              },
+              {
+                timestamp: now - 30 * 60 * 1e3,
+                price: tradeData.history_30m_price || tradeData.price
+              },
+              { timestamp: now, price: tradeData.price }
+            ].filter((p) => p.price != null && p.price > 0);
+            const hasRugPullPattern = tradeData.price_change_24h_percent < -90 || // 90% drop in 24h
+            tradeData.volume_24h_usd < 1e3 && tokenData.marketCap && tokenData.marketCap > 1e5 || // Low volume but high market cap
+            security && security.top10HolderPercent > 95;
+            tokenData.isKnownScam = hasRugPullPattern;
+          }
+        } catch (error) {
+          logger.warn(
+            `[CommunityInvestorService] Error fetching Solana token data for ${address}:`,
+            error
+          );
+          try {
+            const dexScreenerData = await this.dexscreenerClient.search(
+              address,
+              { expires: "5m" }
+            );
+            const dexPair = dexScreenerData.pairs?.[0];
+            if (dexPair) {
+              tokenData = {
+                name: dexPair.baseToken.name,
+                symbol: dexPair.baseToken.symbol,
+                currentPrice: parseFloat(dexPair.priceUsd || "0"),
+                liquidity: dexPair.liquidity?.usd || 0,
+                marketCap: dexPair.marketCap || 0,
+                isKnownScam: false
+                // Dexscreener doesn't directly provide this
+              };
+            } else {
+              logger.debug(
+                `[CommunityInvestorService] DexScreener found no pair for ${address} after Birdeye failure.`
+              );
+              return null;
+            }
+          } catch (fallbackError) {
+            logger.error(
+              `[CommunityInvestorService] Fallback DexScreener search also failed for ${address}:`,
+              fallbackError
+            );
+            return null;
+          }
+        }
+      } else if (chain === SupportedChain.ETHEREUM || chain === SupportedChain.BASE) {
+        try {
+          const dexScreenerData = await this.dexscreenerClient.search(address, {
+            expires: "5m"
+          });
+          const chainFilter = chain === SupportedChain.ETHEREUM ? "ethereum" : "base";
+          const dexPair = dexScreenerData.pairs?.find(
+            (pair) => pair.chainId.toLowerCase() === chainFilter
+          );
+          if (dexPair) {
+            tokenData = {
+              name: dexPair.baseToken.name,
+              symbol: dexPair.baseToken.symbol,
+              currentPrice: parseFloat(dexPair.priceUsd || "0"),
+              liquidity: dexPair.liquidity?.usd || 0,
+              marketCap: dexPair.marketCap || 0,
+              isKnownScam: false
+            };
+            const now = Date.now();
+            const currentPrice = parseFloat(dexPair.priceUsd || "0");
+            tokenData.priceHistory = [
+              {
+                timestamp: now - 24 * 60 * 60 * 1e3,
+                price: currentPrice / (1 + (dexPair.priceChange?.h24 || 0) / 100)
+              },
+              {
+                timestamp: now - 6 * 60 * 60 * 1e3,
+                price: currentPrice / (1 + (dexPair.priceChange?.h6 || 0) / 100)
+              },
+              {
+                timestamp: now - 1 * 60 * 60 * 1e3,
+                price: currentPrice / (1 + (dexPair.priceChange?.h1 || 0) / 100)
+              },
+              {
+                timestamp: now - 5 * 60 * 1e3,
+                price: currentPrice / (1 + (dexPair.priceChange?.m5 || 0) / 100)
+              },
+              { timestamp: now, price: currentPrice }
+            ].filter((p) => p.price > 0);
+            if (tokenData.priceHistory.length > 0) {
+              tokenData.ath = Math.max(
+                ...tokenData.priceHistory.map((p) => p.price)
+              );
+              tokenData.atl = Math.min(
+                ...tokenData.priceHistory.map((p) => p.price)
+              );
+            }
+            const hasRugPullPattern = (dexPair.priceChange?.h24 || 0) < -90 || // 90% drop in 24h
+            (dexPair.volume?.h24 || 0) < 1e3 && (dexPair.marketCap || 0) > 1e5;
+            tokenData.isKnownScam = hasRugPullPattern;
+          }
+        } catch (error) {
+          logger.error(
+            `[CommunityInvestorService] Error fetching ${chain} token data for ${address}:`,
+            error
+          );
+          return null;
+        }
+      } else {
+        logger.warn(`[CommunityInvestorService] Unsupported chain: ${chain}`);
+        return null;
+      }
+      if (Object.keys(tokenData).length > 0) {
+        if (!tokenData.ath && tokenData.currentPrice) {
+          tokenData.ath = tokenData.currentPrice * 1.1;
+        }
+        if (!tokenData.atl && tokenData.currentPrice) {
+          tokenData.atl = tokenData.currentPrice * 0.9;
+        }
+        logger.debug(
+          `[CommunityInvestorService] Successfully fetched token data for ${tokenData.symbol || address} (${address})`
+        );
+        return tokenData;
+      } else if (chain !== SupportedChain.SOLANA) {
+        logger.warn(
+          `[CommunityInvestorService] Failed to fetch token data for ${address} on ${chain} after all attempts.`
+        );
+        return null;
+      }
+      return null;
+    } catch (error) {
+      logger.error(
+        `[CommunityInvestorService] Unexpected error fetching token API data for ${address}:`,
+        error
+      );
+      return null;
+    }
+  }
+  async isLikelyScamOrRug(tokenData, recommendationTimestamp) {
+    if (tokenData.isKnownScam) {
+      logger.warn(
+        `[CommunityInvestorService] Token ${tokenData.symbol} already flagged as known scam`
+      );
+      return true;
+    }
+    const warnings = [];
+    let riskScore = 0;
+    const pricesPostRecommendation = tokenData.priceHistory?.filter(
+      (p) => p.timestamp > recommendationTimestamp
+    ) || [];
+    if (pricesPostRecommendation.length > 1) {
+      const peakPricePostRec = Math.max(
+        ...pricesPostRecommendation.map((p) => p.price)
+      );
+      const lastKnownPricePostRec = pricesPostRecommendation[pricesPostRecommendation.length - 1].price;
+      const currentPrice = tokenData.currentPrice || 0;
+      if (peakPricePostRec > 0 && lastKnownPricePostRec < peakPricePostRec * 0.1 && currentPrice < peakPricePostRec * 0.1) {
+        warnings.push(
+          `Severe price drop: >90% from peak ($${peakPricePostRec.toFixed(6)} to $${currentPrice.toFixed(6)})`
+        );
+        riskScore += 40;
+      } else if (peakPricePostRec > 0 && lastKnownPricePostRec < peakPricePostRec * 0.3 && currentPrice < peakPricePostRec * 0.3) {
+        warnings.push(
+          `Major price drop: >70% from peak ($${peakPricePostRec.toFixed(6)} to $${currentPrice.toFixed(6)})`
+        );
+        riskScore += 25;
+      }
+    }
+    const marketCap = tokenData.marketCap || 0;
+    const liquidity = tokenData.liquidity || 0;
+    if (marketCap > 1e4 && liquidity > 0) {
+      const liquidityRatio = liquidity / marketCap;
+      if (liquidityRatio < 5e-3) {
+        warnings.push(
+          `Extremely low liquidity ratio: ${(liquidityRatio * 100).toFixed(2)}% (Liquidity: $${liquidity.toFixed(0)}, MC: $${marketCap.toFixed(0)})`
+        );
+        riskScore += 30;
+      } else if (liquidityRatio < 0.01) {
+        warnings.push(
+          `Very low liquidity ratio: ${(liquidityRatio * 100).toFixed(2)}%`
+        );
+        riskScore += 20;
+      } else if (liquidityRatio < 0.02) {
+        warnings.push(
+          `Low liquidity ratio: ${(liquidityRatio * 100).toFixed(2)}%`
+        );
+        riskScore += 10;
+      }
+    }
+    if (liquidity > 0) {
+      if (liquidity < 500) {
+        warnings.push(`Critical liquidity: $${liquidity.toFixed(0)}`);
+        riskScore += 35;
+      } else if (liquidity < 2e3) {
+        warnings.push(`Very low liquidity: $${liquidity.toFixed(0)}`);
+        riskScore += 20;
+      } else if (liquidity < 5e3) {
+        warnings.push(`Low liquidity: $${liquidity.toFixed(0)}`);
+        riskScore += 10;
+      }
+    } else {
+      warnings.push("No liquidity data available");
+      riskScore += 15;
+    }
+    if (marketCap > 0 && tokenData.currentPrice && tokenData.currentPrice > 0) {
+      if (marketCap > 1e6 && liquidity < 1e4) {
+        warnings.push(
+          `Suspicious MC/Liquidity: MC $${marketCap.toFixed(0)} vs Liquidity $${liquidity.toFixed(0)}`
+        );
+        riskScore += 25;
+      }
+    }
+    if (tokenData.priceHistory && tokenData.priceHistory.length >= 3) {
+      const prices = tokenData.priceHistory.map((p) => p.price);
+      const priceChanges = [];
+      for (let i = 1; i < prices.length; i++) {
+        if (prices[i - 1] > 0) {
+          const change = (prices[i] - prices[i - 1]) / prices[i - 1] * 100;
+          priceChanges.push(Math.abs(change));
+        }
+      }
+      if (priceChanges.length > 0) {
+        const avgVolatility = priceChanges.reduce((sum, change) => sum + change, 0) / priceChanges.length;
+        const maxChange = Math.max(...priceChanges);
+        if (maxChange > 200) {
+          warnings.push(
+            `Extreme volatility: ${maxChange.toFixed(1)}% max change`
+          );
+          riskScore += 20;
+        } else if (avgVolatility > 50) {
+          warnings.push(
+            `High volatility: ${avgVolatility.toFixed(1)}% average change`
+          );
+          riskScore += 10;
+        }
+      }
+    }
+    const tokenAge = Date.now() - recommendationTimestamp;
+    const ageInHours = tokenAge / (1e3 * 60 * 60);
+    if (ageInHours < 24) {
+      warnings.push(`Very new token: ${ageInHours.toFixed(1)} hours old`);
+      riskScore += 15;
+    } else if (ageInHours < 72) {
+      warnings.push(`New token: ${ageInHours.toFixed(1)} hours old`);
+      riskScore += 8;
+    }
+    const isLikelyRug = riskScore >= 50;
+    if (warnings.length > 0) {
+      const logLevel = isLikelyRug ? "warn" : "debug";
+      logger[logLevel](
+        `[CommunityInvestorService] Token ${tokenData.symbol} risk analysis (Score: ${riskScore}/100): ${warnings.join("; ")}`
+      );
+    }
+    if (isLikelyRug) {
+      logger.warn(
+        `[CommunityInvestorService] Token ${tokenData.symbol} classified as likely scam/rug (Risk Score: ${riskScore}/100)`
+      );
+    }
+    return isLikelyRug;
+  }
+  async evaluateRecommendationPerformance(recommendation, tokenData) {
+    logger.debug(
+      `[CommunityInvestorService] Evaluating performance for rec ID: ${recommendation.id}`
+    );
+    const metric = {
+      evaluationTimestamp: Date.now(),
+      isScamOrRug: await this.isLikelyScamOrRug(
+        tokenData,
+        recommendation.timestamp
+      ),
+      notes: ""
+    };
+    const priceAtRec = recommendation.priceAtRecommendation || tokenData.priceHistory?.find(
+      (p) => p.timestamp >= recommendation.timestamp
+    )?.price || tokenData.currentPrice || 0;
+    const pricesAfterRec = tokenData.priceHistory?.filter(
+      (p) => p.timestamp > recommendation.timestamp
+    ) || [];
+    if (metric.isScamOrRug) {
+      if (recommendation.recommendationType === "BUY") {
+        metric.potentialProfitPercent = -99;
+        metric.notes = "Token identified as likely scam/rug pull after BUY recommendation.";
+      }
+      if (recommendation.recommendationType === "SELL") {
+        metric.avoidedLossPercent = 99;
+        metric.notes = "Criticism/SELL recommendation was correct; token identified as likely scam/rug pull.";
+      }
+      logger.debug(
+        `[CommunityInvestorService] Rec ${recommendation.id} (Scam/Rug): Performance ${metric.potentialProfitPercent || metric.avoidedLossPercent}%`
+      );
+      return metric;
+    }
+    if (pricesAfterRec.length === 0) {
+      metric.notes = "No significant price data available after recommendation time to evaluate performance yet.";
+      if (tokenData.currentPrice && tokenData.currentPrice !== priceAtRec && priceAtRec > 0) {
+        const currentPerformance = (tokenData.currentPrice - priceAtRec) / priceAtRec * 100;
+        if (recommendation.recommendationType === "BUY")
+          metric.potentialProfitPercent = currentPerformance;
+        if (recommendation.recommendationType === "SELL")
+          metric.avoidedLossPercent = -currentPerformance;
+        metric.notes = "Evaluated based on current price vs price at recommendation.";
+      } else if (priceAtRec === 0 && tokenData.currentPrice && tokenData.currentPrice > 0 && recommendation.recommendationType === "BUY") {
+        metric.potentialProfitPercent = Infinity;
+        metric.notes = "Token acquired at effectively zero cost and now has value.";
+      } else if (priceAtRec > 0 && tokenData.currentPrice === 0 && recommendation.recommendationType === "SELL") {
+        metric.avoidedLossPercent = 100;
+        metric.notes = "Token value went to zero after sell recommendation.";
+      }
+      logger.debug(
+        `[CommunityInvestorService] Rec ${recommendation.id} (No prices after): Performance ${metric.potentialProfitPercent || metric.avoidedLossPercent}%`
+      );
+      return metric;
+    }
+    const peakPriceAfterRec = Math.max(
+      ...pricesAfterRec.map((p) => p.price),
+      priceAtRec
+    );
+    const troughPriceAfterRec = Math.min(
+      ...pricesAfterRec.map((p) => p.price),
+      priceAtRec
+    );
+    if (recommendation.recommendationType === "BUY") {
+      if (priceAtRec > 0) {
+        if (peakPriceAfterRec > priceAtRec) {
+          metric.potentialProfitPercent = (peakPriceAfterRec - priceAtRec) / priceAtRec * 100;
+          metric.notes = `Potential profit to peak of $${peakPriceAfterRec.toFixed(4)} from $${priceAtRec.toFixed(4)}.`;
+        } else {
+          const lossPrice = Math.min(
+            tokenData.currentPrice || 0,
+            troughPriceAfterRec
+          );
+          metric.potentialProfitPercent = (lossPrice - priceAtRec) / priceAtRec * 100;
+          metric.notes = `No profitable exit; current/trough price $${lossPrice.toFixed(4)} vs buy $${priceAtRec.toFixed(4)}.`;
+        }
+      } else {
+        metric.potentialProfitPercent = peakPriceAfterRec > 0 ? Infinity : 0;
+        metric.notes = `Bought at effectively zero, peak price $${peakPriceAfterRec.toFixed(4)}.`;
+      }
+    } else if (recommendation.recommendationType === "SELL") {
+      if (priceAtRec > 0) {
+        if (troughPriceAfterRec < priceAtRec) {
+          metric.avoidedLossPercent = (priceAtRec - troughPriceAfterRec) / priceAtRec * 100;
+          metric.notes = `Avoided loss as price dropped to $${troughPriceAfterRec.toFixed(4)} from $${priceAtRec.toFixed(4)}.`;
+        } else {
+          const missedProfitPrice = Math.max(
+            tokenData.currentPrice || 0,
+            peakPriceAfterRec
+          );
+          metric.avoidedLossPercent = (priceAtRec - missedProfitPrice) / priceAtRec * 100;
+          metric.notes = `Missed potential gains; price rose/stayed above $${priceAtRec.toFixed(4)}, reaching $${missedProfitPrice.toFixed(4)}.`;
+        }
+      } else {
+        metric.avoidedLossPercent = 0;
+        metric.notes = `Token was at zero or near-zero at time of sell/criticism.`;
+      }
+    }
+    logger.debug(
+      `[CommunityInvestorService] Rec ${recommendation.id}: Performance ${metric.potentialProfitPercent || metric.avoidedLossPercent}%`
+    );
+    return metric;
+  }
+  getRecencyWeight(recommendationTimestamp) {
+    const now = Date.now();
+    const ageInMilliseconds = now - recommendationTimestamp;
+    const ageInMonths = ageInMilliseconds / (1e3 * 60 * 60 * 24 * 30.44);
+    if (ageInMonths > this.RECENCY_WEIGHT_MONTHS) return 0.1;
+    return Math.max(0.1, 1 - ageInMonths / this.RECENCY_WEIGHT_MONTHS * 0.9);
+  }
+  getConvictionWeight(conviction) {
+    switch (conviction) {
+      case "HIGH":
+        return 1.5;
+      case "MEDIUM":
+        return 1;
+      case "LOW":
+        return 0.5;
+      default:
+        return 0.25;
+    }
+  }
+  async calculateUserTrustScore(userId, runtime, _worldId) {
+    logger.info(
+      `[CommunityInvestorService] Starting calculateUserTrustScore for user ${userId} (components in world/room: ${this.componentWorldId})`
+    );
+    const componentResult = await runtime.getComponent(
+      userId,
+      TRUST_MARKETPLACE_COMPONENT_TYPE,
+      this.componentWorldId,
+      runtime.agentId
+    );
+    if (!componentResult) {
+      const newProfile = {
+        version: "1.0.0",
+        userId,
+        trustScore: 0,
+        lastTrustScoreCalculationTimestamp: Date.now(),
+        recommendations: []
+      };
+      await runtime.createComponent({
+        id: userId,
+        // Use userId as component ID
+        entityId: userId,
+        agentId: runtime.agentId,
+        worldId: this.componentWorldId,
+        roomId: this.componentRoomId,
+        sourceEntityId: runtime.agentId,
+        type: TRUST_MARKETPLACE_COMPONENT_TYPE,
+        createdAt: Date.now(),
+        data: newProfile
+      });
+      this.registerUser(userId);
+      logger.info(
+        `[CommunityInvestorService] User ${userId} trust score is now: 0.00. Profile marked for update.`
+      );
+      return 0;
+    }
+    const userProfile = componentResult.data;
+    if (!Array.isArray(userProfile.recommendations)) {
+      logger.warn(
+        `[calculateUserTrustScore] User ${userId} profile recommendations was not an array. Initializing.`
+      );
+      userProfile.recommendations = [];
+    }
+    let _metricsUpdated = false;
+    for (const rec of userProfile.recommendations) {
+      if (!rec.tokenAddress || !rec.chain) {
+        logger.warn(
+          `[calculateUserTrustScore] Rec ${rec.id} for user ${userId} missing address/chain. Skipping metric evaluation.`
+        );
+        continue;
+      }
+      const needsReEval = !rec.metrics?.evaluationTimestamp || Date.now() - rec.metrics.evaluationTimestamp > this.METRIC_REFRESH_INTERVAL;
+      if (needsReEval) {
+        try {
+          const tokenData = await this.getTokenAPIData(
+            rec.tokenAddress,
+            rec.chain
+          );
+          if (!tokenData) {
+            logger.warn(
+              `[calculateUserTrustScore] No token data for ${rec.tokenAddress} (rec ${rec.id}, user ${userId}) to update metrics.`
+            );
+            continue;
+          }
+          const newMetric = await this.evaluateRecommendationPerformance(
+            rec,
+            tokenData
+          );
+          rec.metrics = newMetric;
+          _metricsUpdated = true;
+          logger.debug(
+            `[calculateUserTrustScore] Updated metrics for rec ${rec.id}, user ${userId}: ${JSON.stringify(newMetric)}`
+          );
+        } catch (error) {
+          logger.error(
+            `[calculateUserTrustScore] Error updating metrics for rec ${rec.id}, user ${userId}:`,
+            error
+          );
+        }
+      } else {
+        logger.debug(
+          `[calculateUserTrustScore] Rec ${rec.id} for user ${userId} has fresh metrics, skipping re-evaluation.`
+        );
+      }
+      if (!rec.metrics) {
+        logger.warn(
+          `[calculateUserTrustScore] Rec ${rec.id} for user ${userId} still has no metrics. It will not contribute to score.`
+        );
+      }
+    }
+    const { trustScore: updatedScore } = this.calculateNewScoreFromProfile(userProfile);
+    userProfile.trustScore = updatedScore;
+    userProfile.lastTrustScoreCalculationTimestamp = Date.now();
+    await runtime.updateComponent({
+      ...componentResult,
+      data: userProfile
+    });
+    this.registerUser(userId);
+    logger.info(
+      `[CommunityInvestorService] User ${userId} trust score is now: ${updatedScore.toFixed(2)}. Profile updated.`
+    );
+    return updatedScore;
+  }
+  /**
+   * Calculate trust score from user profile recommendations
+   */
+  calculateNewScoreFromProfile(userProfile) {
+    const recommendations = userProfile.recommendations || [];
+    if (recommendations.length === 0) {
+      return { trustScore: 0 };
+    }
+    const aggregatedMetrics = {
+      totalCalls: recommendations.length,
+      profitableCalls: 0,
+      totalProfit: 0,
+      totalWeightedProfit: 0,
+      totalWeight: 0,
+      profits: [],
+      rugPromotions: 0,
+      goodCalls: 0
+    };
+    for (const rec of recommendations) {
+      if (!rec.metrics) continue;
+      let performance = 0;
+      const potentialProfit = rec.metrics.potentialProfitPercent || 0;
+      const isLikelyRug = rec.metrics.isScamOrRug || potentialProfit <= -80;
+      if (isLikelyRug) {
+        if (rec.recommendationType === "BUY") {
+          aggregatedMetrics.rugPromotions++;
+          performance = -100;
+        } else if (rec.recommendationType === "SELL") {
+          aggregatedMetrics.goodCalls++;
+          performance = rec.metrics.avoidedLossPercent || 50;
+        }
+      } else if (rec.recommendationType === "BUY") {
+        performance = potentialProfit;
+        if (performance > 20) {
+          aggregatedMetrics.goodCalls++;
+        }
+      } else if (rec.recommendationType === "SELL") {
+        performance = rec.metrics.avoidedLossPercent || 0;
+        if (potentialProfit < -30) {
+          aggregatedMetrics.goodCalls++;
+        }
+      }
+      const recencyWeight = this.getRecencyWeight(rec.timestamp);
+      const convictionWeight = this.getConvictionWeight(rec.conviction);
+      const totalRecWeight = recencyWeight * convictionWeight;
+      aggregatedMetrics.totalWeightedProfit += performance * totalRecWeight;
+      aggregatedMetrics.totalWeight += totalRecWeight;
+      aggregatedMetrics.totalProfit += performance;
+      aggregatedMetrics.profits.push(performance);
+      if (performance > 0) {
+        aggregatedMetrics.profitableCalls++;
+      }
+    }
+    const winRate = aggregatedMetrics.profitableCalls / aggregatedMetrics.totalCalls;
+    const averageProfit = aggregatedMetrics.totalProfit / aggregatedMetrics.totalCalls;
+    const profitMean = averageProfit;
+    const variance = aggregatedMetrics.profits.reduce(
+      (sum, p) => sum + (p - profitMean) ** 2,
+      0
+    ) / aggregatedMetrics.profits.length;
+    const stdDev = Math.sqrt(variance);
+    const consistency = stdDev > 0 ? Math.max(0, 1 - stdDev / 100) : 1;
+    const sharpeRatio = stdDev > 0 ? averageProfit / stdDev : 0;
+    const marketAverage = 0;
+    const alpha = averageProfit - marketAverage;
+    const metrics = {
+      totalCalls: aggregatedMetrics.totalCalls,
+      profitableCalls: aggregatedMetrics.profitableCalls,
+      averageProfit,
+      winRate,
+      sharpeRatio,
+      alpha,
+      volumePenalty: 0,
+      // Not used in balanced calculator
+      consistency
+    };
+    let archetype = "newbie";
+    if (winRate > 0.7 && averageProfit > 30) {
+      archetype = "elite_analyst";
+    } else if (winRate > 0.6 && averageProfit > 15) {
+      archetype = "skilled_trader";
+    } else if (winRate > 0.5) {
+      archetype = "technical_analyst";
+    } else if (aggregatedMetrics.rugPromotions > aggregatedMetrics.totalCalls * 0.5) {
+      archetype = "rug_promoter";
+    } else if (aggregatedMetrics.totalCalls > 50 && winRate < 0.3) {
+      archetype = "bot_spammer";
+    }
+    const trustScore = this.balancedTrustCalculator.calculateBalancedTrustScore(
+      metrics,
+      archetype,
+      aggregatedMetrics.rugPromotions,
+      aggregatedMetrics.goodCalls,
+      aggregatedMetrics.totalCalls
+    );
+    logger.debug(
+      `[calculateNewScoreFromProfile] User ${userProfile.userId}: archetype=${archetype}, winRate=${(winRate * 100).toFixed(1)}%, avgProfit=${averageProfit.toFixed(1)}%, trustScore=${trustScore.toFixed(1)}`
+    );
+    return { trustScore };
+  }
+  // --- Task Worker Execution --- (Could be in a separate tasks.ts file)
+  async executeProcessTradeDecision(options, task) {
+    logger.info(
+      `[CommunityInvestorService] Task Worker: Processing rec: ${options.recommendationId}, user: ${options.userId}`
+    );
+    const { recommendationId, userId } = options;
+    const runtime = this.runtime;
+    const userProfileWorldId = runtime.agentId;
+    const componentResult = await runtime.getComponent(
+      userId,
+      TRUST_MARKETPLACE_COMPONENT_TYPE,
+      userProfileWorldId,
+      runtime.agentId
+    );
+    if (!componentResult?.data) {
+      logger.error(
+        `Task Worker: UserProfile component not found for user ${userId}. Deleting task.`
+      );
+      await runtime.deleteTask(task.id);
+      return;
+    }
+    const userProfile = componentResult.data;
+    let recommendation = userProfile.recommendations.find(
+      (r) => r.id === recommendationId
+    );
+    if (!recommendation) {
+      logger.error(
+        `Task Worker: Rec ${recommendationId} not found in profile for user ${userId}. Deleting task.`
+      );
+      await runtime.deleteTask(task.id);
+      return;
+    }
+    if (recommendation.processedForTradeDecision && !(userProfile.lastTradeDecisionMadeTimestamp && Date.now() - userProfile.lastTradeDecisionMadeTimestamp < this.USER_TRADE_COOLDOWN_HOURS * 36e5)) {
+      logger.info(
+        `Task Worker: Rec ${recommendationId} already fully processed & not in cooldown. Deleting task.`
+      );
+      await runtime.deleteTask(task.id);
+      return;
+    }
+    await this.calculateUserTrustScore(userId, runtime);
+    const updatedComponent = await runtime.getComponent(
+      userId,
+      TRUST_MARKETPLACE_COMPONENT_TYPE,
+      userProfileWorldId,
+      runtime.agentId
+    );
+    if (!updatedComponent?.data) {
+      logger.error(
+        `Task Worker: Profile for ${userId} disappeared after score recalc. Deleting task.`
+      );
+      await runtime.deleteTask(task.id);
+      return;
+    }
+    const updatedUserProfile = updatedComponent.data;
+    const finalTrustScore = updatedUserProfile.trustScore;
+    recommendation = updatedUserProfile.recommendations.find(
+      (r) => r.id === recommendationId
+    ) || recommendation;
+    const now = Date.now();
+    if (updatedUserProfile.lastTradeDecisionMadeTimestamp && now - updatedUserProfile.lastTradeDecisionMadeTimestamp < this.USER_TRADE_COOLDOWN_HOURS * 36e5) {
+      logger.info(
+        `Task Worker: User ${userId} on trade cooldown (post-score update). Holding on rec ${recommendationId}.`
+      );
+      if (recommendation) {
+        recommendation.processedForTradeDecision = false;
+      } else {
+        logger.error(
+          "Task Worker: Rec null after profile refresh in cooldown check."
+        );
+      }
+      await runtime.updateComponent({
+        ...updatedComponent,
+        data: updatedUserProfile
+      });
+      await runtime.deleteTask(task.id);
+      return;
+    }
+    let decisionMade = false;
+    if (recommendation.recommendationType === "BUY") {
+      if (finalTrustScore > this.POSITIVE_TRADE_THRESHOLD) {
+        logger.info(
+          `Task Worker: SIMULATING BUY for rec ${recommendationId}. User ${userId}, Score: ${finalTrustScore.toFixed(2)}`
+        );
+        updatedUserProfile.lastTradeDecisionMadeTimestamp = now;
+        decisionMade = true;
+      } else {
+        logger.info(
+          `Task Worker: HOLDING on BUY rec ${recommendationId}. User ${userId}, Score: ${finalTrustScore.toFixed(2)}, Threshold: >${this.POSITIVE_TRADE_THRESHOLD})`
+        );
+      }
+    } else {
+      if (finalTrustScore > this.POSITIVE_TRADE_THRESHOLD) {
+        logger.info(
+          `Task Worker: ACKNOWLEDGING VALID SELL/CRITICISM for rec ${recommendationId}. User ${userId}, Score: ${finalTrustScore.toFixed(2)}`
+        );
+        updatedUserProfile.lastTradeDecisionMadeTimestamp = now;
+        decisionMade = true;
+      } else if (finalTrustScore < -this.NEUTRAL_MARGIN) {
+        logger.info(
+          `Task Worker: IGNORING POTENTIAL FUD SELL/CRITICISM for rec ${recommendationId}. User ${userId}, Score: ${finalTrustScore.toFixed(2)} (Threshold for FUD: <${-this.NEUTRAL_MARGIN})`
+        );
+      } else {
+        logger.info(
+          `Task Worker: NOTING SELL/CRITICISM for rec ${recommendationId}. User ${userId}, Score: ${finalTrustScore.toFixed(2)}`
+        );
+      }
+    }
+    const recToUpdate = updatedUserProfile.recommendations.find(
+      (r) => r.id === recommendationId
+    );
+    if (recToUpdate) {
+      recToUpdate.processedForTradeDecision = true;
+    } else {
+      logger.error(
+        `[CommunityInvestorService] Task Worker: Could not find rec ${recommendationId} in updated profile to mark as processed.`
+      );
+    }
+    await runtime.updateComponent({
+      ...updatedComponent,
+      data: updatedUserProfile
+    });
+    await runtime.deleteTask(task.id);
+    logger.info(
+      `Task Worker: Finished trade decision for rec ${recommendationId}. User: ${userId}. Made Sim Trade: ${decisionMade}`
+    );
+  }
+  registerTaskWorkers(runtime) {
+    runtime.registerTaskWorker({
+      name: "PROCESS_TRADE_DECISION",
+      execute: async (_runtime, options, task) => {
+        await this.executeProcessTradeDecision(
+          options,
+          task
+        );
+        return void 0;
+      }
+    });
+    logger.info(
+      "[CommunityInvestorService] Registered PROCESS_TRADE_DECISION task worker."
+    );
+  }
+  async getLeaderboardData(runtime) {
+    logger.info("[CommunityInvestorService] getLeaderboardData called");
+    const leaderboardEntries = [];
+    const worldIdForComponents = this.componentWorldId;
+    logger.info(
+      `[CommunityInvestorService] Preparing leaderboard from world ${worldIdForComponents}. Checking ${this.userRegistry.size} registered users from userRegistry: [${Array.from(this.userRegistry).join(", ")}]`
+    );
+    for (const userId of this.userRegistry) {
+      logger.debug(
+        `[CommunityInvestorService] Leaderboard: Processing registered user ${userId} from world ${worldIdForComponents}`
+      );
+      try {
+        const component = await runtime.getComponent(
+          userId,
+          TRUST_MARKETPLACE_COMPONENT_TYPE,
+          worldIdForComponents,
+          // Use consistent worldId
+          runtime.agentId
+        );
+        if (component?.data) {
+          const profileData = component.data;
+          const entityDetails = await runtime.getEntityById(component.entityId);
+          const recommendations = Array.isArray(profileData.recommendations) ? profileData.recommendations : [];
+          leaderboardEntries.push({
+            userId: component.entityId,
+            username: entityDetails?.names?.[0] || component.entityId.toString(),
+            trustScore: profileData.trustScore || 0,
+            recommendations
+          });
+          logger.debug(
+            `[CommunityInvestorService] Added user ${userId} to leaderboard with score ${profileData.trustScore}`
+          );
+        } else {
+          logger.debug(
+            `[CommunityInvestorService] Leaderboard: No profile component found for registered user ${userId}`
+          );
+        }
+      } catch (error) {
+        logger.error(
+          `[CommunityInvestorService] Leaderboard: Error fetching profile component for user ${userId}:`,
+          error
+        );
+      }
+    }
+    logger.info(
+      `[CommunityInvestorService] Leaderboard: Found ${leaderboardEntries.length} users with profiles to include.`
+    );
+    leaderboardEntries.sort((a, b) => b.trustScore - a.trustScore);
+    const rankedLeaderboard = leaderboardEntries.map((entry, index) => ({
+      ...entry,
+      rank: index + 1
+    }));
+    logger.info(
+      `[CommunityInvestorService] Leaderboard generated with ${rankedLeaderboard.length} entries.`
+    );
+    return rankedLeaderboard;
+  }
+  // Add this method to register a user when they make a recommendation
+  registerUser(userId) {
+    const originalSize = this.userRegistry.size;
+    this.userRegistry.add(userId);
+    if (this.userRegistry.size > originalSize) {
+      logger.info(
+        `[CommunityInvestorService] User ${userId} ADDED to registry. New size: ${this.userRegistry.size}. Registry now: [${Array.from(this.userRegistry).join(", ")}]`
+      );
+    } else {
+      logger.debug(
+        `[CommunityInvestorService] User ${userId} already in registry. Size: ${this.userRegistry.size}`
+      );
+    }
+    const registryCacheKey = `community-investor:user-registry:${this.componentWorldId}`;
+    this.runtime.setCache(registryCacheKey, Array.from(this.userRegistry)).then(
+      () => logger.debug(
+        `[CommunityInvestorService] User registry cache updated for user ${userId} at key ${registryCacheKey}.`
+      )
+    ).catch(
+      (err) => logger.error(
+        `[CommunityInvestorService] FAILED to update user registry cache for ${userId} at key ${registryCacheKey}:`,
+        err
+      )
+    );
+  }
+  // Load user registry on initialization
+  async loadUserRegistry() {
+    const registryCacheKey = `community-investor:user-registry:${this.componentWorldId}`;
+    try {
+      const cached = await this.runtime.getCache(registryCacheKey);
+      if (cached && Array.isArray(cached)) {
+        this.userRegistry = new Set(cached);
+        logger.info(
+          `[CommunityInvestorService] Loaded ${this.userRegistry.size} users from registry cache at key ${registryCacheKey}. Users: [${Array.from(this.userRegistry).join(", ")}]`
+        );
+      } else {
+        logger.info(
+          `[CommunityInvestorService] No user registry found in cache at key ${registryCacheKey}, starting fresh.`
+        );
+      }
+    } catch (error) {
+      logger.warn(
+        `[CommunityInvestorService] Failed to load user registry from cache at key ${registryCacheKey}:`,
+        error
+      );
+    }
+  }
+  async ensurePluginComponentContext() {
+    try {
+      await this.runtime.ensureWorldExists({
+        id: this.componentWorldId,
+        name: `Social Alpha Global World (Agent: ${this.runtime.agentId})`,
+        agentId: this.runtime.agentId,
+        metadata: {
+          plugin_managed: true,
+          description: "World context for CommunityInvestor plugin components"
+        }
+      });
+      logger.info(
+        `[CommunityInvestorService] Ensured plugin component world ${this.componentWorldId} exists.`
+      );
+      await this.runtime.ensureRoomExists({
+        id: this.componentRoomId,
+        name: `Social Alpha Global Room (Agent: ${this.runtime.agentId})`,
+        worldId: this.componentWorldId,
+        agentId: this.runtime.agentId,
+        channelId: TRUST_LEADERBOARD_WORLD_SEED,
+        source: "plugin_internal",
+        type: ChannelType.API,
+        // Use API as fallback channel type
+        metadata: {
+          plugin_managed: true,
+          description: "Room context for CommunityInvestor plugin components"
+        }
+      });
+      logger.info(
+        `[CommunityInvestorService] Ensured plugin component room ${this.componentRoomId} in world ${this.componentWorldId} exists.`
+      );
+    } catch (error) {
+      logger.error(
+        `[CommunityInvestorService] FAILED to ensure plugin component world/room context (ID: ${this.componentWorldId}):`,
+        error
+      );
+    }
+  }
+  // ===================== NEW CORE PROCESSING LOGIC =====================
+  /**
+   * Processes a batch of historical messages, intended to be called from a script.
+   */
+  async processHistoricalData(batch) {
+    logger.info(
+      `[Service] Processing historical batch ${batch.fileId}_${batch.batchIndex}`
+    );
+    const { messages, userMap } = batch;
+    const contextText = "";
+    const messagesText = messages.map(
+      (msg, idx) => `[${idx}] ${userMap[msg.uid] || msg.uid}: ${msg.content}`
+    ).join("\n");
+    const { systemPrompt, userPrompt } = this.buildExtractionPrompts(
+      contextText,
+      messagesText,
+      messages.length,
+      "Multiple Users"
+    );
+    try {
+      const response = await this.runtime.useModel(ModelType.TEXT_LARGE, {
+        prompt: `${systemPrompt}
+${userPrompt}`
+      });
+      const parsed = parseRecommendationExtraction(response);
+      if (!parsed?.recommendations || parsed.recommendations.length === 0) {
+        logger.debug(
+          `[Service] No recommendations extracted from historical batch ${batch.fileId}_${batch.batchIndex}.`
+        );
+        return [];
+      }
+      const callsByUserId = /* @__PURE__ */ new Map();
+      for (const rec of parsed.recommendations) {
+        const message = messages[rec.messageIndex];
+        if (!message) continue;
+        const userId = asUUID(createUniqueUuid(this.runtime, message.uid));
+        if (!callsByUserId.has(userId)) {
+          callsByUserId.set(userId, { messages: [], recommendations: [] });
+        }
+        callsByUserId.get(userId)?.messages.push(message);
+        callsByUserId.get(userId)?.recommendations.push(rec);
+      }
+      for (const [userId, data] of callsByUserId.entries()) {
+        await this.updateProfileWithRecommendations(
+          userId,
+          data.messages,
+          data.recommendations
+        );
+      }
+      return parsed.recommendations;
+    } catch (error) {
+      logger.error(
+        `[Service] Error processing historical batch ${batch.fileId}_${batch.batchIndex}:`,
+        error
+      );
+      return [];
+    }
+  }
+  /**
+   * Main entry point for processing a single, real-time message from the event handler.
+   */
+  async processIncomingMessage(message) {
+    const { userId, roomId, text, timestamp, id, username } = message;
+    const messageId = id || asUUID(createUniqueUuid(this.runtime, `${userId}-${timestamp}`));
+    const recentMessages = await this.runtime.getMemories({
+      tableName: "messages",
+      roomId,
+      count: 10,
+      // Fetch recent messages for context
+      unique: false
+    });
+    const contextText = recentMessages.map(
+      (msg) => `${msg.content?.name || msg.entityId.toString()}: ${msg.content?.text || ""}`
+    ).join("\n");
+    const messagesText = `[0] ${username || userId}: ${text}`;
+    const { systemPrompt, userPrompt } = this.buildExtractionPrompts(
+      contextText,
+      messagesText,
+      1,
+      username || userId.toString()
+    );
+    try {
+      const response = await this.runtime.useModel(ModelType.TEXT_LARGE, {
+        prompt: `${systemPrompt}
+${userPrompt}`
+      });
+      const parsed = parseRecommendationExtraction(response);
+      if (!parsed?.recommendations || parsed.recommendations.length === 0) {
+        logger.debug(
+          `[Service] No recommendations extracted from message ${messageId}.`
+        );
+        return;
+      }
+      const messageForUpdate = {
+        id: messageId,
+        content: text,
+        uid: userId,
+        ts: new Date(timestamp).toISOString()
+      };
+      await this.updateProfileWithRecommendations(
+        userId,
+        [messageForUpdate],
+        parsed.recommendations
+      );
+    } catch (e) {
+      logger.error(
+        `[Service] Error processing incoming message for user ${userId}:`,
+        e
+      );
+    }
+  }
+  /**
+   * Builds the system and user prompts for the recommendation extraction LLM call.
+   */
+  buildExtractionPrompts(contextText, messagesText, batchSize, _senderName) {
+    const systemPrompt = `Extract crypto trading signals, calls, recommendations, and sentiment from Discord messages.
+
+\u{1F3AF} WHAT COUNTS AS A TRADING SIGNAL:
+\u2022 Direct trading advice: "buy X", "sell Y", "hold Z"
+\u2022 Token mentions with $ symbol: $SOL, $PEPE, $DOGE, etc.
+\u2022 Contract addresses posted for token discovery
+\u2022 Price predictions: "X going to moon", "Y will dump"
+\u2022 Market sentiment: "bullish on X", "bearish on Y"
+\u2022 Technical analysis mentions
+\u2022 FUD or criticism about specific tokens/projects
+\u2022 Trading intent: "I'm buying X", "waiting for dip"
+\u2022 Token performance discussion
+
+\u{1F6AB} WHAT TO EXCLUDE:
+\u2022 Rick bot automated messages (User ID: 1081815963990761542)
+\u2022 Generic DAO/protocol discussion without specific tokens
+\u2022 Users with "*bot" in username
+\u2022 Messages about "mintable" (it's a property, not a token)
+\u2022 General crypto news without specific token focus
+
+\u{1F524} CRYPTO SLANG DICTIONARY:
+\u2022 fsh = full stack hitler (derogatory)
+\u2022 dca = dollar cost averaging
+\u2022 ath = all time high
+\u2022 atl = all time low
+\u2022 mcap = market cap
+\u2022 ser = sir
+\u2022 ngmi = not gonna make it
+\u2022 wagmi = we're all gonna make it
+\u2022 wen = when
+\u2022 gm = good morning
+\u2022 ser = sir
+
+\u26A0\uFE0F CRITICAL OUTPUT REQUIREMENTS:
+- Respond with JSON only.
+- EXACTLY ${batchSize} recommendations entries (messageIndex 0 to ${batchSize - 1})
+- Every entry MUST include ALL required fields
+
+REQUIRED JSON SHAPE:
+{"recommendations":[{"messageIndex":0,"isCall":true,"tokenMentioned":"SOL","nameMentioned":"","caMentioned":"","chain":"solana","sentiment":"positive","conviction":"medium","llmReasoning":"User mentioned buying $SOL with medium confidence"}]}
+
+FIELD REQUIREMENTS:
+\u2022 messageIndex: 0 to ${batchSize - 1}
+\u2022 isCall: true/false
+\u2022 tokenMentioned: ticker without $ (or "" if none)
+\u2022 nameMentioned: full token name (or "" if none)  
+\u2022 caMentioned: contract address (or "" if none)
+\u2022 chain: "solana", "ethereum", "bitcoin", "base", "unknown"
+\u2022 sentiment: "positive", "negative", "neutral"
+\u2022 conviction: "high", "medium", "low", "neutral"
+\u2022 llmReasoning: 1-2 sentence explanation
+
+VALIDATION RULES:
+\u2022 If isCall=true: At least ONE of tokenMentioned, nameMentioned, or caMentioned must be non-empty
+\u2022 If isCall=false: ALL three can be empty
+\u2022 sentiment "bullish"\u2192"positive", "bearish"\u2192"negative"
+\u2022 Be VERY generous with extraction - include borderline cases`;
+    const userPrompt = `
+RECENT CONTEXT:
+${contextText}
+
+\u{1F50D} ANALYZE THESE ${batchSize} MESSAGES FOR TRADING SIGNALS:
+${messagesText}
+
+\u{1F4CB} EXTRACTION RULES:
+1. Look for contract addresses: long alphanumeric strings (32-44 chars for Solana, 0x+40 chars for ETH/Base)
+2. Extract ANY token mentions: $BTC, $ETH, $SOL, $PEPE, etc.
+3. Capture trading sentiment and conviction level
+4. Include FUD, criticism, or warnings about tokens
+5. Be generous - include subtle references
+6. MUST return EXACTLY ${batchSize} results
+
+Examples that SHOULD be extracted:
+- "the dev is a CA spammer so we dont know where it could go from here" \u2192 negative sentiment about a project
+- "Dqyrmg6y7QFhsbCgpkNwnp8wFMs81z3ToPACYAipump is this legit?" \u2192 contract address inquiry
+- "I will wait for retrace to enter" \u2192 trading intent
+- "$SOL looking good" \u2192 positive sentiment
+- "most ai stuff are getting a dump" \u2192 negative sentiment on AI tokens
+- Contract addresses without context \u2192 neutral discovery
+
+RESPOND WITH JSON CONTAINING EXACTLY ${batchSize} RECOMMENDATION ENTRIES:`;
+    return { systemPrompt, userPrompt };
+  }
+  /**
+   * Updates a user's profile with new recommendations extracted from a message batch.
+   */
+  async updateProfileWithRecommendations(userId, messagesInBatch, recommendationsFromLlm) {
+    const component = await this.runtime.getComponent(
+      userId,
+      TRUST_MARKETPLACE_COMPONENT_TYPE,
+      this.componentWorldId,
+      this.runtime.agentId
+    );
+    let userProfile;
+    if (!component?.data) {
+      userProfile = {
+        version: "1.0.0",
+        userId,
+        trustScore: 0,
+        lastTrustScoreCalculationTimestamp: Date.now(),
+        recommendations: []
+      };
+    } else {
+      userProfile = component.data;
+      if (!Array.isArray(userProfile.recommendations))
+        userProfile.recommendations = [];
+    }
+    let profileUpdated = false;
+    for (const rec of recommendationsFromLlm) {
+      if (!rec.isCall || !rec.sentiment || rec.sentiment === "neutral") {
+        continue;
+      }
+      const sentiment = rec.sentiment;
+      const tokenMentioned = rec.tokenMentioned?.trim() && rec.tokenMentioned !== "N/A" ? rec.tokenMentioned : void 0;
+      const nameMentioned = rec.nameMentioned?.trim() ? rec.nameMentioned : void 0;
+      const caMentioned = rec.caMentioned?.trim() ? rec.caMentioned : void 0;
+      if (!tokenMentioned && !nameMentioned && !caMentioned) {
+        continue;
+      }
+      const originalMessage = messagesInBatch[rec.messageIndex];
+      if (!originalMessage) continue;
+      let resolvedToken = null;
+      if (caMentioned) {
+        resolvedToken = {
+          address: caMentioned,
+          chain: rec.chain || SupportedChain.SOLANA,
+          ticker: tokenMentioned || nameMentioned || caMentioned.slice(0, 8)
+        };
+      } else if (tokenMentioned) {
+        resolvedToken = await this.resolveTicker(
+          tokenMentioned,
+          rec.chain || SupportedChain.SOLANA
+        );
+      } else if (nameMentioned) {
+        resolvedToken = await this.resolveTicker(
+          nameMentioned,
+          rec.chain || SupportedChain.SOLANA
+        );
+      }
+      if (!resolvedToken) {
+        logger.warn(
+          `[Service] Could not resolve token for: "${tokenMentioned || nameMentioned || caMentioned}". Skipping.`
+        );
+        continue;
+      }
+      const newRecommendation = {
+        id: asUUID(uuidv4()),
+        userId,
+        messageId: originalMessage.id,
+        timestamp: new Date(originalMessage.ts).getTime(),
+        tokenTicker: resolvedToken.ticker,
+        tokenAddress: resolvedToken.address,
+        chain: resolvedToken.chain,
+        recommendationType: sentiment === "positive" ? "BUY" : "SELL",
+        conviction: rec.conviction,
+        rawMessageQuote: originalMessage.content,
+        priceAtRecommendation: 0,
+        processedForTradeDecision: false
+      };
+      userProfile.recommendations.unshift(newRecommendation);
+      profileUpdated = true;
+      logger.info(
+        `[Service] Added ${sentiment.toUpperCase()} recommendation for ${resolvedToken.ticker} from user ${userId}`
+      );
+      await this.runtime.createTask({
+        name: "PROCESS_TRADE_DECISION",
+        description: `Process trade decision for rec ${newRecommendation.id}`,
+        metadata: { recommendationId: newRecommendation.id, userId },
+        tags: ["socialAlpha", "tradeDecision"],
+        roomId: this.componentRoomId,
+        worldId: this.componentWorldId,
+        entityId: userId
+      });
+    }
+    if (profileUpdated) {
+      if (component) {
+        await this.runtime.updateComponent({
+          ...component,
+          data: userProfile
+        });
+      } else {
+        const newComponentId = asUUID(
+          createUniqueUuid(this.runtime, userId.toString())
+        );
+        await this.runtime.createComponent({
+          id: newComponentId,
+          entityId: userId,
+          agentId: this.runtime.agentId,
+          worldId: this.componentWorldId,
+          roomId: this.componentRoomId,
+          sourceEntityId: this.runtime.agentId,
+          type: TRUST_MARKETPLACE_COMPONENT_TYPE,
+          createdAt: Date.now(),
+          data: userProfile
+        });
+      }
+      await this.calculateUserTrustScore(userId, this.runtime);
+    }
+  }
+}
+export {
+  CommunityInvestorService
+};
+//# sourceMappingURL=service.js.map