@elizaos/plugin-social-alpha 2.0.0-alpha.3

package/dist/services/balancedTrustScoreCalculator.d.ts

@@ -0,0 +1,60 @@
+import type { TrustScoreResult } from "./trustScoreOptimizer";
+export interface BalancedTrustScoreParams {
+    profitWeight: number;
+    winRateWeight: number;
+    sharpeWeight: number;
+    alphaWeight: number;
+    consistencyWeight: number;
+    qualityWeight: number;
+    normalVolumeThreshold: number;
+    highVolumeThreshold: number;
+    extremeVolumeThreshold: number;
+    volumeToleranceByArchetype: Record<string, number>;
+}
+export declare class BalancedTrustScoreCalculator {
+    private params;
+    /**
+     * Calculate balanced trust score
+     */
+    calculateBalancedTrustScore(metrics: TrustScoreResult["metrics"], archetype: string, rugPromotions: number, goodCalls: number, totalCalls: number): number;
+    /**
+     * Archetype base scores with good spread
+     */
+    private getArchetypeBase;
+    /**
+     * Profit component with better scaling
+     */
+    private calculateProfitComponent;
+    /**
+     * Win rate component with smooth curve
+     */
+    private calculateWinRateComponent;
+    /**
+     * Sharpe ratio component
+     */
+    private calculateSharpeComponent;
+    /**
+     * Alpha component - fixed to handle negative values better
+     */
+    private calculateAlphaComponent;
+    /**
+     * Quality component based on call quality
+     */
+    private calculateQualityComponent;
+    /**
+     * Volume adjustment - multiplicative factor instead of penalty
+     */
+    private calculateVolumeAdjustment;
+    /**
+     * Archetype performance scaling
+     */
+    private getArchetypeScaling;
+    /**
+     * Set custom parameters
+     */
+    setParameters(params: Partial<BalancedTrustScoreParams>): void;
+    /**
+     * Get current parameters
+     */
+    getParameters(): BalancedTrustScoreParams;
+}

package/dist/services/historicalPriceService.d.ts

@@ -0,0 +1,58 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { SupportedChain } from "../types.ts";
+export interface PricePoint {
+    timestamp: number;
+    price: number;
+    volume?: number;
+    liquidity?: number;
+}
+export interface HistoricalPriceData {
+    address: string;
+    chain: SupportedChain;
+    priceHistory: PricePoint[];
+    firstPrice?: number;
+    lastPrice?: number;
+    minPrice?: number;
+    maxPrice?: number;
+    fetchedAt: number;
+}
+export interface TokenResolution {
+    symbol: string;
+    address: string;
+    name: string;
+    chain: SupportedChain;
+    liquidity?: number;
+    volume24h?: number;
+    marketCap?: number;
+    createdAt?: number;
+}
+export declare class HistoricalPriceService {
+    private birdeyeClient;
+    private dexscreenerClient;
+    constructor(runtime: IAgentRuntime);
+    /**
+     * Fetch historical price data from Birdeye using OHLCV endpoint
+     */
+    fetchBirdeyeHistoricalPrices(address: string, fromTimestamp: number, toTimestamp: number): Promise<HistoricalPriceData | null>;
+    /**
+     * Fetch historical price data from Dexscreener
+     * Note: DexScreener doesn't provide true historical data, only recent price changes
+     */
+    fetchDexscreenerHistoricalPrices(address: string, chain: SupportedChain, _fromTimestamp: number, _toTimestamp: number): Promise<HistoricalPriceData | null>;
+    /**
+     * Get price at specific timestamp using interpolation
+     */
+    getPriceAtTimestamp(historicalData: HistoricalPriceData, timestamp: number): number | null;
+    /**
+     * Get max price in time window
+     */
+    getMaxPriceInWindow(historicalData: HistoricalPriceData, fromTimestamp: number, toTimestamp: number): {
+        price: number;
+        timestamp: number;
+    } | null;
+    /**
+     * Search for best token match by symbol
+     */
+    findBestTokenMatch(symbol: string, chain: SupportedChain): Promise<TokenResolution | null>;
+    private getChainId;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,22 @@
+export { BalancedTrustScoreCalculator } from "./balancedTrustScoreCalculator";
+export { HistoricalPriceService } from "./historicalPriceService";
+export type { EnrichedTradingCall, HistoricalPriceData, PricePoint, TokenResolution, TradingCall, TrustScore, } from "./PriceDataService";
+export { PriceDataService } from "./PriceDataService";
+export { PriceEnrichmentService } from "./priceEnrichmentService";
+export type { ActorArchetypeV2, ActorConfig, SimulatedActorV2, SimulatedCallData, SimulatedCallV2, SimulationConfig, SimulationResult, SimulationToken, TokenPrice, TokenScenario, } from "./SimulationService";
+export { SimulationService } from "./SimulationService";
+export { SimulationActorsServiceV2 } from "./simulationActorsV2";
+export { SimulationRunner } from "./simulationRunner";
+export type { BalancedTrustScoreParams, OptimizationResult, TrustScoreParameters, TrustScoreResult, } from "./TrustScoreService";
+export { TrustScoreService } from "./TrustScoreService";
+export { TokenSimulationService } from "./tokenSimulationService";
+export { TrustScoreOptimizer } from "./trustScoreOptimizer";
+import type { IAgentRuntime } from "@elizaos/core";
+import { PriceDataService } from "./PriceDataService";
+import { SimulationService } from "./SimulationService";
+import { TrustScoreService } from "./TrustScoreService";
+export declare function createServices(runtime?: IAgentRuntime): {
+    simulation: SimulationService;
+    priceData: PriceDataService | null;
+    trustScore: TrustScoreService;
+};

package/dist/services/priceEnrichmentService.d.ts

@@ -0,0 +1,112 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { SupportedChain } from "../types.ts";
+export interface TradingCall {
+    callId: string;
+    originalMessageId: string;
+    userId: string;
+    username: string;
+    timestamp: number;
+    content: string;
+    tokenMentioned?: string;
+    caMentioned?: string;
+    chain: string;
+    sentiment: "positive" | "negative" | "neutral";
+    conviction: "NONE" | "LOW" | "MEDIUM" | "HIGH";
+    llmReasoning: string;
+    certainty: "low" | "medium" | "high";
+    fileSource: string;
+}
+export interface EnrichedTradingCall extends TradingCall {
+    resolvedToken?: {
+        address: string;
+        symbol: string;
+        name: string;
+        chain: SupportedChain;
+    };
+    priceData?: {
+        calledPrice: number;
+        calledPriceTimestamp: number;
+        bestPrice: number;
+        bestPriceTimestamp: number;
+        worstPrice: number;
+        worstPriceTimestamp: number;
+        idealProfitLoss: number;
+        idealProfitLossPercent: number;
+        windowDays: number;
+    };
+    enrichmentStatus: "pending" | "success" | "failed";
+    enrichmentError?: string;
+    enrichedAt?: number;
+}
+export interface TrustScore {
+    userId: string;
+    username: string;
+    totalCalls: number;
+    successfulCalls: number;
+    failedCalls: number;
+    averageProfitLoss: number;
+    averageProfitLossPercent: number;
+    trustScore: number;
+    consistency: number;
+    recencyWeight: number;
+    convictionAccuracy: number;
+    lastUpdated: number;
+}
+export declare class PriceEnrichmentService {
+    private birdeyeClient;
+    private dexscreenerClient;
+    constructor(runtime: IAgentRuntime);
+    /**
+     * Load batch files from the cache directory
+     */
+    loadBatchFiles(batchCacheDir: string): Promise<TradingCall[]>;
+    /**
+     * Resolve contract address or token mention to standardized token info
+     */
+    resolveToken(call: TradingCall): Promise<{
+        address: string;
+        symbol: string;
+        name: string;
+        chain: SupportedChain;
+    } | null>;
+    /**
+     * Get historical price data for a token within a time window
+     */
+    getPriceDataInWindow(tokenAddress: string, chain: SupportedChain, callTimestamp: number, windowDays?: number): Promise<{
+        calledPrice: number;
+        bestPrice: number;
+        bestPriceTimestamp: number;
+        worstPrice: number;
+        worstPriceTimestamp: number;
+    } | null>;
+    /**
+     * Enrich a single trading call with price data
+     */
+    enrichCall(call: TradingCall): Promise<EnrichedTradingCall>;
+    /**
+     * Process all calls in batches and save enriched data
+     */
+    enrichAllCalls(batchCacheDir: string, outputDir: string, batchSize?: number): Promise<void>;
+    /**
+     * Calculate trust scores for all users
+     */
+    calculateTrustScores(enrichedCalls: EnrichedTradingCall[]): Promise<TrustScore[]>;
+    private chainStringToEnum;
+    private getTokenInfo;
+    private searchTokenBySymbol;
+    private getCurrentPrice;
+    private simulatePriceWindow;
+    private calculateConvictionAccuracy;
+    /**
+     * Get static token mappings for well-known tokens
+     */
+    private getStaticTokenMapping;
+    /**
+     * Search for token using Birdeye API
+     */
+    private searchTokenOnBirdeye;
+    /**
+     * Search for token using DexScreener API
+     */
+    private searchTokenOnDexscreener;
+}

package/dist/services/simulationActorsV2.d.ts

@@ -0,0 +1,53 @@
+import type { UUID } from "@elizaos/core";
+import type { SimulatedToken } from "../mockPriceService";
+import { Conviction, type SupportedChain } from "../types";
+import type { TokenScenario } from "./tokenSimulationService";
+export interface SimulatedCallV2 {
+    callId: string;
+    userId: string;
+    username: string;
+    timestamp: number;
+    tokenMentioned: string;
+    tokenAddress: string;
+    sentiment: "positive" | "negative" | "neutral";
+    conviction: Conviction;
+    content: string;
+    chain: SupportedChain;
+    certainty: "high" | "medium" | "low";
+    llmReasoning: string;
+}
+export type ActorArchetypeV2 = "elite_analyst" | "skilled_trader" | "pump_chaser" | "rug_promoter" | "fomo_trader" | "contrarian" | "whale_watcher" | "technical_analyst" | "newbie" | "bot_spammer";
+export interface SimulatedActorV2 {
+    id: UUID;
+    username: string;
+    archetype: ActorArchetypeV2;
+    trustScore?: number;
+    callHistory: SimulatedCallV2[];
+    preferences: {
+        favoriteTokenTypes?: TokenScenario["type"][];
+        callFrequency: "high" | "medium" | "low";
+        timingBias: "early" | "middle" | "late" | "random";
+    };
+}
+export declare class SimulationActorsServiceV2 {
+    private actors;
+    constructor();
+    private initializeActors;
+    private addActor;
+    generateCallsForActor(actor: SimulatedActorV2, token: SimulatedToken, tokenScenario: TokenScenario, currentStep: number, priceHistory: {
+        step: number;
+        price: number;
+    }[]): SimulatedCallV2 | null;
+    private shouldMakeCall;
+    private determineSentiment;
+    private determineConviction;
+    private generateCallContent;
+    private determineCertainty;
+    private generateReasoning;
+    getAllActors(): SimulatedActorV2[];
+    getActorById(id: UUID): SimulatedActorV2 | undefined;
+    getExpectedRankings(): {
+        username: string;
+        expectedTrustScore: number;
+    }[];
+}

package/dist/services/simulationRunner.d.ts

@@ -0,0 +1,112 @@
+import type { UUID } from "@elizaos/core";
+import { Conviction, SupportedChain } from "../types";
+export declare enum TokenScenario {
+    RUG_PULL_FAST = "rug_fast",
+    RUG_PULL_SLOW = "rug_slow",
+    SCAM_TOKEN = "scam",
+    RUNNER_MOON = "runner_moon",
+    RUNNER_STEADY = "runner_steady",
+    SUCCESSFUL = "successful",
+    MEDIOCRE = "mediocre",
+    STAGNANT = "stagnant",
+    BLUE_CHIP = "bluechip",
+    PUMP_AND_DUMP = "pump_dump",
+    SLOW_BLEED = "slow_bleed"
+}
+export interface TokenPrice {
+    timestamp: Date;
+    price: number;
+    volume: number;
+    liquidity: number;
+    marketCap: number;
+}
+export interface ActorConfig {
+    id: UUID;
+    username: string;
+    archetype: "elite_analyst" | "skilled_trader" | "pump_chaser" | "rug_promoter" | "fomo_trader" | "contrarian" | "technical_analyst" | "newbie" | "bot_spammer";
+    expectedTrustScore: number;
+    tokenPreferences: TokenScenario[];
+    callFrequency: "high" | "medium" | "low";
+    timingBias: "early" | "middle" | "late" | "random";
+}
+export interface SimulatedCallData {
+    callId: UUID;
+    originalMessageId: string;
+    userId: string;
+    username: string;
+    timestamp: number;
+    content: string;
+    nameMentioned?: string;
+    tokenMentioned?: string;
+    caMentioned?: string;
+    chain: SupportedChain | "unknown";
+    sentiment: "positive" | "negative" | "neutral";
+    conviction: Conviction;
+    llmReasoning: string;
+    certainty: "high" | "medium" | "low";
+    fileSource: string;
+    simulationMetadata: {
+        tokenScenario: TokenScenario;
+        actorArchetype: string;
+        priceAtCall: number;
+        marketCapAtCall: number;
+        liquidityAtCall: number;
+        expectedOutcome: "profit" | "loss" | "neutral";
+        actualProfit?: number;
+    };
+}
+export interface SimulationToken {
+    address: string;
+    symbol: string;
+    name: string;
+    scenario: TokenScenario;
+    launchTime: Date;
+    initialPrice: number;
+    initialMarketCap: number;
+    initialLiquidity: number;
+    priceTrajectory?: (step: number) => number;
+}
+export interface SimulationConfig {
+    startTime: Date;
+    endTime: Date;
+    timeStepMinutes: number;
+    tokenCount: number;
+    tokenScenarioDistribution?: Partial<Record<TokenScenario, number>>;
+    actors: ActorConfig[];
+    outputDir: string;
+    cacheResults: boolean;
+}
+export interface SimulationResult {
+    calls: SimulatedCallData[];
+    tokens: Map<string, SimulationToken>;
+    priceHistory: Map<string, TokenPrice[]>;
+    actorPerformance: Map<string, {
+        totalCalls: number;
+        profitableCalls: number;
+        totalProfit: number;
+        averageProfit: number;
+        trustScore?: number;
+    }>;
+}
+export declare class SimulationRunner {
+    private tokenService;
+    constructor();
+    runSimulation(config: SimulationConfig): Promise<SimulationResult>;
+    private calculateTokenPrice;
+    private mapScenarioToTypes;
+    private generateTokens;
+    private selectScenarioByWeight;
+    private createToken;
+    private getScenarioConfig;
+    private generateCallsForTimeStep;
+    private shouldActorCall;
+    private selectTokensForActor;
+    private generateActorCall;
+    private generateMessage;
+    private determineActorSentiment;
+    private determineActorConviction;
+    private predictOutcome;
+    private calculateActualProfits;
+    private cacheResults;
+    loadCachedSimulation(outputDir: string): Promise<SimulationResult | null>;
+}

package/dist/services/tokenSimulationService.d.ts

@@ -0,0 +1,33 @@
+import { type SimulatedToken } from "../mockPriceService";
+export interface TokenScenario {
+    type: "rug" | "scam" | "runner" | "successful" | "mediocre" | "stagnant" | "bluechip" | "pump_dump" | "slow_bleed";
+    name: string;
+    symbol: string;
+    description: string;
+    initialPrice: number;
+    initialLiquidity: number;
+    initialMarketCap: number;
+    rugTiming?: number;
+    pumpTiming?: number;
+    dumpTiming?: number;
+}
+export declare class TokenSimulationService {
+    private scenarios;
+    constructor();
+    private initializeScenarios;
+    private addScenario;
+    createTokenFromScenario(scenario: TokenScenario): SimulatedToken;
+    private mapScenarioToPerformanceType;
+    private createRugTrajectory;
+    private createScamTrajectory;
+    private createRunnerTrajectory;
+    private createSuccessfulTrajectory;
+    private createMediocreTrajectory;
+    private createStagnantTrajectory;
+    private createBluechipTrajectory;
+    private createPumpDumpTrajectory;
+    private createSlowBleedTrajectory;
+    getAllScenarios(): TokenScenario[];
+    getScenarioBySymbol(symbol: string): TokenScenario | undefined;
+    generateDiverseTokenSet(): SimulatedToken[];
+}

package/dist/services/trustScoreOptimizer.d.ts

@@ -0,0 +1,109 @@
+import { type SimulationConfig, type SimulationResult } from "./simulationRunner";
+export interface TrustScoreResult {
+    userId: string;
+    username: string;
+    calculatedScore: number;
+    expectedScore: number;
+    difference: number;
+    metrics: {
+        totalCalls: number;
+        profitableCalls: number;
+        averageProfit: number;
+        winRate: number;
+        sharpeRatio: number;
+        alpha: number;
+        volumePenalty: number;
+        consistency: number;
+    };
+}
+export interface OptimizationResult {
+    scores: TrustScoreResult[];
+    accuracy: {
+        mae: number;
+        rmse: number;
+        correlation: number;
+        rankingAccuracy: number;
+    };
+    suggestions: string[];
+}
+export interface TrustScoreParameters {
+    profitWeight: number;
+    consistencyWeight: number;
+    volumeWeight: number;
+    alphaWeight: number;
+    sharpeWeight: number;
+    minCallsThreshold: number;
+    volumePenaltyThreshold: number;
+    timeDecayFactor: number;
+    rugPullPenalty: number;
+}
+export declare class TrustScoreOptimizer {
+    private simulationRunner;
+    private currentParams;
+    private balancedCalculator;
+    constructor();
+    /**
+     * Run a full optimization cycle
+     */
+    runOptimizationCycle(simulationConfig?: SimulationConfig, useCache?: boolean): Promise<OptimizationResult>;
+    /**
+     * Get simulation data, either from cache or by running new simulation
+     */
+    private getSimulationData;
+    /**
+     * Create default set of actors for testing
+     */
+    private createDefaultActors;
+    /**
+     * Calculate detailed metrics for an actor
+     */
+    private calculateMetrics;
+    /**
+     * Calculate Sharpe ratio
+     */
+    private calculateSharpeRatio;
+    /**
+     * Calculate market return (average of all token performances)
+     */
+    private calculateMarketReturn;
+    /**
+     * Calculate consistency score
+     */
+    private calculateConsistency;
+    /**
+     * Final optimized trust score calculation
+     */
+    calculateFinalTrustScore(metrics: TrustScoreResult["metrics"], archetype?: string, rugPromotionPenalty?: number, goodCallBonus?: number): number;
+    /**
+     * Enhanced trust score calculation with token quality consideration
+     */
+    calculateTrustScoresEnhanced(simulationData: SimulationResult): Promise<TrustScoreResult[]>;
+    /**
+     * Evaluate accuracy of calculated scores vs expected
+     */
+    private evaluateAccuracy;
+    /**
+     * Calculate Pearson correlation coefficient
+     */
+    private calculateCorrelation;
+    /**
+     * Calculate ranking accuracy (% of correctly ordered pairs)
+     */
+    private calculateRankingAccuracy;
+    /**
+     * Generate optimization suggestions based on results
+     */
+    private generateSuggestions;
+    /**
+     * Log detailed results
+     */
+    private logResults;
+    /**
+     * Grid search for optimal parameters
+     */
+    optimizeParameters(parameterRanges: Partial<Record<keyof TrustScoreParameters, number[]>>, simulationConfig?: SimulationConfig): Promise<TrustScoreParameters>;
+    /**
+     * Generate all combinations of parameters for grid search
+     */
+    private generateParameterCombinations;
+}

package/dist/simulationActors.d.ts

@@ -0,0 +1,23 @@
+export type { SimulatedActorV2 as SimulatedActor, SimulatedCallV2 as SimulatedCall, } from "./services/simulationActorsV2";
+export * from "./services/simulationActorsV2";
+import type { SimulatedActorV2 } from "./services/simulationActorsV2";
+export type CallGenerationStrategy = (actor: any, token: any, currentStep: number, priceHistory: any[]) => any;
+export interface SimulatedActorWithLegacy extends SimulatedActorV2 {
+    expectedTrustScore?: number;
+    callGenerationStrategy?: CallGenerationStrategy;
+    actorSpecificData?: {
+        calls?: any[];
+    };
+}
+export declare const goodActorStrategy: CallGenerationStrategy;
+export declare const badActorStrategy: CallGenerationStrategy;
+export declare const neutralObserverStrategy: CallGenerationStrategy;
+export declare const dataDrivenShillStrategy: CallGenerationStrategy;
+export declare function parseDiscordDataToActors(_filePath: string, _runtime: any): Promise<SimulatedActorWithLegacy[]>;
+export declare function createLegacyActor(params: {
+    id: string;
+    username: string;
+    archetype: string;
+    expectedTrustScore?: number;
+    callGenerationStrategy?: CallGenerationStrategy;
+}): SimulatedActorWithLegacy;

package/dist/tests/index.d.ts

@@ -0,0 +1,3 @@
+import type { TestSuite } from "@elizaos/core";
+export declare const testSuites: TestSuite[];
+export default testSuites;