WETH-230928-121007.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;

contract WETH {
    string public name    = "Wrapped Ether";
    string public symbol  = "WETH";
    uint8 public decimals = 18;
    uint256 public constant maxInt = type(uint256).max;

    event LogDeposit(address _src, uint _amount);
    event LogWithdraw(address _src, uint _amount);
    event LogApproved(address _sender, address _receiver, uint _amount);
    event LogTransfer(address _src, address _dst, uint _amount);

    mapping (address => uint)                       public balanceOf;
    mapping (address => mapping (address => uint))  public allowance;

    constructor() {}

    function deposit() public payable {
        balanceOf[msg.sender] += msg.value;
        emit LogDeposit(msg.sender, msg.value);
    }

    function withdraw(uint _amount) public {
        require(balanceOf[msg.sender] >= _amount, "not enough funds!");
        balanceOf[msg.sender] -= _amount;

        payable(msg.sender).transfer(_amount);

        emit LogWithdraw(msg.sender, _amount);
    }

    function totalSupply() public view returns(uint) {
        return address(this).balance;
    }

    function approve(address _account, uint _amount) public returns(bool) {
        allowance[msg.sender][_account] = _amount;
        emit LogApproved(msg.sender, _account, _amount);

        return true;
    }

    function transfer(address _dst, uint _amount) public returns (bool){
        return transferFrom(msg.sender, _dst, _amount);
    }

    function transferFrom(address _src, address _dst, uint _amount) public returns (bool){
        require(balanceOf[_src] >= _amount, "not enough funds!");

        if(_src != msg.sender && allowance[_src][msg.sender] != maxInt) {
            require(allowance[_src][msg.sender] >= _amount, "not enough allowance");
            allowance[_src][msg.sender] -= _amount;
        }

        balanceOf[_src] -= _amount;
        balanceOf[_dst] += _amount;

        emit LogTransfer(_src, _dst, _amount);
        return true;
    }
}