Reputation-Based Access Control

What it does:
Grants or restricts access to services, content, or features based on a user’s reputation score, enabling trust-based ecosystems.

Why it matters:
Encourages positive behavior, prevents abuse, automates access control, and creates transparent, merit-based participation systems.

How it works:

  • Users have a reputation score tracked on-chain

  • Access policies define minimum reputation required for certain services or content

  • Reputation can be earned through contributions, participation, or verified achievements

  • Smart contracts automatically allow or deny access based on reputation thresholds

  • Integrates with Metaverse Identity, AI Agent Payment, Play-to-Earn Reward Engine, or Smart City Micro-Payments

  • Dashboards show reputation scores, access history, and earned privileges

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

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

/**
 * @title ReputationAccessControl
 * @author Nam
 * @notice Grants access to services based on user reputation on-chain
 */
contract ReputationAccessControl is Ownable {

    struct User {
        uint256 reputation;
        bool exists;
    }

    mapping(address => User) public users;

    struct Service {
        string name;
        uint256 minReputation;
        bool active;
    }

    mapping(uint256 => Service) public services;
    uint256 public serviceCount;

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

    event UserReputationUpdated(address indexed user, uint256 newReputation);
    event ServiceRegistered(uint256 indexed serviceId, string name, uint256 minReputation);
    event ServiceDeactivated(uint256 indexed serviceId);

    // -------------------- USER MANAGEMENT --------------------

    function updateReputation(address _user, uint256 _reputation) external onlyOwner {
        users[_user].reputation = _reputation;
        users[_user].exists = true;

        emit UserReputationUpdated(_user, _reputation);
    }

    function getReputation(address _user) external view returns (uint256) {
        return users[_user].reputation;
    }

    // -------------------- SERVICE MANAGEMENT --------------------

    function registerService(string calldata _name, uint256 _minReputation) external onlyOwner {
        serviceCount += 1;
        services[serviceCount] = Service({
            name: _name,
            minReputation: _minReputation,
            active: true
        });

        emit ServiceRegistered(serviceCount, _name, _minReputation);
    }

    function deactivateService(uint256 _serviceId) external onlyOwner {
        services[_serviceId].active = false;
        emit ServiceDeactivated(_serviceId);
    }

    // -------------------- ACCESS CHECK --------------------

    function canAccess(uint256 _serviceId, address _user) external view returns (bool) {
        Service storage s = services[_serviceId];
        require(s.active, "Service inactive");
        User storage u = users[_user];
        return u.exists && u.reputation >= s.minReputation;
    }
}