└── token.sol /token.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity ^0.8.0; 4 | 5 | contract Ownable { 6 | address public owner; 7 | 8 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 9 | 10 | modifier onlyOwner() { 11 | require(msg.sender == owner, "Ownable: caller is not the owner"); 12 | _; 13 | } 14 | 15 | function transferOwnership(address newOwner) public onlyOwner { 16 | require(newOwner != address(0), "Ownable: new owner is the zero address"); 17 | emit OwnershipTransferred(owner, newOwner); 18 | owner = newOwner; 19 | } 20 | } 21 | 22 | contract Pausable is Ownable { 23 | event Pause(); 24 | event Unpause(); 25 | 26 | bool public paused = false; 27 | 28 | modifier whenNotPaused() { 29 | require(!paused, "Pausable: paused"); 30 | _; 31 | } 32 | 33 | modifier whenPaused() { 34 | require(paused, "Pausable: not paused"); 35 | _; 36 | } 37 | 38 | function pause() onlyOwner whenNotPaused public { 39 | paused = true; 40 | emit Pause(); 41 | } 42 | 43 | function unpause() onlyOwner whenPaused public { 44 | paused = false; 45 | emit Unpause(); 46 | } 47 | } 48 | 49 | abstract contract ERC20Basic { 50 | uint256 public totalSupply; 51 | 52 | function balanceOf(address who) virtual public view returns (uint256); 53 | function transfer(address to, uint256 value) virtual public returns (bool); 54 | 55 | event Transfer(address indexed from, address indexed to, uint256 value); 56 | } 57 | 58 | abstract contract ERC20 is ERC20Basic { 59 | function allowance(address owner, address spender) virtual public view returns (uint256); 60 | function transferFrom(address from, address to, uint256 value) virtual public returns (bool); 61 | function approve(address spender, uint256 value) virtual public returns (bool); 62 | 63 | event Approval(address indexed owner, address indexed spender, uint256 value); 64 | } 65 | 66 | contract StandardToken is ERC20 { 67 | mapping(address => mapping(address => uint256)) internal allowed; 68 | mapping(address => bool) tokenBlacklist; 69 | event Blacklist(address indexed blackListed, bool value); 70 | 71 | mapping(address => uint256) balances; 72 | 73 | function transfer(address _to, uint256 _value) virtual override public returns (bool) { 74 | require(!tokenBlacklist[msg.sender], "StandardToken: sender is blacklisted"); 75 | require(_to != address(0), "StandardToken: transfer to the zero address"); 76 | require(_value <= balances[msg.sender], "StandardToken: insufficient balance"); 77 | 78 | balances[msg.sender] -= _value; 79 | balances[_to] += _value; 80 | emit Transfer(msg.sender, _to, _value); 81 | return true; 82 | } 83 | 84 | function balanceOf(address _owner) override public view returns (uint256 balance) { 85 | return balances[_owner]; 86 | } 87 | 88 | function transferFrom(address _from, address _to, uint256 _value) virtual override public returns (bool) { 89 | require(!tokenBlacklist[msg.sender], "StandardToken: sender is blacklisted"); 90 | require(_to != address(0), "StandardToken: transfer to the zero address"); 91 | require(_value <= balances[_from], "StandardToken: insufficient balance"); 92 | require(_value <= allowed[_from][msg.sender], "StandardToken: allowance exceeded"); 93 | 94 | balances[_from] -= _value; 95 | balances[_to] += _value; 96 | allowed[_from][msg.sender] -= _value; 97 | emit Transfer(_from, _to, _value); 98 | return true; 99 | } 100 | 101 | function approve(address _spender, uint256 _value) virtual override public returns (bool) { 102 | allowed[msg.sender][_spender] = _value; 103 | emit Approval(msg.sender, _spender, _value); 104 | return true; 105 | } 106 | 107 | function allowance(address _owner, address _spender) virtual override public view returns (uint256) { 108 | return allowed[_owner][_spender]; 109 | } 110 | 111 | function increaseApproval(address _spender, uint _addedValue) virtual public returns (bool) { 112 | allowed[msg.sender][_spender] += _addedValue; 113 | emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 114 | return true; 115 | } 116 | 117 | function decreaseApproval(address _spender, uint _subtractedValue) virtual public returns (bool) { 118 | uint oldValue = allowed[msg.sender][_spender]; 119 | if (_subtractedValue > oldValue) { 120 | allowed[msg.sender][_spender] = 0; 121 | } else { 122 | allowed[msg.sender][_spender] = oldValue - _subtractedValue; 123 | } 124 | emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 125 | return true; 126 | } 127 | 128 | function _blackList(address _address, bool _isBlackListed) internal returns (bool) { 129 | require(tokenBlacklist[_address] != _isBlackListed, "StandardToken: address already in the given state"); 130 | tokenBlacklist[_address] = _isBlackListed; 131 | emit Blacklist(_address, _isBlackListed); 132 | return true; 133 | } 134 | } 135 | 136 | contract PausableToken is StandardToken, Pausable { 137 | 138 | function transfer(address _to, uint256 _value) override public whenNotPaused returns (bool) { 139 | return super.transfer(_to, _value); 140 | } 141 | 142 | function transferFrom(address _from, address _to, uint256 _value) override public whenNotPaused returns (bool) { 143 | return super.transferFrom(_from, _to, _value); 144 | } 145 | 146 | function approve(address _spender, uint256 _value) override public whenNotPaused returns (bool) { 147 | return super.approve(_spender, _value); 148 | } 149 | 150 | function increaseApproval(address _spender, uint _addedValue) override public whenNotPaused returns (bool success) { 151 | return super.increaseApproval(_spender, _addedValue); 152 | } 153 | 154 | function decreaseApproval(address _spender, uint _subtractedValue) override public whenNotPaused returns (bool success) { 155 | return super.decreaseApproval(_spender, _subtractedValue); 156 | } 157 | 158 | function blackListAddress(address listAddress, bool isBlackListed) public whenNotPaused onlyOwner returns (bool success) { 159 | return super._blackList(listAddress, isBlackListed); 160 | } 161 | } 162 | 163 | contract Rokda is PausableToken { 164 | string public name; 165 | string public symbol; 166 | uint public decimals; 167 | 168 | event Mint(address indexed from, address indexed to, uint256 value); 169 | event Burn(address indexed burner, uint256 value); 170 | 171 | constructor(string memory _name, string memory _symbol, uint256 _decimals, uint256 _supply, address tokenOwner) { 172 | name = _name; 173 | symbol = _symbol; 174 | decimals = _decimals; 175 | totalSupply = _supply * 10 ** _decimals; 176 | balances[tokenOwner] = totalSupply; 177 | owner = tokenOwner; 178 | emit Transfer(address(0), tokenOwner, totalSupply); 179 | } 180 | 181 | function burn(uint256 _value) public { 182 | _burn(msg.sender, _value); 183 | } 184 | 185 | function _burn(address _who, uint256 _value) internal { 186 | require(_value <= balances[_who], "Rokda: burn amount exceeds balance"); 187 | balances[_who] -= _value; 188 | totalSupply -= _value; 189 | emit Burn(_who, _value); 190 | emit Transfer(_who, address(0), _value); 191 | } 192 | 193 | function mint(address account, uint256 amount) onlyOwner public { 194 | totalSupply += amount; 195 | balances[account] += amount; 196 | emit Mint(address(0), account, amount); 197 | emit Transfer(address(0), account, amount); 198 | } 199 | } 200 | --------------------------------------------------------------------------------