{"RoyaleToken.sol":{"content":"// SPDX-License-Identifier: MIT\r\npragma solidity ^0.6.0;\r\n\r\nimport \u0027./SafeMath.sol\u0027;\r\n\r\ncontract RoyaleToken{\r\n\r\n    using SafeMath for uint256;\r\n    \r\n    string public name = \"Royale\";\r\n    string public symbol = \"ROYA\";\r\n    uint8  public decimals=18;\r\n    uint256 public totalSupply=72000000 * (uint256(10) ** decimals);\r\n    mapping(address =\u003e uint256)  balances;\r\n    mapping (address =\u003e mapping (address =\u003e uint256)) allowances;\r\n    \r\n    event Transfer(\r\n      address indexed _from,\r\n      address indexed _to,\r\n      uint256 _value\r\n    );\r\n\r\n    event Approval(\r\n        address indexed _owner,\r\n        address indexed _spender,\r\n        uint256 _value\r\n    );\r\n    \r\n    \r\n     constructor () public {\r\n            balances[msg.sender] = totalSupply;\r\n           \r\n    }\r\n    \r\n    \r\n   \r\n    function balanceOf(address _address) public view returns (uint256){\r\n            return balances[_address];\r\n    }\r\n\r\n   \r\n     function transfer(address _to, uint256 _amount) public  returns (bool success) {\r\n            require(_amount\u003e0 , \"amount can not be zero \");\r\n            require(balances[msg.sender]\u003e=_amount  , \"Insufficient balance \");\r\n            balances[msg.sender] = balances[msg.sender].sub(_amount);     \r\n            balances[_to] =balances[_to].add(_amount);\r\n            emit Transfer(msg.sender, _to, _amount);\r\n            return true;\r\n    }\r\n    \r\n   \r\n    function approve(address _spender, uint256 _amount) public returns (bool success) {\r\n            allowances[msg.sender][_spender]=allowances[msg.sender][_spender].add(_amount);                                \r\n            emit Approval(msg.sender,_spender, _amount);\r\n            return true;\r\n    }\r\n    \r\n    function transferFrom(address _from, address _to, uint256 _amount) public  returns (bool success) {\r\n         require(_amount\u003e0 , \"amount can not be zero \");\r\n         require(_amount \u003c= allowances[_from][msg.sender] , \"Transfer amount exceeds allowance\");  //checking that whether sender is approved or not...\r\n         balances[_from]= balances[_from].sub(_amount);\r\n         balances[_to] = balances[_to].add(_amount);\r\n         allowances[_from][msg.sender]=allowances[_from][msg.sender].sub(_amount);\r\n          emit Transfer(_from, _to, _amount);\r\n         return true;\r\n    }\r\n\r\n    function allowance(address _owner, address _spender) public view returns (uint256 remaining){\r\n      return allowances[_owner][_spender];\r\n    }\r\n    \r\n}\r\n\r\n\r\n"},"SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\r\npragma solidity ^0.6.0;\r\nlibrary SafeMath {\r\n    /**\r\n     * @dev Returns the addition of two unsigned integers, reverting on\r\n     * overflow.\r\n     *\r\n     * Counterpart to Solidity\u0027s `+` operator.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - Addition cannot overflow.\r\n     */\r\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        uint256 c = a + b;\r\n        require(c \u003e= a, \"SafeMath: addition overflow\");\r\n\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the subtraction of two unsigned integers, reverting on\r\n     * overflow (when the result is negative).\r\n     *\r\n     * Counterpart to Solidity\u0027s `-` operator.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - Subtraction cannot overflow.\r\n     */\r\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return sub(a, b, \"SafeMath: subtraction overflow\");\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\r\n     * overflow (when the result is negative).\r\n     *\r\n     * Counterpart to Solidity\u0027s `-` operator.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - Subtraction cannot overflow.\r\n     */\r\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        require(b \u003c= a, errorMessage);\r\n        uint256 c = a - b;\r\n\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the multiplication of two unsigned integers, reverting on\r\n     * overflow.\r\n     *\r\n     * Counterpart to Solidity\u0027s `*` operator.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - Multiplication cannot overflow.\r\n     */\r\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        // Gas optimization: this is cheaper than requiring \u0027a\u0027 not being zero, but the\r\n        // benefit is lost if \u0027b\u0027 is also tested.\r\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\r\n        if (a == 0) {\r\n            return 0;\r\n        }\r\n\r\n        uint256 c = a * b;\r\n        require(c / a == b, \"SafeMath: multiplication overflow\");\r\n\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the integer division of two unsigned integers. Reverts on\r\n     * division by zero. The result is rounded towards zero.\r\n     *\r\n     * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\r\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\r\n     * uses an invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return div(a, b, \"SafeMath: division by zero\");\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\r\n     * division by zero. The result is rounded towards zero.\r\n     *\r\n     * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\r\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\r\n     * uses an invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        require(b \u003e 0, errorMessage);\r\n        uint256 c = a / b;\r\n        // assert(a == b * c + a % b); // There is no case in which this doesn\u0027t hold\r\n\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\r\n     * Reverts when dividing by zero.\r\n     *\r\n     * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\r\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\r\n     * invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return mod(a, b, \"SafeMath: modulo by zero\");\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\r\n     * Reverts with custom message when dividing by zero.\r\n     *\r\n     * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\r\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\r\n     * invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        require(b != 0, errorMessage);\r\n        return a % b;\r\n    }\r\n}"}}