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

package/dist/providers/socialAlphaProvider.d.ts

@@ -0,0 +1,14 @@
+import type { Provider } from "@elizaos/core";
+/**
+ * socialAlphaProvider — Injects trust-score intelligence into agent context.
+ *
+ * When the agent processes a message, this provider:
+ *   1. Looks up the sender's trust profile (if they have one).
+ *   2. Provides a compact leaderboard summary (top callers + bottom callers).
+ *   3. Surfaces win rate, rank, avg P&L, scam detection stats.
+ *
+ * The agent can use this data to weigh recommendations, respond with trust
+ * context, or decline to act on low-trust callers.
+ */
+export declare const socialAlphaProvider: Provider;
+export default socialAlphaProvider;

package/dist/reports.d.ts

@@ -0,0 +1,56 @@
+import type { Entity } from "@elizaos/core";
+import type { PositionWithBalance, RecommenderMetrics, RecommenderMetricsHistory, TokenPerformance, Transaction } from "./types";
+/**
+ * Formats a full report based on the provided data.
+ *
+ * @param {TokenPerformance[]} tokens - Array of token performance data.
+ * @param {PositionWithBalance[]} positions - Array of positions with balance data.
+ * @param {Transaction[]} transactions - Array of transactions data.
+ * @returns {{
+ *   tokenReports: Object[],
+ *   positionReports: Object[],
+ *   totalCurrentValue: string,
+ *   totalRealizedPnL: string,
+ *   totalUnrealizedPnL: string,
+ *   totalPnL: string,
+ *   positionsWithBalance: Object[],
+ * }} Formatted full report containing token reports, position reports, total values, and positions with balance.
+ */
+export declare function formatFullReport(tokens: TokenPerformance[], positions: PositionWithBalance[], transactions: Transaction[]): {
+    tokenReports: string[];
+    positionReports: string[];
+    totalCurrentValue: string;
+    totalRealizedPnL: string;
+    totalUnrealizedPnL: string;
+    totalPnL: string;
+    positionsWithBalance: {
+        position: PositionWithBalance;
+        token: TokenPerformance;
+        transactions: Transaction[];
+    }[];
+};
+/**
+ * Formats the recommender profile for a given entity based on the provided metrics and history.
+ * @param {Entity} entity - The entity for which the profile is being formatted.
+ * @param {RecommenderMetrics} metrics - The metrics related to the recommendations for the entity.
+ * @param {RecommenderMetricsHistory[]} history - The history of metrics for the entity.
+ * @returns {string} The formatted recommender profile string.
+ */
+export declare function formatRecommenderProfile(entity: Entity, metrics: RecommenderMetrics, history: RecommenderMetricsHistory[]): string;
+/**
+ * Formats a recommender report for an entity with provided metrics and history.
+ * @param {Entity} entity - The entity for which the report is being generated.
+ * @param {RecommenderMetrics} metrics - The metrics for the entity's recommendations.
+ * @param {RecommenderMetricsHistory[]} history - The historical metrics for the entity's recommendations.
+ * @returns {string} The formatted recommender report.
+ */
+export declare function formatRecommenderReport(entity: Entity, metrics: RecommenderMetrics, history: RecommenderMetricsHistory[]): string;
+/**
+ * Formats the top recommenders overview based on the provided data.
+ *
+ * @param {Entity[]} recommenders - The list of recommenders to be formatted
+ * @param {Map<string, RecommenderMetrics>} metrics - The map of recommender metrics
+ * @param {Map<string, RecommenderMetricsHistory[]>} history - The map of historical metrics data
+ * @returns {string} The formatted top recommenders overview in XML format
+ */
+export declare function formatTopRecommendersOverview(recommenders: Entity[], metrics: Map<string, RecommenderMetrics>, history: Map<string, RecommenderMetricsHistory[]>): string;

package/dist/routes.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from "@elizaos/core";
+export declare const communityInvestorRoutes: Route[];

package/dist/schemas.d.ts

@@ -0,0 +1,150 @@
+import { z } from "zod";
+import type { Transaction } from "./types";
+/**
+ * Core schema definitions for community-trader plugin
+ * This approach provides runtime validation and better type safety
+ */
+export declare const TransactionType: {
+    readonly BUY: "BUY";
+    readonly SELL: "SELL";
+    readonly TRANSFER_IN: "transfer_in";
+    readonly TRANSFER_OUT: "transfer_out";
+};
+export declare const tokenPerformanceSchema: z.ZodObject<{
+    chain: z.ZodDefault<z.ZodString>;
+    address: z.ZodString;
+    name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    symbol: z.ZodString;
+    decimals: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    price: z.ZodDefault<z.ZodNumber>;
+    volume: z.ZodDefault<z.ZodNumber>;
+    trades: z.ZodDefault<z.ZodNumber>;
+    liquidity: z.ZodDefault<z.ZodNumber>;
+    holders: z.ZodDefault<z.ZodNumber>;
+    price24hChange: z.ZodDefault<z.ZodNumber>;
+    volume24hChange: z.ZodDefault<z.ZodNumber>;
+    trades24hChange: z.ZodDefault<z.ZodNumber>;
+    holders24hChange: z.ZodDefault<z.ZodNumber>;
+    initialMarketCap: z.ZodDefault<z.ZodNumber>;
+    currentMarketCap: z.ZodDefault<z.ZodNumber>;
+    rugPull: z.ZodDefault<z.ZodBoolean>;
+    isScam: z.ZodDefault<z.ZodBoolean>;
+    sustainedGrowth: z.ZodDefault<z.ZodBoolean>;
+    rapidDump: z.ZodDefault<z.ZodBoolean>;
+    suspiciousVolume: z.ZodDefault<z.ZodBoolean>;
+    validationTrust: z.ZodDefault<z.ZodNumber>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, z.core.$strip>;
+export declare const transactionSchema: z.ZodObject<{
+    id: z.ZodString;
+    positionId: z.ZodString;
+    chain: z.ZodDefault<z.ZodString>;
+    tokenAddress: z.ZodString;
+    transactionHash: z.ZodString;
+    type: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    amount: z.ZodNumber;
+    price: z.ZodOptional<z.ZodNumber>;
+    isSimulation: z.ZodDefault<z.ZodBoolean>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const recommenderMetricsSchema: z.ZodObject<{
+    entityId: z.ZodString;
+    trustScore: z.ZodNumber;
+    totalRecommendations: z.ZodNumber;
+    successfulRecs: z.ZodNumber;
+    avgTokenPerformance: z.ZodNumber;
+    riskScore: z.ZodNumber;
+    consistencyScore: z.ZodNumber;
+    virtualConfidence: z.ZodNumber;
+    lastActiveDate: z.ZodDate;
+    trustDecay: z.ZodNumber;
+    updatedAt: z.ZodDefault<z.ZodOptional<z.ZodDate>>;
+}, z.core.$strip>;
+export declare const positionSchema: z.ZodObject<{
+    id: z.ZodString;
+    chain: z.ZodString;
+    tokenAddress: z.ZodString;
+    walletAddress: z.ZodString;
+    isSimulation: z.ZodBoolean;
+    entityId: z.ZodString;
+    recommendationId: z.ZodString;
+    initialPrice: z.ZodString;
+    initialMarketCap: z.ZodString;
+    initialLiquidity: z.ZodString;
+    performanceScore: z.ZodNumber;
+    rapidDump: z.ZodBoolean;
+    openedAt: z.ZodDate;
+    closedAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodDate;
+    amount: z.ZodString;
+    entryPrice: z.ZodString;
+    currentPrice: z.ZodString;
+}, z.core.$strip>;
+export declare const tokenRecommendationSchema: z.ZodObject<{
+    id: z.ZodString;
+    entityId: z.ZodString;
+    chain: z.ZodString;
+    tokenAddress: z.ZodString;
+    type: z.ZodString;
+    conviction: z.ZodString;
+    initialMarketCap: z.ZodString;
+    initialLiquidity: z.ZodString;
+    initialPrice: z.ZodString;
+    marketCap: z.ZodString;
+    liquidity: z.ZodString;
+    price: z.ZodString;
+    rugPull: z.ZodBoolean;
+    isScam: z.ZodBoolean;
+    riskScore: z.ZodNumber;
+    performanceScore: z.ZodNumber;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    status: z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        COMPLETED: "COMPLETED";
+        EXPIRED: "EXPIRED";
+        WITHDRAWN: "WITHDRAWN";
+    }>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export type TokenPerformance = z.infer<typeof tokenPerformanceSchema>;
+export type RecommenderMetrics = z.infer<typeof recommenderMetricsSchema>;
+export type Position = z.infer<typeof positionSchema>;
+export type TokenRecommendation = z.infer<typeof tokenRecommendationSchema>;
+/**
+ * Transform functions to convert database objects to schema-validated objects
+ */
+export declare function transformTokenPerformance(dbToken: Record<string, unknown>, chain?: string): TokenPerformance;
+export declare function transformTransaction(dbTx: Record<string, unknown>, positionId?: string, chain?: string): Transaction;
+export declare function transformPosition(dbPos: Record<string, unknown>): Position;
+/**
+ * Type definition for MessageRecommendation based on the schema recommendationSchema
+ */
+export type MessageRecommendation = z.infer<typeof recommendationSchema>;
+/**
+ * Schema for extracting trading recommendations from conversational text, capturing the key components of who made the recommendation, what asset was discussed, what action was recommended, and how strongly it was recommended
+ */
+export declare const recommendationSchema: z.ZodObject<{
+    username: z.ZodString;
+    ticker: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    tokenAddress: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    type: z.ZodEnum<{
+        NONE: "NONE";
+        BUY: "BUY";
+        DONT_BUY: "DONT_BUY";
+        SELL: "SELL";
+        DONT_SELL: "DONT_SELL";
+    }>;
+    conviction: z.ZodEnum<{
+        NONE: "NONE";
+        LOW: "LOW";
+        MEDIUM: "MEDIUM";
+        HIGH: "HIGH";
+    }>;
+}, z.core.$strip>;
+export declare function transformTokenRecommendation(dbRec: Record<string, unknown>): TokenRecommendation;

package/dist/scripts/analyze-trust-scores.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Analyze Trust Scores
+ *
+ * This script analyzes trust scores from enriched trading call data:
+ * 1. Load enriched call data
+ * 2. Calculate trust scores using the balanced algorithm
+ * 3. Generate rankings and statistics
+ * 4. Compare different algorithms if requested
+ * 5. Visualize results
+ *
+ * Usage:
+ *   npm run analyze-trust-scores [--input <file>] [--output <dir>] [--compare] [--visualize]
+ */
+export {};

package/dist/scripts/enrich-price-data.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Enrich Price Data
+ *
+ * This script enriches trading calls with historical price data:
+ * 1. Load trading calls from batches
+ * 2. Resolve token addresses
+ * 3. Fetch historical price data
+ * 4. Calculate profit/loss metrics
+ * 5. Save enriched data
+ *
+ * Usage:
+ *   npm run enrich-price-data [--input <dir>] [--output <dir>] [--batch-size <number>] [--resume]
+ */
+export {};

package/dist/scripts/optimize-algorithm.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * Optimize Trust Score Algorithm
+ *
+ * This script optimizes the trust score algorithm parameters:
+ * 1. Run simulations with different actor types
+ * 2. Test various parameter combinations
+ * 3. Find the best parameters that minimize error
+ * 4. Generate optimization report
+ *
+ * Usage:
+ *   npm run optimize-algorithm [--cache] [--quick] [--output <dir>]
+ */
+export {};

package/dist/scripts/process-discord-data.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * Process Discord Data
+ *
+ * This script processes Discord trading call data through the following steps:
+ * 1. Load raw Discord data from JSON files
+ * 2. Parse and validate trading calls
+ * 3. Batch the data for processing
+ * 4. Analyze the processed data
+ *
+ * Usage:
+ *   npm run process-discord-data [--input <dir>] [--output <dir>] [--batch-size <number>]
+ */
+export {};

package/dist/service.d.ts

@@ -0,0 +1,286 @@
+import { type Entity, type IAgentRuntime, type Memory, Service, type UUID } from "@elizaos/core";
+import { type TradingConfig } from "./config";
+import { type BuySignalMessage, Conviction, type ICommunityInvestorService, type LeaderboardEntry, type Position, type PositionWithBalance, type ProcessedTokenData, type Recommendation, type RecommendationMetric, RecommendationType, type RecommenderMetrics, type RecommenderMetricsHistory, ServiceType, SupportedChain, type TokenAPIData, type TokenMarketData, type TokenMetadata, type TokenPerformance, type TokenRecommendation, type Transaction } from "./types";
+/**
+ * Represents different types of trading events that can occur.
+ * @typedef {Object} TradingEvent
+ * @property {string} type - The type of trading event.
+ * @property {Position} [position] - The position associated with the event. (if type is 'position_opened' or 'position_closed')
+ * @property {Transaction} [transaction] - The transaction associated with the event. (if type is 'transaction_added')
+ * @property {TokenRecommendation} [recommendation] - The token recommendation associated with the event. (if type is 'recommendation_added')
+ * @property {TokenPerformance} [performance] - The token performance associated with the event. (if type is 'token_performance_updated')
+ */
+export type TradingEvent = {
+    type: "position_opened";
+    position: Position;
+} | {
+    type: "position_closed";
+    position: Position;
+} | {
+    type: "transaction_added";
+    transaction: Transaction;
+} | {
+    type: "recommendation_added";
+    recommendation: TokenRecommendation;
+} | {
+    type: "token_performance_updated";
+    performance: TokenPerformance;
+};
+/**
+ * Unified Trading Service that centralizes all trading operations
+ */
+/**
+ * CommunityInvestorService class representing a service for trading on the Solana blockchain.
+ * @extends Service
+ * @property {string} serviceType - The type of service, set to ServiceType.COMMUNITY_INVESTOR.
+ * @property {string} capabilityDescription - Description of the agent's ability to trade on the Solana blockchain.
+ * @method storeRecommenderMetrics - Store entity metrics and cache for 5 minutes.
+ * @method storeRecommenderMetricsHistory - Store entity metrics history.
+ */
+export declare class CommunityInvestorService extends Service implements ICommunityInvestorService {
+    protected runtime: IAgentRuntime;
+    static serviceType: ServiceType;
+    capabilityDescription: string;
+    private birdeyeClient;
+    private dexscreenerClient;
+    private heliusClient;
+    tradingConfig: TradingConfig;
+    private apiKeys;
+    private balancedTrustCalculator;
+    private readonly POSITIVE_TRADE_THRESHOLD;
+    private readonly NEUTRAL_MARGIN;
+    private readonly RECENCY_WEIGHT_MONTHS;
+    private readonly USER_TRADE_COOLDOWN_HOURS;
+    private readonly METRIC_REFRESH_INTERVAL;
+    private userRegistry;
+    readonly componentWorldId: UUID;
+    readonly componentRoomId: UUID;
+    constructor(runtime: IAgentRuntime);
+    static start(runtime: IAgentRuntime): Promise<CommunityInvestorService>;
+    static stop(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Process a buy signal from an entity
+     */
+    processBuySignal(buySignal: BuySignalMessage, entity: Entity): Promise<Position | null>;
+    /**
+     * Process a sell signal for an existing position
+     */
+    processSellSignal(positionId: UUID, _sellRecommenderId: UUID): Promise<boolean>;
+    /**
+     * Handle a recommendation from a entity
+     */
+    handleRecommendation(entity: Entity, recommendation: {
+        chain: string;
+        tokenAddress: string;
+        conviction: Conviction;
+        type: RecommendationType;
+        timestamp: Date;
+        metadata?: Record<string, any>;
+    }): Promise<Position | null>;
+    /**
+     * Check if a wallet is registered for a chain
+     */
+    hasWallet(chain: string): boolean;
+    /**
+     * Get token overview data
+     */
+    getTokenOverview(chain: string, tokenAddress: string, forceRefresh?: boolean): Promise<TokenMetadata & TokenMarketData>;
+    /**
+     * Resolve a ticker to a token address
+     */
+    resolveTicker(ticker: string, chain?: SupportedChain, contextMessages?: Memory[]): Promise<{
+        address: string;
+        chain: SupportedChain;
+        ticker?: string;
+    } | null>;
+    /**
+     * Get current price for a token
+     */
+    getCurrentPrice(chain: string, tokenAddress: string): Promise<number>;
+    /**
+     * Determine if a token should be traded
+     */
+    shouldTradeToken(chain: string, tokenAddress: string): Promise<boolean>;
+    /**
+     * Get processed token data with security and trade information
+     */
+    getProcessedTokenData(chain: string, tokenAddress: string): Promise<ProcessedTokenData | null>;
+    /**
+     * Analyze holder distribution trend
+     */
+    private analyzeHolderDistribution;
+    /**
+     * Update token performance data
+     */
+    updateTokenPerformance(chain: string, tokenAddress: string): Promise<TokenPerformance>;
+    /**
+     * Calculate risk score for a token
+     */
+    calculateRiskScore(token: TokenPerformance): number;
+    /**
+     * Update entity metrics based on their recommendation performance
+     */
+    updateRecommenderMetrics(entityId: UUID, performance?: number): Promise<void>;
+    /**
+     * Calculate trust score based on metrics and new performance
+     */
+    private calculateTrustScore;
+    /**
+     * Get or fetch token performance data
+     */
+    private getOrFetchTokenPerformance;
+    /**
+     * Validate if a token meets trading criteria
+     */
+    private validateToken;
+    /**
+     * Create a token recommendation
+     */
+    private createTokenRecommendation;
+    /**
+     * Calculate buy amount based on entity trust score and conviction
+     */
+    private calculateBuyAmount;
+    /**
+     * Create a new position
+     */
+    private createPosition;
+    /**
+     * Record a transaction
+     */
+    private recordTransaction;
+    /**
+     * Get all positions for an entity
+     */
+    getPositionsByRecommender(entityId: UUID): Promise<Position[]>;
+    /**
+     * Get all positions for a token
+     */
+    private getPositionsByToken;
+    /**
+     * Get all transactions for a position
+     */
+    getTransactionsByPosition(positionId: UUID): Promise<Transaction[]>;
+    /**
+     * Get all transactions for a token
+     */
+    getTransactionsByToken(tokenAddress: string): Promise<Transaction[]>;
+    /**
+     * Get a position by ID
+     */
+    getPosition(positionId: UUID): Promise<Position | null>;
+    /**
+     * Get all recommendations by a entity
+     */
+    getRecommendationsByRecommender(entityId: UUID): Promise<TokenRecommendation[]>;
+    /**
+     * Close a position and update metrics
+     */
+    closePosition(positionId: UUID): Promise<boolean>;
+    /**
+     * Calculate position performance
+     */
+    private calculatePositionPerformance;
+    /**
+     * Store token performance data
+     */
+    private storeTokenPerformance;
+    /**
+     * Store position data
+     */
+    private storePosition;
+    /**
+     * Store transaction data
+     */
+    private storeTransaction;
+    /**
+     * Store token recommendation data
+     */
+    private storeTokenRecommendation;
+    /**
+     * Store entity metrics
+     */
+    private storeRecommenderMetrics;
+    /**
+     * Store entity metrics history
+     */
+    private storeRecommenderMetricsHistory;
+    /**
+     * Get entity metrics
+     */
+    getRecommenderMetrics(entityId: UUID): Promise<RecommenderMetrics | null>;
+    /**
+     * Get entity metrics history
+     */
+    getRecommenderMetricsHistory(entityId: UUID): Promise<RecommenderMetricsHistory[]>;
+    /**
+     * Initialize entity metrics
+     */
+    initializeRecommenderMetrics(entityId: UUID, platform: string): Promise<void>;
+    /**
+     * Get token performance
+     */
+    getTokenPerformance(tokenAddress: string, chain: string): Promise<TokenPerformance | null>;
+    /**
+     * Get open positions with balance
+     */
+    getOpenPositionsWithBalance(): Promise<PositionWithBalance[]>;
+    /**
+     * Get positions transactions
+     */
+    getPositionsTransactions(positionIds: UUID[]): Promise<Transaction[]>;
+    /**
+     * Get formatted portfolio report
+     */
+    getFormattedPortfolioReport(entityId?: UUID): Promise<string>;
+    initialize(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Fetches token data from an external API.
+     * Uses Birdeye and DexScreener for real market data.
+     */
+    getTokenAPIData(address: string, chain: SupportedChain): Promise<TokenAPIData | null>;
+    isLikelyScamOrRug(tokenData: TokenAPIData, recommendationTimestamp: number): Promise<boolean>;
+    evaluateRecommendationPerformance(recommendation: Recommendation, tokenData: TokenAPIData): Promise<RecommendationMetric>;
+    getRecencyWeight(recommendationTimestamp: number): number;
+    getConvictionWeight(conviction: Recommendation["conviction"]): number;
+    calculateUserTrustScore(userId: UUID, runtime: IAgentRuntime, _worldId?: UUID): Promise<number>;
+    /**
+     * Calculate trust score from user profile recommendations
+     */
+    private calculateNewScoreFromProfile;
+    private executeProcessTradeDecision;
+    private registerTaskWorkers;
+    getLeaderboardData(runtime: IAgentRuntime): Promise<LeaderboardEntry[]>;
+    private registerUser;
+    private loadUserRegistry;
+    private ensurePluginComponentContext;
+    /**
+     * Processes a batch of historical messages, intended to be called from a script.
+     */
+    processHistoricalData(batch: {
+        fileId: string;
+        batchIndex: number;
+        messages: any[];
+        userMap: Record<string, string>;
+    }): Promise<any[]>;
+    /**
+     * Main entry point for processing a single, real-time message from the event handler.
+     */
+    processIncomingMessage(message: {
+        id?: UUID;
+        userId: UUID;
+        roomId: UUID;
+        text: string;
+        timestamp: number;
+        username?: string;
+    }): Promise<void>;
+    /**
+     * Builds the system and user prompts for the recommendation extraction LLM call.
+     */
+    private buildExtractionPrompts;
+    /**
+     * Updates a user's profile with new recommendations extracted from a message batch.
+     */
+    private updateProfileWithRecommendations;
+}

package/dist/services/PriceDataService.d.ts

@@ -0,0 +1,34 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { SupportedChain } from "../types";
+export { HistoricalPriceData, PricePoint, TokenResolution, } from "./historicalPriceService";
+export { EnrichedTradingCall, TradingCall, TrustScore, } from "./priceEnrichmentService";
+/**
+ * Consolidated Price Data Service that combines historical and enrichment functionality
+ */
+export declare class PriceDataService {
+    private historicalService;
+    private enrichmentService;
+    constructor(runtime: IAgentRuntime);
+    fetchBirdeyeHistoricalPrices(address: string, fromTimestamp: number, toTimestamp: number): Promise<any>;
+    fetchDexscreenerHistoricalPrices(address: string, chain: SupportedChain, fromTimestamp: number, toTimestamp: number): Promise<any>;
+    getPriceAtTimestamp(historicalData: any, timestamp: number): number | null;
+    getMaxPriceInWindow(historicalData: any, fromTimestamp: number, toTimestamp: number): any;
+    findBestTokenMatch(symbol: string, chain: SupportedChain): Promise<any>;
+    loadBatchFiles(batchCacheDir: string): Promise<any[]>;
+    resolveToken(call: any): Promise<any>;
+    getPriceDataInWindow(tokenAddress: string, chain: SupportedChain, callTimestamp: number, windowDays?: number): Promise<any>;
+    enrichCall(call: any): Promise<any>;
+    enrichAllCalls(batchCacheDir: string, outputDir: string, batchSize?: number): Promise<void>;
+    calculateTrustScores(enrichedCalls: any[]): Promise<any[]>;
+    /**
+     * Get current price for a token using the best available source
+     */
+    getCurrentPrice(address: string, chain: SupportedChain): Promise<number | null>;
+    /**
+     * Enrich a batch of trading calls with price data and calculate trust scores
+     */
+    processAndScoreTradingCalls(calls: any[], outputDir: string): Promise<{
+        enrichedCalls: any[];
+        trustScores: any[];
+    }>;
+}

package/dist/services/SimulationService.d.ts

@@ -0,0 +1,31 @@
+import type { UUID } from "@elizaos/core";
+export { ActorArchetypeV2, SimulatedActorV2, SimulatedCallV2, } from "./simulationActorsV2";
+export { ActorConfig, SimulatedCallData, SimulationConfig, SimulationResult, SimulationToken, TokenPrice, TokenScenario, } from "./simulationRunner";
+export { TokenScenario as TokenScenarioInterface } from "./tokenSimulationService";
+/**
+ * Consolidated Simulation Service that combines all simulation functionality
+ */
+export declare class SimulationService {
+    private simulationRunner;
+    private actorsService;
+    private tokenService;
+    constructor();
+    runSimulation(config: any): Promise<any>;
+    loadCachedSimulation(outputDir: string): Promise<any>;
+    generateCallsForActor(actor: any, token: any, tokenScenario: any, currentStep: number, priceHistory: any[]): any;
+    getAllActors(): any[];
+    getActorById(id: UUID): any;
+    getExpectedRankings(): any[];
+    createTokenFromScenario(scenario: any): any;
+    getAllScenarios(): any[];
+    getScenarioBySymbol(symbol: string): any;
+    generateDiverseTokenSet(): any[];
+    /**
+     * Create default actors for testing
+     */
+    createDefaultActors(): any[];
+    /**
+     * Run a quick test simulation
+     */
+    runTestSimulation(): Promise<any>;
+}

package/dist/services/TrustScoreService.d.ts

@@ -0,0 +1,35 @@
+import { type TrustScoreResult } from "./trustScoreOptimizer";
+export { BalancedTrustScoreParams } from "./balancedTrustScoreCalculator";
+export { OptimizationResult, TrustScoreParameters, TrustScoreResult, } from "./trustScoreOptimizer";
+/**
+ * Consolidated Trust Score Service
+ */
+export declare class TrustScoreService {
+    private calculator;
+    private optimizer;
+    constructor();
+    calculateBalancedTrustScore(metrics: TrustScoreResult["metrics"], archetype: string, rugPromotions: number, goodCalls: number, totalCalls: number): number;
+    setCalculatorParameters(params: Partial<any>): void;
+    getCalculatorParameters(): any;
+    runOptimizationCycle(simulationConfig?: any, useCache?: boolean): Promise<any>;
+    optimizeParameters(parameterRanges: any, simulationConfig?: any): Promise<any>;
+    /**
+     * Calculate trust score for a user based on their trading history
+     */
+    calculateUserTrustScore(userCalls: any[], archetype?: string): {
+        score: number;
+        metrics: TrustScoreResult["metrics"];
+        breakdown: {
+            profitComponent: number;
+            winRateComponent: number;
+            sharpeComponent: number;
+            alphaComponent: number;
+            consistencyComponent: number;
+            qualityComponent: number;
+        };
+    };
+    /**
+     * Run a complete optimization test
+     */
+    runOptimizationTest(): Promise<void>;
+}