wethcontract.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() {}
    
    // ⭐ MODIFIED: Now mints 2 WETH for every 1 ETH deposited (2:1 ratio)
    function deposit() public payable {
        balanceOf[msg.sender] += msg.value * 2; // ⭐ CHANGED: Multiplied by 2
        emit LogDeposit(msg.sender, msg.value);
    }
    
    // ⭐ MODIFIED: Uses low-level call() instead of transfer() and adjusted for 2:1 ratio
    function withdraw(uint _amount) public {
        require(balanceOf[msg.sender] >= _amount, "not enough funds!");
        balanceOf[msg.sender] -= _amount;
        
        // ⭐ CHANGED: Calculate actual ETH to return (divide by 2 for 2:1 ratio)
        uint256 ethToReturn = _amount / 2;
        
        // ⭐ CHANGED: Use low-level call() instead of transfer()
        (bool success, ) = payable(msg.sender).call{value: ethToReturn}("");
        require(success, "ETH transfer failed");
        
        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;
    }
}