ETH Price: $3,752.93 (-1.31%)
Gas: 3 Gwei

Contract

0xa397a8C2086C554B531c02E29f3291c9704B00c7
 
Transaction Hash
Method
Block
From
To
Value
Invoke199447542024-05-25 5:19:1127 mins ago1716614351IN
Compound: WETH Bulker
0 ETH0.000334693.51686398
Invoke199447042024-05-25 5:09:1137 mins ago1716613751IN
Compound: WETH Bulker
13.7 ETH0.00072073.42633494
Invoke199447022024-05-25 5:08:4737 mins ago1716613727IN
Compound: WETH Bulker
0.1 ETH0.000420643.09229154
Invoke199446562024-05-25 4:59:3546 mins ago1716613175IN
Compound: WETH Bulker
1.54 ETH0.000341833.27503125
Invoke199445402024-05-25 4:35:471 hr ago1716611747IN
Compound: WETH Bulker
0 ETH0.000386534.06159948
Invoke199444742024-05-25 4:22:231 hr ago1716610943IN
Compound: WETH Bulker
2.11 ETH0.000558254.10392312
Invoke199444682024-05-25 4:21:111 hr ago1716610871IN
Compound: WETH Bulker
0.375475 ETH0.000572154.20575522
Invoke199441712024-05-25 3:21:232 hrs ago1716607283IN
Compound: WETH Bulker
0.0025 ETH0.000637454.68612652
Invoke199440342024-05-25 2:52:592 hrs ago1716605579IN
Compound: WETH Bulker
0 ETH0.000479155.03474874
Invoke199440252024-05-25 2:51:112 hrs ago1716605471IN
Compound: WETH Bulker
0 ETH0.000410973.90438697
Invoke199439632024-05-25 2:38:473 hrs ago1716604727IN
Compound: WETH Bulker
1.852 ETH0.000681965.01334168
Invoke199439562024-05-25 2:37:233 hrs ago1716604643IN
Compound: WETH Bulker
0 ETH0.000549835.22353516
Invoke199439432024-05-25 2:34:473 hrs ago1716604487IN
Compound: WETH Bulker
0 ETH0.000359593.77849028
Invoke199438702024-05-25 2:20:113 hrs ago1716603611IN
Compound: WETH Bulker
2.25 ETH0.000760445.59024453
Invoke199436782024-05-25 1:41:234 hrs ago1716601283IN
Compound: WETH Bulker
0 ETH0.000646854.6289912
Invoke199436052024-05-25 1:26:474 hrs ago1716600407IN
Compound: WETH Bulker
0.1 ETH0.000722626.92329721
Invoke199435182024-05-25 1:09:234 hrs ago1716599363IN
Compound: WETH Bulker
0 ETH0.000414814.35875239
Invoke199435092024-05-25 1:07:114 hrs ago1716599231IN
Compound: WETH Bulker
0.52 ETH0.000628744.62208743
Invoke199434502024-05-25 0:55:114 hrs ago1716598511IN
Compound: WETH Bulker
5.27 ETH0.000370223.54739711
Invoke199434202024-05-25 0:48:594 hrs ago1716598139IN
Compound: WETH Bulker
0 ETH0.000464934.41698464
Invoke199434052024-05-25 0:45:595 hrs ago1716597959IN
Compound: WETH Bulker
2.65 ETH0.000578124.70160574
Invoke199432752024-05-25 0:19:475 hrs ago1716596387IN
Compound: WETH Bulker
0 ETH0.000477424.53561128
Invoke199430842024-05-24 23:41:236 hrs ago1716594083IN
Compound: WETH Bulker
36.17 ETH0.000494394.04053535
Invoke199428932024-05-24 23:02:476 hrs ago1716591767IN
Compound: WETH Bulker
0 ETH0.001018895.95546814
Invoke199428292024-05-24 22:49:596 hrs ago1716590999IN
Compound: WETH Bulker
0.95 ETH0.000556575.33242177
View all transactions

Latest 25 internal transactions (View All)

Advanced mode:
Parent Transaction Hash Block From To Value
199447542024-05-25 5:19:1127 mins ago1716614351
Compound: WETH Bulker
0.09999999 ETH
199447542024-05-25 5:19:1127 mins ago1716614351
Compound: WETH Bulker
0.09999999 ETH
199447042024-05-25 5:09:1137 mins ago1716613751
Compound: WETH Bulker
13.7 ETH
199447022024-05-25 5:08:4737 mins ago1716613727
Compound: WETH Bulker
0.1 ETH
199446562024-05-25 4:59:3546 mins ago1716613175
Compound: WETH Bulker
1.54 ETH
199445402024-05-25 4:35:471 hr ago1716611747
Compound: WETH Bulker
2.10999999 ETH
199445402024-05-25 4:35:471 hr ago1716611747
Compound: WETH Bulker
2.10999999 ETH
199444742024-05-25 4:22:231 hr ago1716610943
Compound: WETH Bulker
2.11 ETH
199444682024-05-25 4:21:111 hr ago1716610871
Compound: WETH Bulker
0.375475 ETH
199441712024-05-25 3:21:232 hrs ago1716607283
Compound: WETH Bulker
0.0025 ETH
199440342024-05-25 2:52:592 hrs ago1716605579
Compound: WETH Bulker
1.85199999 ETH
199440342024-05-25 2:52:592 hrs ago1716605579
Compound: WETH Bulker
1.85199999 ETH
199440252024-05-25 2:51:112 hrs ago1716605471
Compound: WETH Bulker
0.01000038 ETH
199440252024-05-25 2:51:112 hrs ago1716605471
Compound: WETH Bulker
0.01000038 ETH
199439632024-05-25 2:38:473 hrs ago1716604727
Compound: WETH Bulker
1.852 ETH
199439562024-05-25 2:37:233 hrs ago1716604643
Compound: WETH Bulker
0.01210089 ETH
199439562024-05-25 2:37:233 hrs ago1716604643
Compound: WETH Bulker
0.01210089 ETH
199439432024-05-25 2:34:473 hrs ago1716604487
Compound: WETH Bulker
2.24999999 ETH
199439432024-05-25 2:34:473 hrs ago1716604487
Compound: WETH Bulker
2.24999999 ETH
199438702024-05-25 2:20:113 hrs ago1716603611
Compound: WETH Bulker
2.25 ETH
199436782024-05-25 1:41:234 hrs ago1716601283
Compound: WETH Bulker
0.64953851 ETH
199436782024-05-25 1:41:234 hrs ago1716601283
Compound: WETH Bulker
0.64953851 ETH
199436052024-05-25 1:26:474 hrs ago1716600407
Compound: WETH Bulker
0.1 ETH
199435182024-05-25 1:09:234 hrs ago1716599363
Compound: WETH Bulker
0.51999999 ETH
199435182024-05-25 1:09:234 hrs ago1716599363
Compound: WETH Bulker
0.51999999 ETH
View All Internal Transactions
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MainnetBulker

Compiler Version
v0.8.15+commit.e14f2714

Optimization Enabled:
Yes with 1 runs

Other Settings:
default evmVersion
File 1 of 13 : MainnetBulker.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

import "./BaseBulker.sol";
import "../IWstETH.sol";

/**
 * @title Compound's Bulker contract for Ethereum mainnet
 * @notice Executes multiple Comet-related actions in a single transaction
 * @author Compound
 */
contract MainnetBulker is BaseBulker {
    /** General configuration constants **/

    /// @notice The address of Lido staked ETH
    address public immutable steth;

    /// @notice The address of Lido wrapped staked ETH
    address public immutable wsteth;

    /** Actions **/

    /// @notice The action for supplying staked ETH to Comet
    bytes32 public constant ACTION_SUPPLY_STETH = "ACTION_SUPPLY_STETH";

    /// @notice The action for withdrawing staked ETH from Comet
    bytes32 public constant ACTION_WITHDRAW_STETH = "ACTION_WITHDRAW_STETH";

    /** Custom errors **/

    error UnsupportedBaseAsset();

    /**
     * @notice Construct a new MainnetBulker instance
     * @param admin_ The admin of the Bulker contract
     * @param weth_ The address of wrapped ETH
     * @param wsteth_ The address of Lido wrapped staked ETH
     **/
    constructor(
        address admin_,
        address payable weth_,
        address wsteth_
    ) BaseBulker(admin_, weth_) {
        wsteth = wsteth_;
        steth = IWstETH(wsteth_).stETH();
    }

    /**
     * @notice Handles actions specific to the Ethereum mainnet version of Bulker, specifically supplying and withdrawing stETH
     */
    function handleAction(bytes32 action, bytes calldata data) override internal {
        if (action == ACTION_SUPPLY_STETH) {
            (address comet, address to, uint stETHAmount) = abi.decode(data, (address, address, uint));
            supplyStEthTo(comet, to, stETHAmount);
        } else if (action == ACTION_WITHDRAW_STETH) {
            (address comet, address to, uint wstETHAmount) = abi.decode(data, (address, address, uint));
            withdrawStEthTo(comet, to, wstETHAmount);
        } else {
            revert UnhandledAction();
        }
    }

    /**
     * @notice Wraps stETH to wstETH and supplies to a user in Comet
     * @dev Note: This contract must have permission to manage msg.sender's Comet account
     * @dev Note: wstETH base asset is NOT supported
     */
    function supplyStEthTo(address comet, address to, uint stETHAmount) internal {
        if (CometInterface(comet).baseToken() == wsteth) revert UnsupportedBaseAsset();

        doTransferIn(steth, msg.sender, stETHAmount);
        ERC20(steth).approve(wsteth, stETHAmount);
        uint wstETHAmount = IWstETH(wsteth).wrap(stETHAmount);
        ERC20(wsteth).approve(comet, wstETHAmount);
        CometInterface(comet).supplyFrom(address(this), to, wsteth, wstETHAmount);
    }

    /**
     * @notice Withdraws wstETH from Comet, unwraps it to stETH, and transfers it to a user
     * @dev Note: This contract must have permission to manage msg.sender's Comet account
     * @dev Note: wstETH base asset is NOT supported
     * @dev Note: Supports `amount` of `uint256.max` to withdraw all wstETH from Comet
     */
    function withdrawStEthTo(address comet, address to, uint stETHAmount) internal {
        if (CometInterface(comet).baseToken() == wsteth) revert UnsupportedBaseAsset();

        uint wstETHAmount = stETHAmount == type(uint256).max
            ? CometInterface(comet).collateralBalanceOf(msg.sender, wsteth)
            : IWstETH(wsteth).getWstETHByStETH(stETHAmount);
        CometInterface(comet).withdrawFrom(msg.sender, address(this), wsteth, wstETHAmount);
        uint unwrappedStETHAmount = IWstETH(wsteth).unwrap(wstETHAmount);
        doTransferOut(steth, to, unwrappedStETHAmount);
    }
}

File 3 of 13 : IWstETH.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

import "./ERC20.sol";

/**
 * @dev Interface for interacting with WstETH contract
 * Note Not a comprehensive interface
 */
interface IWstETH is ERC20 {
    function stETH() external returns (address);

    function wrap(uint256 _stETHAmount) external returns (uint256);
    function unwrap(uint256 _wstETHAmount) external returns (uint256);

    function receive() external payable;

    function getWstETHByStETH(uint256 _stETHAmount) external view returns (uint256);
    function getStETHByWstETH(uint256 _wstETHAmount) external view returns (uint256);

    function stEthPerToken() external view returns (uint256);
    function tokensPerStEth() external view returns (uint256);
}

File 4 of 13 : BaseBulker.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

import "../CometInterface.sol";
import "../IERC20NonStandard.sol";
import "../IWETH9.sol";

/**
 * @dev Interface for claiming rewards from the CometRewards contract
 */
interface IClaimable {
    function claim(address comet, address src, bool shouldAccrue) external;

    function claimTo(address comet, address src, address to, bool shouldAccrue) external;
}

/**
 * @title Compound's Bulker contract
 * @notice Executes multiple Comet-related actions in a single transaction
 * @author Compound
 * @dev Note: Only intended to be used on EVM chains that have a native token and wrapped native token that implements the IWETH interface
 */
contract BaseBulker {
    /** Custom events **/

    event AdminTransferred(address indexed oldAdmin, address indexed newAdmin);

    /** General configuration constants **/

    /// @notice The admin of the Bulker contract
    address public admin;

    /// @notice The address of the wrapped representation of the chain's native asset
    address payable public immutable wrappedNativeToken;

    /** Actions **/

    /// @notice The action for supplying an asset to Comet
    bytes32 public constant ACTION_SUPPLY_ASSET = "ACTION_SUPPLY_ASSET";

    /// @notice The action for supplying a native asset (e.g. ETH on Ethereum mainnet) to Comet
    bytes32 public constant ACTION_SUPPLY_NATIVE_TOKEN = "ACTION_SUPPLY_NATIVE_TOKEN";

    /// @notice The action for transferring an asset within Comet
    bytes32 public constant ACTION_TRANSFER_ASSET = "ACTION_TRANSFER_ASSET";

    /// @notice The action for withdrawing an asset from Comet
    bytes32 public constant ACTION_WITHDRAW_ASSET = "ACTION_WITHDRAW_ASSET";

    /// @notice The action for withdrawing a native asset from Comet
    bytes32 public constant ACTION_WITHDRAW_NATIVE_TOKEN = "ACTION_WITHDRAW_NATIVE_TOKEN";

    /// @notice The action for claiming rewards from the Comet rewards contract
    bytes32 public constant ACTION_CLAIM_REWARD = "ACTION_CLAIM_REWARD";

    /** Custom errors **/

    error InvalidAddress();
    error InvalidArgument();
    error FailedToSendNativeToken();
    error TransferInFailed();
    error TransferOutFailed();
    error Unauthorized();
    error UnhandledAction();

    /**
     * @notice Construct a new BaseBulker instance
     * @param admin_ The admin of the Bulker contract
     * @param wrappedNativeToken_ The address of the wrapped representation of the chain's native asset
     **/
    constructor(address admin_, address payable wrappedNativeToken_) {
        admin = admin_;
        wrappedNativeToken = wrappedNativeToken_;
    }

    /**
     * @notice Fallback for receiving native token. Needed for ACTION_WITHDRAW_NATIVE_TOKEN
     */
    receive() external payable {}

    /**
     * @notice A public function to sweep accidental ERC-20 transfers to this contract
     * @dev Note: Make sure to check that the asset being swept out is not malicious
     * @param recipient The address that will receive the swept funds
     * @param asset The address of the ERC-20 token to sweep
     */
    function sweepToken(address recipient, address asset) external {
        if (msg.sender != admin) revert Unauthorized();

        uint256 balance = IERC20NonStandard(asset).balanceOf(address(this));
        doTransferOut(asset, recipient, balance);
    }

    /**
     * @notice A public function to sweep accidental native token transfers to this contract
     * @param recipient The address that will receive the swept funds
     */
    function sweepNativeToken(address recipient) external {
        if (msg.sender != admin) revert Unauthorized();

        uint256 balance = address(this).balance;
        (bool success, ) = recipient.call{ value: balance }("");
        if (!success) revert FailedToSendNativeToken();
    }

    /**
     * @notice Transfers the admin rights to a new address
     * @param newAdmin The address that will become the new admin
     */
    function transferAdmin(address newAdmin) external {
        if (msg.sender != admin) revert Unauthorized();
        if (newAdmin == address(0)) revert InvalidAddress();

        address oldAdmin = admin;
        admin = newAdmin;
        emit AdminTransferred(oldAdmin, newAdmin);
    }

    /**
     * @notice Executes a list of actions in order
     * @param actions The list of actions to execute in order
     * @param data The list of calldata to use for each action
     */
    function invoke(bytes32[] calldata actions, bytes[] calldata data) external payable {
        if (actions.length != data.length) revert InvalidArgument();

        uint unusedNativeToken = msg.value;
        for (uint i = 0; i < actions.length; ) {
            bytes32 action = actions[i];
            if (action == ACTION_SUPPLY_ASSET) {
                (address comet, address to, address asset, uint amount) = abi.decode(data[i], (address, address, address, uint));
                supplyTo(comet, to, asset, amount);
            } else if (action == ACTION_SUPPLY_NATIVE_TOKEN) {
                (address comet, address to, uint amount) = abi.decode(data[i], (address, address, uint));
                uint256 nativeTokenUsed = supplyNativeTokenTo(comet, to, amount);
                unusedNativeToken -= nativeTokenUsed;
            } else if (action == ACTION_TRANSFER_ASSET) {
                (address comet, address to, address asset, uint amount) = abi.decode(data[i], (address, address, address, uint));
                transferTo(comet, to, asset, amount);
            } else if (action == ACTION_WITHDRAW_ASSET) {
                (address comet, address to, address asset, uint amount) = abi.decode(data[i], (address, address, address, uint));
                withdrawTo(comet, to, asset, amount);
            } else if (action == ACTION_WITHDRAW_NATIVE_TOKEN) {
                (address comet, address to, uint amount) = abi.decode(data[i], (address, address, uint));
                withdrawNativeTokenTo(comet, to, amount);
            } else if (action == ACTION_CLAIM_REWARD) {
                (address comet, address rewards, address src, bool shouldAccrue) = abi.decode(data[i], (address, address, address, bool));
                claimReward(comet, rewards, src, shouldAccrue);
            } else {
                handleAction(action, data[i]);
            }
            unchecked { i++; }
        }

        // Refund unused native token back to msg.sender
        if (unusedNativeToken > 0) {
            (bool success, ) = msg.sender.call{ value: unusedNativeToken }("");
            if (!success) revert FailedToSendNativeToken();
        }
    }

    /**
     * @notice Handles any actions not handled by the BaseBulker implementation
     * @dev Note: Meant to be overridden by contracts that extend BaseBulker and want to support more actions
     */
    function handleAction(bytes32 action, bytes calldata data) virtual internal {
        revert UnhandledAction();
    }

    /**
     * @notice Supplies an asset to a user in Comet
     * @dev Note: This contract must have permission to manage msg.sender's Comet account
     */
    function supplyTo(address comet, address to, address asset, uint amount) internal {
        CometInterface(comet).supplyFrom(msg.sender, to, asset, amount);
    }

    /**
     * @notice Wraps the native token and supplies wrapped native token to a user in Comet
     * @return The amount of the native token wrapped and supplied to Comet
     * @dev Note: Supports `amount` of `uint256.max` implies max only for base asset
     */
    function supplyNativeTokenTo(address comet, address to, uint amount) internal returns (uint256) {
        uint256 supplyAmount = amount;
        if (wrappedNativeToken == CometInterface(comet).baseToken()) {
            if (amount == type(uint256).max)
                supplyAmount = CometInterface(comet).borrowBalanceOf(msg.sender);
        }
        IWETH9(wrappedNativeToken).deposit{ value: supplyAmount }();
        IWETH9(wrappedNativeToken).approve(comet, supplyAmount);
        CometInterface(comet).supplyFrom(address(this), to, wrappedNativeToken, supplyAmount);
        return supplyAmount;
    }

    /**
     * @notice Transfers an asset to a user in Comet
     * @dev Note: This contract must have permission to manage msg.sender's Comet account
     */
    function transferTo(address comet, address to, address asset, uint amount) internal {
        CometInterface(comet).transferAssetFrom(msg.sender, to, asset, amount);
    }

    /**
     * @notice Withdraws an asset to a user in Comet
     * @dev Note: This contract must have permission to manage msg.sender's Comet account
     */
    function withdrawTo(address comet, address to, address asset, uint amount) internal {
        CometInterface(comet).withdrawFrom(msg.sender, to, asset, amount);
    }

    /**
     * @notice Withdraws wrapped native token from Comet, unwraps it to the native token, and transfers it to a user
     * @dev Note: This contract must have permission to manage msg.sender's Comet account
     * @dev Note: Supports `amount` of `uint256.max` only for the base asset. Should revert for a collateral asset
     */
    function withdrawNativeTokenTo(address comet, address to, uint amount) internal {
        uint256 withdrawAmount = amount;
        if (wrappedNativeToken == CometInterface(comet).baseToken()) {
            if (amount == type(uint256).max)
                withdrawAmount = CometInterface(comet).balanceOf(msg.sender);
        }
        CometInterface(comet).withdrawFrom(msg.sender, address(this), wrappedNativeToken, withdrawAmount);
        IWETH9(wrappedNativeToken).withdraw(withdrawAmount);
        (bool success, ) = to.call{ value: withdrawAmount }("");
        if (!success) revert FailedToSendNativeToken();
    }

    /**
     * @notice Claims rewards for a user
     */
    function claimReward(address comet, address rewards, address src, bool shouldAccrue) internal {
        IClaimable(rewards).claim(comet, src, shouldAccrue);
    }

    /**
     * @notice Similar to ERC-20 transfer, except it properly handles `transferFrom` from non-standard ERC-20 tokens
     * @param asset The ERC-20 token to transfer in
     * @param from The address to transfer from
     * @param amount The amount of the token to transfer
     * @dev Note: This does not check that the amount transferred in is actually equals to the amount specified (e.g. fee tokens will not revert)
     * @dev Note: This wrapper safely handles non-standard ERC-20 tokens that do not return a value. See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
     */
    function doTransferIn(address asset, address from, uint amount) internal {
        IERC20NonStandard(asset).transferFrom(from, address(this), amount);

        bool success;
        assembly {
            switch returndatasize()
                case 0 {                       // This is a non-standard ERC-20
                    success := not(0)          // set success to true
                }
                case 32 {                      // This is a compliant ERC-20
                    returndatacopy(0, 0, 32)
                    success := mload(0)        // Set `success = returndata` of override external call
                }
                default {                      // This is an excessively non-compliant ERC-20, revert.
                    revert(0, 0)
                }
        }
        if (!success) revert TransferInFailed();
    }

    /**
     * @notice Similar to ERC-20 transfer, except it properly handles `transfer` from non-standard ERC-20 tokens
     * @param asset The ERC-20 token to transfer out
     * @param to The recipient of the token transfer
     * @param amount The amount of the token to transfer
     * @dev Note: This wrapper safely handles non-standard ERC-20 tokens that do not return a value. See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
     */
    function doTransferOut(address asset, address to, uint amount) internal {
        IERC20NonStandard(asset).transfer(to, amount);

        bool success;
        assembly {
            switch returndatasize()
                case 0 {                      // This is a non-standard ERC-20
                    success := not(0)         // set success to true
                }
                case 32 {                     // This is a compliant ERC-20
                    returndatacopy(0, 0, 32)
                    success := mload(0)       // Set `success = returndata` of override external call
                }
                default {                     // This is an excessively non-compliant ERC-20, revert.
                    revert(0, 0)
                }
        }
        if (!success) revert TransferOutFailed();
    }
}

File 5 of 13 : ERC20.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

/**
 * @title ERC 20 Token Standard Interface
 *  https://eips.ethereum.org/EIPS/eip-20
 */
interface ERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);

    /**
      * @notice Get the total number of tokens in circulation
      * @return The supply of tokens
      */
    function totalSupply() external view returns (uint256);

    /**
     * @notice Gets the balance of the specified address
     * @param owner The address from which the balance will be retrieved
     * @return The balance
     */
    function balanceOf(address owner) external view returns (uint256);

    /**
      * @notice Transfer `amount` tokens from `msg.sender` to `dst`
      * @param dst The address of the destination account
      * @param amount The number of tokens to transfer
      * @return Whether or not the transfer succeeded
      */
    function transfer(address dst, uint256 amount) external returns (bool);

    /**
      * @notice Transfer `amount` tokens from `src` to `dst`
      * @param src The address of the source account
      * @param dst The address of the destination account
      * @param amount The number of tokens to transfer
      * @return Whether or not the transfer succeeded
      */
    function transferFrom(address src, address dst, uint256 amount) external returns (bool);

    /**
      * @notice Approve `spender` to transfer up to `amount` from `src`
      * @dev This will overwrite the approval amount for `spender`
      *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
      * @param spender The address of the account which may transfer tokens
      * @param amount The number of tokens that are approved (-1 means infinite)
      * @return Whether or not the approval succeeded
      */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
      * @notice Get the current allowance from `owner` for `spender`
      * @param owner The address of the account which owns the tokens to be spent
      * @param spender The address of the account which may transfer tokens
      * @return The number of tokens allowed to be spent (-1 means infinite)
      */
    function allowance(address owner, address spender) external view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 amount);
    event Approval(address indexed owner, address indexed spender, uint256 amount);
}

File 6 of 13 : CometInterface.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

import "./CometMainInterface.sol";
import "./CometExtInterface.sol";

/**
 * @title Compound's Comet Interface
 * @notice An efficient monolithic money market protocol
 * @author Compound
 */
abstract contract CometInterface is CometMainInterface, CometExtInterface {}

File 7 of 13 : IERC20NonStandard.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

/**
 * @title IERC20NonStandard
 * @dev Version of ERC20 with no return values for `approve`, `transfer`, and `transferFrom`
 *  See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
 */
interface IERC20NonStandard {
    function approve(address spender, uint256 amount) external;
    function transfer(address to, uint256 value) external;
    function transferFrom(address from, address to, uint256 value) external;
    function balanceOf(address account) external view returns (uint256);
}

File 8 of 13 : IWETH9.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

interface IWETH9 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function balanceOf(address) external view returns (uint);

    function allowance(address, address) external view returns (uint);

    receive() external payable;

    function deposit() external payable;

    function withdraw(uint wad) external;

    function totalSupply() external view returns (uint);

    function approve(address guy, uint wad) external returns (bool);

    function transfer(address dst, uint wad) external returns (bool);

    function transferFrom(address src, address dst, uint wad)
    external
    returns (bool);
}

File 9 of 13 : CometMainInterface.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

import "./CometCore.sol";

/**
 * @title Compound's Comet Main Interface (without Ext)
 * @notice An efficient monolithic money market protocol
 * @author Compound
 */
abstract contract CometMainInterface is CometCore {
    error Absurd();
    error AlreadyInitialized();
    error BadAsset();
    error BadDecimals();
    error BadDiscount();
    error BadMinimum();
    error BadPrice();
    error BorrowTooSmall();
    error BorrowCFTooLarge();
    error InsufficientReserves();
    error LiquidateCFTooLarge();
    error NoSelfTransfer();
    error NotCollateralized();
    error NotForSale();
    error NotLiquidatable();
    error Paused();
    error SupplyCapExceeded();
    error TimestampTooLarge();
    error TooManyAssets();
    error TooMuchSlippage();
    error TransferInFailed();
    error TransferOutFailed();
    error Unauthorized();

    event Supply(address indexed from, address indexed dst, uint amount);
    event Transfer(address indexed from, address indexed to, uint amount);
    event Withdraw(address indexed src, address indexed to, uint amount);

    event SupplyCollateral(address indexed from, address indexed dst, address indexed asset, uint amount);
    event TransferCollateral(address indexed from, address indexed to, address indexed asset, uint amount);
    event WithdrawCollateral(address indexed src, address indexed to, address indexed asset, uint amount);

    /// @notice Event emitted when a borrow position is absorbed by the protocol
    event AbsorbDebt(address indexed absorber, address indexed borrower, uint basePaidOut, uint usdValue);

    /// @notice Event emitted when a user's collateral is absorbed by the protocol
    event AbsorbCollateral(address indexed absorber, address indexed borrower, address indexed asset, uint collateralAbsorbed, uint usdValue);

    /// @notice Event emitted when a collateral asset is purchased from the protocol
    event BuyCollateral(address indexed buyer, address indexed asset, uint baseAmount, uint collateralAmount);

    /// @notice Event emitted when an action is paused/unpaused
    event PauseAction(bool supplyPaused, bool transferPaused, bool withdrawPaused, bool absorbPaused, bool buyPaused);

    /// @notice Event emitted when reserves are withdrawn by the governor
    event WithdrawReserves(address indexed to, uint amount);

    function supply(address asset, uint amount) virtual external;
    function supplyTo(address dst, address asset, uint amount) virtual external;
    function supplyFrom(address from, address dst, address asset, uint amount) virtual external;

    function transfer(address dst, uint amount) virtual external returns (bool);
    function transferFrom(address src, address dst, uint amount) virtual external returns (bool);

    function transferAsset(address dst, address asset, uint amount) virtual external;
    function transferAssetFrom(address src, address dst, address asset, uint amount) virtual external;

    function withdraw(address asset, uint amount) virtual external;
    function withdrawTo(address to, address asset, uint amount) virtual external;
    function withdrawFrom(address src, address to, address asset, uint amount) virtual external;

    function approveThis(address manager, address asset, uint amount) virtual external;
    function withdrawReserves(address to, uint amount) virtual external;

    function absorb(address absorber, address[] calldata accounts) virtual external;
    function buyCollateral(address asset, uint minAmount, uint baseAmount, address recipient) virtual external;
    function quoteCollateral(address asset, uint baseAmount) virtual public view returns (uint);

    function getAssetInfo(uint8 i) virtual public view returns (AssetInfo memory);
    function getAssetInfoByAddress(address asset) virtual public view returns (AssetInfo memory);
    function getCollateralReserves(address asset) virtual public view returns (uint);
    function getReserves() virtual public view returns (int);
    function getPrice(address priceFeed) virtual public view returns (uint);

    function isBorrowCollateralized(address account) virtual public view returns (bool);
    function isLiquidatable(address account) virtual public view returns (bool);

    function totalSupply() virtual external view returns (uint256);
    function totalBorrow() virtual external view returns (uint256);
    function balanceOf(address owner) virtual public view returns (uint256);
    function borrowBalanceOf(address account) virtual public view returns (uint256);

    function pause(bool supplyPaused, bool transferPaused, bool withdrawPaused, bool absorbPaused, bool buyPaused) virtual external;
    function isSupplyPaused() virtual public view returns (bool);
    function isTransferPaused() virtual public view returns (bool);
    function isWithdrawPaused() virtual public view returns (bool);
    function isAbsorbPaused() virtual public view returns (bool);
    function isBuyPaused() virtual public view returns (bool);

    function accrueAccount(address account) virtual external;
    function getSupplyRate(uint utilization) virtual public view returns (uint64);
    function getBorrowRate(uint utilization) virtual public view returns (uint64);
    function getUtilization() virtual public view returns (uint);

    function governor() virtual external view returns (address);
    function pauseGuardian() virtual external view returns (address);
    function baseToken() virtual external view returns (address);
    function baseTokenPriceFeed() virtual external view returns (address);
    function extensionDelegate() virtual external view returns (address);

    /// @dev uint64
    function supplyKink() virtual external view returns (uint);
    /// @dev uint64
    function supplyPerSecondInterestRateSlopeLow() virtual external view returns (uint);
    /// @dev uint64
    function supplyPerSecondInterestRateSlopeHigh() virtual external view returns (uint);
    /// @dev uint64
    function supplyPerSecondInterestRateBase() virtual external view returns (uint);
    /// @dev uint64
    function borrowKink() virtual external view returns (uint);
    /// @dev uint64
    function borrowPerSecondInterestRateSlopeLow() virtual external view returns (uint);
    /// @dev uint64
    function borrowPerSecondInterestRateSlopeHigh() virtual external view returns (uint);
    /// @dev uint64
    function borrowPerSecondInterestRateBase() virtual external view returns (uint);
    /// @dev uint64
    function storeFrontPriceFactor() virtual external view returns (uint);

    /// @dev uint64
    function baseScale() virtual external view returns (uint);
    /// @dev uint64
    function trackingIndexScale() virtual external view returns (uint);

    /// @dev uint64
    function baseTrackingSupplySpeed() virtual external view returns (uint);
    /// @dev uint64
    function baseTrackingBorrowSpeed() virtual external view returns (uint);
    /// @dev uint104
    function baseMinForRewards() virtual external view returns (uint);
    /// @dev uint104
    function baseBorrowMin() virtual external view returns (uint);
    /// @dev uint104
    function targetReserves() virtual external view returns (uint);

    function numAssets() virtual external view returns (uint8);
    function decimals() virtual external view returns (uint8);

    function initializeStorage() virtual external;
}

File 10 of 13 : CometExtInterface.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

import "./CometCore.sol";

/**
 * @title Compound's Comet Ext Interface
 * @notice An efficient monolithic money market protocol
 * @author Compound
 */
abstract contract CometExtInterface is CometCore {
    error BadAmount();
    error BadNonce();
    error BadSignatory();
    error InvalidValueS();
    error InvalidValueV();
    error SignatureExpired();

    function allow(address manager, bool isAllowed) virtual external;
    function allowBySig(address owner, address manager, bool isAllowed, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) virtual external;

    function collateralBalanceOf(address account, address asset) virtual external view returns (uint128);
    function baseTrackingAccrued(address account) virtual external view returns (uint64);

    function baseAccrualScale() virtual external view returns (uint64);
    function baseIndexScale() virtual external view returns (uint64);
    function factorScale() virtual external view returns (uint64);
    function priceScale() virtual external view returns (uint64);

    function maxAssets() virtual external view returns (uint8);

    function totalsBasic() virtual external view returns (TotalsBasic memory);

    function version() virtual external view returns (string memory);

    /**
      * ===== ERC20 interfaces =====
      * Does not include the following functions/events, which are defined in `CometMainInterface` instead:
      * - function decimals() virtual external view returns (uint8)
      * - function totalSupply() virtual external view returns (uint256)
      * - function transfer(address dst, uint amount) virtual external returns (bool)
      * - function transferFrom(address src, address dst, uint amount) virtual external returns (bool)
      * - function balanceOf(address owner) virtual external view returns (uint256)
      * - event Transfer(address indexed from, address indexed to, uint256 amount)
      */
    function name() virtual external view returns (string memory);
    function symbol() virtual external view returns (string memory);

    /**
      * @notice Approve `spender` to transfer up to `amount` from `src`
      * @dev This will overwrite the approval amount for `spender`
      *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
      * @param spender The address of the account which may transfer tokens
      * @param amount The number of tokens that are approved (-1 means infinite)
      * @return Whether or not the approval succeeded
      */
    function approve(address spender, uint256 amount) virtual external returns (bool);

    /**
      * @notice Get the current allowance from `owner` for `spender`
      * @param owner The address of the account which owns the tokens to be spent
      * @param spender The address of the account which may transfer tokens
      * @return The number of tokens allowed to be spent (-1 means infinite)
      */
    function allowance(address owner, address spender) virtual external view returns (uint256);

    event Approval(address indexed owner, address indexed spender, uint256 amount);
}

File 11 of 13 : CometCore.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

import "./CometConfiguration.sol";
import "./CometStorage.sol";
import "./CometMath.sol";

abstract contract CometCore is CometConfiguration, CometStorage, CometMath {
    struct AssetInfo {
        uint8 offset;
        address asset;
        address priceFeed;
        uint64 scale;
        uint64 borrowCollateralFactor;
        uint64 liquidateCollateralFactor;
        uint64 liquidationFactor;
        uint128 supplyCap;
    }

    /** Internal constants **/

    /// @dev The max number of assets this contract is hardcoded to support
    ///  Do not change this variable without updating all the fields throughout the contract,
    //    including the size of UserBasic.assetsIn and corresponding integer conversions.
    uint8 internal constant MAX_ASSETS = 15;

    /// @dev The max number of decimals base token can have
    ///  Note this cannot just be increased arbitrarily.
    uint8 internal constant MAX_BASE_DECIMALS = 18;

    /// @dev The max value for a collateral factor (1)
    uint64 internal constant MAX_COLLATERAL_FACTOR = FACTOR_SCALE;

    /// @dev Offsets for specific actions in the pause flag bit array
    uint8 internal constant PAUSE_SUPPLY_OFFSET = 0;
    uint8 internal constant PAUSE_TRANSFER_OFFSET = 1;
    uint8 internal constant PAUSE_WITHDRAW_OFFSET = 2;
    uint8 internal constant PAUSE_ABSORB_OFFSET = 3;
    uint8 internal constant PAUSE_BUY_OFFSET = 4;

    /// @dev The decimals required for a price feed
    uint8 internal constant PRICE_FEED_DECIMALS = 8;

    /// @dev 365 days * 24 hours * 60 minutes * 60 seconds
    uint64 internal constant SECONDS_PER_YEAR = 31_536_000;

    /// @dev The scale for base tracking accrual
    uint64 internal constant BASE_ACCRUAL_SCALE = 1e6;

    /// @dev The scale for base index (depends on time/rate scales, not base token)
    uint64 internal constant BASE_INDEX_SCALE = 1e15;

    /// @dev The scale for prices (in USD)
    uint64 internal constant PRICE_SCALE = uint64(10 ** PRICE_FEED_DECIMALS);

    /// @dev The scale for factors
    uint64 internal constant FACTOR_SCALE = 1e18;

    /**
     * @notice Determine if the manager has permission to act on behalf of the owner
     * @param owner The owner account
     * @param manager The manager account
     * @return Whether or not the manager has permission
     */
    function hasPermission(address owner, address manager) public view returns (bool) {
        return owner == manager || isAllowed[owner][manager];
    }

    /**
     * @dev The positive present supply balance if positive or the negative borrow balance if negative
     */
    function presentValue(int104 principalValue_) internal view returns (int256) {
        if (principalValue_ >= 0) {
            return signed256(presentValueSupply(baseSupplyIndex, uint104(principalValue_)));
        } else {
            return -signed256(presentValueBorrow(baseBorrowIndex, uint104(-principalValue_)));
        }
    }

    /**
     * @dev The principal amount projected forward by the supply index
     */
    function presentValueSupply(uint64 baseSupplyIndex_, uint104 principalValue_) internal pure returns (uint256) {
        return uint256(principalValue_) * baseSupplyIndex_ / BASE_INDEX_SCALE;
    }

    /**
     * @dev The principal amount projected forward by the borrow index
     */
    function presentValueBorrow(uint64 baseBorrowIndex_, uint104 principalValue_) internal pure returns (uint256) {
        return uint256(principalValue_) * baseBorrowIndex_ / BASE_INDEX_SCALE;
    }

    /**
     * @dev The positive principal if positive or the negative principal if negative
     */
    function principalValue(int256 presentValue_) internal view returns (int104) {
        if (presentValue_ >= 0) {
            return signed104(principalValueSupply(baseSupplyIndex, uint256(presentValue_)));
        } else {
            return -signed104(principalValueBorrow(baseBorrowIndex, uint256(-presentValue_)));
        }
    }

    /**
     * @dev The present value projected backward by the supply index (rounded down)
     *  Note: This will overflow (revert) at 2^104/1e18=~20 trillion principal for assets with 18 decimals.
     */
    function principalValueSupply(uint64 baseSupplyIndex_, uint256 presentValue_) internal pure returns (uint104) {
        return safe104((presentValue_ * BASE_INDEX_SCALE) / baseSupplyIndex_);
    }

    /**
     * @dev The present value projected backward by the borrow index (rounded up)
     *  Note: This will overflow (revert) at 2^104/1e18=~20 trillion principal for assets with 18 decimals.
     */
    function principalValueBorrow(uint64 baseBorrowIndex_, uint256 presentValue_) internal pure returns (uint104) {
        return safe104((presentValue_ * BASE_INDEX_SCALE + baseBorrowIndex_ - 1) / baseBorrowIndex_);
    }
}

File 12 of 13 : CometConfiguration.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

/**
 * @title Compound's Comet Configuration Interface
 * @author Compound
 */
contract CometConfiguration {
    struct ExtConfiguration {
        bytes32 name32;
        bytes32 symbol32;
    }

    struct Configuration {
        address governor;
        address pauseGuardian;
        address baseToken;
        address baseTokenPriceFeed;
        address extensionDelegate;

        uint64 supplyKink;
        uint64 supplyPerYearInterestRateSlopeLow;
        uint64 supplyPerYearInterestRateSlopeHigh;
        uint64 supplyPerYearInterestRateBase;
        uint64 borrowKink;
        uint64 borrowPerYearInterestRateSlopeLow;
        uint64 borrowPerYearInterestRateSlopeHigh;
        uint64 borrowPerYearInterestRateBase;
        uint64 storeFrontPriceFactor;
        uint64 trackingIndexScale;
        uint64 baseTrackingSupplySpeed;
        uint64 baseTrackingBorrowSpeed;
        uint104 baseMinForRewards;
        uint104 baseBorrowMin;
        uint104 targetReserves;

        AssetConfig[] assetConfigs;
    }

    struct AssetConfig {
        address asset;
        address priceFeed;
        uint8 decimals;
        uint64 borrowCollateralFactor;
        uint64 liquidateCollateralFactor;
        uint64 liquidationFactor;
        uint128 supplyCap;
    }
}

File 13 of 13 : CometStorage.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

/**
 * @title Compound's Comet Storage Interface
 * @dev Versions can enforce append-only storage slots via inheritance.
 * @author Compound
 */
contract CometStorage {
    // 512 bits total = 2 slots
    struct TotalsBasic {
        // 1st slot
        uint64 baseSupplyIndex;
        uint64 baseBorrowIndex;
        uint64 trackingSupplyIndex;
        uint64 trackingBorrowIndex;
        // 2nd slot
        uint104 totalSupplyBase;
        uint104 totalBorrowBase;
        uint40 lastAccrualTime;
        uint8 pauseFlags;
    }

    struct TotalsCollateral {
        uint128 totalSupplyAsset;
        uint128 _reserved;
    }

    struct UserBasic {
        int104 principal;
        uint64 baseTrackingIndex;
        uint64 baseTrackingAccrued;
        uint16 assetsIn;
        uint8 _reserved;
    }

    struct UserCollateral {
        uint128 balance;
        uint128 _reserved;
    }

    struct LiquidatorPoints {
        uint32 numAbsorbs;
        uint64 numAbsorbed;
        uint128 approxSpend;
        uint32 _reserved;
    }

    /// @dev Aggregate variables tracked for the entire market
    uint64 internal baseSupplyIndex;
    uint64 internal baseBorrowIndex;
    uint64 internal trackingSupplyIndex;
    uint64 internal trackingBorrowIndex;
    uint104 internal totalSupplyBase;
    uint104 internal totalBorrowBase;
    uint40 internal lastAccrualTime;
    uint8 internal pauseFlags;

    /// @notice Aggregate variables tracked for each collateral asset
    mapping(address => TotalsCollateral) public totalsCollateral;

    /// @notice Mapping of users to accounts which may be permitted to manage the user account
    mapping(address => mapping(address => bool)) public isAllowed;

    /// @notice The next expected nonce for an address, for validating authorizations via signature
    mapping(address => uint) public userNonce;

    /// @notice Mapping of users to base principal and other basic data
    mapping(address => UserBasic) public userBasic;

    /// @notice Mapping of users to collateral data per collateral asset
    mapping(address => mapping(address => UserCollateral)) public userCollateral;

    /// @notice Mapping of magic liquidator points
    mapping(address => LiquidatorPoints) public liquidatorPoints;
}

File 14 of 13 : CometMath.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;

/**
 * @title Compound's Comet Math Contract
 * @dev Pure math functions
 * @author Compound
 */
contract CometMath {
    /** Custom errors **/

    error InvalidUInt64();
    error InvalidUInt104();
    error InvalidUInt128();
    error InvalidInt104();
    error InvalidInt256();
    error NegativeNumber();

    function safe64(uint n) internal pure returns (uint64) {
        if (n > type(uint64).max) revert InvalidUInt64();
        return uint64(n);
    }

    function safe104(uint n) internal pure returns (uint104) {
        if (n > type(uint104).max) revert InvalidUInt104();
        return uint104(n);
    }

    function safe128(uint n) internal pure returns (uint128) {
        if (n > type(uint128).max) revert InvalidUInt128();
        return uint128(n);
    }

    function signed104(uint104 n) internal pure returns (int104) {
        if (n > uint104(type(int104).max)) revert InvalidInt104();
        return int104(n);
    }

    function signed256(uint256 n) internal pure returns (int256) {
        if (n > uint256(type(int256).max)) revert InvalidInt256();
        return int256(n);
    }

    function unsigned104(int104 n) internal pure returns (uint104) {
        if (n < 0) revert NegativeNumber();
        return uint104(n);
    }

    function unsigned256(int256 n) internal pure returns (uint256) {
        if (n < 0) revert NegativeNumber();
        return uint256(n);
    }

    function toUInt8(bool x) internal pure returns (uint8) {
        return x ? 1 : 0;
    }

    function toBool(uint8 x) internal pure returns (bool) {
        return x != 0;
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 1,
    "details": {
      "yulDetails": {
        "optimizerSteps": "dhfoDgvulfnTUtnIf [xa[r]scLM cCTUtTOntnfDIul Lcul Vcul [j] Tpeul xa[rul] xa[r]cL gvif CTUca[r]LsTOtfDnca[r]Iulc] jmul[jul] VcTOcul jmul"
      }
    }
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "viaIR": true,
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"admin_","type":"address"},{"internalType":"address payable","name":"weth_","type":"address"},{"internalType":"address","name":"wsteth_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"FailedToSendNativeToken","type":"error"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[],"name":"InvalidArgument","type":"error"},{"inputs":[],"name":"TransferInFailed","type":"error"},{"inputs":[],"name":"TransferOutFailed","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"UnhandledAction","type":"error"},{"inputs":[],"name":"UnsupportedBaseAsset","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAdmin","type":"address"},{"indexed":true,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminTransferred","type":"event"},{"inputs":[],"name":"ACTION_CLAIM_REWARD","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ACTION_SUPPLY_ASSET","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ACTION_SUPPLY_NATIVE_TOKEN","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ACTION_SUPPLY_STETH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ACTION_TRANSFER_ASSET","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ACTION_WITHDRAW_ASSET","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ACTION_WITHDRAW_NATIVE_TOKEN","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ACTION_WITHDRAW_STETH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"actions","type":"bytes32[]"},{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"invoke","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"steth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"sweepNativeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"asset","type":"address"}],"name":"sweepToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"transferAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wrappedNativeToken","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wsteth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000006d903f6003cca6255d85cca4d3b5e5146dc33925000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0

-----Decoded View---------------
Arg [0] : admin_ (address): 0x6d903f6003cca6255D85CcA4D3B5E5146dC33925
Arg [1] : weth_ (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
Arg [2] : wsteth_ (address): 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000006d903f6003cca6255d85cca4d3b5e5146dc33925
Arg [1] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
Arg [2] : 0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0


Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.