Whitelist

{{
  "language": "Solidity",
  "sources": {
    "src/ths-sale/Whitelist.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import {ACLConsumer} from "../aux/ACLConsumer.sol";
import {IWhitelist} from "./interfaces/IWhitelist.sol";

contract Whitelist is ACLConsumer, IWhitelist {
    mapping(address => bool) private _whitelist;

    constructor(address aclManagerAddress) ACLConsumer(aclManagerAddress) {}

    function addToWhitelist(address _address) public onlyWhitelistOperator {
        require(_address != address(0), ZeroAddress());
        require(!isWhitelisted(_address), AlreadyInWhitelist(_address));

        _whitelist[_address] = true;
        emit AddressAddedToWhitelist(_address);
    }

    function addToWhitelistBatch(address[] calldata addresses) external onlyWhitelistOperator {
        for (uint256 i = 0; i < addresses.length; i++) {
            addToWhitelist(addresses[i]);
        }
    }

    function removeFromWhitelist(address _address) public onlyWhitelistOperator {
        require(_address != address(0), ZeroAddress());
        require(_whitelist[_address], AddressToRemoveNotFound(_address));

        delete _whitelist[_address];
        emit AddressRemovedFromWhitelist(_address);
    }

    function removeFromWhitelistBatch(address[] calldata addresses) external onlyWhitelistOperator {
        for (uint256 i = 0; i < addresses.length; i++) {
            removeFromWhitelist(addresses[i]);
        }
    }

    function isWhitelisted(address _address) public view returns (bool) {
        require(_address != address(0), ZeroAddress());

        return _whitelist[_address];
    }
}
"
    },
    "src/aux/ACLConsumer.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import {IACLManager} from "./interfaces/IACLManager.sol";
import {ICommonErrors} from "../common/interfaces/ICommonErrors.sol";
import {ACLRoles} from "./lib/ACLRoles.sol";

abstract contract ACLConsumer is ICommonErrors {
    // IMMUTABLES

    IACLManager public immutable aclManager;

    // MODIFIERS

    modifier onlyProtocolAdmin() {
        aclManager.checkRole(ACLRoles.PROTOCOL_ADMIN_ROLE, msg.sender);
        _;
    }

    modifier onlyWhitelistOperator() {
        aclManager.checkRole(ACLRoles.WHITELIST_OPERATOR_ROLE, msg.sender);
        _;
    }

    modifier onlySaleOperator() {
        aclManager.checkRole(ACLRoles.SALE_OPERATOR_ROLE, msg.sender);
        _;
    }

    modifier onlyOtcSaleExecutor() {
        aclManager.checkRole(ACLRoles.OTC_SALE_EXECUTOR_ROLE, msg.sender);
        _;
    }

    modifier onlyRewardsDistributor() {
        aclManager.checkRole(ACLRoles.REWARDS_DISTRIBUTOR_ROLE, msg.sender);
        _;
    }

    // CONSTRUCTOR

    constructor(address aclManagerAddress) {
        require(aclManagerAddress != address(0), ZeroAddress());
        aclManager = IACLManager(aclManagerAddress);
    }
}
"
    },
    "src/ths-sale/interfaces/IWhitelist.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {IWhitelistErrors} from "./IWhitelistErrors.sol";
import {IWhitelistEvents} from "./IWhitelistEvents.sol";

interface IWhitelist is IWhitelistErrors, IWhitelistEvents {
    function addToWhitelist(address _address) external;
    function addToWhitelistBatch(address[] calldata _addresses) external;

    function removeFromWhitelist(address _address) external;
    function removeFromWhitelistBatch(address[] calldata _addresses) external;

    function isWhitelisted(address _address) external view returns (bool);
}
"
    },
    "src/aux/interfaces/IACLManager.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import {ICommonErrors} from "../../common/interfaces/ICommonErrors.sol";

interface IACLManager is ICommonErrors {
    function setRoleAdmin(bytes32 role, bytes32 adminRole) external;

    function addProtocolAdmin(address account) external;
    function removeProtocolAdmin(address account) external;

    function addWhitelistOperator(address account) external;
    function removeWhitelistOperator(address account) external;

    function addSaleOperator(address account) external;
    function removeSaleOperator(address account) external;

    function addOtcSaleExecutor(address account) external;
    function removeOtcSaleExecutor(address account) external;

    function addRewardsDistributor(address account) external;
    function removeRewardsDistributor(address account) external;

    function checkRole(bytes32 role, address account) external view;
    function isProtocolAdmin(address account) external view returns (bool);
    function isWhitelistOperator(address account) external view returns (bool);
    function isSaleOperator(address account) external view returns (bool);
    function isOtcSaleExecutor(address account) external view returns (bool);
    function isRewardsDistributor(address account) external view returns (bool);
}
"
    },
    "src/common/interfaces/ICommonErrors.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

interface ICommonErrors {
    error ZeroAmount();
    error ZeroAddress();
}
"
    },
    "src/aux/lib/ACLRoles.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

library ACLRoles {
    // Same as DEFAULT_ADMIN_ROLE of OpenZeppelin's AccessControl
    bytes32 internal constant PROTOCOL_ADMIN_ROLE = 0x00;
    bytes32 internal constant WHITELIST_OPERATOR_ROLE = keccak256("WHITELIST_OPERATOR_ROLE");
    bytes32 internal constant SALE_OPERATOR_ROLE = keccak256("SALE_OPERATOR_ROLE");
    bytes32 internal constant OTC_SALE_EXECUTOR_ROLE = keccak256("OTC_SALE_EXECUTOR_ROLE");
    bytes32 internal constant REWARDS_DISTRIBUTOR_ROLE = keccak256("REWARDS_DISTRIBUTOR_ROLE");
}
"
    },
    "src/ths-sale/interfaces/IWhitelistErrors.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {ICommonErrors} from "../../common/interfaces/ICommonErrors.sol";

interface IWhitelistErrors is ICommonErrors {
    error AlreadyInWhitelist(address _address);
    error AddressToRemoveNotFound(address _address);
}
"
    },
    "src/ths-sale/interfaces/IWhitelistEvents.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

interface IWhitelistEvents {
    event AddressAddedToWhitelist(address user);
    event AddressRemovedFromWhitelist(address user);
}
"
    }
  },
  "settings": {
    "remappings": [
      "forge-std/=lib/forge-std/src/",
      "@openzeppelin-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
      "@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",
      "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
      "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
      "halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
      "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
      "openzeppelin-contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/"
    ],
    "optimizer": {
      "enabled": true,
      "runs": 1000000
    },
    "metadata": {
      "useLiteralContent": false,
      "bytecodeHash": "ipfs",
      "appendCBOR": true
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "evmVersion": "prague",
    "viaIR": true
  }
}}