Creator Reputation System

What it does:
Builds an on-chain reputation profile for creators based on their publishing history, revenue performance, community feedback, and governance participation.

Why it matters:
Creates portable trust across platforms, reduces reliance on follower counts, helps audiences and collaborators assess credibility, and rewards long-term, high-quality contributions.

How it works:

  • Each creator is represented by a unique on-chain profile

  • Reputation points are earned through verified actions (publishing, sales, grants, DAO votes)

  • Negative actions (content removal, disputes, slashing) reduce reputation

  • Reputation is non-transferable and tied to a wallet identity

  • Scores are calculated and updated transparently on-chain

  • Reputation can gate access to grants, features, or monetization tools

  • Integrates with DAOs, marketplaces, and publishing platforms

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

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

/**
 * @title CreatorReputationSystem
 * @author Nam
 * @notice On-chain non-transferable reputation tracking for creators
 */
contract CreatorReputationSystem is Ownable {

    struct Reputation {
        uint256 score;
        uint256 publishedCount;
        uint256 totalRevenue;
        bool exists;
    }

    mapping(address => Reputation) public reputations;

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

    event ReputationCreated(address indexed creator);
    event ReputationUpdated(address indexed creator, uint256 newScore);
    event RevenueRecorded(address indexed creator, uint256 amount);
    event PublicationRecorded(address indexed creator);

    // -------------------- PROFILE MANAGEMENT --------------------

    function createProfile() external {
        require(!reputations[msg.sender].exists, "Profile exists");

        reputations[msg.sender] = Reputation({
            score: 0,
            publishedCount: 0,
            totalRevenue: 0,
            exists: true
        });

        emit ReputationCreated(msg.sender);
    }

    // -------------------- REPUTATION LOGIC --------------------

    function recordPublication(address _creator) external onlyOwner {
        Reputation storage r = reputations[_creator];
        require(r.exists, "Profile not found");

        r.publishedCount += 1;
        r.score += 10;

        emit PublicationRecorded(_creator);
        emit ReputationUpdated(_creator, r.score);
    }

    function recordRevenue(address _creator, uint256 _amount) external onlyOwner {
        Reputation storage r = reputations[_creator];
        require(r.exists, "Profile not found");

        r.totalRevenue += _amount;
        r.score += _amount / 1e15; // example weighting

        emit RevenueRecorded(_creator, _amount);
        emit ReputationUpdated(_creator, r.score);
    }

    function penalize(address _creator, uint256 _penalty) external onlyOwner {
        Reputation storage r = reputations[_creator];
        require(r.exists, "Profile not found");

        if (_penalty >= r.score) {
            r.score = 0;
        } else {
            r.score -= _penalty;
        }

        emit ReputationUpdated(_creator, r.score);
    }

    // -------------------- VIEW --------------------

    function getReputation(address _creator)
        external
        view
        returns (
            uint256 score,
            uint256 publishedCount,
            uint256 totalRevenue
        )
    {
        Reputation memory r = reputations[_creator];
        require(r.exists, "Profile not found");
        return (r.score, r.publishedCount, r.totalRevenue);
    }
}