@elizaos/plugin-social-alpha 2.0.0-alpha.8 → 2.0.0-beta.1

package/dist/services/balancedTrustScoreCalculator.d.ts

@@ -1,60 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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 runtime;
-    private runtime;
-    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

@@ -1,22 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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 runtime;
-    private runtime;
-    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

@@ -1,53 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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;
-    private actorsService;
-    private actorsService;
-    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

@@ -1,33 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

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