1 // ----------------------------------------------------------------------------  2 // ERC Token Standard #20 Interface  3 // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md  4 // ----------------------------------------------------------------------------  5 contract ERC20Interface {  6     function totalSupply() public constant returns (uint);  7     function balanceOf(address tokenOwner) public constant returns (uint balance);  8     function allowance(address tokenOwner, address spender) public constant returns (uint remaining);  9     function transfer(address to, uint tokens) public returns (bool success); 10     function approve(address spender, uint tokens) public returns (bool success); 11     function transferFrom(address from, address to, uint tokens) public returns (bool success); 12  13     event Transfer(address indexed from, address indexed to, uint tokens); 14     event Approval(address indexed tokenOwner, address indexed spender, uint tokens); 15 } 

1     string public constant name = "Token Name"; 2     string public constant symbol = "SYM"; 3     uint8 public constant decimals = 18;  // 18 is the most common number of decimal places 

 1 contract TokenContractFragment {  2    3     // Balances for each account  4     mapping(address => uint256) balances;  5    6     // Owner of account approves the transfer of an amount to another account  7     mapping(address => mapping (address => uint256)) allowed;  8    9     // Get the token balance for account `tokenOwner` 10     function balanceOf(address tokenOwner) public constant returns (uint balance) { 11         return balances[tokenOwner]; 12     } 13   14     // Transfer the balance from owner's account to another account 15     function transfer(address to, uint tokens) public returns (bool success) { 16         balances[msg.sender] = balances[msg.sender].sub(tokens); 17         balances[to] = balances[to].add(tokens); 18         Transfer(msg.sender, to, tokens); 19         return true; 20     } 21   22     // Send `tokens` amount of tokens from address `from` to address `to` 23     // The transferFrom method is used for a withdraw workflow, allowing contracts to send 24     // tokens on your behalf, for example to "deposit" to a contract address and/or to charge 25     // fees in sub-currencies; the command should fail unless the _from account has 26     // deliberately authorized the sender of the message via some mechanism; we propose 27     // these standardized APIs for approval: 28     function transferFrom(address from, address to, uint tokens) public returns (bool success) { 29         balances[from] = balances[from].sub(tokens); 30         allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens); 31         balances[to] = balances[to].add(tokens); 32         Transfer(from, to, tokens); 33         return true; 34     } 35   36     // Allow `spender` to withdraw from your account, multiple times, up to the `tokens` amount. 37     // If this function is called again it overwrites the current allowance with _value. 38     function approve(address spender, uint tokens) public returns (bool success) { 39         allowed[msg.sender][spender] = tokens; 40         Approval(msg.sender, spender, tokens); 41         return true; 42     } 43 } 

  1 // SPDX-License-Identifier: MIT   2 // ----------------------------------------------------------------------------   3 // 'FIXED' 'Example Fixed Supply Token' token contract   4 //   5 // Symbol      : FIXED   6 // Name        : Example Fixed Supply Token   7 // Total supply: 1,000,000.000000000000000000   8 // Decimals    : 18   9 //  10 // Enjoy.  11 //  12 // (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.  13 // ----------------------------------------------------------------------------  14   15 // ----------------------------------------------------------------------------  16 // Updated     : To support Solidity version 0.6.12  17 // Programmer  : Ts. Dr. Mohd Anuar Mat Isa, PhDs (EE & CS), iExplotech & IPTM Secretariat (www.iexplotech.com)  18 // Link        : https://github.com/iexplotech/SmartContract/blob/master/FixedSupplyToken_0.6.x.sol  19 // Tested      : Remix IDE, 10 Nov 2020  20 // ----------------------------------------------------------------------------  21   22 pragma solidity ^0.6.12;  23   24 // ----------------------------------------------------------------------------  25 // Safe maths  26 // ----------------------------------------------------------------------------  27 library SafeMath {  28     function add(uint a, uint b) internal pure returns (uint c) {  29         c = a + b;  30         require(c >= a);  31     }  32     function sub(uint a, uint b) internal pure returns (uint c) {  33         require(b <= a);  34         c = a - b;  35     }  36     function mul(uint a, uint b) internal pure returns (uint c) {  37         c = a * b;  38         require(a == 0 || c / a == b);  39     }  40     function div(uint a, uint b) internal pure returns (uint c) {  41         require(b > 0);  42         c = a / b;  43     }  44 }  45   46   47 // ----------------------------------------------------------------------------  48 // ERC Token Standard #20 Interface  49 // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md  50 // ----------------------------------------------------------------------------  51 interface ERC20Interface {  52     function totalSupply() external view returns (uint);  53     function balanceOf(address tokenOwner) external view returns (uint balance);  54     function allowance(address tokenOwner, address spender) external view returns (uint remaining);  55     function transfer(address to, uint tokens) external returns (bool success);  56     function approve(address spender, uint tokens) external returns (bool success);  57     function transferFrom(address from, address to, uint tokens) external returns (bool success);  58   59     event Transfer(address indexed from, address indexed to, uint tokens);  60     event Approval(address indexed tokenOwner, address indexed spender, uint tokens);  61 }  62   63   64 // ----------------------------------------------------------------------------  65 // Contract function to receive approval and execute function in one call  66 //  67 // Borrowed from MiniMeToken  68 // ----------------------------------------------------------------------------  69 interface ApproveAndCallFallBack {  70     function receiveApproval(address from, uint256 tokens, address token, bytes memory data) external;  71 }  72   73   74 // ----------------------------------------------------------------------------  75 // Owned contract  76 // ----------------------------------------------------------------------------  77 contract Owned {  78     address payable public  owner;  79     address payable public newOwner;  80   81     event OwnershipTransferred(address indexed _from, address indexed _to);  82   83     constructor() public {  84         owner = msg.sender;  85     }  86   87     modifier onlyOwner {  88         require(msg.sender == owner);  89         _;  90     }  91   92     function transferOwnership(address payable _newOwner) public onlyOwner {  93         newOwner = _newOwner;  94     }  95     function acceptOwnership() public {  96         require(msg.sender == newOwner);  97         emit OwnershipTransferred(owner, newOwner);  98         owner = newOwner;  99         newOwner = address(0); 100     } 101 } 102  103  104 // ---------------------------------------------------------------------------- 105 // ERC20 Token, with the addition of symbol, name and decimals and a 106 // fixed supply 107 // ---------------------------------------------------------------------------- 108 contract FixedSupplyToken is ERC20Interface, Owned { 109     using SafeMath for uint; 110  111     string public symbol; 112     string public  name; 113     uint8 public decimals; 114     uint _totalSupply; 115  116     mapping(address => uint) balances; 117     mapping(address => mapping(address => uint)) allowed; 118  119  120     // ------------------------------------------------------------------------ 121     // Constructor 122     // ------------------------------------------------------------------------ 123     constructor() public { 124         symbol = "FIXED"; 125         name = "Example Fixed Supply Token"; 126         decimals = 18; 127         _totalSupply = 1000000 * 10**uint(decimals); 128         balances[owner] = _totalSupply; 129         emit Transfer(address(0), owner, _totalSupply); 130     } 131  132     // ------------------------------------------------------------------------ 133     // Total supply 134     // ------------------------------------------------------------------------ 135     function totalSupply() public view virtual override returns (uint) { 136         return _totalSupply.sub(balances[address(0)]); 137     } 138  139  140     // ------------------------------------------------------------------------ 141     // Get the token balance for account `tokenOwner` 142     // ------------------------------------------------------------------------ 143     function balanceOf(address tokenOwner) public view virtual override returns (uint balance) { 144         return balances[tokenOwner]; 145     } 146  147  148     // ------------------------------------------------------------------------ 149     // Transfer the balance from token owner's account to `to` account 150     // - Owner's account must have sufficient balance to transfer 151     // - 0 value transfers are allowed 152     // ------------------------------------------------------------------------ 153     function transfer(address to, uint tokens) public virtual override returns (bool success) { 154         balances[msg.sender] = balances[msg.sender].sub(tokens); 155         balances[to] = balances[to].add(tokens); 156         emit Transfer(msg.sender, to, tokens); 157         return true; 158     } 159  160  161     // ------------------------------------------------------------------------ 162     // Token owner can approve for `spender` to transferFrom(...) `tokens` 163     // from the token owner's account 164     // 165     // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md 166     // recommends that there are no checks for the approval double-spend attack 167     // as this should be implemented in user interfaces 168     // ------------------------------------------------------------------------ 169     function approve(address spender, uint tokens) public virtual override returns (bool success) { 170         allowed[msg.sender][spender] = tokens; 171         emit Approval(msg.sender, spender, tokens); 172         return true; 173     } 174  175  176     // ------------------------------------------------------------------------ 177     // Transfer `tokens` from the `from` account to the `to` account 178     // 179     // The calling account must already have sufficient tokens approve(...)-d 180     // for spending from the `from` account and 181     // - From account must have sufficient balance to transfer 182     // - Spender must have sufficient allowance to transfer 183     // - 0 value transfers are allowed 184     // ------------------------------------------------------------------------ 185     function transferFrom(address from, address to, uint tokens) public virtual override returns (bool success) { 186         balances[from] = balances[from].sub(tokens); 187         allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens); 188         balances[to] = balances[to].add(tokens); 189         emit Transfer(from, to, tokens); 190         return true; 191     } 192  193  194     // ------------------------------------------------------------------------ 195     // Returns the amount of tokens approved by the owner that can be 196     // transferred to the spender's account 197     // ------------------------------------------------------------------------ 198     function allowance(address tokenOwner, address spender) public view virtual override returns (uint remaining) { 199         return allowed[tokenOwner][spender]; 200     } 201  202  203     // ------------------------------------------------------------------------ 204     // Token owner can approve for `spender` to transferFrom(...) `tokens` 205     // from the token owner's account. The `spender` contract function 206     // `receiveApproval(...)` is then executed 207     // ------------------------------------------------------------------------ 208     function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) { 209         allowed[msg.sender][spender] = tokens; 210         emit Approval(msg.sender, spender, tokens); 211         ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data); 212         return true; 213     } 214  215  216     // ------------------------------------------------------------------------ 217     // Don't accept ETH 218     // ------------------------------------------------------------------------ 219     fallback () external { 220         revert("Not Accepting Ether"); 221     } 222  223  224     // ------------------------------------------------------------------------ 225     // Owner can transfer out any accidentally sent ERC20 tokens 226     // ------------------------------------------------------------------------ 227     function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) { 228         return ERC20Interface(tokenAddress).transfer(owner, tokens); 229     } 230 }