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

package/dist/services/simulationRunner.js

@@ -0,0 +1,771 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { v4 as uuidv4 } from "uuid";
+import { Conviction, SupportedChain } from "../types.js";
+import {
+  TokenSimulationService
+} from "./tokenSimulationService.js";
+var TokenScenario = /* @__PURE__ */ ((TokenScenario2) => {
+  TokenScenario2["RUG_PULL_FAST"] = "rug_fast";
+  TokenScenario2["RUG_PULL_SLOW"] = "rug_slow";
+  TokenScenario2["SCAM_TOKEN"] = "scam";
+  TokenScenario2["RUNNER_MOON"] = "runner_moon";
+  TokenScenario2["RUNNER_STEADY"] = "runner_steady";
+  TokenScenario2["SUCCESSFUL"] = "successful";
+  TokenScenario2["MEDIOCRE"] = "mediocre";
+  TokenScenario2["STAGNANT"] = "stagnant";
+  TokenScenario2["BLUE_CHIP"] = "bluechip";
+  TokenScenario2["PUMP_AND_DUMP"] = "pump_dump";
+  TokenScenario2["SLOW_BLEED"] = "slow_bleed";
+  return TokenScenario2;
+})(TokenScenario || {});
+class SimulationRunner {
+  tokenService;
+  constructor() {
+    this.tokenService = new TokenSimulationService();
+  }
+  async runSimulation(config) {
+    console.log("\u{1F680} Starting comprehensive market simulation...");
+    const calls = [];
+    const tokens = /* @__PURE__ */ new Map();
+    const priceHistory = /* @__PURE__ */ new Map();
+    const actorPerformance = /* @__PURE__ */ new Map();
+    for (const actor of config.actors) {
+      const _simulatedActor = {
+        id: actor.id,
+        username: actor.username,
+        archetype: actor.archetype,
+        trustScore: actor.expectedTrustScore,
+        callHistory: [],
+        preferences: {
+          favoriteTokenTypes: this.mapScenarioToTypes(actor.tokenPreferences),
+          callFrequency: actor.callFrequency,
+          timingBias: actor.timingBias
+        }
+      };
+      actorPerformance.set(actor.id, {
+        totalCalls: 0,
+        profitableCalls: 0,
+        totalProfit: 0,
+        averageProfit: 0
+      });
+    }
+    const generatedTokens = this.generateTokens(config);
+    for (const token of generatedTokens) {
+      tokens.set(token.address, token);
+      priceHistory.set(token.address, []);
+    }
+    let currentTime = new Date(config.startTime);
+    const endTime = new Date(config.endTime);
+    let stepCount = 0;
+    while (currentTime <= endTime) {
+      stepCount++;
+      for (const [address, token] of tokens) {
+        const timeSinceLaunch = (currentTime.getTime() - token.launchTime.getTime()) / (1e3 * 60 * 60);
+        if (timeSinceLaunch >= 0) {
+          const price = this.calculateTokenPrice(token, timeSinceLaunch);
+          priceHistory.get(address)?.push({
+            timestamp: currentTime,
+            price: price.price,
+            volume: price.volume,
+            liquidity: price.liquidity,
+            marketCap: price.marketCap
+          });
+        }
+      }
+      const stepCalls = this.generateCallsForTimeStep(
+        currentTime,
+        tokens,
+        priceHistory,
+        config
+      );
+      calls.push(...stepCalls);
+      currentTime = new Date(
+        currentTime.getTime() + config.timeStepMinutes * 60 * 1e3
+      );
+    }
+    console.log(
+      `\u2705 Simulation complete: ${stepCount} time steps, ${calls.length} calls generated`
+    );
+    await this.calculateActualProfits(calls, tokens, priceHistory);
+    for (const call of calls) {
+      const perf = actorPerformance.get(call.userId);
+      if (!perf) continue;
+      perf.totalCalls++;
+      if (call.simulationMetadata.actualProfit && call.simulationMetadata.actualProfit > 0) {
+        perf.profitableCalls++;
+      }
+      perf.totalProfit += call.simulationMetadata.actualProfit || 0;
+    }
+    for (const [_actorId, perf] of actorPerformance) {
+      perf.averageProfit = perf.totalCalls > 0 ? perf.totalProfit / perf.totalCalls : 0;
+    }
+    const result = {
+      calls,
+      tokens,
+      priceHistory,
+      actorPerformance
+    };
+    if (config.cacheResults) {
+      await this.cacheResults(result, config);
+    }
+    return result;
+  }
+  calculateTokenPrice(token, hoursSinceLaunch) {
+    let price = token.initialPrice;
+    if (token.priceTrajectory) {
+      const step = Math.floor(hoursSinceLaunch / 24);
+      price = token.priceTrajectory(step);
+    }
+    const priceRatio = price / token.initialPrice;
+    const marketCap = token.initialMarketCap * priceRatio;
+    const liquidity = token.initialLiquidity * Math.sqrt(priceRatio);
+    const volume = marketCap * 0.1 * (1 + Math.random() * 0.5);
+    return {
+      timestamp: /* @__PURE__ */ new Date(),
+      price,
+      volume,
+      liquidity,
+      marketCap
+    };
+  }
+  mapScenarioToTypes(scenarios) {
+    const mapping = {
+      ["rug_fast" /* RUG_PULL_FAST */]: "rug",
+      ["rug_slow" /* RUG_PULL_SLOW */]: "rug",
+      ["scam" /* SCAM_TOKEN */]: "scam",
+      ["runner_moon" /* RUNNER_MOON */]: "runner",
+      ["runner_steady" /* RUNNER_STEADY */]: "runner",
+      ["successful" /* SUCCESSFUL */]: "successful",
+      ["mediocre" /* MEDIOCRE */]: "mediocre",
+      ["stagnant" /* STAGNANT */]: "stagnant",
+      ["bluechip" /* BLUE_CHIP */]: "bluechip",
+      ["pump_dump" /* PUMP_AND_DUMP */]: "pump_dump",
+      ["slow_bleed" /* SLOW_BLEED */]: "slow_bleed"
+    };
+    return scenarios.map((s) => mapping[s]);
+  }
+  generateTokens(config) {
+    const tokens = [];
+    const distribution = config.tokenScenarioDistribution || {
+      ["rug_fast" /* RUG_PULL_FAST */]: 0.15,
+      ["rug_slow" /* RUG_PULL_SLOW */]: 0.1,
+      ["scam" /* SCAM_TOKEN */]: 0.1,
+      ["pump_dump" /* PUMP_AND_DUMP */]: 0.15,
+      ["mediocre" /* MEDIOCRE */]: 0.2,
+      ["successful" /* SUCCESSFUL */]: 0.15,
+      ["runner_moon" /* RUNNER_MOON */]: 0.05,
+      ["bluechip" /* BLUE_CHIP */]: 0.05,
+      ["slow_bleed" /* SLOW_BLEED */]: 0.05
+    };
+    for (let i = 0; i < config.tokenCount; i++) {
+      const scenario = this.selectScenarioByWeight(distribution);
+      const token = this.createToken(scenario, i, config);
+      tokens.push(token);
+    }
+    console.log(
+      `\u{1F4CA} Generated ${tokens.length} tokens with scenarios:`,
+      tokens.reduce(
+        (acc, t) => {
+          acc[t.scenario] = (acc[t.scenario] || 0) + 1;
+          return acc;
+        },
+        {}
+      )
+    );
+    return tokens;
+  }
+  selectScenarioByWeight(distribution) {
+    const entries = Object.entries(distribution);
+    const totalWeight = entries.reduce((sum, [_, weight]) => sum + weight, 0);
+    let random = Math.random() * totalWeight;
+    for (const [scenario, weight] of entries) {
+      random -= weight;
+      if (random <= 0) {
+        return scenario;
+      }
+    }
+    return "mediocre" /* MEDIOCRE */;
+  }
+  createToken(scenario, index, config) {
+    const launchSpread = config.endTime.getTime() - config.startTime.getTime();
+    const launchOffset = Math.random() * launchSpread * 0.8;
+    const scenarioConfig = this.getScenarioConfig(scenario);
+    const tokenFromService = this.tokenService.createTokenFromScenario(scenarioConfig);
+    return {
+      address: `0x${uuidv4().replace(/-/g, "")}${index.toString().padStart(8, "0")}`,
+      symbol: `SIM${scenario.substring(0, 3).toUpperCase()}${index}`,
+      name: `Simulated ${scenario.replace(/_/g, " ")} Token ${index}`,
+      scenario,
+      launchTime: new Date(config.startTime.getTime() + launchOffset),
+      initialPrice: 1e-5 + Math.random() * 1e-4,
+      // $0.00001 - $0.0001
+      initialMarketCap: 1e4 + Math.random() * 9e4,
+      // $10k - $100k
+      initialLiquidity: 5e3 + Math.random() * 45e3,
+      // $5k - $50k
+      priceTrajectory: tokenFromService.priceTrajectory
+    };
+  }
+  getScenarioConfig(scenario) {
+    const configs = {
+      ["rug_fast" /* RUG_PULL_FAST */]: {
+        type: "rug",
+        name: "FastRug Token",
+        symbol: "FRUG",
+        description: "Rugs within 2 days",
+        initialPrice: 1e-5,
+        initialLiquidity: 5e3,
+        initialMarketCap: 1e4,
+        rugTiming: 2
+      },
+      ["rug_slow" /* RUG_PULL_SLOW */]: {
+        type: "rug",
+        name: "SlowRug Token",
+        symbol: "SRUG",
+        description: "Builds trust then rugs",
+        initialPrice: 5e-5,
+        initialLiquidity: 2e4,
+        initialMarketCap: 5e4,
+        rugTiming: 10
+      },
+      ["scam" /* SCAM_TOKEN */]: {
+        type: "scam",
+        name: "Scam Token",
+        symbol: "SCAM",
+        description: "Low liquidity scam",
+        initialPrice: 1e-3,
+        initialLiquidity: 500,
+        initialMarketCap: 5e3
+      },
+      ["runner_moon" /* RUNNER_MOON */]: {
+        type: "runner",
+        name: "MoonShot Token",
+        symbol: "MOON",
+        description: "50x growth potential",
+        initialPrice: 1e-5,
+        initialLiquidity: 5e4,
+        initialMarketCap: 1e5
+      },
+      ["runner_steady" /* RUNNER_STEADY */]: {
+        type: "runner",
+        name: "SteadyGains Token",
+        symbol: "GAIN",
+        description: "10x steady growth",
+        initialPrice: 1e-4,
+        initialLiquidity: 3e4,
+        initialMarketCap: 2e5
+      },
+      ["successful" /* SUCCESSFUL */]: {
+        type: "successful",
+        name: "Solid Project",
+        symbol: "SOLID",
+        description: "3x growth",
+        initialPrice: 1e-3,
+        initialLiquidity: 1e5,
+        initialMarketCap: 5e5
+      },
+      ["mediocre" /* MEDIOCRE */]: {
+        type: "mediocre",
+        name: "Crabwalk Token",
+        symbol: "CRAB",
+        description: "Sideways movement",
+        initialPrice: 0.01,
+        initialLiquidity: 5e4,
+        initialMarketCap: 3e5
+      },
+      ["stagnant" /* STAGNANT */]: {
+        type: "stagnant",
+        name: "Dead Project",
+        symbol: "DEAD",
+        description: "No volume",
+        initialPrice: 5e-3,
+        initialLiquidity: 1e4,
+        initialMarketCap: 5e4
+      },
+      ["bluechip" /* BLUE_CHIP */]: {
+        type: "bluechip",
+        name: "Established Token",
+        symbol: "BLUE",
+        description: "Stable growth",
+        initialPrice: 10,
+        initialLiquidity: 5e6,
+        initialMarketCap: 1e8
+      },
+      ["pump_dump" /* PUMP_AND_DUMP */]: {
+        type: "pump_dump",
+        name: "PumpDump Token",
+        symbol: "PUMP",
+        description: "20x then dump",
+        initialPrice: 1e-5,
+        initialLiquidity: 15e3,
+        initialMarketCap: 2e4,
+        pumpTiming: 3,
+        dumpTiming: 5
+      },
+      ["slow_bleed" /* SLOW_BLEED */]: {
+        type: "slow_bleed",
+        name: "BleedOut Token",
+        symbol: "BLEED",
+        description: "Slow decline",
+        initialPrice: 0.01,
+        initialLiquidity: 4e4,
+        initialMarketCap: 2e5
+      }
+    };
+    return configs[scenario];
+  }
+  generateCallsForTimeStep(currentTime, tokens, priceHistory, config) {
+    const calls = [];
+    const activeTokens = Array.from(tokens.values()).filter((token) => {
+      const isLaunched = token.launchTime <= currentTime;
+      const history = priceHistory.get(token.address) || [];
+      const latestPrice = history[history.length - 1];
+      const isDead = latestPrice && latestPrice.price < token.initialPrice * 0.01;
+      return isLaunched && !isDead;
+    });
+    if (activeTokens.length === 0) return calls;
+    for (const actor of config.actors) {
+      const shouldCall = this.shouldActorCall(actor, currentTime);
+      if (!shouldCall) continue;
+      const targetTokens = this.selectTokensForActor(
+        actor,
+        activeTokens,
+        priceHistory,
+        currentTime
+      );
+      for (const token of targetTokens) {
+        const tokenPriceHistory = priceHistory.get(token.address);
+        if (!tokenPriceHistory) continue;
+        const call = this.generateActorCall(
+          actor,
+          token,
+          tokenPriceHistory,
+          currentTime
+        );
+        if (call) {
+          calls.push(call);
+        }
+      }
+    }
+    return calls;
+  }
+  shouldActorCall(actor, _currentTime) {
+    const frequencyMultiplier = {
+      high: 0.7,
+      // Increased from 0.3
+      medium: 0.4,
+      // Increased from 0.1
+      low: 0.15
+      // Increased from 0.03
+    }[actor.callFrequency];
+    return Math.random() < frequencyMultiplier;
+  }
+  selectTokensForActor(actor, activeTokens, priceHistory, currentTime) {
+    let candidateTokens = activeTokens;
+    if (["elite_analyst", "skilled_trader"].includes(actor.archetype)) {
+      candidateTokens = activeTokens.filter((token) => {
+        const _history = priceHistory.get(token.address) || [];
+        const timeSinceLaunch = (currentTime.getTime() - token.launchTime.getTime()) / (1e3 * 60 * 60);
+        if (actor.archetype === "elite_analyst") {
+          if ([
+            "rug_fast" /* RUG_PULL_FAST */,
+            "rug_slow" /* RUG_PULL_SLOW */,
+            "scam" /* SCAM_TOKEN */
+          ].includes(token.scenario)) {
+            return false;
+          }
+          return timeSinceLaunch < 48 && // Within 2 days of launch
+          [
+            "successful" /* SUCCESSFUL */,
+            "runner_moon" /* RUNNER_MOON */,
+            "runner_steady" /* RUNNER_STEADY */,
+            "bluechip" /* BLUE_CHIP */
+          ].includes(token.scenario);
+        } else {
+          return timeSinceLaunch < 72 && // Within 3 days
+          !["scam" /* SCAM_TOKEN */].includes(token.scenario);
+        }
+      });
+    } else if (actor.archetype === "fomo_trader") {
+      candidateTokens = activeTokens.filter((token) => {
+        const history = priceHistory.get(token.address) || [];
+        if (history.length < 10) return false;
+        const recentGain = history[history.length - 1].price / history[history.length - 10].price - 1;
+        return recentGain > 0.5;
+      });
+    } else if (actor.archetype === "pump_chaser") {
+      candidateTokens = activeTokens.filter((token) => {
+        const history = priceHistory.get(token.address) || [];
+        if (history.length < 5) return false;
+        const recentGain = history[history.length - 1].price / history[history.length - 5].price - 1;
+        return recentGain > 0.3;
+      });
+    } else if (actor.archetype === "rug_promoter") {
+      candidateTokens = activeTokens.filter(
+        (token) => actor.tokenPreferences.includes(token.scenario) && token.scenario !== "bluechip" /* BLUE_CHIP */
+        // Even rug promoters avoid obvious blue chips
+      );
+    }
+    if (candidateTokens.length === 0) {
+      candidateTokens = activeTokens.filter(
+        (token) => actor.tokenPreferences.includes(token.scenario)
+      );
+    }
+    if (candidateTokens.length === 0) return [];
+    const timedTokens = candidateTokens.filter((token) => {
+      const _history = priceHistory.get(token.address) || [];
+      const timeSinceLaunch = (currentTime.getTime() - token.launchTime.getTime()) / (1e3 * 60 * 60);
+      switch (actor.timingBias) {
+        case "early":
+          return timeSinceLaunch < 24;
+        // First day only
+        case "middle":
+          return timeSinceLaunch >= 24 && timeSinceLaunch < 120;
+        // Day 1-5
+        case "late":
+          return timeSinceLaunch >= 72;
+        // After 3 days
+        default:
+          return true;
+      }
+    });
+    const finalTokens = timedTokens.length > 0 ? timedTokens : candidateTokens;
+    const maxTokens = actor.archetype === "elite_analyst" ? 1 : 2;
+    const numTokens = Math.min(
+      finalTokens.length,
+      Math.floor(Math.random() * maxTokens) + 1
+    );
+    return finalTokens.sort(() => Math.random() - 0.5).slice(0, numTokens);
+  }
+  generateActorCall(actor, token, priceHistory, currentTime) {
+    const latestPrice = priceHistory[priceHistory.length - 1];
+    if (!latestPrice) return null;
+    const message = this.generateMessage(
+      actor,
+      token.symbol,
+      token.scenario,
+      "positive"
+      // Will be overridden based on actor logic
+    );
+    if (!message) return null;
+    const sentiment = this.determineActorSentiment(actor, token, priceHistory);
+    const conviction = this.determineActorConviction(
+      actor,
+      token,
+      priceHistory
+    );
+    return {
+      callId: uuidv4(),
+      originalMessageId: `sim_msg_${uuidv4()}`,
+      userId: actor.id,
+      username: actor.username,
+      timestamp: currentTime.getTime(),
+      content: message,
+      tokenMentioned: token.symbol,
+      nameMentioned: token.name,
+      caMentioned: token.address,
+      chain: SupportedChain.SOLANA,
+      sentiment,
+      conviction,
+      llmReasoning: `${actor.username} (${actor.archetype}) analyzing ${token.symbol}`,
+      certainty: "high",
+      fileSource: "simulation",
+      simulationMetadata: {
+        tokenScenario: token.scenario,
+        actorArchetype: actor.archetype,
+        priceAtCall: latestPrice.price,
+        marketCapAtCall: latestPrice.marketCap,
+        liquidityAtCall: latestPrice.liquidity,
+        expectedOutcome: this.predictOutcome(actor, token)
+      }
+    };
+  }
+  generateMessage(actor, tokenSymbol, _scenario, _sentiment) {
+    const templates = {
+      elite_analyst: [
+        `$${tokenSymbol} showing strong fundamentals. This is a long-term hold.`,
+        `Been researching $${tokenSymbol} - solid team and execution plan. Accumulating here.`
+      ],
+      skilled_trader: [
+        `$${tokenSymbol} looking strong here. Adding to position.`,
+        `Good entry point for $${tokenSymbol}. Risk/reward favorable.`
+      ],
+      pump_chaser: [
+        `$${tokenSymbol} is pumping hard! Just aped in!`,
+        `Holy shit $${tokenSymbol} is flying! This is going to $1!`
+      ],
+      rug_promoter: [
+        `\u{1F680}\u{1F680} $${tokenSymbol} TO THE MOON! 1000X GEM! GET IN NOW! \u{1F680}\u{1F680}`,
+        `$${tokenSymbol} NEXT 100X!!! DEV DOXXED! LIQUIDITY LOCKED! SAFU! \u{1F48E}\u{1F48E}`
+      ],
+      fomo_trader: [
+        `Everyone buying $${tokenSymbol}! I'm in!`,
+        `$${tokenSymbol} trending everywhere! Don't want to miss this!`
+      ],
+      contrarian: [
+        `$${tokenSymbol} overhyped. Taking opposite position.`,
+        `While everyone's bullish on $${tokenSymbol}, I see weakness.`
+      ],
+      technical_analyst: [
+        `$${tokenSymbol} breaking key resistance. Chart looks bullish.`,
+        `RSI oversold on $${tokenSymbol}. Bounce incoming.`
+      ],
+      newbie: [
+        `Is $${tokenSymbol} a good buy? Thinking about getting some.`,
+        `Just bought my first $${tokenSymbol}! Hope it goes up!`
+      ],
+      bot_spammer: [
+        `\u{1F48E} $${tokenSymbol} \u{1F48E} BUY NOW \u{1F48E}`,
+        `$${tokenSymbol} $${tokenSymbol} $${tokenSymbol} \u{1F680}\u{1F680}\u{1F680}`
+      ]
+    };
+    const archetypeTemplates = templates[actor.archetype];
+    return archetypeTemplates[Math.floor(Math.random() * archetypeTemplates.length)];
+  }
+  determineActorSentiment(actor, token, priceHistory) {
+    if (actor.archetype === "elite_analyst") {
+      if ([
+        "successful" /* SUCCESSFUL */,
+        "runner_moon" /* RUNNER_MOON */,
+        "runner_steady" /* RUNNER_STEADY */,
+        "bluechip" /* BLUE_CHIP */
+      ].includes(token.scenario)) {
+        return "positive";
+      }
+      if ([
+        "rug_fast" /* RUG_PULL_FAST */,
+        "rug_slow" /* RUG_PULL_SLOW */,
+        "scam" /* SCAM_TOKEN */
+      ].includes(token.scenario)) {
+        return "negative";
+      }
+      return "neutral";
+    }
+    if (actor.archetype === "skilled_trader") {
+      if ([
+        "successful" /* SUCCESSFUL */,
+        "runner_moon" /* RUNNER_MOON */,
+        "runner_steady" /* RUNNER_STEADY */
+      ].includes(token.scenario)) {
+        return "positive";
+      }
+      if (["rug_fast" /* RUG_PULL_FAST */, "scam" /* SCAM_TOKEN */].includes(
+        token.scenario
+      )) {
+        return Math.random() < 0.7 ? "negative" : "positive";
+      }
+      if (token.scenario === "pump_dump" /* PUMP_AND_DUMP */) {
+        const timeSinceLaunch = priceHistory.length;
+        return timeSinceLaunch < 5 ? "positive" : "negative";
+      }
+      return "neutral";
+    }
+    if (actor.archetype === "rug_promoter") {
+      if ([
+        "rug_fast" /* RUG_PULL_FAST */,
+        "rug_slow" /* RUG_PULL_SLOW */,
+        "scam" /* SCAM_TOKEN */
+      ].includes(token.scenario)) {
+        return "positive";
+      }
+      return "neutral";
+    }
+    if (actor.archetype === "fomo_trader") {
+      return "positive";
+    }
+    if (actor.archetype === "pump_chaser") {
+      const priceChange = priceHistory.length > 5 ? priceHistory[priceHistory.length - 1].price / priceHistory[priceHistory.length - 5].price - 1 : 0;
+      return priceChange > 0.1 ? "positive" : "neutral";
+    }
+    if (actor.archetype === "contrarian") {
+      const priceChange = priceHistory.length > 10 ? priceHistory[priceHistory.length - 1].price / priceHistory[priceHistory.length - 10].price - 1 : 0;
+      return priceChange > 0.2 ? "negative" : "positive";
+    }
+    return actor.tokenPreferences.includes(token.scenario) ? "positive" : "neutral";
+  }
+  determineActorConviction(actor, _token, priceHistory) {
+    const baseConviction = {
+      elite_analyst: Conviction.HIGH,
+      skilled_trader: Conviction.MEDIUM,
+      pump_chaser: Conviction.HIGH,
+      rug_promoter: Conviction.VERY_HIGH,
+      fomo_trader: Conviction.MEDIUM,
+      contrarian: Conviction.MEDIUM,
+      technical_analyst: Conviction.MEDIUM,
+      newbie: Conviction.LOW,
+      bot_spammer: Conviction.LOW
+    }[actor.archetype] || Conviction.MEDIUM;
+    if (["pump_chaser", "fomo_trader"].includes(actor.archetype)) {
+      const recentGain = priceHistory.length > 5 ? priceHistory[priceHistory.length - 1].price / priceHistory[priceHistory.length - 5].price - 1 : 0;
+      if (recentGain > 0.5) {
+        return Conviction.VERY_HIGH;
+      }
+    }
+    return baseConviction;
+  }
+  predictOutcome(actor, token) {
+    const successfulScenarios = [
+      "successful" /* SUCCESSFUL */,
+      "runner_moon" /* RUNNER_MOON */,
+      "bluechip" /* BLUE_CHIP */
+    ];
+    const isGoodToken = successfulScenarios.includes(token.scenario);
+    const isSkilled = [
+      "elite_analyst",
+      "skilled_trader",
+      "contrarian"
+    ].includes(actor.archetype);
+    if (isSkilled && isGoodToken) return "profit";
+    if (!isSkilled && !isGoodToken) return "loss";
+    if (actor.archetype === "rug_promoter" && !isGoodToken) return "loss";
+    return "neutral";
+  }
+  calculateActualProfits(calls, tokens, priceHistory) {
+    for (const call of calls) {
+      const token = tokens.get(call.caMentioned || "");
+      if (!token) continue;
+      const history = priceHistory.get(token.address) || [];
+      const callIndex = history.findIndex(
+        (p) => p.timestamp.getTime() === call.timestamp
+      );
+      if (callIndex === -1 || callIndex === history.length - 1) {
+        call.simulationMetadata.actualProfit = 0;
+        continue;
+      }
+      if (call.sentiment === "negative") {
+        const entryPrice2 = history[callIndex].price;
+        const exitIndex2 = Math.min(callIndex + 24, history.length - 1);
+        const exitPrice2 = history[exitIndex2].price;
+        const priceDropPercent = (entryPrice2 - exitPrice2) / entryPrice2 * 100;
+        call.simulationMetadata.actualProfit = priceDropPercent;
+        continue;
+      }
+      let exitIndex;
+      let forcedExit = false;
+      if ([
+        "rug_fast" /* RUG_PULL_FAST */,
+        "rug_slow" /* RUG_PULL_SLOW */,
+        "scam" /* SCAM_TOKEN */
+      ].includes(token.scenario)) {
+        let rugIndex = callIndex;
+        for (let i = callIndex + 1; i < history.length; i++) {
+          if (history[i].price < history[callIndex].price * 0.1) {
+            rugIndex = i;
+            forcedExit = true;
+            break;
+          }
+        }
+        exitIndex = rugIndex;
+      } else if (token.scenario === "pump_dump" /* PUMP_AND_DUMP */) {
+        let dumpIndex = callIndex;
+        let peakPrice = history[callIndex].price;
+        for (let i = callIndex + 1; i < history.length; i++) {
+          if (history[i].price > peakPrice) {
+            peakPrice = history[i].price;
+          } else if (history[i].price < peakPrice * 0.3) {
+            dumpIndex = i;
+            forcedExit = true;
+            break;
+          }
+        }
+        exitIndex = dumpIndex;
+      } else {
+        if (call.simulationMetadata.actorArchetype === "elite_analyst") {
+          exitIndex = Math.min(callIndex + 72, history.length - 1);
+        } else if (call.simulationMetadata.actorArchetype === "skilled_trader") {
+          exitIndex = Math.min(callIndex + 48, history.length - 1);
+        } else if (["pump_chaser", "fomo_trader"].includes(
+          call.simulationMetadata.actorArchetype
+        )) {
+          exitIndex = Math.min(callIndex + 24, history.length - 1);
+        } else {
+          exitIndex = Math.min(callIndex + 24, history.length - 1);
+        }
+      }
+      const entryPrice = history[callIndex].price;
+      const exitPrice = history[exitIndex].price;
+      let effectiveEntryPrice = entryPrice;
+      if (["fomo_trader", "pump_chaser"].includes(
+        call.simulationMetadata.actorArchetype
+      )) {
+        effectiveEntryPrice = entryPrice * 1.15;
+      } else if (call.simulationMetadata.actorArchetype === "rug_promoter") {
+        if ([
+          "rug_fast" /* RUG_PULL_FAST */,
+          "rug_slow" /* RUG_PULL_SLOW */,
+          "scam" /* SCAM_TOKEN */
+        ].includes(token.scenario)) {
+          effectiveEntryPrice = entryPrice * 1.2;
+        }
+      } else if (call.simulationMetadata.actorArchetype === "elite_analyst") {
+        effectiveEntryPrice = entryPrice * 0.98;
+      }
+      let effectiveExitPrice = exitPrice;
+      if (forcedExit && ["pump_chaser", "fomo_trader", "rug_promoter"].includes(
+        call.simulationMetadata.actorArchetype
+      )) {
+        effectiveExitPrice = exitPrice * 0.9;
+      }
+      const profitPercent = (effectiveExitPrice - effectiveEntryPrice) / effectiveEntryPrice * 100;
+      call.simulationMetadata.actualProfit = profitPercent;
+    }
+    return Promise.resolve();
+  }
+  async cacheResults(result, config) {
+    const outputDir = config.outputDir;
+    await fs.mkdir(outputDir, { recursive: true });
+    const callsPath = path.join(outputDir, "simulated_calls.json");
+    await fs.writeFile(callsPath, JSON.stringify(result.calls, null, 2));
+    const tokensPath = path.join(outputDir, "simulated_tokens.json");
+    await fs.writeFile(
+      tokensPath,
+      JSON.stringify(Array.from(result.tokens.entries()), null, 2)
+    );
+    const pricesPath = path.join(outputDir, "price_history.json");
+    await fs.writeFile(
+      pricesPath,
+      JSON.stringify(Array.from(result.priceHistory.entries()), null, 2)
+    );
+    const perfPath = path.join(outputDir, "actor_performance.json");
+    await fs.writeFile(
+      perfPath,
+      JSON.stringify(Array.from(result.actorPerformance.entries()), null, 2)
+    );
+    console.log(`\u{1F4C1} Results cached to ${outputDir}`);
+  }
+  async loadCachedSimulation(outputDir) {
+    try {
+      const callsData = await fs.readFile(
+        path.join(outputDir, "simulated_calls.json"),
+        "utf-8"
+      );
+      const tokensData = await fs.readFile(
+        path.join(outputDir, "simulated_tokens.json"),
+        "utf-8"
+      );
+      const pricesData = await fs.readFile(
+        path.join(outputDir, "price_history.json"),
+        "utf-8"
+      );
+      const perfData = await fs.readFile(
+        path.join(outputDir, "actor_performance.json"),
+        "utf-8"
+      );
+      return {
+        calls: JSON.parse(callsData),
+        tokens: new Map(JSON.parse(tokensData)),
+        priceHistory: new Map(JSON.parse(pricesData)),
+        actorPerformance: new Map(JSON.parse(perfData))
+      };
+    } catch (error) {
+      console.error("Failed to load cached simulation:", error);
+      return null;
+    }
+  }
+}
+export {
+  SimulationRunner,
+  TokenScenario
+};
+//# sourceMappingURL=simulationRunner.js.map