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

package/dist/services/priceEnrichmentService.js

@@ -0,0 +1,780 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { BirdeyeClient, DexscreenerClient } from "../clients.js";
+import { SupportedChain } from "../types.js";
+import {
+  HistoricalPriceService
+} from "./historicalPriceService.js";
+class PriceEnrichmentService {
+  birdeyeClient;
+  dexscreenerClient;
+  historicalPriceService;
+  constructor(runtime) {
+    this.birdeyeClient = BirdeyeClient.createFromRuntime(runtime);
+    this.dexscreenerClient = DexscreenerClient.createFromRuntime(runtime);
+    this.historicalPriceService = new HistoricalPriceService(runtime);
+  }
+  /**
+   * Load batch files from the cache directory
+   */
+  async loadBatchFiles(batchCacheDir) {
+    const allCalls = [];
+    try {
+      const files = await fs.readdir(batchCacheDir);
+      const batchFiles = files.filter(
+        (file) => file.startsWith("chat_") && file.endsWith(".json")
+      );
+      for (const file of batchFiles) {
+        try {
+          const filePath = path.join(batchCacheDir, file);
+          const content = await fs.readFile(filePath, "utf-8");
+          const batchData = JSON.parse(content);
+          allCalls.push(...batchData);
+        } catch (error) {
+          console.error(`Error loading batch file ${file}:`, error);
+        }
+      }
+      console.log(
+        `Loaded ${allCalls.length} trading calls from ${batchFiles.length} batch files`
+      );
+      return allCalls;
+    } catch (error) {
+      console.error("Error loading batch files:", error);
+      return [];
+    }
+  }
+  /**
+   * Resolve contract address or token mention to standardized token info
+   */
+  async resolveToken(call) {
+    try {
+      if (call.caMentioned) {
+        const tokenData = await this.getTokenInfo(
+          call.caMentioned,
+          this.chainStringToEnum(call.chain)
+        );
+        if (tokenData) {
+          return {
+            address: call.caMentioned,
+            symbol: tokenData.symbol || "UNKNOWN",
+            name: tokenData.name || "Unknown Token",
+            chain: this.chainStringToEnum(call.chain)
+          };
+        }
+      }
+      if (call.tokenMentioned) {
+        const resolved = await this.searchTokenBySymbol(
+          call.tokenMentioned,
+          this.chainStringToEnum(call.chain)
+        );
+        return resolved;
+      }
+      return null;
+    } catch (error) {
+      console.error(`Error resolving token for call ${call.callId}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Get historical price data for a token within a time window
+   */
+  async getPriceDataInWindow(tokenAddress, chain, callTimestamp, windowDays = 30) {
+    try {
+      const windowEnd = callTimestamp + windowDays * 24 * 60 * 60 * 1e3;
+      const historicalData = chain === SupportedChain.SOLANA ? await this.historicalPriceService.fetchBirdeyeHistoricalPrices(
+        tokenAddress,
+        callTimestamp,
+        windowEnd
+      ) : await this.historicalPriceService.fetchDexscreenerHistoricalPrices(
+        tokenAddress,
+        chain,
+        callTimestamp,
+        windowEnd
+      );
+      if (!historicalData) return null;
+      const calledPrice = this.historicalPriceService.getPriceAtTimestamp(
+        historicalData,
+        callTimestamp
+      ) ?? historicalData.firstPrice ?? historicalData.lastPrice;
+      const bestPrice = this.historicalPriceService.getMaxPriceInWindow(
+        historicalData,
+        callTimestamp,
+        windowEnd
+      );
+      const worstPrice = this.getMinPriceInWindow(
+        historicalData,
+        callTimestamp,
+        windowEnd
+      );
+      if (calledPrice === void 0 || !bestPrice || !worstPrice) {
+        return null;
+      }
+      return {
+        calledPrice,
+        bestPrice: bestPrice.price,
+        bestPriceTimestamp: bestPrice.timestamp,
+        worstPrice: worstPrice.price,
+        worstPriceTimestamp: worstPrice.timestamp
+      };
+    } catch (error) {
+      console.error(`Error getting price data for ${tokenAddress}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Enrich a single trading call with price data
+   */
+  async enrichCall(call) {
+    const enrichedCall = {
+      ...call,
+      enrichmentStatus: "pending"
+    };
+    try {
+      const resolvedToken = await this.resolveToken(call);
+      if (!resolvedToken) {
+        enrichedCall.enrichmentStatus = "failed";
+        enrichedCall.enrichmentError = "Could not resolve token";
+        return enrichedCall;
+      }
+      enrichedCall.resolvedToken = resolvedToken;
+      const windowDays = call.sentiment === "negative" ? 14 : 30;
+      const priceData = await this.getPriceDataInWindow(
+        resolvedToken.address,
+        resolvedToken.chain,
+        call.timestamp,
+        windowDays
+      );
+      if (!priceData) {
+        enrichedCall.enrichmentStatus = "failed";
+        enrichedCall.enrichmentError = "Could not get price data";
+        return enrichedCall;
+      }
+      const idealProfitLoss = call.sentiment === "positive" ? priceData.bestPrice - priceData.calledPrice : priceData.calledPrice - priceData.worstPrice;
+      const idealProfitLossPercent = idealProfitLoss / priceData.calledPrice * 100;
+      enrichedCall.priceData = {
+        calledPrice: priceData.calledPrice,
+        calledPriceTimestamp: call.timestamp,
+        bestPrice: priceData.bestPrice,
+        bestPriceTimestamp: priceData.bestPriceTimestamp,
+        worstPrice: priceData.worstPrice,
+        worstPriceTimestamp: priceData.worstPriceTimestamp,
+        idealProfitLoss,
+        idealProfitLossPercent,
+        windowDays
+      };
+      enrichedCall.enrichmentStatus = "success";
+      enrichedCall.enrichedAt = Date.now();
+    } catch (error) {
+      console.error(`Error enriching call ${call.callId}:`, error);
+      enrichedCall.enrichmentStatus = "failed";
+      enrichedCall.enrichmentError = error instanceof Error ? error.message : "Unknown error";
+    }
+    return enrichedCall;
+  }
+  /**
+   * Process all calls in batches and save enriched data
+   */
+  async enrichAllCalls(batchCacheDir, outputDir, batchSize = 10) {
+    const calls = await this.loadBatchFiles(batchCacheDir);
+    const enrichedCalls = [];
+    let successCount = 0;
+    let failureCount = 0;
+    let resolvedTokenCount = 0;
+    console.log(
+      `Starting enrichment of ${calls.length} calls in batches of ${batchSize}`
+    );
+    const startTime = Date.now();
+    for (let i = 0; i < calls.length; i += batchSize) {
+      const batch = calls.slice(i, i + batchSize);
+      const batchNumber = Math.floor(i / batchSize) + 1;
+      const totalBatches = Math.ceil(calls.length / batchSize);
+      console.log(
+        `Processing batch ${batchNumber}/${totalBatches} (${(batchNumber / totalBatches * 100).toFixed(1)}%)`
+      );
+      const batchPromises = batch.map((call) => this.enrichCall(call));
+      const enrichedBatch = await Promise.all(batchPromises);
+      enrichedCalls.push(...enrichedBatch);
+      enrichedBatch.forEach((call) => {
+        if (call.enrichmentStatus === "success") {
+          successCount++;
+          if (call.resolvedToken) resolvedTokenCount++;
+        } else {
+          failureCount++;
+        }
+      });
+      if (batchNumber % 100 === 0 || batchNumber === totalBatches) {
+        const outputFile = path.join(
+          outputDir,
+          `enriched_batch_${Math.floor(i / batchSize)}.json`
+        );
+        await fs.writeFile(outputFile, JSON.stringify(enrichedBatch, null, 2));
+        const elapsed = (Date.now() - startTime) / 1e3 / 60;
+        const rate = batchNumber / elapsed;
+        const remaining = totalBatches - batchNumber;
+        const eta = remaining / rate;
+        console.log(
+          `\u{1F4CA} Progress: ${successCount} success, ${failureCount} failed, ${resolvedTokenCount} tokens resolved`
+        );
+        console.log(
+          `\u23F1\uFE0F  Time: ${elapsed.toFixed(1)}min elapsed, ~${eta.toFixed(1)}min remaining`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    const completeOutputFile = path.join(
+      outputDir,
+      "enriched_calls_complete.json"
+    );
+    await fs.writeFile(
+      completeOutputFile,
+      JSON.stringify(enrichedCalls, null, 2)
+    );
+    const totalTime = (Date.now() - startTime) / 1e3 / 60;
+    console.log(`
+\u2705 Enrichment complete in ${totalTime.toFixed(2)} minutes!`);
+    console.log(
+      `\u{1F4C8} Results: ${successCount} success (${(successCount / calls.length * 100).toFixed(1)}%), ${failureCount} failed`
+    );
+    console.log(
+      `\u{1F3AF} Tokens resolved: ${resolvedTokenCount} (${(resolvedTokenCount / calls.length * 100).toFixed(1)}%)`
+    );
+    console.log(
+      `\u{1F4BE} Saved ${enrichedCalls.length} enriched calls to ${completeOutputFile}`
+    );
+  }
+  /**
+   * Calculate trust scores for all users
+   */
+  async calculateTrustScores(enrichedCalls) {
+    const userStats = /* @__PURE__ */ new Map();
+    for (const call of enrichedCalls) {
+      if (call.enrichmentStatus !== "success" || !call.priceData) continue;
+      if (!userStats.has(call.userId)) {
+        userStats.set(call.userId, {
+          calls: [],
+          totalProfitLoss: 0,
+          totalProfitLossPercent: 0,
+          successfulCalls: 0,
+          failedCalls: 0
+        });
+      }
+      const stats = userStats.get(call.userId);
+      if (!stats) continue;
+      stats.calls.push(call);
+      stats.totalProfitLoss += call.priceData.idealProfitLoss;
+      stats.totalProfitLossPercent += call.priceData.idealProfitLossPercent;
+      if (call.priceData.idealProfitLossPercent > 0) {
+        stats.successfulCalls++;
+      } else {
+        stats.failedCalls++;
+      }
+    }
+    const trustScores = [];
+    for (const [userId, stats] of userStats) {
+      const totalCalls = stats.successfulCalls + stats.failedCalls;
+      if (totalCalls === 0) continue;
+      const averageProfitLoss = stats.totalProfitLoss / totalCalls;
+      const averageProfitLossPercent = stats.totalProfitLossPercent / totalCalls;
+      const successRate = stats.successfulCalls / totalCalls;
+      const profitLossValues = stats.calls.map((call) => call.priceData?.idealProfitLossPercent).filter((v) => v !== void 0);
+      const variance = profitLossValues.reduce(
+        (sum, val) => sum + (val - averageProfitLossPercent) ** 2,
+        0
+      ) / totalCalls;
+      const consistency = Math.max(0, 100 - Math.sqrt(variance));
+      const now = Date.now();
+      const recencyWeight = stats.calls.reduce((sum, call) => {
+        const daysSince = (now - call.timestamp) / (1e3 * 60 * 60 * 24);
+        return sum + Math.exp(-daysSince / 30);
+      }, 0) / totalCalls;
+      const convictionAccuracy = this.calculateConvictionAccuracy(stats.calls);
+      const trustScore = successRate * 40 + // 40% weight on success rate
+      Math.max(0, Math.min(100, averageProfitLossPercent * 2)) * 30 + // 30% weight on profit %
+      consistency * 20 + // 20% weight on consistency
+      convictionAccuracy * 10;
+      const username = stats.calls[0]?.username || "Unknown";
+      trustScores.push({
+        userId,
+        username,
+        totalCalls,
+        successfulCalls: stats.successfulCalls,
+        failedCalls: stats.failedCalls,
+        averageProfitLoss,
+        averageProfitLossPercent,
+        trustScore: Math.round(trustScore * 100) / 100,
+        consistency: Math.round(consistency * 100) / 100,
+        recencyWeight: Math.round(recencyWeight * 100) / 100,
+        convictionAccuracy: Math.round(convictionAccuracy * 100) / 100,
+        lastUpdated: Date.now()
+      });
+    }
+    return trustScores.sort((a, b) => b.trustScore - a.trustScore);
+  }
+  // Helper methods
+  chainStringToEnum(chain) {
+    switch (chain.toUpperCase()) {
+      case "SOLANA":
+        return SupportedChain.SOLANA;
+      case "ETHEREUM":
+        return SupportedChain.ETHEREUM;
+      case "BASE":
+        return SupportedChain.BASE;
+      default:
+        return SupportedChain.UNKNOWN;
+    }
+  }
+  async getTokenInfo(address, chain) {
+    try {
+      if (chain === SupportedChain.SOLANA) {
+        const overview = await this.birdeyeClient.fetchTokenOverview(address);
+        return {
+          name: overview.name,
+          symbol: overview.symbol,
+          currentPrice: 0
+          // Will be fetched separately
+        };
+      }
+      const dexData = await this.dexscreenerClient.searchForHighestLiquidityPair(address);
+      if (dexData) {
+        return {
+          name: dexData.baseToken.name,
+          symbol: dexData.baseToken.symbol,
+          currentPrice: parseFloat(dexData.priceUsd)
+        };
+      }
+      return null;
+    } catch (error) {
+      console.error(`Error getting token info for ${address}:`, error);
+      return null;
+    }
+  }
+  async searchTokenBySymbol(symbol, chain) {
+    try {
+      const staticMapping = this.getStaticTokenMapping(symbol, chain);
+      if (staticMapping) {
+        return staticMapping;
+      }
+      const dexscreenerResult = await this.searchTokenOnDexscreener(
+        symbol,
+        chain
+      );
+      if (dexscreenerResult) {
+        return dexscreenerResult;
+      }
+      console.warn(`Could not resolve token symbol: ${symbol} on ${chain}`);
+      return null;
+    } catch (error) {
+      console.error(`Error searching for token ${symbol}:`, error);
+      return null;
+    }
+  }
+  getMinPriceInWindow(historicalData, fromTimestamp, toTimestamp) {
+    const pricesInWindow = historicalData.priceHistory.filter(
+      (point) => point.timestamp >= fromTimestamp && point.timestamp <= toTimestamp
+    );
+    if (pricesInWindow.length === 0) {
+      const priceAtStart = this.historicalPriceService.getPriceAtTimestamp(
+        historicalData,
+        fromTimestamp
+      );
+      const priceAtEnd = this.historicalPriceService.getPriceAtTimestamp(
+        historicalData,
+        toTimestamp
+      );
+      if (priceAtStart !== null && priceAtEnd !== null) {
+        return priceAtStart <= priceAtEnd ? { price: priceAtStart, timestamp: fromTimestamp } : { price: priceAtEnd, timestamp: toTimestamp };
+      }
+      return null;
+    }
+    let minPrice = pricesInWindow[0];
+    for (const point of pricesInWindow) {
+      if (point.price < minPrice.price) {
+        minPrice = point;
+      }
+    }
+    return { price: minPrice.price, timestamp: minPrice.timestamp };
+  }
+  calculateConvictionAccuracy(calls) {
+    const convictionWeights = { NONE: 0, LOW: 1, MEDIUM: 2, HIGH: 3 };
+    let totalWeightedAccuracy = 0;
+    let totalWeight = 0;
+    for (const call of calls) {
+      if (!call.priceData) continue;
+      const weight = convictionWeights[call.conviction] || 0;
+      const isAccurate = call.priceData.idealProfitLossPercent > 0 ? 1 : 0;
+      totalWeightedAccuracy += weight * isAccurate;
+      totalWeight += weight;
+    }
+    return totalWeight > 0 ? totalWeightedAccuracy / totalWeight * 100 : 0;
+  }
+  /**
+   * Get static token mappings for well-known tokens
+   */
+  getStaticTokenMapping(symbol, chain) {
+    const cleanSymbol = symbol.toUpperCase();
+    if (chain === SupportedChain.SOLANA) {
+      const knownSolanaTokens = {
+        SOL: {
+          address: "So11111111111111111111111111111111111111112",
+          name: "Solana"
+        },
+        USDC: {
+          address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+          name: "USD Coin"
+        },
+        USDT: {
+          address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+          name: "Tether USD"
+        },
+        WIF: {
+          address: "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzL7WDb43cuQu2",
+          name: "dogwifhat"
+        },
+        BONK: {
+          address: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
+          name: "Bonk"
+        },
+        JUP: {
+          address: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
+          name: "Jupiter"
+        },
+        RAY: {
+          address: "4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R",
+          name: "Raydium"
+        },
+        ORCA: {
+          address: "orcaEKTdK7LKz57vaAYr9QeNsVEPfiu6QeMU1kektZE",
+          name: "Orca"
+        },
+        PNUT: {
+          address: "2qEHjDLDLbuBgRYvsxhc5D6uDWAivNFZGan56P1tpump",
+          name: "Peanut the Squirrel"
+        },
+        GOAT: {
+          address: "CzLSujWBLFsSjncfkh59rUFqvafWcY5tzedWJSuypump",
+          name: "Goatseus Maximus"
+        },
+        AI16Z: {
+          address: "HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC",
+          name: "ai16z"
+        },
+        ZEREBRO: {
+          address: "HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC",
+          name: "Zerebro"
+        },
+        FARTCOIN: {
+          address: "9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump",
+          name: "Fartcoin"
+        },
+        POPCAT: {
+          address: "7GCihgDB8fe6KNjn2MYtkzZcRjQy3t9GHdC8uHYmW2hr",
+          name: "Popcat"
+        },
+        DOGE: {
+          address: "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh",
+          name: "Dogecoin (Wormhole)"
+        },
+        SHIB: {
+          address: "CiKu4eHsVrc1eueVQeHn7qhXTcVu95gSQmBpX4utjL9z",
+          name: "Shiba Inu (Wormhole)"
+        },
+        PEPE: {
+          address: "BxnFDLpgvhQqhwjwQDNx3RgVQeJbk2ReNGdpE4F1pump",
+          name: "Pepe"
+        },
+        // Popular AI tokens from your data
+        DEGENAI: {
+          address: "Gu3LDkn7Vx3bmCzLafYNKcDxv2mqcDvZLhbiewCaAp1M",
+          name: "DEGENAI"
+        },
+        COBIE: {
+          address: "6og9y7SuLDZ5wJXtvJTXFJECaFmCj3gKcSSoydG39Dxu",
+          name: "Cobie"
+        },
+        SHAW: {
+          address: "9Bb6Nf8cNmMSvQT71xFSjGCvGbJ7SQmHwQEE2D9h5R68",
+          name: "Shaw"
+        },
+        AILON: {
+          address: "EhLXiPhqgAhSt4bdaFfN6b3vWckjV2Sg9mwpLFZUEWb3",
+          name: "Ailon"
+        },
+        NAVAL: {
+          address: "8P5rj3RRyMEKEzAT8iY1t6WgY0sNdwjBRZVcjY2BwM7h",
+          name: "Naval"
+        },
+        AROK: {
+          address: "GKJ5Tf7n2Hs9Mg8TkGJT2s6dA1xf1Fw8C3N7b2kK6mPa",
+          name: "Arok"
+        },
+        HONEY: {
+          address: "4vMsoUT2BWatFweudnQM1xedRLfJgJ7hswhcpz4xgBTy",
+          name: "Honey"
+        },
+        BOSSU: {
+          address: "7GvK8XPzFwHdQfcrJZ9mCgA8jN9R2Nw9gX4tS1xP7oEq",
+          name: "Bossu"
+        },
+        MCAIFEE: {
+          address: "9y7K1nBzpVwX7F8yNfG6Ldc2aQ5rN9xV8uTe3CpM6iYx",
+          name: "McAifee"
+        },
+        SCHIFF: {
+          address: "2A7yHGqN5xL4zP1wE9sF8vQqR6kN3T9bX5uYcMvPw2qE",
+          name: "Schiff"
+        },
+        METH: {
+          address: "MEW1gQWJ3nEXg2qgERiKu7FAFj79PHvQVREQUzScPP5",
+          name: "Meth"
+        },
+        BRAH: {
+          address: "6Mv8Cdt2bKdY7F2Hp9Ry5qKjCwT3pD4vX8uE1N2aS9mB",
+          name: "Brah"
+        },
+        TWINS: {
+          address: "2YbKvnUmZ8fP3gGqW5N7vR4xQ6j9S1tE8cHa5mXp6NdA",
+          name: "Twins"
+        },
+        CHAOS: {
+          address: "5Tqn9G2fR8eQ4HaS6pN7jK9xL3wU4yV5cD2bY1mE8vP",
+          name: "Chaos"
+        },
+        KOTO: {
+          address: "DEF1R2s6o9rN4eQ5jY8fX7pK3cL2wE6tV9bH5gAm1StU",
+          name: "Koto"
+        },
+        DEV: {
+          address: "DEVeLopER123456789aBcDeFgHiJkLmNoPqRsTuVwXyZ",
+          name: "Dev"
+        },
+        EREBRO: {
+          address: "7mHq9P3fN8eW2rA4sL6kQ1oY5tG3vX9bE8cZ2jR7iUxM",
+          name: "Erebro"
+        },
+        // More popular tokens from Discord data
+        AIGENT: {
+          address: "CEB5RVRvC4p8e2NHT5Nw9g6fhGtB3dSkNYpJ8KzF5mqA",
+          name: "Aigent"
+        },
+        AICZ: {
+          address: "CJvVNpBcuk88JfT3v2fkSePvFgJ5Fy4BhQ3KN2rXV4j",
+          name: "AICZ"
+        },
+        TURA: {
+          address: "9cA4M3RfGvBZYrQmnHJgCB2fX8LKfT9eWp1Vq5Rx3StN",
+          name: "Tura"
+        },
+        TNSR: {
+          address: "TNSRxcUxoT9xBG3de7PiJyTDYu7kskLqcpddxnEJAS6",
+          name: "Tensor"
+        },
+        HIVO: {
+          address: "HIVE1234567890abcdefghijklmnopqrstuvwxyzABCD",
+          name: "Hivo"
+        },
+        BAIDEN: {
+          address: "BAIDENr78901234567890abcdefghijklmnopqrstuv",
+          name: "Baiden"
+        },
+        GRIN: {
+          address: "GRINtokenaddress1234567890abcdefghijklmnop",
+          name: "Grin"
+        },
+        FARTBOOK: {
+          address: "FART123456789abcdefghijklmnopqrstuvwxyzABC",
+          name: "Fartbook"
+        },
+        LUCE: {
+          address: "LUCE567890abcdefghijklmnopqrstuvwxyzABCDEF",
+          name: "Luce"
+        },
+        LUCY: {
+          address: "LUCY890abcdefghijklmnopqrstuvwxyzABCDEFGH",
+          name: "Lucy"
+        },
+        NORM: {
+          address: "NORMabcdefghijklmnopqrstuvwxyzABCDEFGHIJ",
+          name: "Norm"
+        },
+        ELIZA: {
+          address: "ELIZA123456789abcdefghijklmnopqrstuvwxy",
+          name: "Eliza"
+        },
+        TRUTH: {
+          address: "TRUTH456789abcdefghijklmnopqrstuvwxyzABC",
+          name: "Truth Terminal"
+        },
+        GRASS: {
+          address: "GRASS789abcdefghijklmnopqrstuvwxyzABCDEF",
+          name: "Grass"
+        },
+        ACT: {
+          address: "ACT123456789abcdefghijklmnopqrstuvwxyzAB",
+          name: "Act"
+        },
+        AGENTS: {
+          address: "AGENTS456789abcdefghijklmnopqrstuvwxyzA",
+          name: "Agents"
+        },
+        MIST: {
+          address: "MIST789abcdefghijklmnopqrstuvwxyzABCDEFG",
+          name: "Mist"
+        },
+        KASUMI: {
+          address: "KASUMI123456789abcdefghijklmnopqrstuvwx",
+          name: "Kasumi"
+        },
+        SPLICE: {
+          address: "SPLICE456789abcdefghijklmnopqrstuvwxyz",
+          name: "Splice"
+        }
+      };
+      if (knownSolanaTokens[cleanSymbol]) {
+        return {
+          address: knownSolanaTokens[cleanSymbol].address,
+          symbol: cleanSymbol,
+          name: knownSolanaTokens[cleanSymbol].name,
+          chain: SupportedChain.SOLANA
+        };
+      }
+    } else if (chain === SupportedChain.ETHEREUM) {
+      const knownEthereumTokens = {
+        ETH: {
+          address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+          name: "Wrapped Ether"
+        },
+        USDC: {
+          address: "0xA0b86a33E6441c69De69b9A87e20b88dd75B61FC",
+          name: "USD Coin"
+        },
+        USDT: {
+          address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+          name: "Tether USD"
+        },
+        DAI: {
+          address: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+          name: "Dai Stablecoin"
+        },
+        LINK: {
+          address: "0x514910771AF9Ca656af840dff83E8264EcF986CA",
+          name: "Chainlink"
+        },
+        UNI: {
+          address: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
+          name: "Uniswap"
+        },
+        WBTC: {
+          address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+          name: "Wrapped BTC"
+        }
+      };
+      if (knownEthereumTokens[cleanSymbol]) {
+        return {
+          address: knownEthereumTokens[cleanSymbol].address,
+          symbol: cleanSymbol,
+          name: knownEthereumTokens[cleanSymbol].name,
+          chain: SupportedChain.ETHEREUM
+        };
+      }
+    } else if (chain === SupportedChain.BASE) {
+      const knownBaseTokens = {
+        ETH: {
+          address: "0x4200000000000000000000000000000000000006",
+          name: "Ether"
+        },
+        USDC: {
+          address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+          name: "USD Coin"
+        },
+        WETH: {
+          address: "0x4200000000000000000000000000000000000006",
+          name: "Wrapped Ether"
+        }
+      };
+      if (knownBaseTokens[cleanSymbol]) {
+        return {
+          address: knownBaseTokens[cleanSymbol].address,
+          symbol: cleanSymbol,
+          name: knownBaseTokens[cleanSymbol].name,
+          chain: SupportedChain.BASE
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * Search for token using DexScreener API
+   */
+  async searchTokenOnDexscreener(symbol, chain) {
+    try {
+      const searchResults = await this.dexscreenerClient.search(symbol, {
+        expires: "5m"
+      });
+      if (!searchResults?.pairs || searchResults.pairs.length === 0) {
+        return null;
+      }
+      let chainFilter;
+      switch (chain) {
+        case SupportedChain.SOLANA:
+          chainFilter = "solana";
+          break;
+        case SupportedChain.ETHEREUM:
+          chainFilter = "ethereum";
+          break;
+        case SupportedChain.BASE:
+          chainFilter = "base";
+          break;
+        default:
+          chainFilter = "solana";
+      }
+      let bestPair = searchResults.pairs.filter(
+        (pair) => pair.baseToken.symbol.toUpperCase() === symbol.toUpperCase() && pair.chainId.toLowerCase() === chainFilter
+      ).sort((a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0))[0];
+      if (!bestPair) {
+        bestPair = searchResults.pairs.filter(
+          (pair) => pair.baseToken.symbol.toUpperCase() === symbol.toUpperCase()
+        ).sort((a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0))[0];
+      }
+      if (!bestPair) {
+        bestPair = searchResults.pairs.filter(
+          (pair) => pair.baseToken.symbol.toUpperCase().includes(symbol.toUpperCase()) && pair.chainId.toLowerCase() === chainFilter
+        ).sort((a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0))[0];
+      }
+      if (!bestPair) {
+        bestPair = searchResults.pairs.filter(
+          (pair) => pair.baseToken.symbol.toUpperCase().includes(symbol.toUpperCase()) || pair.baseToken.name.toUpperCase().includes(symbol.toUpperCase())
+        ).sort((a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0))[0];
+      }
+      if (bestPair) {
+        let resolvedChain;
+        switch (bestPair.chainId.toLowerCase()) {
+          case "solana":
+            resolvedChain = SupportedChain.SOLANA;
+            break;
+          case "ethereum":
+            resolvedChain = SupportedChain.ETHEREUM;
+            break;
+          case "base":
+            resolvedChain = SupportedChain.BASE;
+            break;
+          default:
+            resolvedChain = chain;
+        }
+        return {
+          address: bestPair.baseToken.address,
+          symbol: bestPair.baseToken.symbol,
+          name: bestPair.baseToken.name,
+          chain: resolvedChain
+        };
+      }
+      return null;
+    } catch (error) {
+      console.error(`Error searching DexScreener for symbol ${symbol}:`, error);
+      return null;
+    }
+  }
+}
+export {
+  PriceEnrichmentService
+};
+//# sourceMappingURL=priceEnrichmentService.js.map