Cryo Explorer Ethereum Mainnet

// 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);
    }
}

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

pragma solidity ^0.8.0;

import "../token/ERC20/extensions/IERC20Metadata.sol";

// 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 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.4) (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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./libraries/ERC20Helpers.sol";
import "./interfaces/ICvxLocker.sol";
import "./interfaces/IManager.sol";
import "./interfaces/ITCvx.sol";

/**
 * @title TCvxOperator
 * @notice Contract that generates tCVX and locks CVX or migrates bentCVX 1:1
 */
contract TCvxOperator is Ownable {

  ICvxLocker public locker;
  IManager public manager;
  IERC20 public bentCVX;
  IERC20 public cvx;
  ITCvx public tCvx;

  bool public migrationCooldown;
  bool public cooldown;

  event Migrated(address indexed user, address indexed recipient, uint256 amount, bool relockAttempted, bool relockSuccess);
  event Deposited(address indexed user, address indexed recipient, uint256 amount, bool lockSuccess, bool relockAttempted, bool relockSuccess);

  constructor(
    address _cvx,
    address _locker,
    address _manager,
    address _bentCVX
  ) {
    cvx = IERC20(_cvx);
    bentCVX = IERC20(_bentCVX);
    manager = IManager(_manager);
    locker = ICvxLocker(_locker);
    cvx.approve(_locker, type(uint256).max);
  }

  /**
   * @notice Allows the owner to set the tCVX
   */
  function setTCvx(ITCvx _tCvx) external onlyOwner {
    require(address(tCvx) == address(0), "already set");
    tCvx = _tCvx;
  }

  /**
   * @notice Allows the owner to update the cvx locker address.
   * @param _locker Address of the locker
   */
  function setLocker(address _locker) external onlyOwner {
    require(_locker != address(locker), "already set");
    require(_locker != address(0), "Invalid address");
    cvx.approve(_locker, type(uint256).max);
    cvx.approve(address(locker), 0);
    locker = ICvxLocker(_locker);
  }

  /**
   * @notice Allows the owner to update the manager address.
   * @param _manager Address of the manager
   */
  function setManager(IManager _manager) external onlyOwner {
    require(address(_manager) != address(0), "Invalid address");
    manager = _manager;
  }

  /**
    @notice withdraws the specified token to the owner in case of emergency
    @param _token address The token to withdraw
   */
  function emergencyWithdraw(address _token) external onlyOwner {
    IERC20 token = IERC20(_token);
    uint256 amount = token.balanceOf(address(this));
    ERC20Helpers.safeTransfer(_token, msg.sender, amount);
  }

  /**
   * @notice Allows the owner to update the migration cooldown
   * @param _cooldown Boolean indicating cooldown
   */
  function setMigrationCooldown(bool _cooldown) external onlyOwner {
    migrationCooldown = _cooldown;
  }

  /**
   * @notice Allows the owner to update deposits being cooldown or active
   * @param _cooldown Boolean indicating cooldown
   */
  function setDepositsCooldown(bool _cooldown) external onlyOwner {
    cooldown = _cooldown;
  }

  /**
   * @notice Migrate bentCVX tokens and generate tCVX 1:1.
   * @param amount The amount of bentCVX to migrate.
   * @param processExpiredLocks bool to relock or not
   */
  function migrateBentCVX(uint256 amount, bool processExpiredLocks) external {
    migrateBentCVXFor(amount, msg.sender, processExpiredLocks);
  }

  /**
   * @notice Migrate bentCVX tokens and generate tCVX 1:1.
   * @param amount The amount of bentCVX to migrate.
   * @param recipient The user to receive the tCvx
   * @param processExpiredLocks bool to relock or not
   */
  function migrateBentCVXFor(uint256 amount, address recipient, bool processExpiredLocks) public {
    require(amount > 0, "Amount must be greater than 0");
    require(!migrationCooldown, "Migration is in cooldown");
    require(bentCVX.transferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD, amount), "bentCVX transfer failed");

    // Relock any unlocked cvx and don't
    // throw exception if it doesn't work
    bool relockSuccess;
    if (processExpiredLocks)
      (relockSuccess,) = address(manager).call(
        abi.encodeWithSelector(manager.relock.selector)
      );

    tCvx.generate(recipient, amount);
    emit Migrated(msg.sender, recipient, amount, processExpiredLocks, relockSuccess);
  }

  /**
   * @notice Deposit CVX tokens and generates tCVX 1:1.
   * @param amount The amount of CVX to deposit.
   * @param processExpiredLocks true if should attempt relock on manager
   */
  function deposit(uint256 amount, bool processExpiredLocks) external returns (uint256) {
    return depositFor(amount, msg.sender, processExpiredLocks);
  }

  /**
   * @notice Deposit CVX tokens and generates tCVX 1:1 for the recipient
   * @param amount amount to deposit
   * @param recipient the user to receive the tCVX
   * @param processExpiredLocks true if should attempt relock on manager
   * @return The amount of tCVX minted to the recipient (equal to `amount`).
   */
  function depositFor(uint256 amount, address recipient, bool processExpiredLocks) public returns (uint256) {
    require(!cooldown, "cooldown");
    require(amount > 0, "Amount must be greater than 0");
    require(cvx.transferFrom(msg.sender, address(this), amount), "cvx transfer failed");

    // Attempt to lock cvx, if it fails, don't revert
    (bool lockSuccess,) = address(locker).call(
      abi.encodeWithSelector(locker.lock.selector, address(manager), amount, 0)
    );

    // Relock any unlocked cvx and don't
    // throw exception if it doesn't work
    bool relockSuccess;
    if (processExpiredLocks)
      (relockSuccess,) = address(manager).call(
        abi.encodeWithSelector(manager.relock.selector)
      );

    tCvx.generate(recipient, amount);
    emit Deposited(msg.sender, recipient, amount, lockSuccess, processExpiredLocks, relockSuccess);
    return amount;
  }

}

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

interface ICvxLocker {
  struct LockedBalance {
    uint112 amount;
    uint112 boosted;
    uint32 unlockTime;
  }
  struct EarnedData {
    address token;
    uint256 amount;
  }

  struct Balances {
    uint112 locked;
    uint112 boosted;
    uint32 nextUnlockIndex;
  }

  function lock(
    address _account,
    uint256 _amount,
    uint256 _spendRatio
  ) external;

  function userLocks(address _user, uint256 index) external view returns (LockedBalance memory);
  function balances(address _user) external view returns (Balances memory);

  function lockedBalances(address _user)
  external
  view
  returns (
    uint256 total,
    uint256 unlockable,
    uint256 locked,
    LockedBalance[] memory lockData
  );

  function withdrawExpiredLocksTo(address recipient) external;
  function processExpiredLocks(bool _relock) external;

  function claimableRewards(address _account)
  external
  view
  returns (EarnedData[] memory userRewards);

  function getReward(address _account, bool _stake) external;

  function lockedBalanceOf(address _user) external view returns (uint256 amount);
  function balanceOf(address _user) external view returns (uint256 amount);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

interface IManager {
  function relock() external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

interface ITCvx {
  function balanceOf(address account) external view returns (uint256);
  function approve(address spender, uint256 amount) external returns (bool);
  function generate(address receiver, uint256 amount) external returns (uint256);
}

// SPDX-License-Identifier: GPL-3.0-or-later
import "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';

pragma solidity >=0.6.0;

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library ERC20Helpers {

  function safeApprove(
    address token,
    address to,
    uint256 value
  ) internal {
    // bytes4(keccak256(bytes('approve(address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
    require(
      success && (data.length == 0 || abi.decode(data, (bool))),
      'ERC20Helpers::safeApprove: approve failed'
    );
  }

  function safeTransfer(
    address token,
    address to,
    uint256 value
  ) internal {
    // bytes4(keccak256(bytes('transfer(address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
    require(
      success && (data.length == 0 || abi.decode(data, (bool))),
      'ERC20Helpers::safeTransfer: transfer failed'
    );
  }

  function safeTransferFrom(
    address token,
    address from,
    address to,
    uint256 value
  ) internal {
    // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
    require(
      success && (data.length == 0 || abi.decode(data, (bool))),
      'ERC20Helpers::transferFrom: transferFrom failed'
    );
  }

  function safeTransferETH(address to, uint256 value) internal {
    (bool success, ) = to.call{value: value}(new bytes(0));
    require(success, 'ERC20Helpers::safeTransferETH: ETH transfer failed');
  }

}