erc20 token.txt

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

abstract contract ERC20_STD{
    // ONly Name : Symbols : Decimals
    function name() public view virtual returns (string memory);

    function symbol() public view virtual returns (string memory);

    function decimals() public view virtual returns (uint8);




    function totalSupply() public view virtual returns (uint256);

    function balanceOf(address _owner) public view virtual returns (uint256 balance);

    function transfer(address _to, uint256 _value) public virtual returns (bool success);
    
    function transferFrom(address _from, address _to, uint256 _value) public virtual returns (bool success);
    
    function approve(address _spender, uint256 _value) public virtual returns (bool success);
    
    function allowance(address _owner, address _spender) public view virtual returns (uint256 remaining);


    // EVENTS
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);


}

contract OwnerShip{
    address public ContractOwner;
    address public newOwner;

    event TransferOwnerShip(address indexed _from,address indexed _to);

    constructor(){
        ContractOwner=msg.sender;
    }

    function changeOwner(address _to) public{
        require(msg.sender== ContractOwner,"only Ownwer of Contract can Execute it.........");
        newOwner=_to;
    }

    function   acceptOwner() public{
        require(msg.sender==newOwner,"only owner can access this ");
        emit TransferOwnerShip(ContractOwner,newOwner);
        ContractOwner== newOwner;
        newOwner= address(0);
    }
}

contract MYERC20 is ERC20_STD,OwnerShip{

    string public _name;
    string public _symbol;
    uint8 public _decimals;
    uint256 public _totalSupply;

    // Minter 
    address public _minter;

    mapping (address=>uint256) toeknBalances;

    mapping(address=>mapping(address=>uint256)) allowed;

    constructor(address minter_){
        _name="yazib";
        _symbol="YY";
        _totalSupply=1000000;
        _minter=minter_;

        toeknBalances[_minter]=_totalSupply;
    }


    function name() public view override returns (string memory){
        return _name;
    }

    function symbol() public view override returns (string memory){
        return _symbol;
    }

    function decimals() public view override returns (uint8){
        return _decimals;
    }


    function totalSupply() public view override returns (uint256){
        return _totalSupply;
    }


    function balanceOf(address _owner) public view override returns (uint256 balance){
            return toeknBalances[_owner];
    }

    function transfer(address _to, uint256 _value) public override returns (bool success){
        require(toeknBalances[msg.sender]>=_value,"insufficient Balance !!!");
        toeknBalances[msg.sender] -=_value;
        toeknBalances[_to] +=_value;
        emit Transfer(msg.sender,_to,_value);
        return true;
    }
    
    function transferFrom(address _from, address _to, uint256 _value) public override returns (bool success){
        uint256 allowedBal= allowed[_from][msg.sender];
        require(allowedBal>=_value,"Insuffcient Balance");
        toeknBalances[_from] -=_value;
        toeknBalances[_to] +=_value;

        emit Transfer(_from,_to,_value);
        return true;


    }
    
    function approve(address _spender, uint256 _value) public override returns (bool success){
        require(toeknBalances[msg.sender]>=_value,"insufficient Balance !!!");
        allowed[msg.sender][_spender]= _value;
        emit Approval(msg.sender,_spender,_value);
        return true;

    }
    
    function allowance(address _owner, address _spender) public view override returns (uint256 remaining){
        return allowed[_owner][_spender];
    }


}