Community Trust Score Contract

What it does:
Calculates and manages trust scores for community members based on their participation, contributions, and verified actions on-chain.

Why it matters:
Encourages positive engagement, provides accountability, supports reputation-weighted governance, and helps DAOs or local communities make informed decisions.

How it works:

  • Members register and are verified on-chain

  • Trust points are awarded for participation, contributions, or verified actions

  • Scores can decay over time or be adjusted for inactivity

  • High trust scores can unlock governance privileges, voting power, or rewards

  • Smart contracts maintain immutable score history and transparency

  • Public dashboards display trust scores and contribution history

  • Integrates with DAO governance, Citizen Feedback, and Civic Participation Reward Contracts

      // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title CommunityTrustScore
 * @author Nam
 * @notice Tracks trust scores for community members on-chain
 */
contract CommunityTrustScore is Ownable {

    struct Member {
        bool registered;
        uint256 trustScore;
        uint256 lastUpdated;
    }

    mapping(address => Member) public members;

    // -------------------- EVENTS --------------------

    event MemberRegistered(address indexed member);
    event TrustScoreUpdated(address indexed member, uint256 newScore);
    event TrustScoreAdjusted(address indexed member, int256 adjustment);

    // -------------------- MEMBER MANAGEMENT --------------------

    function registerMember(address _member) external onlyOwner {
        require(!members[_member].registered, "Already registered");
        members[_member] = Member({
            registered: true,
            trustScore: 0,
            lastUpdated: block.timestamp
        });

        emit MemberRegistered(_member);
    }

    function isMember(address _member) public view returns (bool) {
        return members[_member].registered;
    }

    // -------------------- TRUST SCORE MANAGEMENT --------------------

    function awardTrustPoints(address _member, uint256 _points) external onlyOwner {
        require(isMember(_member), "Not a registered member");
        members[_member].trustScore += _points;
        members[_member].lastUpdated = block.timestamp;

        emit TrustScoreUpdated(_member, members[_member].trustScore);
    }

    function adjustTrustScore(address _member, int256 _adjustment) external onlyOwner {
        require(isMember(_member), "Not a registered member");

        if (_adjustment < 0) {
            uint256 absAdjustment = uint256(-_adjustment);
            if (members[_member].trustScore < absAdjustment) {
                members[_member].trustScore = 0;
            } else {
                members[_member].trustScore -= absAdjustment;
            }
        } else {
            members[_member].trustScore += uint256(_adjustment);
        }

        members[_member].lastUpdated = block.timestamp;
        emit TrustScoreAdjusted(_member, _adjustment);
    }

    // -------------------- VIEW FUNCTIONS --------------------

    function getTrustScore(address _member) external view returns (uint256) {
        require(isMember(_member), "Not a registered member");
        return members[_member].trustScore;
    }
}