Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.23;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {IWETH} from "./interfaces/IWETH.sol";
import {IWeETH} from "./interfaces/IWeETH.sol";
import {IWstETH} from "./interfaces/IWstETH.sol";
import {ISimpleStakingERC20} from "./interfaces/ISimpleStakingERC20.sol";

contract Zap {
    IWETH public immutable weth;
    IERC20 public immutable eETH;
    IERC20 public immutable stETH;
    IWeETH public immutable weETH;
    IWstETH public immutable wstETH;
    ISimpleStakingERC20 public immutable stakingContract;

    constructor(address payable _weth, address _wstETH, address _weETH, address _stakingContract) {
        weth = IWETH(_weth);
        weETH = IWeETH(_weETH);
        wstETH = IWstETH(_wstETH);
        eETH = IERC20(weETH.eETH());
        stETH = IERC20(wstETH.stETH());
        stakingContract = ISimpleStakingERC20(_stakingContract);

        eETH.approve(address(weETH), type(uint256).max);
        weth.approve(_stakingContract, type(uint256).max);
        stETH.approve(address(wstETH), type(uint256).max);
        weETH.approve(address(stakingContract), type(uint256).max);
        wstETH.approve(address(stakingContract), type(uint256).max);
    }

    function ethZapIn() external payable {
        if (msg.value == 0) revert ISimpleStakingERC20.AMOUNT_NULL();
        // Wrap ETH to wETH
        weth.deposit{value: msg.value}();

        // Deposit wETH to staking contract
        stakingContract.deposit(IERC20(address(weth)), msg.value, msg.sender);
    }

    function stETHZapIn(uint256 _amount) external {
        if (_amount == 0) revert ISimpleStakingERC20.AMOUNT_NULL();
        // Transfer stETH from msg.sender to this contract, sometimes 1 or 2 wei can be missing.
        stETH.transferFrom(msg.sender, address(this), _amount);

        // Deposit wstETH to staking contract
        stakingContract.deposit(IERC20(address(wstETH)), wstETH.wrap(stETH.balanceOf(address(this))), msg.sender);
    }

    function eETHZapIn(uint256 _amount) external {
        if (_amount == 0) revert ISimpleStakingERC20.AMOUNT_NULL();
        // Transfer eETH from msg.sender to this contract, sometimes 1 or 2 wei can be missing.
        eETH.transferFrom(msg.sender, address(this), _amount);

        // Deposit eETH to staking contract
        stakingContract.deposit(IERC20(address(weETH)), weETH.wrap(eETH.balanceOf(address(this))), msg.sender);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.23;

interface IWETH {
    function deposit() external payable;

    function withdraw(uint256) external;

    function approve(address, uint256) external returns (bool);

    function transfer(address, uint256) external returns (bool);

    function transferFrom(address, address, uint256) external returns (bool);

    function balanceOf(address) external view returns (uint256);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.23;

interface IWeETH {
    function approve(address _spender, uint256 _amount) external returns (bool);
    function eETH() external view returns (address);
    function liquidityPool() external view returns (address);
    function wrap(uint256 _stETHAmount) external returns (uint256);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.23;

interface IWstETH {
    function approve(address _spender, uint256 _amount) external returns (bool);
    function getWstETHByStETH(uint256 _stETHAmount) external view returns (uint256);
    function stETH() external view returns (address);
    function wrap(uint256 _stETHAmount) external returns (uint256);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.23;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface ISimpleStakingERC20 {
    /// @notice Struct to hold the supported booleans
    /// @param deposit true if deposit is supported
    /// @param withdraw true if withdraw is supported
    struct Supported {
        bool deposit;
        bool withdraw;
    }

    /// @notice Error emitted when the amount is null
    error AMOUNT_NULL();

    /// @notice Error emitted when the address is null
    error ADDRESS_NULL();

    /// @notice Error emitted when the balance is insufficient
    error INSUFFICIENT_BALANCE();

    /// @notice Error emitted when the token is not allowed
    error TOKEN_NOT_ALLOWED(IERC20 token);

    /// @notice Event emitted when a token is added or removed
    /// @param token address of the token
    /// @param supported struct with deposit and withdraw booleans
    event SupportedToken(IERC20 indexed token, Supported supported);

    /// @notice Event emitted when a deposit is made
    /// @param token address of the token
    /// @param staker address of the staker
    /// @param amount amount of the deposit
    event Deposit(IERC20 indexed token, address indexed staker, uint256 amount);

    /// @notice Event emitted when a withdrawal is made
    /// @param token address of the token
    /// @param staker address of the staker
    /// @param amount amount of the withdrawal
    event Withdraw(IERC20 indexed token, address indexed staker, uint256 amount);

    /// @notice Method to deposit tokens
    /// @dev token are transferred from the sender, and the receiver is credited
    /// @param _token address of the token
    /// @param _amount amount to deposit
    /// @param _receiver address of the receiver
    function deposit(IERC20 _token, uint256 _amount, address _receiver) external;

    /// @notice Method to rescue tokens, only callable by the owner
    /// @dev difference between balance and internal balance is transferred to the owner
    /// @param _token address of the token
    function rescueERC20(IERC20 _token) external;

    /// @notice Method to add or remove a token
    /// @dev only callable by the owner
    /// @param _token address of the token
    /// @param _supported struct with deposit and withdraw booleans
    function supportToken(IERC20 _token, Supported calldata _supported) external;

    /// @notice Method to rescue tokens, only callable by the owner
    /// @dev token are transferred to the receiver and sender is credited
    /// @param _token address of the token
    /// @param _amount amount to withdraw
    /// @param _receiver address of the receiver
    function withdraw(IERC20 _token, uint256 _amount, address _receiver) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}