TrustScore = BaseScore + Modifiers

Where:
  BaseScore = Seniority + Repayments + Volume + Social + LevelBonus

Constraints:
  - Minimum: 0
  - Maximum: 100

function calculateSeniority(accountCreatedAt: Date): number {
  const monthsActive = differenceInMonths(new Date(), accountCreatedAt);
  return Math.min(monthsActive, 12); // Cap at 12 points
}

function calculateRepaymentScore(repayments: Repayment[]): number {
  const onTimeCount = repayments.filter(r => r.status === 'ON_TIME').length;
  return Math.min(onTimeCount * 2, 40); // Cap at 40 points
}

function calculateVolumeScore(totalVolume: number): number {
  if (totalVolume <= 0) return 0;

  // Logarithmic scaling with normalization
  const logVolume = Math.log10(totalVolume + 1);
  const normalized = (logVolume / Math.log10(100000)) * 20;

  return Math.min(Math.floor(normalized), 20); // Cap at 20 points
}

function calculateSocialScore(guardians: Guardian[]): number {
  const activeGuardians = guardians.filter(g => g.status === 'ACTIVE');
  return Math.min(activeGuardians.length * 5, 15); // Cap at 15 points
}

function calculateLevelBonus(xp: number): number {
  const level = getLevel(xp);

  const bonusMap = {
    'Bronze': 0,
    'Silver': 3,
    'Gold': 6,
    'Platinum': 10,
    'Diamond': 13
  };

  return bonusMap[level];
}

function applyModifiers(baseScore: number, events: Event[]): number {
  let score = baseScore;

  for (const event of events) {
    switch (event.type) {
      case 'ON_TIME_REPAYMENT':
        score *= 1.01; // +1%
        break;
      case 'LATE_PAYMENT':
        score *= 0.95; // -5%
        break;
      case 'DEFAULT':
        score *= 0.70; // -30%
        break;
    }
  }

  return Math.max(0, Math.min(100, Math.floor(score)));
}

interface TrustScoreInput {
  accountCreatedAt: Date;
  repayments: Repayment[];
  totalVolume: number;
  guardians: Guardian[];
  xp: number;
  events: Event[];
}

function calculateTrustScore(input: TrustScoreInput): number {
  // Calculate base components
  const seniority = calculateSeniority(input.accountCreatedAt);
  const repaymentScore = calculateRepaymentScore(input.repayments);
  const volumeScore = calculateVolumeScore(input.totalVolume);
  const socialScore = calculateSocialScore(input.guardians);
  const levelBonus = calculateLevelBonus(input.xp);

  // Sum base score
  const baseScore = seniority + repaymentScore + volumeScore + socialScore + levelBonus;

  // Apply modifiers
  const finalScore = applyModifiers(baseScore, input.events);

  return finalScore;
}

// TrustScore.sol (simplified)
mapping(address => uint8) public trustScores;

function updateTrustScore(address user, uint8 score) external onlyOracle {
    require(score <= 100, "Score exceeds maximum");
    trustScores[user] = score;
    emit TrustScoreUpdated(user, score);
}