require(Reputable.reputationOf(0x3e5...) > X, "Reputation is insufficient")

pragma solidity >=0.8.0;

import "./Controlled.sol";

contract Reputable is Controlled {
    // name and symbol of the token
    string public name;
    string public symbol;
    
    // Each address's balance represents its level of reputation
    mapping(address => uint256) private _balances;
    
    event ReputationSet(address indexed account, uint256 amount);
    
     /**
     * Constructor
     * @param chainId_ makes signatures unique to a chain
     * @param attestor_ is the address of the Reputation Service (backend)
     */
    constructor(string memory name_, string memory symbol_, uint256 chainId_, address attestor_) 
    Controlled(chainId_, attestor_) {
        name = name_;
        symbol = symbol_;
    }
    
    function _mint(address account, uint256 amount) private {
        require(account != address(0), "Can't mint to the zero address");
        
        // overrides with new reputation level
        _balances[account] = amount;
        
        emit ReputationSet(account, amount);
    }
    
    function setReputation(address _recipient, uint256 _amount, bytes memory _signature) public
    onlyAttestor()
    withValidAttestation( _recipient,  _amount, _signature)  {
        _mint(_recipient, _amount);
    }
    
    // Returns the reputation level of _account
    function reputationOf(address _account) public view returns (uint256) {
        return _balances[_account];
    }
}


//////////////////////////////////////////////////////////////////////

pragma solidity >=0.8.0;


import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol";


contract Controlled {
    uint256 public chainId;
    address private attestor;
    
    constructor(uint256 _chainId, address _attestor) {
        chainId = _chainId;
        attestor = _attestor;
    }

    /**
     * Outputs the full "attestation hash" including chainId
     */
    function _getAttestationHash(address _recipient, uint256 _amount)
        private
        view
        returns (bytes32)
    {
        bytes32 hash = keccak256(
            abi.encodePacked(chainId, _recipient, _amount)
        );
        return hash;
    }
    
    /**
     * Outputs the signer of _signature
     * after re-constructing the full attestation hash
     */
    function _recoverSigner(
        address _recipient,
        uint256 _amount,
        bytes memory _signature
    ) private view returns (address) {
        bytes32 hash = _getAttestationHash(_recipient, _amount);
        address signer = ECDSA.recover(hash, _signature);
        
        return signer;
    }
    
     /**
     * Verifies that the attestation was signed by _recipient
     * and reverts if it's not the case
     */
    modifier withValidAttestation(
        address _recipient,
        uint256 _amount,
        bytes memory _signature
    ) {
        require(
            _recoverSigner(_recipient, _amount, _signature) == _recipient,
            "Invalid signature"
        );
        _;
    }
    
     /**
     * Restricts execution to the attestor
     */
     modifier onlyAttestor() {
         require(msg.sender == attestor, "Permission denied");
         _;
     }
    
}

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

interface IBadge {
    /**
     * @dev Emitted when `tokenId` token is minted to `to`.
     * @param to The address that received the token
     * @param tokenId The id of the token that was minted
     * @param timestamp Block timestamp from when the token was minted
     */
    event Minted(
        address indexed to,
        uint256 indexed tokenId,
        uint256 timestamp
    );

    /**
     * @dev Emitted when `tokenId` token is burned.
     * @param owner The address that used to own the token
     * @param tokenId The id of the token that was burned
     * @param timestamp Block timestamp from when the token was burned
     */
    event Burned(
        address indexed owner,
        uint256 indexed tokenId,
        uint256 timestamp
    );

    /**
     * @dev Returns the badge's name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the badge's symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the ID of the token owned by `owner`, if it owns one, and 0 otherwise
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     */
    function tokenOf(address owner) external view returns (uint256);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address);
}

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

import "./IBadge.sol";

contract Badge is IBadge {
    // Badge's name
    string private _name;

    // Badge's symbol
    string private _symbol;

    // Mapping from token ID to owner's address
    mapping(uint256 => address) private _owners;

    // Mapping from owner's address to token ID
    mapping(address => uint256) private _tokens;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    // Returns the badge's name
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    // Returns the badge's symbol
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    // Returns the token ID owned by `owner`, if it exists, and 0 otherwise
    function tokenOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "Invalid owner at zero address");

        return _tokens[owner];
    }

    // Returns the owner of a given token ID, reverts if the token does not exist
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        require(tokenId != 0, "Invalid tokenId value");

        address owner = _owners[tokenId];

        require(owner != address(0), "Invalid owner at zero address");

        return owner;
    }

    // Checks if a token ID exists
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Minted} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "Invalid owner at zero address");
        require(tokenId != 0, "Token ID cannot be zero");
        require(!_exists(tokenId), "Token already minted");
        require(tokenOf(to) == 0, "Owner already has a token");


        _tokens[to] = tokenId;
        _owners[tokenId] = to;

        emit Minted(to, tokenId, block.timestamp);
    }

    /**
     * @dev Burns `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Burned} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = Badge.ownerOf(tokenId);

        delete _tokens[owner];
        delete _owners[tokenId];

        emit Burned(owner, tokenId, block.timestamp);
    }
}

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

import "./Badge.sol";
import "../shared/Controlled.sol";

contract TwitterBadge is Badge, Controlled {
    constructor(address backendAddress_)
        Badge("TwitterBadge", "TWITT")
        Controlled(backendAddress_)
    {}

    function mint(address to, uint256 tokenId) external {
        require(msg.sender == _backendAddress, "Unauthorized");
        _mint(to, tokenId);
    }

    function burn(uint256 tokenId) external {
        require(
            msg.sender == _backendAddress || msg.sender == ownerOf(tokenId),
            "Unauthorized"
        );
        _burn(tokenId);
    }
}