Distribution.sol

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

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import '@openzeppelin/contracts-upgradeable/access/extensions/AccessControlEnumerableUpgradeable.sol';
import './lib/TransferHelper.sol';

contract Distribution is EIP712Upgradeable, ReentrancyGuardUpgradeable, AccessControlEnumerableUpgradeable {

    // Subsequent upgrades do not use enumeration
    uint8 public constant TYPE_AIRDROP    = 0;
    uint8 public constant TYPE_GOVERNANCE = 1;
    uint8 public constant TYPE_REWARDS    = 2;
    uint8 public constant TYPE_SALARY     = 3;
    uint8 public constant TYPE_BOUNTY     = 4;

    bytes32 public constant OPERATOR_ROLE = keccak256("DISTRIBUTION_OPERATOR_ROLE");

    event DistributionEvent(address indexed operator, address indexed token, address indexed user, uint256 amount, uint8 distType);

    constructor() {
        _disableInitializers();
    }

    function initialize(address admin) public initializer {
        
        __ReentrancyGuard_init();
        __AccessControlEnumerable_init();
        __EIP712_init("Distribution", "1.0.0");

        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(OPERATOR_ROLE, admin);
    }

    function airdrop(
        address token,
        address[] calldata users,
        uint256[] calldata amount
    ) external nonReentrant onlyRole(OPERATOR_ROLE) {
        require(users.length == amount.length, "Users and amounts length mismatch");
        if (token == address(0)) {
            _distributionETH(users, amount, TYPE_AIRDROP);
        } else {
            _distributionToken(token, users, amount, TYPE_AIRDROP);
        }
    }

    function governance(
        address token,
        address[] calldata users,
        uint256[] calldata amount
    ) external nonReentrant onlyRole(OPERATOR_ROLE) {
        require(users.length == amount.length, "Users and amounts length mismatch");
        if (token == address(0)) {
            _distributionETH(users, amount, TYPE_GOVERNANCE);
        } else {
            _distributionToken(token, users, amount, TYPE_GOVERNANCE);
        }
    }

    function Rewards(
        address token,
        address[] calldata users,
        uint256[] calldata amount
    ) external nonReentrant onlyRole(OPERATOR_ROLE) {
        require(users.length == amount.length, "Users and amounts length mismatch");
        if (token == address(0)) {
            _distributionETH(users, amount, TYPE_REWARDS);
        } else {
            _distributionToken(token, users, amount, TYPE_REWARDS);
        }
    }

    function Salary(
        address token,
        address[] calldata users,
        uint256[] calldata amount
    ) external nonReentrant onlyRole(OPERATOR_ROLE) {
        require(users.length == amount.length, "Users and amounts length mismatch");
        if (token == address(0)) {
            _distributionETH(users, amount, TYPE_SALARY);
        } else {
            _distributionToken(token, users, amount, TYPE_SALARY);
        }
    }

    function Bounty(
        address token,
        address[] calldata users,
        uint256[] calldata amount
    ) external nonReentrant onlyRole(OPERATOR_ROLE) {
        require(users.length == amount.length, "Users and amounts length mismatch");
        if (token == address(0)) {
            _distributionETH(users, amount, TYPE_BOUNTY);
        } else {
            _distributionToken(token, users, amount, TYPE_BOUNTY);
        }
    }

    function _distributionToken(address _token, address[] calldata _users, uint256[] calldata _amount, uint8 _distType) internal  {
        for (uint i = 0; i < _users.length;) {
            TransferHelper.safeTransfer(_token, _users[i], _amount[i]);
            emit DistributionEvent(msg.sender, _token, _users[i], _amount[i], _distType);
            unchecked {
                i++;
            }
        } 
    }

    function _distributionSameToken(address _token, address[] calldata _users, uint256 _amount, uint8 _distType) internal  {
        for (uint i = 0; i < _users.length;) {
            TransferHelper.safeTransfer(_token, _users[i], _amount);
            emit DistributionEvent(msg.sender, _token, _users[i], _amount, _distType);
            unchecked {
                i++;
            }
        } 
    }

    function _distributionETH(address[] calldata _users, uint256[] calldata _amount, uint8 _distType) internal  {
        for (uint i = 0; i < _users.length;) {
            TransferHelper.safeTransferXOC(_users[i], _amount[i]);
            emit DistributionEvent(msg.sender, address(0), _users[i], _amount[i], _distType);
            unchecked {
                i++;
            }
        } 
    }

    function _distributionSameETH(address[] calldata _users, uint256 _amount, uint8 _distType) internal  {
        for (uint i = 0; i < _users.length;) {
            TransferHelper.safeTransferXOC(_users[i], _amount);
            emit DistributionEvent(msg.sender, address(0), _users[i], _amount, _distType);
            unchecked {
                i++;
            }
        }
    }

    function withdrawToken(
        address token,
        address recipient,
        uint256 amount
    ) external onlyRole(DEFAULT_ADMIN_ROLE) {
        TransferHelper.safeTransfer(token, recipient, amount);
    }

    function withdrawETH(address payable recipient, uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE) {
        TransferHelper.safeTransferXOC(recipient, amount);
    }

    receive() external payable {}
   
}