Trending Blockchain
for Token Development

																																										
                                                                                                                                                                              // SPDX-License-Identifier: MIT
    pragma solidity ^
                                                                                                                
                                                                                                                                                                              0.8.
                                                                                                                
                                                                                                                                                                              0;
    
    contract ERC20Token {
        
                                                                                                                
                                                                                                                                                                              string
                                                                                                                                                                              public name = 
                                                                                                                
                                                                                                                                                                              "MyToken";
        
                                                                                                                
                                                                                                                                                                              string
                                                                                                                                                                              public symbol = 
                                                                                                                
                                                                                                                                                                              "MTK";
        uint8 
                                                                                                                
                                                                                                                                                                              public decimals = 
                                                                                                                
                                                                                                                                                                              18;
        uint256 
                                                                                                                
                                                                                                                                                                              public totalSupply = 
                                                                                                                
                                                                                                                                                                              1000000 * (
                                                                                                                
                                                                                                                                                                              10 ** 
                                                                                                                
                                                                                                                                                                              uint256(decimals));
    
        
                                                                                                                
                                                                                                                                                                              mapping(address => uint256) 
                                                                                                                
                                                                                                                                                                              public balanceOf;
        
                                                                                                                
                                                                                                                                                                              mapping(address => 
                                                                                                                
                                                                                                                                                                              mapping(address => uint256)) 
                                                                                                                
                                                                                                                                                                              public allowance;
    
        event 
                                                                                                                
                                                                                                                                                                              Transfer(address indexed 
                                                                                                                
                                                                                                                                                                              from, address indexed to, uint256 value);
        event 
                                                                                                                
                                                                                                                                                                              Approval(address indexed owner, address indexed spender, uint256 value);
    
        
                                                                                                                
                                                                                                                                                                              constructor() {
            balanceOf[msg.sender] = totalSupply;
        }
    
        
                                                                                                                
                                                                                                                                                                              
                                                                                                                                                                                  function
                                                                                                                                                                                  transfer(
                                                                                                                    
                                                                                                                                                                                  address to, uint256 value) 
                                                                                                                    
                                                                                                                                                                                  external
                                                                                                                                                                                  returns (
                                                                                                                    
                                                                                                                                                                                  
                                                                                                                                                                                      bool success
                                                                                                                    
                                                                                                                                                                                  ) 
                                                                                                                
                                                                                                                                                                              {
            
                                                                                                                
                                                                                                                                                                              require(to != 
                                                                                                                
                                                                                                                                                                              address(
                                                                                                                
                                                                                                                                                                              0), 
                                                                                                                
                                                                                                                                                                              "Invalid address");
            
                                                                                                                
                                                                                                                                                                              require(balanceOf[msg.sender] >= value, 
                                                                                                                
                                                                                                                                                                              "Insufficient balance");
    
            balanceOf[msg.sender] -= value;
            balanceOf[to] += value;
            emit 
                                                                                                                
                                                                                                                                                                              Transfer(msg.sender, to, value);
    
            
                                                                                                                
                                                                                                                                                                              return
                                                                                                                                                                              true;
        }
    
        
                                                                                                                
                                                                                                                                                                              
                                                                                                                                                                                  function
                                                                                                                                                                                  approve(
                                                                                                                    
                                                                                                                                                                                  address spender, uint256 value) 
                                                                                                                    
                                                                                                                                                                                  external
                                                                                                                                                                                  returns (
                                                                                                                    
                                                                                                                                                                                  
                                                                                                                                                                                      bool success
                                                                                                                    
                                                                                                                                                                                  ) 
                                                                                                                
                                                                                                                                                                              {
            allowance[msg.sender][spender] = value;
            emit 
                                                                                                                
                                                                                                                                                                              Approval(msg.sender, spender, value);
            
                                                                                                                
                                                                                                                                                                              return
                                                                                                                                                                              true;
        }
    
        
                                                                                                                
                                                                                                                                                                              
                                                                                                                                                                                  function
                                                                                                                                                                                  transferFrom(
                                                                                                                    
                                                                                                                                                                                  address 
                                                                                                                        
                                                                                                                                                                                      from, address to, uint256 value
                                                                                                                    
                                                                                                                                                                                  ) 
                                                                                                                    
                                                                                                                                                                                  external
                                                                                                                                                                                  returns (
                                                                                                                    
                                                                                                                                                                                  
                                                                                                                                                                                      bool success
                                                                                                                    
                                                                                                                                                                                  ) 
                                                                                                                
                                                                                                                                                                              {
            
                                                                                                                
                                                                                                                                                                              require(
                                                                                                                
                                                                                                                                                                              from != 
                                                                                                                
                                                                                                                                                                              address(
                                                                                                                
                                                                                                                                                                              0), 
                                                                                                                
                                                                                                                                                                              "Invalid address");
            
                                                                                                                
                                                                                                                                                                              require(to != 
                                                                                                                
                                                                                                                                                                              address(
                                                                                                                
                                                                                                                                                                              0), 
                                                                                                                
                                                                                                                                                                              "Invalid address");
            
                                                                                                                
                                                                                                                                                                              require(balanceOf[
                                                                                                                
                                                                                                                                                                              from] >= value, 
                                                                                                                
                                                                                                                                                                              "Insufficient balance");
            
                                                                                                                
                                                                                                                                                                              require(allowance[
                                                                                                                
                                                                                                                                                                              from][msg.sender] >= value, 
                                                                                                                
                                                                                                                                                                              "Allowance exceeded");
    
            balanceOf[
                                                                                                                
                                                                                                                                                                              from] -= value;
            balanceOf[to] += value;
            allowance[
                                                                                                                
                                                                                                                                                                              from][msg.sender] -= value;
            emit 
                                                                                                                
                                                                                                                                                                              Transfer(
                                                                                                                
                                                                                                                                                                              from, to, value);
    
            
                                                                                                                
                                                                                                                                                                              return
                                                                                                                                                                              true;
        }
    }