🤝 Trust Engine

Overview

The Trust Engine is a sophisticated system for evaluating, tracking, and managing trust scores for token recommendations and trading activity. It combines on-chain analysis, trader metrics, and historical performance to create a comprehensive trust framework.

Core Components

Trust Score Database

The database schema manages various aspects of trust:

interface TrustScoreDatabase {
  // Core data structures
  recommenders: Recommender[];
  metrics: RecommenderMetrics[];
  tokenPerformance: TokenPerformance[];
  recommendations: TokenRecommendation[];
}

interface Recommender {
  id: string;
  address: string;
  solanaPubkey?: string;
  telegramId?: string;
  discordId?: string;
  twitterId?: string;
  ip?: string;
}

interface RecommenderMetrics {
  recommenderId: string;
  trustScore: number;
  totalRecommendations: number;
  successfulRecs: number;
  avgTokenPerformance: number;
  riskScore: number;
  consistencyScore: number;
  virtualConfidence: number;
  lastActiveDate: Date;
}

Token Analysis

The system tracks comprehensive token metrics:

interface TokenPerformance {
  tokenAddress: string;
  priceChange24h: number;
  volumeChange24h: number;
  trade_24h_change: number;
  liquidity: number;
  liquidityChange24h: number;
  holderChange24h: number;
  rugPull: boolean;
  isScam: boolean;
  marketCapChange24h: number;
  sustainedGrowth: boolean;
  rapidDump: boolean;
  suspiciousVolume: boolean;
  validationTrust: number;
  lastUpdated: Date;
}

Trust Scoring System

Score Calculation

async function calculateTrustScore(
  recommenderId: string,
  metrics: RecommenderMetrics,
): Promise<number> {
  const weights = {
    successRate: 0.3,
    avgPerformance: 0.2,
    consistency: 0.2,
    riskMetric: 0.15,
    timeDecay: 0.15,
  };

  const successRate = metrics.successfulRecs / metrics.totalRecommendations;
  const normalizedPerformance = normalizePerformance(
    metrics.avgTokenPerformance,
  );
  const timeDecayFactor = calculateTimeDecay(metrics.lastActiveDate);

  return (
    (successRate * weights.successRate +
      normalizedPerformance * weights.avgPerformance +
      metrics.consistencyScore * weights.consistency +
      (1 - metrics.riskScore) * weights.riskMetric +
      timeDecayFactor * weights.timeDecay) *
    100
  );
}

Token Validation

async function validateToken(
  tokenAddress: string,
  performance: TokenPerformance,
): Promise<boolean> {
  // Minimum requirements
  const requirements = {
    minLiquidity: 1000, // $1000 USD
    minHolders: 100,
    maxOwnership: 0.2, // 20% max single holder
    minVolume: 500, // $500 USD daily volume
  };

  // Red flags
  if (
    performance.rugPull ||
    performance.isScam ||
    performance.rapidDump ||
    performance.suspiciousVolume
  ) {
    return false;
  }

  // Basic requirements
  return (
    performance.liquidity >= requirements.minLiquidity &&
    !performance.rapidDump &&
    performance.validationTrust > 0.5
  );
}

Trade Management

Trade Performance Tracking

interface TradePerformance {
  token_address: string;
  recommender_id: string;
  buy_price: number;
  sell_price: number;
  buy_timeStamp: string;
  sell_timeStamp: string;
  profit_usd: number;
  profit_percent: number;
  market_cap_change: number;
  liquidity_change: number;
  rapidDump: boolean;
}

async function recordTradePerformance(
  trade: TradePerformance,
  isSimulation: boolean,
): Promise<void> {
  const tableName = isSimulation ? "simulation_trade" : "trade";
  await db.query(
    `
        INSERT INTO ${tableName} (
            token_address,
            recommender_id,
            buy_price,
            sell_price,
            buy_timeStamp,
            sell_timeStamp,
            profit_usd,
            profit_percent,
            market_cap_change,
            liquidity_change,
            rapidDump
        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
    `,
    [
      /* parameters */
    ],
  );
}

Risk Management

async function assessTradeRisk(
  token: TokenPerformance,
  recommender: RecommenderMetrics,
): Promise<{
  riskLevel: "LOW" | "MEDIUM" | "HIGH";
  maxPositionSize: number;
}> {
  const riskFactors = {
    tokenTrust: token.validationTrust,
    recommenderTrust: recommender.trustScore,
    marketMetrics: {
      liquidity: token.liquidity,
      volume: token.volumeChange24h,
      holders: token.holderChange24h,
    },
  };

  // Calculate composite risk score
  const riskScore = calculateRiskScore(riskFactors);

  // Determine position sizing
  const maxPosition = determinePositionSize(riskScore);

  return {
    riskLevel: getRiskLevel(riskScore),
    maxPositionSize: maxPosition,
  };
}

Recommendation Analysis

Pattern Detection

async function analyzeRecommendationPatterns(
  recommenderId: string,
): Promise<RecommendationPattern> {
  const history = await getRecommenderHistory(recommenderId);

  return {
    timeOfDay: analyzeTimingPatterns(history),
    tokenTypes: analyzeTokenPreferences(history),
    successRateByType: calculateTypeSuccessRates(history),
    riskProfile: assessRiskProfile(history),
  };
}

Performance Metrics

interface PerformanceMetrics {
  profitability: number;
  consistency: number;
  riskAdjustedReturn: number;
  maxDrawdown: number;
  winRate: number;
}

async function calculatePerformanceMetrics(
  recommendations: TokenRecommendation[],
): Promise<PerformanceMetrics> {
  const trades = await getTradesFromRecommendations(recommendations);

  return {
    profitability: calculateProfitability(trades),
    consistency: calculateConsistency(trades),
    riskAdjustedReturn: calculateSharpeRatio(trades),
    maxDrawdown: calculateMaxDrawdown(trades),
    winRate: calculateWinRate(trades),
  };
}

Integration with Trading System

Trade Execution

async function executeTrade(
  recommendation: TokenRecommendation,
  trustScore: number,
): Promise<boolean> {
  const riskAssessment = await assessTradeRisk(
    recommendation.tokenAddress,
    recommendation.recommenderId,
  );

  // Calculate position size based on trust score
  const positionSize = calculatePositionSize(
    trustScore,
    riskAssessment.maxPositionSize,
  );

  if (positionSize > 0) {
    await executeSwap({
      inputToken: "SOL",
      outputToken: recommendation.tokenAddress,
      amount: positionSize,
    });

    await recordTradeEntry(recommendation, positionSize);
    return true;
  }

  return false;
}

Position Management

async function managePosition(
  position: TradePosition,
  metrics: TokenPerformance,
): Promise<void> {
  // Exit conditions
  if (
    metrics.rapidDump ||
    metrics.suspiciousVolume ||
    calculateDrawdown(position) > MAX_DRAWDOWN
  ) {
    await executeExit(position);
    return;
  }

  // Position sizing adjustments
  const newSize = recalculatePosition(position, metrics);
  if (newSize !== position.size) {
    await adjustPosition(position, newSize);
  }
}

Monitoring and Alerts

Performance Monitoring

async function monitorTrustMetrics(): Promise<void> {
  // Monitor trust score changes
  const scoreChanges = await getTrustScoreChanges();
  for (const change of scoreChanges) {
    if (Math.abs(change.delta) > TRUST_THRESHOLD) {
      await notifyTrustChange(change);
    }
  }

  // Monitor trading performance
  const performanceMetrics = await getPerformanceMetrics();
  for (const metric of performanceMetrics) {
    if (metric.drawdown > MAX_DRAWDOWN) {
      await notifyRiskAlert(metric);
    }
  }
}

Alert System

interface TrustAlert {
  type: "SCORE_CHANGE" | "RISK_LEVEL" | "PERFORMANCE";
  severity: "LOW" | "MEDIUM" | "HIGH";
  message: string;
  data: any;
}

async function handleAlert(alert: TrustAlert): Promise<void> {
  switch (alert.severity) {
    case "HIGH":
      await sendImmediateNotification(alert);
      await pauseTrading(alert.data);
      break;
    case "MEDIUM":
      await sendNotification(alert);
      await adjustRiskLevels(alert.data);
      break;
    case "LOW":
      await logAlert(alert);
      break;
  }
}

Troubleshooting

Common Issues

1. Trust Score Anomalies

async function investigateTrustAnomaly(
  recommenderId: string,
): Promise<AnomalyReport> {
  const history = await getRecommenderHistory(recommenderId);
  const metrics = await getRecommenderMetrics(recommenderId);
  const trades = await getRecommenderTrades(recommenderId);

  return analyzeAnomalies(history, metrics, trades);
}

2. Trade Execution Failures

async function handleTradeFailure(
  error: Error,
  trade: TradeAttempt,
): Promise<void> {
  await logTradeError(error, trade);
  await adjustTrustScore(trade.recommenderId, "FAILURE");
  await notifyTradeFailure(trade);
}