recommendations, token info, client auto

packages/client-auto/package.json

@@ -7,6 +7,7 @@
     "dependencies": {
         "@ai16z/eliza": "workspace:*",
         "@ai16z/plugin-image-generation": "workspace:*",
+        "@ai16z/plugin-solana": "workspace:*",
         "@types/body-parser": "1.19.5",
         "@types/cors": "2.8.17",
         "@types/express": "5.0.0",

packages/client-auto/src/index.ts

@@ -1,29 +1,65 @@
-import {
-    Client,
-    IAgentRuntime
-} from "@ai16z/eliza/src/types.ts";
-
+import { Client, IAgentRuntime } from "@ai16z/eliza/src/types.ts";
+import { TrustScoreManager } from "@ai16z/plugin-solana/src/providers/trustScoreProvider.ts";
+import { TokenProvider } from "@ai16z/plugin-solana/src/providers/token.ts";
+import { WalletProvider } from "@ai16z/plugin-solana/src/providers/wallet.ts";
+import { TrustScoreDatabase } from "@ai16z/plugin-solana/src/adapters/trustScoreDatabase.ts";
+import { Connection, PublicKey } from "@solana/web3.js";
 
 export class AutoClient {
     interval: NodeJS.Timeout;
     runtime: IAgentRuntime;
+    trustScoreProvider: TrustScoreManager;
+    walletProvider: WalletProvider;
 
     constructor(runtime: IAgentRuntime) {
         this.runtime = runtime;
-        // start a loop that runs every x seconds
-        this.interval = setInterval(() => {
-            this.makeTrades();
-        }, 60 * 60 * 1000); // 1 hour in milliseconds
 
+        const trustScoreDb = new TrustScoreDatabase(runtime.databaseAdapter.db);
+        this.trustScoreProvider = new TrustScoreManager(null, trustScoreDb);
+        this.walletProvider = new WalletProvider(
+            new Connection(runtime.getSetting("RPC_URL")),
+            new PublicKey(runtime.getSetting("WALLET_PUBLIC_KEY"))
+        );
+
+        // start a loop that runs every x seconds
+        this.interval = setInterval(
+            async () => {
+                await this.makeTrades();
+            },
+            60 * 60 * 1000
+        ); // 1 hour in milliseconds
     }
 
-    makeTrades() {
+    async makeTrades() {
         console.log("Running auto loop");
 
         // malibu todos
+        const startDate = new Date(new Date().getTime() - 60 * 60 * 1000);
+        const endDate = new Date();
+        // get recommendations from the last hour (or whatever time period we want) in order desc by trust score
+        const recommendations =
+            await this.trustScoreProvider.getRecommendations(
+                startDate,
+                endDate
+            );
         // get high trust recommendations
+        const highTrustRecommendations = recommendations.filter(
+            (r) => r.averageTrustScore > 0.7
+        );
 
         // get information for all tokens which were recommended
+        const tokenInfos = highTrustRecommendations.map(
+            async (highTrustRecommendation) => {
+                const tokenProvider = new TokenProvider(
+                    highTrustRecommendation.tokenAddress,
+                    this.walletProvider
+                );
+                const tokenInfo = await tokenProvider.getProcessedTokenData();
+                const shouldTrade = await tokenProvider.shouldTradeToken();
+                return { tokenInfo, shouldTrade };
+            }
+        );
+
         // get any additional information we might need
         // make sure we're looking at the right tokens and data
 

packages/plugin-solana/src/evaluators/trust.ts

@@ -233,7 +233,7 @@ async function handler(runtime: IAgentRuntime, message: Memory) {
         }
 
         // TODO: is this is a buy, sell, dont buy, or dont sell?
-        const shouldTrade = await this.tokenProvider.shouldTrade();
+        const shouldTrade = await this.tokenProvider.shouldTradeToken();
 
         if (!shouldTrade) {
             console.warn(

packages/plugin-solana/src/providers/trustScoreProvider.ts

@@ -15,6 +15,7 @@ import {
     RecommenderMetrics,
     TokenPerformance,
     TradePerformance,
+    TokenRecommendation,
 } from "../adapters/trustScoreDatabase.ts";
 import settings from "@ai16z/eliza/src/settings.ts";
 import {
@@ -33,6 +34,26 @@ interface sellDetails {
     sell_amount: number;
     sell_recommender_id: string | null;
 }
+interface RecommendationGroup {
+    recommendation: any;
+    trustScore: number;
+}
+
+interface RecommenderData {
+    recommenderId: string;
+    trustScore: number;
+    riskScore: number;
+    consistencyScore: number;
+    recommenderMetrics: RecommenderMetrics;
+}
+
+interface TokenRecommendationSummary {
+    tokenAddress: string;
+    averageTrustScore: number;
+    averageRiskScore: number;
+    averageConsistencyScore: number;
+    recommenders: RecommenderData[];
+}
 export class TrustScoreManager {
     private tokenProvider: TokenProvider;
     private trustScoreDb: TrustScoreDatabase;
@@ -436,6 +457,96 @@ export class TrustScoreManager {
         );
         return sellDetailsData;
     }
+
+    // get all recommendations
+    async getRecommendations(
+        startDate: Date,
+        endDate: Date
+    ): Promise<Array<TokenRecommendationSummary>> {
+        const recommendations = this.trustScoreDb.getRecommendationsByDateRange(
+            startDate,
+            endDate
+        );
+
+        // Group recommendations by tokenAddress
+        const groupedRecommendations = recommendations.reduce(
+            (acc, recommendation) => {
+                const { tokenAddress } = recommendation;
+                if (!acc[tokenAddress]) acc[tokenAddress] = [];
+                acc[tokenAddress].push(recommendation);
+                return acc;
+            },
+            {} as Record<string, Array<TokenRecommendation>>
+        );
+
+        const result = Object.keys(groupedRecommendations).map(
+            (tokenAddress) => {
+                const tokenRecommendations =
+                    groupedRecommendations[tokenAddress];
+
+                // Initialize variables to compute averages
+                let totalTrustScore = 0;
+                let totalRiskScore = 0;
+                let totalConsistencyScore = 0;
+                const recommenderData = [];
+
+                tokenRecommendations.forEach((recommendation) => {
+                    const tokenPerformance =
+                        this.trustScoreDb.getTokenPerformance(
+                            recommendation.tokenAddress
+                        );
+                    const recommenderMetrics =
+                        this.trustScoreDb.getRecommenderMetrics(
+                            recommendation.recommenderId
+                        );
+
+                    const trustScore = this.calculateTrustScore(
+                        tokenPerformance,
+                        recommenderMetrics
+                    );
+                    const consistencyScore = this.calculateConsistencyScore(
+                        tokenPerformance,
+                        recommenderMetrics
+                    );
+                    const riskScore = this.calculateRiskScore(tokenPerformance);
+
+                    // Accumulate scores for averaging
+                    totalTrustScore += trustScore;
+                    totalRiskScore += riskScore;
+                    totalConsistencyScore += consistencyScore;
+
+                    recommenderData.push({
+                        recommenderId: recommendation.recommenderId,
+                        trustScore,
+                        riskScore,
+                        consistencyScore,
+                        recommenderMetrics,
+                    });
+                });
+
+                // Calculate averages for this token
+                const averageTrustScore =
+                    totalTrustScore / tokenRecommendations.length;
+                const averageRiskScore =
+                    totalRiskScore / tokenRecommendations.length;
+                const averageConsistencyScore =
+                    totalConsistencyScore / tokenRecommendations.length;
+
+                return {
+                    tokenAddress,
+                    averageTrustScore,
+                    averageRiskScore,
+                    averageConsistencyScore,
+                    recommenders: recommenderData,
+                };
+            }
+        );
+
+        // Sort recommendations by the highest average trust score
+        result.sort((a, b) => b.averageTrustScore - a.averageTrustScore);
+
+        return result;
+    }
 }
 
 export const trustScoreProvider: Provider = {