Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";

import "./IDeposit.sol";

// Based on Stakefish and Staked.us contracts.
//
// We don't need fees, but we want truffle & unit tests.
contract BatchDeposit {
    using Address for address payable;
    using SafeMath for uint256;

    uint256 public constant kDepositAmount = 32 ether;
    IDeposit public immutable depositContract_;

    event LogDepositLeftover(address to, uint256 amount);
    event LogDepositSent(bytes pubkey, bytes withdrawal);

    // We pass the address of a contract here because this will change
    // from one environment to another. On mainnet and testnet we use
    // the official addresses:
    //
    // - testnet: 0xff50ed3d0ec03aC01D4C79aAd74928BFF48a7b2b (https://goerli.etherscan.io/address/0xff50ed3d0ec03aC01D4C79aAd74928BFF48a7b2b)
    // - zheijang: 0x4242424242424242424242424242424242424242 (https://blockscout.com/eth/zhejiang-testnet/address/0x4242424242424242424242424242424242424242)
    // - mainnet: 0x00000000219ab540356cbb839cbe05303d7705fa (https://etherscan.io/address/0x00000000219ab540356cbb839cbe05303d7705fa)
    //
    // The migration script handles this.
    constructor (address deposit_contract_address) {
	    depositContract_ = IDeposit(deposit_contract_address);
    }

    function batchDeposit(
        bytes[] calldata pubkeys,
        bytes[] calldata withdrawal_credentials,
        bytes[] calldata signatures,
        bytes32[] calldata deposit_data_roots
    ) external payable {
        require(
            pubkeys.length == withdrawal_credentials.length &&
            pubkeys.length == signatures.length &&
            pubkeys.length == deposit_data_roots.length,
            "#BatchDeposit batchDeposit(): All parameter array's must have the same length."
        );
        require(
            pubkeys.length > 0,
            "#BatchDeposit batchDeposit(): All parameter array's must have a length greater than zero."
        );
        require(
            msg.value >= kDepositAmount.mul(pubkeys.length),
            "#BatchDeposit batchDeposit(): Ether deposited needs to be at least: 32 * (parameter `pubkeys[]` length)."
        );

        uint256 deposited = 0;

        for (uint256 i = 0; i < pubkeys.length; i++) {
            depositContract_.deposit{value: kDepositAmount}(
                pubkeys[i],
                withdrawal_credentials[i],
                signatures[i],
                deposit_data_roots[i]
            );
	    emit LogDepositSent(pubkeys[i], withdrawal_credentials[i]);
            deposited = deposited.add(kDepositAmount);
        }

        assert(deposited == kDepositAmount.mul(pubkeys.length));

        uint256 ethToReturn = msg.value.sub(deposited);
        if (ethToReturn > 0) {
          emit LogDepositLeftover(msg.sender, ethToReturn);
	  Address.sendValue(payable(msg.sender), ethToReturn);
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/// @notice  Interface of the official Deposit contract from the ETH
///          Foundation.
interface IDeposit {

    /// @notice Submit a Phase 0 DepositData object.
    ///
    /// @param pubkey - A BLS12-381 public key.
    /// @param withdrawal_credentials - Commitment to a public key for withdrawals.
    /// @param signature - A BLS12-381 signature.
    /// @param deposit_data_root - The SHA-256 hash of the SSZ-encoded DepositData object.
    ///                            Used as a protection against malformed input.
    function deposit(
        bytes calldata pubkey,
        bytes calldata withdrawal_credentials,
        bytes calldata signature,
        bytes32 deposit_data_root
    ) external payable;
}

// Used in unit tests.
contract DepositMock is IDeposit {
    function deposit(bytes calldata pubkey, bytes calldata withdrawal_credentials, bytes calldata signature, bytes32 deposit_data_root) external payable {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

{
  "remappings": [],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "london",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"deposit_contract_address","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogDepositLeftover","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubkey","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"withdrawal","type":"bytes"}],"name":"LogDepositSent","type":"event"},{"inputs":[{"internalType":"bytes[]","name":"pubkeys","type":"bytes[]"},{"internalType":"bytes[]","name":"withdrawal_credentials","type":"bytes[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"},{"internalType":"bytes32[]","name":"deposit_data_roots","type":"bytes32[]"}],"name":"batchDeposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"depositContract_","outputs":[{"internalType":"contract IDeposit","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kDepositAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000000000000219ab540356cbb839cbe05303d7705fa

-----Decoded View---------------
Arg [0] : deposit_contract_address (address): 0x00000000219ab540356cBB839Cbe05303d7705Fa

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000219ab540356cbb839cbe05303d7705fa