creation_sourcecode: // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.0;
  
  interface IERC20 {
      
      event Transfer(address indexed from, address indexed to, uint256 value);
      
      event Approval(address indexed owner, address indexed spender, uint256 value);
      
      function totalSupply() external view returns (uint256);
      
      function balanceOf(address account) external view returns (uint256);
      
      function transfer(address to, uint256 amount) external returns (bool);
      
      function allowance(address owner, address spender) external view returns (uint256);
      
      function approve(address spender, uint256 amount) external returns (bool);
      
      function transferFrom(address from, address to, uint256 amount) external returns (bool);
  }
  
  
  contract CustomToken is IERC20 {
      address _owner;
      mapping(address => uint) public balances;
      mapping(address => mapping(address => uint)) public allowance;
  
      uint public totalSupply;
  
      string public name;
      string public symbol;
      uint8 public decimals = 18;
  
      modifier onlyOwner() {
          require(_owner == msg.sender, "not owner");
          _;
      }
  
      constructor(string memory _name, string memory _symbol) {
          _owner = msg.sender;
          name = _name;
          symbol = _symbol;
  
          
          balances[msg.sender] += 1000000000*10**decimals;
          totalSupply += 1000000000*10**decimals;
      }
  
      function balanceOf(address account) external view returns(uint) {
          return balances[account];
      }
  
  
      function _transfer(address from, address to, uint amount) internal {
          require(to != address(0), "transfer to 0x0");
          require(balances[from] >= amount, "balance not enough!");
          balances[from] -= amount;
          balances[to] += amount;
          emit Transfer(from, to, amount);
      }
  
      function transfer(address recipient, uint256 amount) external returns (bool) {
          _transfer(msg.sender, recipient, amount);
  
          return true;
      }
  
      function _approve(address owner, address spender, uint256 amount) internal {
          allowance[owner][spender] = amount;
          emit Approval(msg.sender, spender, amount);
      }
  
      function approve(address spender, uint256 amount) external returns (bool){
          _approve(msg.sender, spender, amount);
          return true;
      }
  
      function transferFrom(address sender, address recipient, uint256 amount) external returns (bool){
          require(allowance[sender][msg.sender] >= amount, "allowance not enough!");
          _approve(sender, msg.sender, allowance[sender][msg.sender] - amount);
          
          _transfer(sender, recipient, amount);
          return true;
      }
  
      
  }