S Price: $0.80465 (-6.16%)
    /

    Contract Diff Checker

    Contract Name:
    GaugeV2_CL

    Contract Source Code:

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v4.7.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 anymore. Can only be called by the current owner.
         *
         * NOTE: Renouncing ownership will leave the contract without an owner,
         * thereby removing 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 (last updated v4.8.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;
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
    
    pragma solidity ^0.8.0;
    
    /**
     * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
     * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
     *
     * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
     * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
     * need to send a transaction, and thus is not required to hold Ether at all.
     */
    interface IERC20Permit {
        /**
         * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
         * given ``owner``'s signed approval.
         *
         * IMPORTANT: The same issues {IERC20-approve} has related to transaction
         * ordering also apply here.
         *
         * Emits an {Approval} event.
         *
         * Requirements:
         *
         * - `spender` cannot be the zero address.
         * - `deadline` must be a timestamp in the future.
         * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
         * over the EIP712-formatted function arguments.
         * - the signature must use ``owner``'s current nonce (see {nonces}).
         *
         * For more information on the signature format, see the
         * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
         * section].
         */
        function permit(
            address owner,
            address spender,
            uint256 value,
            uint256 deadline,
            uint8 v,
            bytes32 r,
            bytes32 s
        ) external;
    
        /**
         * @dev Returns the current nonce for `owner`. This value must be
         * included whenever a signature is generated for {permit}.
         *
         * Every successful call to {permit} increases ``owner``'s nonce by one. This
         * prevents a signature from being used multiple times.
         */
        function nonces(address owner) external view returns (uint256);
    
        /**
         * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
         */
        // solhint-disable-next-line func-name-mixedcase
        function DOMAIN_SEPARATOR() external view returns (bytes32);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v4.6.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.8.0) (token/ERC20/utils/SafeERC20.sol)
    
    pragma solidity ^0.8.0;
    
    import "../IERC20.sol";
    import "../extensions/draft-IERC20Permit.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 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'
            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) + value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    
        function safeDecreaseAllowance(
            IERC20 token,
            address spender,
            uint256 value
        ) internal {
            unchecked {
                uint256 oldAllowance = token.allowance(address(this), spender);
                require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
                uint256 newAllowance = oldAllowance - value;
                _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
            }
        }
    
        function safePermit(
            IERC20Permit token,
            address owner,
            address spender,
            uint256 value,
            uint256 deadline,
            uint8 v,
            bytes32 r,
            bytes32 s
        ) internal {
            uint256 nonceBefore = token.nonces(owner);
            token.permit(owner, spender, value, deadline, v, r, s);
            uint256 nonceAfter = token.nonces(owner);
            require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
        }
    
        /**
         * @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
                require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
            }
        }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
    
    pragma solidity ^0.8.1;
    
    /**
     * @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
         * ====
         *
         * [IMPORTANT]
         * ====
         * You shouldn't rely on `isContract` to protect against flash loan attacks!
         *
         * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
         * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
         * constructor.
         * ====
         */
        function isContract(address account) internal view returns (bool) {
            // This method relies on extcodesize/address.code.length, which returns 0
            // for contracts in construction, since the code is only stored at the end
            // of the constructor execution.
    
            return account.code.length > 0;
        }
    
        /**
         * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
         * `recipient`, forwarding all available gas and reverting on errors.
         *
         * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
         * of certain opcodes, possibly making contracts go over the 2300 gas limit
         * imposed by `transfer`, making them unable to receive funds via
         * `transfer`. {sendValue} removes this limitation.
         *
         * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
         *
         * IMPORTANT: because control is transferred to `recipient`, care must be
         * taken to not create reentrancy vulnerabilities. Consider using
         * {ReentrancyGuard} or the
         * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
         */
        function sendValue(address payable recipient, uint256 amount) internal {
            require(address(this).balance >= amount, "Address: insufficient balance");
    
            (bool success, ) = recipient.call{value: amount}("");
            require(success, "Address: unable to send value, recipient may have reverted");
        }
    
        /**
         * @dev Performs a Solidity function call using a low level `call`. A
         * plain `call` is an unsafe replacement for a function call: use this
         * function instead.
         *
         * If `target` reverts with a revert reason, it is bubbled up by this
         * function (like regular Solidity function calls).
         *
         * Returns the raw returned data. To convert to the expected return value,
         * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
         *
         * Requirements:
         *
         * - `target` must be a contract.
         * - calling `target` with `data` must not revert.
         *
         * _Available since v3.1._
         */
        function functionCall(address target, bytes memory data) internal returns (bytes memory) {
            return functionCallWithValue(target, data, 0, "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");
            (bool success, bytes memory returndata) = target.call{value: value}(data);
            return verifyCallResultFromTarget(target, 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) {
            (bool success, bytes memory returndata) = target.staticcall(data);
            return verifyCallResultFromTarget(target, 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) {
            (bool success, bytes memory returndata) = target.delegatecall(data);
            return verifyCallResultFromTarget(target, success, returndata, errorMessage);
        }
    
        /**
         * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
         * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
         *
         * _Available since v4.8._
         */
        function verifyCallResultFromTarget(
            address target,
            bool success,
            bytes memory returndata,
            string memory errorMessage
        ) internal view returns (bytes memory) {
            if (success) {
                if (returndata.length == 0) {
                    // only check isContract if the call was successful and the return data is empty
                    // otherwise we already know that it was a contract
                    require(isContract(target), "Address: call to non-contract");
                }
                return returndata;
            } else {
                _revert(returndata, errorMessage);
            }
        }
    
        /**
         * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
         * revert reason or using the provided one.
         *
         * _Available since v4.3._
         */
        function verifyCallResult(
            bool success,
            bytes memory returndata,
            string memory errorMessage
        ) internal pure returns (bytes memory) {
            if (success) {
                return returndata;
            } else {
                _revert(returndata, errorMessage);
            }
        }
    
        function _revert(bytes memory returndata, string memory errorMessage) private pure {
            // 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
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }

    // 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
    pragma solidity 0.8.13;
    
    import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
    import "@openzeppelin/contracts/access/Ownable.sol";
    import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
    
    import "./interfaces/IPairInfo.sol";
    import "./interfaces/IBribe.sol";
    import {Constants} from "./libraries/Constants.sol";
    
    interface IRewarder {
        function onReward(
            uint256 pid,
            address user,
            address recipient,
            uint256 amount,
            uint256 newLpAmount
        ) external;
    }
    
    interface IFeeVault {
        function claimFees() external returns (uint256 claimed0, uint256 claimed1);
    }
    
    contract GaugeV2_CL is ReentrancyGuard, Ownable {
        using SafeERC20 for IERC20;
    
        address public constant TOKEN_WITHDRAWER = 0xAdB5A1518713095C39dBcA08Da6656af7249Dd20;
    
        bool public emergency;
    
        IERC20 public rewardToken;
        // IERC20 public _VE;
        IERC20 public TOKEN;
    
        address public DISTRIBUTION;
        address public gaugeRewarder;
        address public internal_bribe;
        address public external_bribe;
        address public feeVault;
        address public feeVault2;
    
        uint256 public rewarderPid; //default to 0
        uint256 public DURATION;
        uint256 public periodFinish;
        uint256 public rewardRate;
        uint256 public lastUpdateTime;
        uint256 public rewardPerTokenStored;
    
        uint public fees0;
        uint public fees1;
    
        mapping(address => uint256) public userRewardPerTokenPaid;
        mapping(address => uint256) public rewards;
    
        uint256 public _totalSupply;
        mapping(address => uint256) public _balances;
    
        event RewardAdded(uint256 reward);
        event Deposit(address indexed user, uint256 amount);
        event Withdraw(address indexed user, uint256 amount);
        event Harvest(address indexed user, uint256 reward);
        event ClaimFees(address indexed from, uint claimed0, uint claimed1);
    
        constructor(
            address _rewardToken,
            address /* _ve */,
            address _token,
            address _distribution,
            address _internal_bribe,
            address _external_bribe,
            address _feeVault,
            address _feeVault2
        ) {
            rewardToken = IERC20(_rewardToken); // main reward
            // _VE = IERC20(_ve);                      // vested
            TOKEN = IERC20(_token); // underlying (LP)
            DISTRIBUTION = _distribution; // distro address (voter)
            DURATION = Constants.EPOCH_LENGTH; // distro time
    
            internal_bribe = _internal_bribe; // lp fees goes here
            external_bribe = _external_bribe; // bribe fees goes here
    
            feeVault = _feeVault; // fee vault concentrated liqudity position (to send trading fees to internal bribe)
            feeVault2 = _feeVault2; // fee vault concentrated liqudity position (to send trading fees to nft staking and treasury)
    
            // emergency = false; // emergency flag
        }
    
        /* -----------------------------------------------------------------------------
        --------------------------------------------------------------------------------
        --------------------------------------------------------------------------------
                                        ONLY OWNER
        --------------------------------------------------------------------------------
        --------------------------------------------------------------------------------
        ----------------------------------------------------------------------------- */
    
        ///@notice set distribution address (should be GaugeProxyL2)
        function setDistribution(address _distribution) external onlyOwner {
            require(_distribution != address(0) && _distribution != DISTRIBUTION);
            DISTRIBUTION = _distribution;
        }
    
        ///@notice set gauge rewarder address
        function setGaugeRewarder(address _gaugeRewarder) external onlyOwner {
            require(_gaugeRewarder != gaugeRewarder);
            gaugeRewarder = _gaugeRewarder;
        }
    
        ///@notice set feeVault address
        function setFeeVaults(
            address _feeVault,
            address _feeVault2
        ) external onlyOwner {
            require(
                _feeVault != address(0) &&
                    _feeVault2 != address(0) &&
                    _feeVault != feeVault &&
                    _feeVault2 != feeVault2
            );
            feeVault = _feeVault;
            feeVault2 = _feeVault2;
        }
    
        ///@notice set extra rewarder pid
        function setRewarderPid(uint256 _pid) external onlyOwner {
            require(/* _pid >= 0 &&  */ _pid != rewarderPid);
            rewarderPid = _pid;
        }
    
        ///@notice set new internal bribe contract (where to send fees)
        function setInternalBribe(address _int) external onlyOwner {
            require(_int >= address(0));
            internal_bribe = _int;
        }
    
        function activateEmergencyMode() external onlyOwner {
            require(!emergency);
            emergency = true;
        }
    
        function stopEmergencyMode() external onlyOwner {
            require(emergency);
            emergency = false;
        }
    
        function withdrawExcess(address token, uint256 amount) external {
            require(msg.sender == TOKEN_WITHDRAWER);
            require(address(TOKEN) != token && token != address(0) && amount > 0);
            IERC20(token).safeTransfer(msg.sender, amount);
        }
    
        /* -----------------------------------------------------------------------------
        --------------------------------------------------------------------------------
        --------------------------------------------------------------------------------
                                        VIEW FUNCTIONS
        --------------------------------------------------------------------------------
        --------------------------------------------------------------------------------
        ----------------------------------------------------------------------------- */
    
        ///@notice total supply held
        function totalSupply() public view returns (uint256) {
            return _totalSupply;
        }
    
        ///@notice balance of a user
        function balanceOf(address account) external view returns (uint256) {
            return _balances[account];
        }
    
        ///@notice last time reward
        function lastTimeRewardApplicable() public view returns (uint256) {
            return block.timestamp < periodFinish ? block.timestamp : periodFinish;
        }
    
        ///@notice  reward for a sinle token
        function rewardPerToken() public view returns (uint256) {
            if (_totalSupply == 0) {
                return rewardPerTokenStored;
            } else {
                return
                    rewardPerTokenStored +
                    (((lastTimeRewardApplicable() - lastUpdateTime) *
                        rewardRate *
                        1e18) / _totalSupply);
            }
        }
    
        ///@notice see earned rewards for user
        function earned(address account) public view returns (uint256) {
            return
                (_balances[account] *
                    (rewardPerToken() - userRewardPerTokenPaid[account])) /
                1e18 +
                rewards[account];
        }
    
        ///@notice get total reward for the duration
        function rewardForDuration() external view returns (uint256) {
            // return rewardRate.mul(DURATION);
            return rewardRate * DURATION;
        }
    
        function _periodFinish() external view returns (uint256) {
            return periodFinish;
        }
    
        /* -----------------------------------------------------------------------------
        --------------------------------------------------------------------------------
        --------------------------------------------------------------------------------
                                        USER INTERACTION
        --------------------------------------------------------------------------------
        --------------------------------------------------------------------------------
        ----------------------------------------------------------------------------- */
    
        ///@notice deposit all TOKEN of msg.sender
        function depositAll() external {
            _deposit(TOKEN.balanceOf(msg.sender), msg.sender);
        }
    
        ///@notice deposit amount TOKEN
        function deposit(uint256 amount) external {
            _deposit(amount, msg.sender);
        }
    
        ///@notice deposit internal
        function _deposit(uint256 amount, address account) internal nonReentrant {
            require(!emergency);
    
            _updateReward(account);
    
            require(amount > 0);
    
            _balances[account] += amount;
            _totalSupply += amount;
    
            if (address(gaugeRewarder) != address(0)) {
                IRewarder(gaugeRewarder).onReward(
                    rewarderPid,
                    account,
                    account,
                    0,
                    _balances[account]
                );
            }
    
            TOKEN.safeTransferFrom(account, address(this), amount);
    
            emit Deposit(account, amount);
        }
    
        ///@notice withdraw all token
        function withdrawAll() external {
            _withdraw(_balances[msg.sender]);
        }
    
        ///@notice withdraw a certain amount of TOKEN
        function withdraw(uint256 amount) external {
            _withdraw(amount);
        }
    
        ///@notice withdraw internal
        function _withdraw(uint256 amount) internal nonReentrant {
            require(!emergency);
    
            _updateReward(msg.sender);
    
            require(
                amount > 0 && _totalSupply >= amount && _balances[msg.sender] > 0
            );
    
            _totalSupply -= amount;
            _balances[msg.sender] -= amount;
    
            if (address(gaugeRewarder) != address(0)) {
                IRewarder(gaugeRewarder).onReward(
                    rewarderPid,
                    msg.sender,
                    msg.sender,
                    0,
                    _balances[msg.sender]
                );
            }
    
            TOKEN.safeTransfer(msg.sender, amount);
    
            emit Withdraw(msg.sender, amount);
        }
    
        function emergencyWithdraw() external nonReentrant {
            require(emergency);
            require(_balances[msg.sender] > 0);
    
            uint256 _amount = _balances[msg.sender];
            _totalSupply -= _amount;
            _balances[msg.sender] = 0;
    
            if (address(gaugeRewarder) != address(0)) {
                try
                    IRewarder(gaugeRewarder).onReward(
                        rewarderPid,
                        msg.sender,
                        msg.sender,
                        0,
                        _balances[msg.sender]
                    )
                {
                    //
                } catch {
                    // 
                }
            }
    
            TOKEN.safeTransfer(msg.sender, _amount);
            emit Withdraw(msg.sender, _amount);
        }
    
        function emergencyWithdrawAmount(uint256 _amount) external nonReentrant {
            require(emergency);
            require(_balances[msg.sender] >= _amount);
    
            _totalSupply -= _amount;
            _balances[msg.sender] -= _amount;
    
            if (address(gaugeRewarder) != address(0)) {
                try
                    IRewarder(gaugeRewarder).onReward(
                        rewarderPid,
                        msg.sender,
                        msg.sender,
                        0,
                        _balances[msg.sender]
                    )
                {
                    //
                } catch {
                    // 
                }
            }
    
            TOKEN.safeTransfer(msg.sender, _amount);
            emit Withdraw(msg.sender, _amount);
        }
    
        ///@notice withdraw all TOKEN and harvest rewardToken
        function withdrawAllAndHarvest() external {
            _withdraw(_balances[msg.sender]);
            getReward();
        }
    
        ///@notice User harvest function called from distribution (voter allows harvest on multiple gauges)
        function getReward(address _user) public nonReentrant {
            require(msg.sender == DISTRIBUTION);
            _updateReward(_user);
    
            uint256 reward = rewards[_user];
            if (reward > 0) {
                rewards[_user] = 0;
                rewardToken.safeTransfer(_user, reward);
                emit Harvest(_user, reward);
            }
    
            if (gaugeRewarder != address(0)) {
                IRewarder(gaugeRewarder).onReward(
                    rewarderPid,
                    _user,
                    _user,
                    reward,
                    _balances[_user]
                );
            }
        }
    
        ///@notice User harvest function
        function getReward() public nonReentrant {
            _updateReward(msg.sender);
    
            uint256 reward = rewards[msg.sender];
            if (reward > 0) {
                rewards[msg.sender] = 0;
                rewardToken.safeTransfer(msg.sender, reward);
                emit Harvest(msg.sender, reward);
            }
    
            if (gaugeRewarder != address(0)) {
                IRewarder(gaugeRewarder).onReward(
                    rewarderPid,
                    msg.sender,
                    msg.sender,
                    reward,
                    _balances[msg.sender]
                );
            }
        }
    
        /* -----------------------------------------------------------------------------
        --------------------------------------------------------------------------------
        --------------------------------------------------------------------------------
                                        DISTRIBUTION
        --------------------------------------------------------------------------------
        --------------------------------------------------------------------------------
        ----------------------------------------------------------------------------- */
    
        /// @dev Receive rewards from distribution
        function notifyRewardAmount(
            address token,
            uint reward
        ) external nonReentrant {
            require(!emergency);
            require(msg.sender == DISTRIBUTION);
            _updateReward(address(0));
    
            require(token == address(rewardToken));
            rewardToken.safeTransferFrom(DISTRIBUTION, address(this), reward);
    
            if (block.timestamp >= periodFinish) {
                rewardRate = reward / DURATION;
            } else {
                uint256 remaining = periodFinish - block.timestamp;
                uint256 leftover = remaining * rewardRate;
                rewardRate = (reward + leftover) / DURATION;
            }
    
            // Ensure the provided reward amount is not more than the balance in the contract.
            // This keeps the reward rate in the right range, preventing overflows due to
            // very high values of rewardRate in the earned and rewardsPerToken functions;
            // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
            uint256 balance = rewardToken.balanceOf(address(this));
            require(rewardRate <= balance / DURATION);
    
            lastUpdateTime = block.timestamp;
            periodFinish = block.timestamp + DURATION;
            emit RewardAdded(reward);
        }
    
        function claimFees()
            external
            nonReentrant
            returns (uint claimed0, uint claimed1)
        {
            return _claimFees();
        }
    
        function _claimFees() internal returns (uint claimed0, uint claimed1) {
            address _token = address(TOKEN);
            (claimed0, claimed1) = IFeeVault(feeVault).claimFees();
            IFeeVault(feeVault2).claimFees();
    
            if (claimed0 > 0 || claimed1 > 0) {
                uint _fees0 = fees0 + claimed0;
                uint _fees1 = fees1 + claimed1;
                address _token0 = IPairInfo(_token).token0();
                address _token1 = IPairInfo(_token).token1();
                if (_fees0 > 0) {
                    fees0 = 0;
                    IERC20(_token0).approve(internal_bribe, 0);
                    IERC20(_token0).approve(internal_bribe, _fees0);
                    IBribe(internal_bribe).notifyRewardAmount(_token0, _fees0);
                } else {
                    fees0 = _fees0;
                }
    
                if (_fees1 > 0) {
                    fees1 = 0;
                    IERC20(_token1).approve(internal_bribe, 0);
                    IERC20(_token1).approve(internal_bribe, _fees1);
                    IBribe(internal_bribe).notifyRewardAmount(_token1, _fees1);
                } else {
                    fees1 = _fees1;
                }
                emit ClaimFees(msg.sender, claimed0, claimed1);
            }
        }
    
        function _updateReward(address account) private {
            rewardPerTokenStored = rewardPerToken();
            lastUpdateTime = lastTimeRewardApplicable();
            if (account != address(0)) {
                rewards[account] = earned(account);
                userRewardPerTokenPaid[account] = rewardPerTokenStored;
            }
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity 0.8.13;
    
    interface IBribe {
        function _deposit(uint amount, uint tokenId) external;
        function _withdraw(uint amount, uint tokenId) external;
        function getRewardForOwner(uint tokenId, address[] memory tokens) external;
        function getRewardForAddress(address _owner, address[] memory tokens) external;
        function notifyRewardAmount(address token, uint amount) external;
        function left(address token) external view returns (uint);
    }

    // SPDX-License-Identifier: MIT
    pragma solidity 0.8.13;
    
    interface IPairInfo {
    
        function token0() external view returns(address);
        function reserve0() external view returns(uint);
        function decimals0() external view returns(uint);
        function token1() external view returns(address);
        function reserve1() external view returns(uint);
        function decimals1() external view returns(uint);
        function isPair(address _pair) external view returns(bool);
    }

    // SPDX-License-Identifier: MIT
    pragma solidity 0.8.13;
    
    library Constants {
        uint256 internal constant EPOCH_LENGTH = 7 days;
    }

    Please enter a contract address above to load the contract details and source code.

    Context size (optional):