ERC-20
Overview
Max Total Supply
2.747493785488010443 aurarsETH/wETH-vault
Holders
5
Market
Price
$0.00 @ 0.000000 ETH
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
0 aurarsETH/wETH-vaultValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x1EBA2154...cC67f54C7 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
BaseRewardPool4626
Compiler Version
v0.6.12+commit.27d51765
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import { IRewards } from "./Interfaces.sol"; import { BaseRewardPool, IDeposit } from "./BaseRewardPool.sol"; import { IERC4626, IERC20Metadata } from "./interfaces/IERC4626.sol"; import { IERC20 } from "@openzeppelin/contracts-0.6/token/ERC20/IERC20.sol"; import { ReentrancyGuard } from "@openzeppelin/contracts-0.6/utils/ReentrancyGuard.sol"; import { SafeERC20 } from "@openzeppelin/contracts-0.6/token/ERC20/SafeERC20.sol"; /** * @title BaseRewardPool4626 * @notice Simply wraps the BaseRewardPool with the new IERC4626 Vault standard functions. * @dev See https://github.com/fei-protocol/ERC4626/blob/main/src/interfaces/IERC4626.sol#L58 * This is not so much a vault as a Reward Pool, therefore asset:share ratio is always 1:1. * To create most utility for this RewardPool, the "asset" has been made to be the crvLP token, * as opposed to the cvxLP token. Therefore, users can easily deposit crvLP, and it will first * go to the Booster and mint the cvxLP before performing the normal staking function. */ contract BaseRewardPool4626 is BaseRewardPool, ReentrancyGuard, IERC4626 { using SafeERC20 for IERC20; /** * @notice The address of the underlying ERC20 token used for * the Vault for accounting, depositing, and withdrawing. */ address public override asset; mapping (address => mapping (address => uint256)) private _allowances; /** * @dev See BaseRewardPool.sol */ constructor( uint256 pid_, address stakingToken_, address rewardToken_, address operator_, address rewardManager_, address lptoken_ ) public BaseRewardPool(pid_, stakingToken_, rewardToken_, operator_, rewardManager_) { asset = lptoken_; IERC20(asset).safeApprove(operator_, type(uint256).max); } /** * @notice Total amount of the underlying asset that is "managed" by Vault. */ function totalAssets() external view virtual override returns(uint256){ return totalSupply(); } /** * @notice Mints `shares` Vault shares to `receiver`. * @dev Because `asset` is not actually what is collected here, first wrap to required token in the booster. */ function deposit(uint256 assets, address receiver) public virtual override nonReentrant returns (uint256) { // Transfer "asset" (crvLP) from sender IERC20(asset).safeTransferFrom(msg.sender, address(this), assets); // Convert crvLP to cvxLP through normal booster deposit process, but don't stake uint256 balBefore = stakingToken.balanceOf(address(this)); IDeposit(operator).deposit(pid, assets, false); uint256 balAfter = stakingToken.balanceOf(address(this)); require(balAfter.sub(balBefore) >= assets, "!deposit"); // Perform stake manually, now that the funds have been received _processStake(assets, receiver); emit Deposit(msg.sender, receiver, assets, assets); emit Staked(receiver, assets); return assets; } /** * @notice Mints exactly `shares` Vault shares to `receiver` * by depositing `assets` of underlying tokens. */ function mint(uint256 shares, address receiver) external virtual override returns (uint256) { return deposit(shares, receiver); } /** * @notice Redeems `shares` from `owner` and sends `assets` * of underlying tokens to `receiver`. */ function withdraw( uint256 assets, address receiver, address owner ) public virtual override nonReentrant returns (uint256) { if (msg.sender != owner) { _approve(owner, msg.sender, _allowances[owner][msg.sender].sub(assets, "ERC4626: withdrawal amount exceeds allowance")); } _withdrawAndUnwrapTo(assets, owner, receiver); emit Withdraw(msg.sender, receiver, owner, assets, assets); return assets; } /** * @notice Redeems `shares` from `owner` and sends `assets` * of underlying tokens to `receiver`. */ function redeem( uint256 shares, address receiver, address owner ) external virtual override returns (uint256) { return withdraw(shares, receiver, owner); } /** * @notice The amount of shares that the vault would * exchange for the amount of assets provided, in an * ideal scenario where all the conditions are met. */ function convertToShares(uint256 assets) public view virtual override returns (uint256) { return assets; } /** * @notice The amount of assets that the vault would * exchange for the amount of shares provided, in an * ideal scenario where all the conditions are met. */ function convertToAssets(uint256 shares) public view virtual override returns (uint256) { return shares; } /** * @notice Total number of underlying assets that can * be deposited by `owner` into the Vault, where `owner` * corresponds to the input parameter `receiver` of a * `deposit` call. */ function maxDeposit(address /* owner */) public view virtual override returns (uint256) { return type(uint256).max; } /** * @notice Allows an on-chain or off-chain user to simulate * the effects of their deposit at the current block, given * current on-chain conditions. */ function previewDeposit(uint256 assets) external view virtual override returns(uint256){ return convertToShares(assets); } /** * @notice Total number of underlying shares that can be minted * for `owner`, where `owner` corresponds to the input * parameter `receiver` of a `mint` call. */ function maxMint(address owner) external view virtual override returns (uint256) { return maxDeposit(owner); } /** * @notice Allows an on-chain or off-chain user to simulate * the effects of their mint at the current block, given * current on-chain conditions. */ function previewMint(uint256 shares) external view virtual override returns(uint256){ return convertToAssets(shares); } /** * @notice Total number of underlying assets that can be * withdrawn from the Vault by `owner`, where `owner` * corresponds to the input parameter of a `withdraw` call. */ function maxWithdraw(address owner) public view virtual override returns (uint256) { return balanceOf(owner); } /** * @notice Allows an on-chain or off-chain user to simulate * the effects of their withdrawal at the current block, * given current on-chain conditions. */ function previewWithdraw(uint256 assets) public view virtual override returns(uint256 shares){ return convertToShares(assets); } /** * @notice Total number of underlying shares that can be * redeemed from the Vault by `owner`, where `owner` corresponds * to the input parameter of a `redeem` call. */ function maxRedeem(address owner) external view virtual override returns (uint256) { return maxWithdraw(owner); } /** * @notice Allows an on-chain or off-chain user to simulate * the effects of their redeemption at the current block, * given current on-chain conditions. */ function previewRedeem(uint256 shares) external view virtual override returns(uint256){ return previewWithdraw(shares); } /* ========== IERC20 ========== */ /** * @dev Returns the name of the token. */ function name() external view override returns (string memory) { return string( abi.encodePacked(IERC20Metadata(address(stakingToken)).name(), " Vault") ); } /** * @dev Returns the symbol of the token. */ function symbol() external view override returns (string memory) { return string( abi.encodePacked(IERC20Metadata(address(stakingToken)).symbol(), "-vault") ); } /** * @dev Returns the decimals places of the token. */ function decimals() external view override returns (uint8) { return 18; } /** * @dev Returns the amount of tokens in existence. */ function totalSupply() public view override(BaseRewardPool, IERC20) returns (uint256) { return BaseRewardPool.totalSupply(); } /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) public view override(BaseRewardPool, IERC20) returns (uint256) { return BaseRewardPool.balanceOf(account); } /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external override returns (bool) { _transfer(msg.sender, recipient, 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}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(msg.sender, spender, amount); return true; } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC4626: approve from the zero address"); require(spender != address(0), "ERC4626: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. */ function transferFrom(address owner, address recipient, uint256 amount) external override returns (bool) { uint256 newAllowance = _allowances[owner][msg.sender].sub(amount, "ERC4626: withdrawal amount exceeds allowance"); _approve(owner, msg.sender, newAllowance); _transfer(owner, recipient, amount); return true; } function _transfer(address from, address to, uint256 amount) internal updateReward(from) updateReward(to) virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); for(uint i=0; i < extraRewards.length; i++){ IRewards(extraRewards[i]).withdraw(from , amount); IRewards(extraRewards[i]).stake(to, amount); } _balances[from] = fromBalance.sub(amount); _balances[to] = _balances[to].add(amount); emit Transfer(from, to, amount); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ 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) { 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) { 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) { // 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) { 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) { 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) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @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) { require(b <= a, "SafeMath: subtraction overflow"); 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) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @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. 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) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); 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) { require(b > 0, "SafeMath: modulo by zero"); 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) { 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. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * 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) { 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) { require(b > 0, errorMessage); return a % b; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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 `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount) external returns (bool); /** * @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); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "./IERC20.sol"; import "../../math/SafeMath.sol"; import "../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <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; // solhint-disable-next-line no-inline-assembly 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"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (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"); // solhint-disable-next-line avoid-low-level-calls (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"); // solhint-disable-next-line avoid-low-level-calls (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"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private 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 // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <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 () internal { _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 make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** *Submitted for verification at Etherscan.io on 2020-07-17 */ /* ____ __ __ __ _ / __/__ __ ___ / /_ / / ___ / /_ (_)__ __ _\ \ / // // _ \/ __// _ \/ -_)/ __// / \ \ / /___/ \_, //_//_/\__//_//_/\__/ \__//_/ /_\_\ /___/ * Synthetix: BaseRewardPool.sol * * Docs: https://docs.synthetix.io/ * * * MIT License * =========== * * Copyright (c) 2020 Synthetix * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE */ import "./Interfaces.sol"; import "./interfaces/MathUtil.sol"; import "@openzeppelin/contracts-0.6/math/SafeMath.sol"; import "@openzeppelin/contracts-0.6/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts-0.6/utils/Address.sol"; import "@openzeppelin/contracts-0.6/token/ERC20/SafeERC20.sol"; /** * @title BaseRewardPool * @author Synthetix -> ConvexFinance * @notice Unipool rewards contract that is re-deployed from rFactory for each staking pool. * @dev Changes made here by ConvexFinance are to do with the delayed reward allocation. Curve is queued for * rewards and the distribution only begins once the new rewards are sufficiently large, or the epoch * has ended. Additionally, enables hooks for `extraRewards` that can be enabled at any point to * distribute a child reward token (i.e. a secondary one from Curve, or a seperate one). */ contract BaseRewardPool { using SafeMath for uint256; using SafeERC20 for IERC20; IERC20 public immutable rewardToken; IERC20 public immutable stakingToken; uint256 public constant duration = 7 days; address public immutable operator; address public immutable rewardManager; uint256 public immutable pid; uint256 public periodFinish = 0; uint256 public rewardRate = 0; uint256 public lastUpdateTime; uint256 public rewardPerTokenStored; uint256 public queuedRewards = 0; uint256 public currentRewards = 0; uint256 public historicalRewards = 0; uint256 public constant newRewardRatio = 830; uint256 private _totalSupply; mapping(address => uint256) public userRewardPerTokenPaid; mapping(address => uint256) public rewards; mapping(address => uint256) internal _balances; address[] public extraRewards; event RewardAdded(uint256 reward); event Staked(address indexed user, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event RewardPaid(address indexed user, uint256 reward); event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev This is called directly from RewardFactory * @param pid_ Effectively the pool identifier - used in the Booster * @param stakingToken_ Pool LP token * @param rewardToken_ Crv * @param operator_ Booster * @param rewardManager_ RewardFactory */ constructor( uint256 pid_, address stakingToken_, address rewardToken_, address operator_, address rewardManager_ ) public { pid = pid_; stakingToken = IERC20(stakingToken_); rewardToken = IERC20(rewardToken_); operator = operator_; rewardManager = rewardManager_; } function totalSupply() public view virtual returns (uint256) { return _totalSupply; } function balanceOf(address account) public view virtual returns (uint256) { return _balances[account]; } function extraRewardsLength() external view returns (uint256) { return extraRewards.length; } function addExtraReward(address _reward) external returns(bool){ require(msg.sender == rewardManager, "!authorized"); require(_reward != address(0),"!reward setting"); if(extraRewards.length >= 12){ return false; } extraRewards.push(_reward); return true; } function clearExtraRewards() external{ require(msg.sender == rewardManager, "!authorized"); delete extraRewards; } modifier updateReward(address account) { rewardPerTokenStored = rewardPerToken(); lastUpdateTime = lastTimeRewardApplicable(); if (account != address(0)) { rewards[account] = earned(account); userRewardPerTokenPaid[account] = rewardPerTokenStored; } _; } function lastTimeRewardApplicable() public view returns (uint256) { return MathUtil.min(block.timestamp, periodFinish); } function rewardPerToken() public view returns (uint256) { if (totalSupply() == 0) { return rewardPerTokenStored; } return rewardPerTokenStored.add( lastTimeRewardApplicable() .sub(lastUpdateTime) .mul(rewardRate) .mul(1e18) .div(totalSupply()) ); } function earned(address account) public view returns (uint256) { return balanceOf(account) .mul(rewardPerToken().sub(userRewardPerTokenPaid[account])) .div(1e18) .add(rewards[account]); } function stake(uint256 _amount) public returns(bool) { _processStake(_amount, msg.sender); stakingToken.safeTransferFrom(msg.sender, address(this), _amount); emit Staked(msg.sender, _amount); return true; } function stakeAll() external returns(bool){ uint256 balance = stakingToken.balanceOf(msg.sender); stake(balance); return true; } function stakeFor(address _for, uint256 _amount) public returns(bool) { _processStake(_amount, _for); //take away from sender stakingToken.safeTransferFrom(msg.sender, address(this), _amount); emit Staked(_for, _amount); return true; } /** * @dev Generic internal staking function that basically does 3 things: update rewards based * on previous balance, trigger also on any child contracts, then update balances. * @param _amount Units to add to the users balance * @param _receiver Address of user who will receive the stake */ function _processStake(uint256 _amount, address _receiver) internal updateReward(_receiver) { require(_amount > 0, 'RewardPool : Cannot stake 0'); //also stake to linked rewards for(uint i=0; i < extraRewards.length; i++){ IRewards(extraRewards[i]).stake(_receiver, _amount); } _totalSupply = _totalSupply.add(_amount); _balances[_receiver] = _balances[_receiver].add(_amount); emit Transfer(address(0), _receiver, _amount); } function withdraw(uint256 amount, bool claim) public updateReward(msg.sender) returns(bool) { require(amount > 0, 'RewardPool : Cannot withdraw 0'); //also withdraw from linked rewards for(uint i=0; i < extraRewards.length; i++){ IRewards(extraRewards[i]).withdraw(msg.sender, amount); } _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = _balances[msg.sender].sub(amount); stakingToken.safeTransfer(msg.sender, amount); emit Withdrawn(msg.sender, amount); if(claim){ getReward(msg.sender,true); } emit Transfer(msg.sender, address(0), amount); return true; } function withdrawAll(bool claim) external{ withdraw(_balances[msg.sender],claim); } function withdrawAndUnwrap(uint256 amount, bool claim) public returns(bool){ _withdrawAndUnwrapTo(amount, msg.sender, msg.sender); //get rewards too if(claim){ getReward(msg.sender,true); } return true; } function _withdrawAndUnwrapTo(uint256 amount, address from, address receiver) internal updateReward(from) returns(bool){ //also withdraw from linked rewards for(uint i=0; i < extraRewards.length; i++){ IRewards(extraRewards[i]).withdraw(from, amount); } _totalSupply = _totalSupply.sub(amount); _balances[from] = _balances[from].sub(amount); //tell operator to withdraw from here directly to user IDeposit(operator).withdrawTo(pid,amount,receiver); emit Withdrawn(from, amount); emit Transfer(from, address(0), amount); return true; } function withdrawAllAndUnwrap(bool claim) external{ withdrawAndUnwrap(_balances[msg.sender],claim); } /** * @dev Gives a staker their rewards, with the option of claiming extra rewards * @param _account Account for which to claim * @param _claimExtras Get the child rewards too? */ function getReward(address _account, bool _claimExtras) public updateReward(_account) returns(bool){ uint256 reward = earned(_account); if (reward > 0) { rewards[_account] = 0; rewardToken.safeTransfer(_account, reward); IDeposit(operator).rewardClaimed(pid, _account, reward); emit RewardPaid(_account, reward); } //also get rewards from linked rewards if(_claimExtras){ for(uint i=0; i < extraRewards.length; i++){ IRewards(extraRewards[i]).getReward(_account); } } return true; } /** * @dev Called by a staker to get their allocated rewards */ function getReward() external returns(bool){ getReward(msg.sender,true); return true; } /** * @dev Processes queued rewards in isolation, providing the period has finished. * This allows a cheaper way to trigger rewards on low value pools. */ function processIdleRewards() external { if (block.timestamp >= periodFinish && queuedRewards > 0) { notifyRewardAmount(queuedRewards); queuedRewards = 0; } } /** * @dev Called by the booster to allocate new Crv rewards to this pool * Curve is queued for rewards and the distribution only begins once the new rewards are sufficiently * large, or the epoch has ended. */ function queueNewRewards(uint256 _rewards) external returns(bool){ require(msg.sender == operator, "!authorized"); _rewards = _rewards.add(queuedRewards); if (block.timestamp >= periodFinish) { notifyRewardAmount(_rewards); queuedRewards = 0; return true; } //et = now - (finish-duration) uint256 elapsedTime = block.timestamp.sub(periodFinish.sub(duration)); //current at now: rewardRate * elapsedTime uint256 currentAtNow = rewardRate * elapsedTime; uint256 queuedRatio = currentAtNow.mul(1000).div(_rewards); //uint256 queuedRatio = currentRewards.mul(1000).div(_rewards); if(queuedRatio < newRewardRatio){ notifyRewardAmount(_rewards); queuedRewards = 0; }else{ queuedRewards = _rewards; } return true; } function notifyRewardAmount(uint256 reward) internal updateReward(address(0)) { historicalRewards = historicalRewards.add(reward); if (block.timestamp >= periodFinish) { rewardRate = reward.div(duration); } else { uint256 remaining = periodFinish.sub(block.timestamp); uint256 leftover = remaining.mul(rewardRate); reward = reward.add(leftover); rewardRate = reward.div(duration); } currentRewards = reward; lastUpdateTime = block.timestamp; periodFinish = block.timestamp.add(duration); emit RewardAdded(reward); } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; interface ICurveGauge { function deposit(uint256) external; function balanceOf(address) external view returns (uint256); function withdraw(uint256) external; function claim_rewards() external; function reward_tokens(uint256) external view returns(address);//v2 function rewarded_token() external view returns(address);//v1 function lp_token() external view returns(address); } interface ICurveVoteEscrow { function create_lock(uint256, uint256) external; function increase_amount(uint256) external; function increase_unlock_time(uint256) external; function withdraw() external; function smart_wallet_checker() external view returns (address); function commit_smart_wallet_checker(address) external; function apply_smart_wallet_checker() external; } interface IWalletChecker { function check(address) external view returns (bool); function approveWallet(address) external; function dao() external view returns (address); } interface IVoting{ function vote(uint256, bool, bool) external; //voteId, support, executeIfDecided function getVote(uint256) external view returns(bool,bool,uint64,uint64,uint64,uint64,uint256,uint256,uint256,bytes memory); function vote_for_gauge_weights(address,uint256) external; } interface IMinter{ function mint(address) external; } interface IStaker{ function deposit(address, address) external returns (bool); function withdraw(address) external returns (uint256); function withdraw(address, address, uint256) external returns (bool); function withdrawAll(address, address) external returns (bool); function createLock(uint256, uint256) external returns(bool); function increaseAmount(uint256) external returns(bool); function increaseTime(uint256) external returns(bool); function release() external returns(bool); function claimCrv(address) external returns (uint256); function claimRewards(address) external returns(bool); function claimFees(address,address) external returns (uint256); function setStashAccess(address, bool) external returns (bool); function vote(uint256,address,bool) external returns(bool); function voteGaugeWeight(address,uint256) external returns(bool); function balanceOfPool(address) external view returns (uint256); function operator() external view returns (address); function execute(address _to, uint256 _value, bytes calldata _data) external returns (bool, bytes memory); function setVote(bytes32 hash, bool valid) external; function migrate(address to) external; } interface IRewards{ function stake(address, uint256) external; function stakeFor(address, uint256) external; function withdraw(address, uint256) external; function exit(address) external; function getReward(address) external; function queueNewRewards(uint256) external; function notifyRewardAmount(uint256) external; function addExtraReward(address) external; function extraRewardsLength() external view returns (uint256); function stakingToken() external view returns (address); function rewardToken() external view returns(address); function earned(address account) external view returns (uint256); } interface IStash{ function stashRewards() external returns (bool); function processStash() external returns (bool); function claimRewards() external returns (bool); function initialize(uint256 _pid, address _operator, address _staker, address _gauge, address _rewardFactory) external; function setExtraReward(address) external; } interface IFeeDistributor { function claimToken(address user, address token) external returns (uint256); function claimTokens(address user, address[] calldata tokens) external returns (uint256[] memory); function getTokenTimeCursor(address token) external view returns (uint256); } interface ITokenMinter{ function mint(address,uint256) external; function burn(address,uint256) external; } interface IDeposit{ function isShutdown() external view returns(bool); function balanceOf(address _account) external view returns(uint256); function totalSupply() external view returns(uint256); function poolInfo(uint256) external view returns(address,address,address,address,address, bool); function rewardClaimed(uint256,address,uint256) external; function withdrawTo(uint256,uint256,address) external; function claimRewards(uint256,address) external returns(bool); function rewardArbitrator() external returns(address); function setGaugeRedirect(uint256 _pid) external returns(bool); function owner() external returns(address); function deposit(uint256 _pid, uint256 _amount, bool _stake) external returns(bool); } interface ICrvDeposit{ function deposit(uint256, bool) external; function lockIncentive() external view returns(uint256); } interface IRewardFactory{ function setAccess(address,bool) external; function CreateCrvRewards(uint256,address,address) external returns(address); function CreateTokenRewards(address,address,address) external returns(address); function activeRewardCount(address) external view returns(uint256); function addActiveReward(address,uint256) external returns(bool); function removeActiveReward(address,uint256) external returns(bool); } interface IStashFactory{ function CreateStash(uint256,address,address,uint256) external returns(address); function setImplementation(address, address, address) external; } interface ITokenFactory{ function CreateDepositToken(address) external returns(address); } interface IPools{ function addPool(address _lptoken, address _gauge, uint256 _stashVersion) external returns(bool); function forceAddPool(address _lptoken, address _gauge, uint256 _stashVersion) external returns(bool); function shutdownPool(uint256 _pid) external returns(bool); function poolInfo(uint256) external view returns(address,address,address,address,address,bool); function poolLength() external view returns (uint256); function gaugeMap(address) external view returns(bool); function setPoolManager(address _poolM) external; function shutdownSystem() external; function setUsedAddress(address[] memory) external; } interface IVestedEscrow{ function fund(address[] calldata _recipient, uint256[] calldata _amount) external returns(bool); } interface IRewardDeposit { function addReward(address, uint256) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import { IERC20 } from "@openzeppelin/contracts-0.6/token/ERC20/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 pragma solidity 0.6.12; import { IERC20Metadata } from "./IERC20Metadata.sol"; /// @title ERC4626 interface /// See: https://eips.ethereum.org/EIPS/eip-4626 abstract contract IERC4626 is IERC20Metadata { /*//////////////////////////////////////////////////////// Events ////////////////////////////////////////////////////////*/ /// @notice `caller` has exchanged `assets` for `shares`, and transferred those `shares` to `owner` event Deposit( address indexed caller, address indexed owner, uint256 assets, uint256 shares ); /// @notice `caller` has exchanged `shares`, owned by `owner`, for /// `assets`, and transferred those `assets` to `receiver`. event Withdraw( address indexed caller, address indexed receiver, address indexed owner, uint256 assets, uint256 shares ); /*//////////////////////////////////////////////////////// Vault properties ////////////////////////////////////////////////////////*/ /// @notice The address of the underlying ERC20 token used for /// the Vault for accounting, depositing, and withdrawing. function asset() external view virtual returns(address); /// @notice Total amount of the underlying asset that /// is "managed" by Vault. function totalAssets() external view virtual returns(uint256); /*//////////////////////////////////////////////////////// Deposit/Withdrawal Logic ////////////////////////////////////////////////////////*/ /// @notice Mints `shares` Vault shares to `receiver` by /// depositing exactly `assets` of underlying tokens. function deposit(uint256 assets, address receiver) external virtual returns(uint256 shares); /// @notice Mints exactly `shares` Vault shares to `receiver` /// by depositing `assets` of underlying tokens. function mint(uint256 shares, address receiver) external virtual returns(uint256 assets); /// @notice Redeems `shares` from `owner` and sends `assets` /// of underlying tokens to `receiver`. function withdraw(uint256 assets, address receiver, address owner) external virtual returns(uint256 shares); /// @notice Redeems `shares` from `owner` and sends `assets` /// of underlying tokens to `receiver`. function redeem(uint256 shares, address receiver, address owner) external virtual returns(uint256 assets); /*//////////////////////////////////////////////////////// Vault Accounting Logic ////////////////////////////////////////////////////////*/ /// @notice The amount of shares that the vault would /// exchange for the amount of assets provided, in an /// ideal scenario where all the conditions are met. function convertToShares(uint256 assets) external view virtual returns(uint256 shares); /// @notice The amount of assets that the vault would /// exchange for the amount of shares provided, in an /// ideal scenario where all the conditions are met. function convertToAssets(uint256 shares) external view virtual returns(uint256 assets); /// @notice Total number of underlying assets that can /// be deposited by `owner` into the Vault, where `owner` /// corresponds to the input parameter `receiver` of a /// `deposit` call. function maxDeposit(address owner) external view virtual returns(uint256 maxAssets); /// @notice Allows an on-chain or off-chain user to simulate /// the effects of their deposit at the current block, given /// current on-chain conditions. function previewDeposit(uint256 assets) external view virtual returns(uint256 shares); /// @notice Total number of underlying shares that can be minted /// for `owner`, where `owner` corresponds to the input /// parameter `receiver` of a `mint` call. function maxMint(address owner) external view virtual returns(uint256 maxShares); /// @notice Allows an on-chain or off-chain user to simulate /// the effects of their mint at the current block, given /// current on-chain conditions. function previewMint(uint256 shares) external view virtual returns(uint256 assets); /// @notice Total number of underlying assets that can be /// withdrawn from the Vault by `owner`, where `owner` /// corresponds to the input parameter of a `withdraw` call. function maxWithdraw(address owner) external view virtual returns(uint256 maxAssets); /// @notice Allows an on-chain or off-chain user to simulate /// the effects of their withdrawal at the current block, /// given current on-chain conditions. function previewWithdraw(uint256 assets) external view virtual returns(uint256 shares); /// @notice Total number of underlying shares that can be /// redeemed from the Vault by `owner`, where `owner` corresponds /// to the input parameter of a `redeem` call. function maxRedeem(address owner) external view virtual returns(uint256 maxShares); /// @notice Allows an on-chain or off-chain user to simulate /// the effects of their redeemption at the current block, /// given current on-chain conditions. function previewRedeem(uint256 shares) external view virtual returns(uint256 assets); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** * @dev Standard math utilities missing in the Solidity language. */ library MathUtil { /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256","name":"pid_","type":"uint256"},{"internalType":"address","name":"stakingToken_","type":"address"},{"internalType":"address","name":"rewardToken_","type":"address"},{"internalType":"address","name":"operator_","type":"address"},{"internalType":"address","name":"rewardManager_","type":"address"},{"internalType":"address","name":"lptoken_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Withdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[{"internalType":"address","name":"_reward","type":"address"}],"name":"addExtraReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"asset","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clearExtraRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"convertToAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"convertToShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"extraRewards","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"extraRewardsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"bool","name":"_claimExtras","type":"bool"}],"name":"getReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"historicalRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"newRewardRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"processIdleRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewards","type":"uint256"}],"name":"queueNewRewards","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"queuedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stake","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakeAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_for","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stakeFor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"claim","type":"bool"}],"name":"withdraw","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"claim","type":"bool"}],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"claim","type":"bool"}],"name":"withdrawAllAndUnwrap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"claim","type":"bool"}],"name":"withdrawAndUnwrap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.