EATokenV1.0

// SPDX-License-Identifier: GPL-2.0-only
/**
 * EAToken
 * v1.0
 */
pragma solidity ^0.6.4;

import "./ERC20Basic.sol";
import "./SafeMath256.sol";
import "./Ownable.sol";
import "./Pausable.sol";

contract EAToken is ERC20Basic, Ownable, Pausable {
    using SafeMath256 for uint256;

    // ERC20 params
    string private _name = "EATokenV1.0";
    string private _symbol = "EA";
    uint8 private _decimals = 6;
    uint256 private _totalSupply;
    mapping(address => uint256) internal balances;
    address[] private _ctl;

    event Mint(address indexed to, uint256 amount);

    /// move tokens
    function _move(address from, address to, uint256 value) private {
        require(value <= balances[from], "EAToken: [_move] balance not enough");
        require(to != address(0), "EAToken: [_move] to[address] is illegal");

        balances[from] = balances[from].sub(value);
        balances[to] = balances[to].add(value);
    }

    /// transfer token
    function transfer(address to, uint256 value) public whenNotPaused override returns (bool) {
        _move(msg.sender, to, value);
        emit Transfer(msg.sender, to, value);
        return true;
    }

    /// erc20 interface
    function name() public view returns (string memory) {
        return _name;
    }

    /// erc20 interface
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /// erc20 interface
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /// erc20 interface
    function balanceOf(address _owner) public override view returns (uint256) {
        return balances[_owner];
    }

    /// erc20 interface
    function totalSupply() public override view returns (uint256) {
        return _totalSupply;
    }

    /// get gameCtl
    function gameCtl() public view returns (address[] memory) {
        return _ctl;
    }

    /// set gameCtl
    function setGameCtl(address[] calldata _gc) external onlyOwner {
        _ctl = _gc;
    }

    // check ctl
    function _isCtl(address _addr) private view returns(bool) {
        for(uint i = 0; i < _ctl.length; i++) {
            if (_ctl[i] == _addr) {
                return true;
            }
        }
        return false;
    }

    /// pay forward
    function payF(address _account, uint256 _value) external {
        require(_isCtl(msg.sender), "EAToken: must use game ctl");
        _move(_account, msg.sender, _value);
    }

    /// mint
    function mint(address _to, uint256 _amount) public onlyOwner returns (bool) {
        _totalSupply = _totalSupply.add(_amount);
        balances[_to] = balances[_to].add(_amount);
        emit Mint(_to, _amount);
        emit Transfer(address(0), _to, _amount);
        return true;
    }
}

pragma solidity ^0.6.4;

/**
 * @title ERC20Basic
 * @dev EA
 */
interface ERC20Basic {
  function totalSupply() external view returns (uint256);
  function balanceOf(address _who) external view returns (uint256);
  function transfer(address _to, uint256 _value) external returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

pragma solidity ^0.6.4;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;

  event OwnershipRenounced(address indexed previousOwner);
  event OwnershipTransferred(
    address indexed previousOwner,
    address indexed newOwner
  );


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  constructor() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner, "Ownable: [onlyOwner]");
    _;
  }

  /**
   * @dev Allows the current owner to relinquish control of the contract.
   * @notice Renouncing to ownership will leave the contract without an owner.
   * It will not be possible to call the functions with the `onlyOwner`
   * modifier anymore.
   */
  function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(owner);
    owner = address(0);
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function transferOwnership(address _newOwner) public onlyOwner {
    _transferOwnership(_newOwner);
  }

  /**
   * @dev Transfers control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function _transferOwnership(address _newOwner) internal {
    require(_newOwner != address(0), "Ownable: [_transferOwnership] _newOwner illegal");
    emit OwnershipTransferred(owner, _newOwner);
    owner = _newOwner;
  }
}

pragma solidity ^0.6.4;

import "./Ownable.sol";

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is Ownable {
  event Pause();
  event Unpause();

  bool public paused = false;


  /**
   * @dev Modifier to make a function callable only when the contract is not paused.
   */
  modifier whenNotPaused() {
    require(!paused, "Pausable: not paused");
    _;
  }

  /**
   * @dev Modifier to make a function callable only when the contract is paused.
   */
  modifier whenPaused() {
    require(paused, "Pausable: paused");
    _;
  }

  /**
   * @dev called by the owner to pause, triggers stopped state
   */
  function pause() public onlyOwner whenNotPaused {
    paused = true;
    emit Pause();
  }

  /**
   * @dev called by the owner to unpause, returns to normal state
   */
  function unpause() public onlyOwner whenPaused {
    paused = false;
    emit Unpause();
  }
}

pragma solidity ^0.6.4;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow checks.
 */
library SafeMath256 {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

{
  "compilationTarget": {
    "localhost/EAToken.sol": "EAToken"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}