Score Calculator Overview

ZKScore = (DeFi × 0.20) + (NFT × 0.15) + (Social × 0.10) + 
          (Trading × 0.20) + (Governance × 0.10) + (Gaming × 0.10) + 
          (Identity × 0.10) + (Trust × 0.05)

function normalizeScore(uint256 rawScore) internal pure returns (uint256) {
    // Apply logarithmic scaling for fair distribution
    if (rawScore == 0) return 0;
    
    uint256 normalized = (Math.log10(rawScore) * 200);
    return Math.min(normalized, 1000);
}

struct CategoryScore {
    uint256 total;              // Total category score (0-1000)
    uint256[] subScores;        // Individual metric scores
    uint256 weight;             // Category weight (basis points)
    uint256 lastUpdated;        // Timestamp of last update
    bool isActive;              // Category active status
}

// Score Calculation
function calculateScore(address user) external returns (uint256);
function getScore(address user) external view returns (uint256);
function getScoreBreakdown(address user) external view returns (CategoryScore[8] memory);

// Category Management
function updateCategoryScore(address user, uint8 category, uint256 score) external;
function getCategoryScore(address user, uint8 category) external view returns (uint256);

// Weight Management
function updateCategoryWeight(uint8 category, uint256 newWeight) external;
function getCategoryWeight(uint8 category) external view returns (uint256);

// Cache Management
function refreshScore(address user) external;
function getLastUpdated(address user) external view returns (uint256);

// Score Events
event ScoreCalculated(address indexed user, uint256 totalScore, uint256 timestamp);
event ScoreUpdated(address indexed user, uint256 oldScore, uint256 newScore);
event CategoryScoreUpdated(address indexed user, uint8 indexed category, uint256 score);

// Configuration Events
event CategoryWeightUpdated(uint8 indexed category, uint256 oldWeight, uint256 newWeight);
event CalculatorConfigured(address indexed admin, uint256 timestamp);

// DeFi Data Sources
- Uniswap V2/V3 liquidity pools
- Aave lending positions
- Compound borrowing history
- Curve pool participation
- Balancer liquidity provision

// NFT Data Sources
- OpenSea trading history
- Blur marketplace activity
- NFT collection ownership
- Rarity.tools scores
- NFT staking protocols

// Governance Data Sources
- Snapshot voting records
- Tally governance participation
- Compound governance
- Aave governance
- ENS DAO participation

// Identity Data Sources
- ENS registrations
- ZKS ID ownership
- Proof of Humanity
- BrightID verification
- Worldcoin verification

function refreshScore(address user) external {
    require(msg.sender == user || hasRole(UPDATER_ROLE, msg.sender), "Unauthorized");
    require(block.timestamp >= lastUpdated[user] + MIN_UPDATE_INTERVAL, "Update too soon");
    
    _calculateAndUpdateScore(user);
}

struct ScoreCache {
    uint256 totalScore;         // Cached total score
    uint256 lastUpdated;        // Last update timestamp
    uint256 updateCount;        // Number of updates
    bool isValid;               // Cache validity flag
}

mapping(address => ScoreCache) private scoreCache;

function batchCalculateScores(address[] calldata users) external returns (uint256[] memory) {
    uint256[] memory scores = new uint256[](users.length);
    
    for (uint256 i = 0; i < users.length; i++) {
        scores[i] = calculateScore(users[i]);
    }
    
    return scores;
}

// Role definitions
bytes32 public constant CALCULATOR_ROLE = keccak256("CALCULATOR_ROLE");
bytes32 public constant UPDATER_ROLE = keccak256("UPDATER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");

// Permission matrix
modifier onlyCalculator() {
    require(hasRole(CALCULATOR_ROLE, msg.sender), "Not authorized calculator");
    _;
}

modifier onlyUpdater() {
    require(hasRole(UPDATER_ROLE, msg.sender), "Not authorized updater");
    _;
}

import { ethers } from 'ethers';

// Contract ABI (simplified)
const SCORE_CALCULATOR_ABI = [
  "function getScore(address user) external view returns (uint256)",
  "function getScoreBreakdown(address user) external view returns (tuple(uint256 total, uint256[] subScores, uint256 weight, uint256 lastUpdated, bool isActive)[8])",
  "function calculateScore(address user) external returns (uint256)",
  "event ScoreCalculated(address indexed user, uint256 totalScore, uint256 timestamp)"
];

// Initialize contract
const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_KEY');
const contract = new ethers.Contract(
  '0x2345678901234567890123456789012345678901',
  SCORE_CALCULATOR_ABI,
  provider
);

// Get user score
async function getUserScore(address) {
  const score = await contract.getScore(address);
  console.log(`User score: ${score.toString()}`);
  return score;
}

// Get score breakdown
async function getScoreBreakdown(address) {
  const breakdown = await contract.getScoreBreakdown(address);
  
  const categories = ['DeFi', 'NFT', 'Social', 'Trading', 'Governance', 'Gaming', 'Identity', 'Trust'];
  
  breakdown.forEach((category, index) => {
    console.log(`${categories[index]}: ${category.total}`);
  });
  
  return breakdown;
}

// Refresh user score
async function refreshUserScore(address) {
  const signer = provider.getSigner();
  const contractWithSigner = contract.connect(signer);
  
  const tx = await contractWithSigner.refreshScore(address);
  const receipt = await tx.wait();
  
  // Get new score from event
  const event = receipt.events.find(e => e.event === 'ScoreCalculated');
  const newScore = event.args.totalScore;
  
  console.log(`Score updated: ${newScore.toString()}`);
  return newScore;
}

function updateCategoryScore(address user, uint8 category, uint256 score) 
    external 
    onlyCalculator 
{
    require(user != address(0), "Invalid user address");
    require(category < 8, "Invalid category");
    require(score <= 1000, "Score out of range");
    
    _updateCategoryScore(user, category, score);
}

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract ScoreCalculator is ReentrancyGuard {
    function calculateScore(address user) 
        external 
        nonReentrant 
        returns (uint256) {
        // Implementation
    }
}