adding get high trust recommendations based on the average trust scor…

…e for recommendation in a period of time

Signed-off-by: MarcoMandar <[email protected]>

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,27 +1,44 @@
-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";
 
 export class AutoClient {
     interval: NodeJS.Timeout;
     runtime: IAgentRuntime;
+    trustScoreProvider: TrustScoreManager;
 
     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);
+        // 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
         // get any additional information we might need

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 = {