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.21;

import {IStoneVault} from "../interfaces/IStoneVault.sol";

import {StoneCarnival} from "./StoneCarnival.sol";

import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {TransferHelper} from "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";

contract StoneCarnivalETH is Ownable2Step, ReentrancyGuard {
    address public immutable stoneAddr;
    address public immutable stoneVaultAddr;
    address public immutable stoneCarvivalAddr;
    uint256 public immutable minEtherAllowed;

    uint256 public round;

    bool public depositPaused;

    mapping(address => mapping(uint256 => uint256)) public etherDeposited;
    mapping(address => mapping(uint256 => bool)) public cStoneClaimedByRound;
    mapping(uint256 => uint256) public etherDepositedByRound;
    mapping(uint256 => uint256) public cStoneReceivedByRound;

    event EtherDeposited(address _user, uint256 _amount, uint256 round);
    event CStoneClaimed(address _user, uint256 _amount);
    event DepositMade(
        uint256 _ethAmount,
        uint256 _stoneAmount,
        uint256 _cStoneAmount,
        uint256 _round
    );
    event DepositPause(uint256 _round);

    modifier DepositNotPaused() {
        require(!depositPaused, "deposit paused");
        _;
    }

    constructor(
        address _stoneAddr,
        address _stoneVaultAddr,
        address _stoneCarvivalAddr,
        uint256 _minEtherAllowed
    ) {
        stoneAddr = _stoneAddr;

        stoneVaultAddr = _stoneVaultAddr;
        stoneCarvivalAddr = _stoneCarvivalAddr;
        minEtherAllowed = _minEtherAllowed;
    }

    function depositETH() external payable {
        _depositETH(msg.sender, msg.value);
    }

    function _depositETH(
        address _user,
        uint256 _amount
    ) internal DepositNotPaused nonReentrant {
        require(_amount >= minEtherAllowed, "not allowed");

        etherDeposited[_user][round] += _amount;

        emit EtherDeposited(_user, _amount, round);
    }

    function claimCStoneByRound(
        uint256[] memory rounds
    ) public returns (uint256 claimed) {
        uint256 i;
        uint256 len = rounds.length;

        for (i; i < len; i++) {
            uint256 r = rounds[i];
            require(r < round, "invalid round");

            if (!cStoneClaimedByRound[msg.sender][r]) {
                uint256 cStoneAmount = (etherDeposited[msg.sender][r] *
                    cStoneReceivedByRound[r]) / etherDepositedByRound[r];
                claimed += cStoneAmount;

                cStoneClaimedByRound[msg.sender][r] = true;
            }
        }

        TransferHelper.safeTransfer(stoneCarvivalAddr, msg.sender, claimed);

        emit CStoneClaimed(msg.sender, claimed);
    }

    function makeDeposit() public onlyOwner {
        uint256 balance = address(this).balance;
        require(balance != 0, "no balance");

        uint256 stoneReceived = IStoneVault(payable(stoneVaultAddr)).deposit{
            value: balance
        }();

        TransferHelper.safeApprove(stoneAddr, stoneCarvivalAddr, stoneReceived);

        uint256 cStoneReceived = StoneCarnival(payable(stoneCarvivalAddr))
            .depositStone(stoneReceived);

        etherDepositedByRound[round] = balance;
        cStoneReceivedByRound[round] = stoneReceived;

        emit DepositMade(balance, stoneReceived, cStoneReceived, round);

        round++;
    }

    function makeDepositAndRoll() public onlyOwner {
        makeDeposit();
        IStoneVault(payable(stoneVaultAddr)).rollToNextRound();
    }

    function pauseDeposit() external onlyOwner DepositNotPaused {
        depositPaused = true;

        emit DepositPause(round);
    }
}

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

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

import {TransferHelper} from "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";

contract StoneCarnival is ERC20, Ownable2Step {
    address public immutable stoneAddr;
    address public immutable stoneVaultAddr;

    uint256 public immutable lockPeriod = 90 days;
    uint256 public immutable startTime;
    uint256 public immutable minStoneAllowed;

    uint256 public cap;
    uint256 public totalStoneDeposited;
    uint256 public finalStoneAmount;

    bool public depositPaused;
    bool public terminated;

    mapping(address => uint256) public stoneDeposited;

    event StoneDeposited(address _user, uint256 _amount);
    event StoneWithdrawn(
        address _user,
        uint256 _amount,
        uint256 _burnAmount,
        uint256 _withAmount
    );
    event RequestMade(uint256 _amount);
    event DepositMade(uint256 _ethAmount, uint256 _stoneAmount);
    event ETHWithdrawn(uint256 _amount);
    event DepositPause(uint256 totalStone);
    event WithdrawalCancelled(uint256 _amount);
    event Terminate(uint256 timestamp);
    event SetCap(uint256 oldCap, uint256 newCap);

    constructor(
        address _stoneAddr,
        address _stoneVaultAddr,
        uint256 _cap,
        uint256 _minStoneAllowed
    ) ERC20("STONE Carnival LP", "cSTONE") {
        require(
            _stoneAddr != address(0) && _stoneVaultAddr != address(0),
            "invalid addr"
        );

        stoneAddr = _stoneAddr;
        stoneVaultAddr = _stoneVaultAddr;
        cap = _cap;
        startTime = block.timestamp;
        minStoneAllowed = _minStoneAllowed;
    }

    modifier DepositNotPaused() {
        require(!depositPaused, "deposit paused");
        _;
    }

    modifier DepositPaused() {
        require(depositPaused, "deposit not paused");
        _;
    }

    modifier OnlyTerminated() {
        require(terminated, "not terminated");
        _;
    }

    modifier NotTerminated() {
        require(!terminated, " terminated");
        _;
    }

    function depositStone(
        uint256 _amount
    ) external DepositNotPaused returns (uint256 cStoneAmount) {
        TransferHelper.safeTransferFrom(
            stoneAddr,
            msg.sender,
            address(this),
            _amount
        );

        cStoneAmount = _depositStone(msg.sender, _amount);
    }

    function depositStoneFor(
        address _user,
        uint256 _amount
    ) external DepositNotPaused returns (uint256 cStoneAmount) {
        TransferHelper.safeTransferFrom(
            stoneAddr,
            msg.sender,
            address(this),
            _amount
        );

        cStoneAmount = _depositStone(_user, _amount);
    }

    function _depositStone(
        address _user,
        uint256 _amount
    ) internal returns (uint256 cStoneAmount) {
        require(cap >= _amount + totalStoneDeposited, "cap");
        require(
            _amount + stoneDeposited[_user] >= minStoneAllowed,
            "not allowed"
        );

        stoneDeposited[_user] += _amount;
        totalStoneDeposited += _amount;

        _mint(_user, _amount);

        cStoneAmount = _amount;

        emit StoneDeposited(_user, _amount);
    }

    function withdrawStone() external OnlyTerminated {
        uint256 stoneShare = balanceOf(msg.sender);

        uint256 stoneAmountWith = (stoneShare * finalStoneAmount) /
            totalStoneDeposited;

        require(stoneAmountWith != 0, "zero amount");

        _burn(msg.sender, stoneShare);

        TransferHelper.safeTransfer(stoneAddr, msg.sender, stoneAmountWith);

        emit StoneWithdrawn(
            msg.sender,
            stoneDeposited[msg.sender],
            stoneShare,
            stoneAmountWith
        );
    }

    function terminate() external NotTerminated {
        require(block.timestamp >= startTime + lockPeriod, "cannot terminate");

        finalStoneAmount = IERC20(stoneAddr).balanceOf(address(this));

        depositPaused = true;
        terminated = true;

        emit Terminate(block.timestamp);
    }

    function setCap(uint256 _cap) external onlyOwner DepositNotPaused {
        emit SetCap(cap, _cap);
        cap = _cap;
    }

    function forceTerminate() external onlyOwner DepositPaused {
        finalStoneAmount = IERC20(stoneAddr).balanceOf(address(this));

        depositPaused = true;
        terminated = true;

        emit Terminate(block.timestamp);
    }

    function pauseDeposit() external onlyOwner DepositNotPaused {
        depositPaused = true;

        emit DepositPause(totalStoneDeposited);
    }

    function makeRequest(
        uint256 _amount
    ) external onlyOwner DepositPaused NotTerminated {
        require(
            _amount <= IERC20(stoneAddr).balanceOf(address(this)),
            "STONE not enough"
        );

        TransferHelper.safeApprove(stoneAddr, stoneVaultAddr, _amount);
        IStoneVault(stoneVaultAddr).requestWithdraw(_amount);

        emit RequestMade(_amount);
    }

    function withdrawETH(
        uint256 _amount
    ) external onlyOwner DepositPaused NotTerminated {
        uint256 amount = IStoneVault(stoneVaultAddr).instantWithdraw(
            _amount,
            0
        );

        emit ETHWithdrawn(amount);
    }

    function cancelWithdraw(
        uint256 _amount
    ) external onlyOwner DepositPaused NotTerminated {
        IStoneVault(stoneVaultAddr).cancelWithdraw(_amount);

        emit WithdrawalCancelled(_amount);
    }

    function makeDeposit(
        uint256 _amount
    ) external onlyOwner DepositPaused NotTerminated {
        require(_amount <= address(this).balance, "ether not enough");

        uint256 stoneAmount = IStoneVault(stoneVaultAddr).deposit{
            value: _amount
        }();

        emit DepositMade(_amount, stoneAmount);
    }

    receive() external payable {}
}

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

interface IStoneVault {
    function deposit() external payable returns (uint256 mintAmount);

    function requestWithdraw(uint256 _shares) external;

    function instantWithdraw(
        uint256 _amount,
        uint256 _shares
    ) external returns (uint256 actualWithdrawn);

    function cancelWithdraw(uint256 _shares) external;

    function rollToNextRound() external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.6.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) =
            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'STE');
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.0;

import "./Ownable.sol";

/**
 * @dev Contract module which provides access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view virtual returns (address) {
        return _pendingOwner;
    }

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stoneAddr","type":"address"},{"internalType":"address","name":"_stoneVaultAddr","type":"address"},{"internalType":"address","name":"_stoneCarvivalAddr","type":"address"},{"internalType":"uint256","name":"_minEtherAllowed","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_user","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"CStoneClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_ethAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_stoneAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_cStoneAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_round","type":"uint256"}],"name":"DepositMade","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_round","type":"uint256"}],"name":"DepositPause","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_user","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"round","type":"uint256"}],"name":"EtherDeposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"cStoneClaimedByRound","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"cStoneReceivedByRound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"rounds","type":"uint256[]"}],"name":"claimCStoneByRound","outputs":[{"internalType":"uint256","name":"claimed","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"depositPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"etherDeposited","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"etherDepositedByRound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"makeDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"makeDepositAndRoll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minEtherAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"round","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stoneAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stoneCarvivalAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stoneVaultAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000007122985656e38bdc0302db86685bb972b145bd3c000000000000000000000000a62f9c5af106feee069f38de51098d9d81b905720000000000000000000000004d831e22f062b5327dfdb15f0b6a5df20e2e3dd000000000000000000000000000000000000000000000000003782dace9d90000

-----Decoded View---------------
Arg [0] : _stoneAddr (address): 0x7122985656e38BDC0302Db86685bb972b145bD3C
Arg [1] : _stoneVaultAddr (address): 0xA62F9C5af106FeEE069F38dE51098D9d81B90572
Arg [2] : _stoneCarvivalAddr (address): 0x4d831e22F062b5327dFdB15f0b6a5dF20E2E3dD0
Arg [3] : _minEtherAllowed (uint256): 250000000000000000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000007122985656e38bdc0302db86685bb972b145bd3c
Arg [1] : 000000000000000000000000a62f9c5af106feee069f38de51098d9d81b90572
Arg [2] : 0000000000000000000000004d831e22f062b5327dfdb15f0b6a5df20e2e3dd0
Arg [3] : 00000000000000000000000000000000000000000000000003782dace9d90000