@harvest-finance/harvest-strategy-polygon 0.0.1-security → 1.0.0

package/contracts/base/VaultStorageV2.sol

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
+
+contract VaultStorageV2 is Initializable {
+
+    bytes32 internal constant _STRATEGY_SLOT = 0xf1a169aa0f736c2813818fdfbdc5755c31e0839c8f49831a16543496b28574ea;
+    bytes32 internal constant _UNDERLYING_SLOT = 0x1994607607e11d53306ef62e45e3bd85762c58d9bf38b5578bc4a258a26a7371;
+    bytes32 internal constant _UNDERLYING_UNIT_SLOT = 0xa66bc57d4b4eed7c7687876ca77997588987307cb13ecc23f5e52725192e5fff;
+    bytes32 internal constant _VAULT_FRACTION_TO_INVEST_NUMERATOR_SLOT = 0x39122c9adfb653455d0c05043bd52fcfbc2be864e832efd3abc72ce5a3d7ed5a;
+    bytes32 internal constant _VAULT_FRACTION_TO_INVEST_DENOMINATOR_SLOT = 0x469a3bad2fab7b936c45eecd1f5da52af89cead3e2ed7f732b6f3fc92ed32308;
+    bytes32 internal constant _NEXT_IMPLEMENTATION_SLOT = 0xb1acf527cd7cd1668b30e5a9a1c0d845714604de29ce560150922c9d8c0937df;
+    bytes32 internal constant _NEXT_IMPLEMENTATION_TIMESTAMP_SLOT = 0x3bc747f4b148b37be485de3223c90b4468252967d2ea7f9fcbd8b6e653f434c9;
+    bytes32 internal constant _NEXT_STRATEGY_SLOT = 0xcd7bd9250b0e02f3b13eccf8c73ef5543cb618e0004628f9ca53b65fbdbde2d0;
+    bytes32 internal constant _NEXT_STRATEGY_TIMESTAMP_SLOT = 0x5d2b24811886ad126f78c499d71a932a5435795e4f2f6552f0900f12d663cdcf;
+    bytes32 internal constant _ALLOW_SHARE_PRICE_DECREASE_SLOT = 0x22f7033891e85fc76735ebd320e0d3f546da431c4729c2f6d2613b11923aaaed;
+    bytes32 internal constant _WITHDRAW_BEFORE_REINVESTING_SLOT = 0x4215fbb95dc0890d3e1660fb9089350f2d3f350c0a756934874cae6febf42a79;
+    bytes32 internal constant _PAUSED_SLOT = 0xf1cf856d03630b74791fc293cfafd739932a5a075b02d357fb7a726a38777930;
+
+    /**
+     * @dev Storage slot with the address of the current implementation.
+     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
+     * validated in the constructor.
+     */
+    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+
+    constructor() public {
+        assert(_STRATEGY_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.strategy")) - 1));
+        assert(_UNDERLYING_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.underlying")) - 1));
+        assert(_UNDERLYING_UNIT_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.underlyingUnit")) - 1));
+        assert(_VAULT_FRACTION_TO_INVEST_NUMERATOR_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.vaultFractionToInvestNumerator")) - 1));
+        assert(_VAULT_FRACTION_TO_INVEST_DENOMINATOR_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.vaultFractionToInvestDenominator")) - 1));
+        assert(_NEXT_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextImplementation")) - 1));
+        assert(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextImplementationTimestamp")) - 1));
+        assert(_NEXT_STRATEGY_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextStrategy")) - 1));
+        assert(_NEXT_STRATEGY_TIMESTAMP_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.nextStrategyTimestamp")) - 1));
+        assert(_ALLOW_SHARE_PRICE_DECREASE_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.allowSharePriceDecrease")) - 1));
+        assert(_WITHDRAW_BEFORE_REINVESTING_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.withdrawBeforeReinvesting")) - 1));
+        assert(_PAUSED_SLOT == bytes32(uint256(keccak256("eip1967.vaultStorage.paused")) - 1));
+    }
+
+    function initialize(
+        address _underlying,
+        uint256 _toInvestNumerator,
+        uint256 _toInvestDenominator,
+        uint256 _underlyingUnit
+    ) public initializer {
+        _setUnderlying(_underlying);
+        _setVaultFractionToInvestNumerator(_toInvestNumerator);
+        _setVaultFractionToInvestDenominator(_toInvestDenominator);
+        _setUnderlyingUnit(_underlyingUnit);
+        _setNextStrategyTimestamp(0);
+        _setNextStrategy(address(0));
+        _setAllowSharePriceDecrease(false);
+        _setWithdrawBeforeReinvesting(false);
+    }
+
+    function _setStrategy(address _address) internal {
+        setAddress(_STRATEGY_SLOT, _address);
+    }
+
+    function _strategy() internal view returns (address) {
+        return getAddress(_STRATEGY_SLOT);
+    }
+
+    function _setUnderlying(address _address) internal {
+        setAddress(_UNDERLYING_SLOT, _address);
+    }
+
+    function _underlying() internal view returns (address) {
+        return getAddress(_UNDERLYING_SLOT);
+    }
+
+    function _setUnderlyingUnit(uint256 _value) internal {
+        setUint256(_UNDERLYING_UNIT_SLOT, _value);
+    }
+
+    function _underlyingUnit() internal view returns (uint256) {
+        return getUint256(_UNDERLYING_UNIT_SLOT);
+    }
+
+    function _setVaultFractionToInvestNumerator(uint256 _value) internal {
+        setUint256(_VAULT_FRACTION_TO_INVEST_NUMERATOR_SLOT, _value);
+    }
+
+    function _vaultFractionToInvestNumerator() internal view returns (uint256) {
+        return getUint256(_VAULT_FRACTION_TO_INVEST_NUMERATOR_SLOT);
+    }
+
+    function _setVaultFractionToInvestDenominator(uint256 _value) internal {
+        setUint256(_VAULT_FRACTION_TO_INVEST_DENOMINATOR_SLOT, _value);
+    }
+
+    function _vaultFractionToInvestDenominator() internal view returns (uint256) {
+        return getUint256(_VAULT_FRACTION_TO_INVEST_DENOMINATOR_SLOT);
+    }
+
+    function _setAllowSharePriceDecrease(bool _value) internal {
+        setBoolean(_ALLOW_SHARE_PRICE_DECREASE_SLOT, _value);
+    }
+
+    function _allowSharePriceDecrease() internal view returns (bool) {
+        return getBoolean(_ALLOW_SHARE_PRICE_DECREASE_SLOT);
+    }
+
+    function _setWithdrawBeforeReinvesting(bool _value) internal {
+        setBoolean(_WITHDRAW_BEFORE_REINVESTING_SLOT, _value);
+    }
+
+    function _withdrawBeforeReinvesting() internal view returns (bool) {
+        return getBoolean(_WITHDRAW_BEFORE_REINVESTING_SLOT);
+    }
+
+    function _setNextImplementation(address _address) internal {
+        setAddress(_NEXT_IMPLEMENTATION_SLOT, _address);
+    }
+
+    function _nextImplementation() internal view returns (address) {
+        return getAddress(_NEXT_IMPLEMENTATION_SLOT);
+    }
+
+    function _setNextImplementationTimestamp(uint256 _value) internal {
+        setUint256(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT, _value);
+    }
+
+    function _nextImplementationTimestamp() internal view returns (uint256) {
+        return getUint256(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT);
+    }
+
+    function _setNextStrategy(address _value) internal {
+        setAddress(_NEXT_STRATEGY_SLOT, _value);
+    }
+
+    function _nextStrategy() internal view returns (address) {
+        return getAddress(_NEXT_STRATEGY_SLOT);
+    }
+
+    function _setNextStrategyTimestamp(uint256 _value) internal {
+        setUint256(_NEXT_STRATEGY_TIMESTAMP_SLOT, _value);
+    }
+
+    function _nextStrategyTimestamp() internal view returns (uint256) {
+        return getUint256(_NEXT_STRATEGY_TIMESTAMP_SLOT);
+    }
+
+    function _implementation() internal view returns (address) {
+        return getAddress(_IMPLEMENTATION_SLOT);
+    }
+
+    function _paused() internal view returns (bool) {
+        return getBoolean(_PAUSED_SLOT);
+    }
+
+    function _setPaused(bool _value) internal {
+        setBoolean(_PAUSED_SLOT, _value);
+    }
+
+    function setBoolean(bytes32 slot, bool _value) internal {
+        setUint256(slot, _value ? 1 : 0);
+    }
+
+    function getBoolean(bytes32 slot) internal view returns (bool) {
+        return (getUint256(slot) == 1);
+    }
+
+    function setAddress(bytes32 slot, address _address) internal {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            sstore(slot, _address)
+        }
+    }
+
+    function setUint256(bytes32 slot, uint256 _value) internal {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            sstore(slot, _value)
+        }
+    }
+
+    function getAddress(bytes32 slot) internal view returns (address str) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            str := sload(slot)
+        }
+    }
+
+    function getUint256(bytes32 slot) internal view returns (uint256 str) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            str := sload(slot)
+        }
+    }
+
+    uint256[50] private ______gap;
+}

package/contracts/base/VaultV2.sol

@@ -0,0 +1,369 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/math/MathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
+import "./interface/IStrategy.sol";
+import "./interface/IVault.sol";
+import "./interface/IControllerV2.sol";
+import "./interface/IUpgradeSource.sol";
+import "./inheritance/ControllableInit.sol";
+import "./VaultStorageV2.sol";
+
+contract VaultV2 is ERC20Upgradeable, IUpgradeSource, ControllableInit, VaultStorageV2 {
+  using SafeERC20Upgradeable for IERC20Upgradeable;
+  using AddressUpgradeable for address;
+  using SafeMathUpgradeable for uint256;
+
+  /**
+   * Caller has exchanged assets for shares, and transferred those shares to owner.
+   *
+   * MUST be emitted when tokens are deposited into the Vault via the mint and deposit methods.
+   */
+  event Deposit(
+      address indexed sender,
+      address indexed receiver,
+      uint256 assets,
+      uint256 shares
+  );
+
+  /**
+   * Caller has exchanged shares, owned by owner, for assets, and transferred those assets to receiver.
+   *
+   * MUST be emitted when shares are withdrawn from the Vault in ERC4626.redeem or ERC4626.withdraw methods.
+   */
+  event Withdraw(
+      address indexed sender,
+      address indexed receiver,
+      address indexed owner,
+      uint256 assets,
+      uint256 shares
+  );
+  event Invest(uint256 amount);
+  event StrategyAnnounced(address newStrategy, uint256 time);
+  event StrategyChanged(address newStrategy, address oldStrategy);
+
+
+  constructor() public {
+  }
+
+  // the function is name differently to not cause inheritance clash in truffle and allows tests
+  function initializeVault(
+    address _storage,
+    address _underlying,
+    uint256 _toInvestNumerator,
+    uint256 _toInvestDenominator
+  ) public initializer {
+    require(_toInvestNumerator <= _toInvestDenominator, "cannot invest more than 100%");
+    require(_toInvestDenominator != 0, "cannot divide by 0");
+
+    __ERC20_init(
+      string(abi.encodePacked("FARM_", ERC20Upgradeable(_underlying).symbol())),
+      string(abi.encodePacked("f", ERC20Upgradeable(_underlying).symbol()))
+    );
+    _setupDecimals(ERC20Upgradeable(_underlying).decimals());
+
+    ControllableInit.initialize(
+      _storage
+    );
+
+    uint256 underlyingUnit = 10 ** uint256(ERC20Upgradeable(address(_underlying)).decimals());
+    VaultStorageV2.initialize(
+      _underlying,
+      _toInvestNumerator,
+      _toInvestDenominator,
+      underlyingUnit
+    );
+  }
+
+  function strategy() public view returns(address) {
+    return _strategy();
+  }
+
+  function underlying() public view returns(address) {
+    return _underlying();
+  }
+
+  function underlyingUnit() public view returns(uint256) {
+    return _underlyingUnit();
+  }
+
+  function vaultFractionToInvestNumerator() public view returns(uint256) {
+    return _vaultFractionToInvestNumerator();
+  }
+
+  function vaultFractionToInvestDenominator() public view returns(uint256) {
+    return _vaultFractionToInvestDenominator();
+  }
+
+  function nextImplementation() public view returns(address) {
+    return _nextImplementation();
+  }
+
+  function nextImplementationTimestamp() public view returns(uint256) {
+    return _nextImplementationTimestamp();
+  }
+
+  function nextImplementationDelay() public view returns (uint256) {
+    return IControllerV2(controller()).nextImplementationDelay();
+  }
+
+  modifier whenStrategyDefined() {
+    require(address(strategy()) != address(0), "Strategy must be defined");
+    _;
+  }
+
+  // Only smart contracts will be affected by this modifier
+  modifier defense() {
+    require(
+      (msg.sender == tx.origin) ||                // If it is a normal user and not smart contract,
+                                                  // then the requirement will pass
+      !IControllerV2(controller()).greyList(msg.sender), // If it is a smart contract, then
+      "This smart contract has been grey listed"  // make sure that it is not on our greyList.
+    );
+    _;
+  }
+
+  /**
+  * Chooses the best strategy and re-invests. If the strategy did not change, it just calls
+  * doHardWork on the current strategy. Call this through controller to claim hard rewards.
+  */
+  function doHardWork() whenStrategyDefined onlyControllerOrGovernance external {
+    // ensure that new funds are invested too
+    invest();
+    IStrategy(strategy()).doHardWork();
+  }
+
+  /*
+  * Returns the cash balance across all users in this contract.
+  */
+  function underlyingBalanceInVault() view public returns (uint256) {
+    return IERC20Upgradeable(underlying()).balanceOf(address(this));
+  }
+
+  /* Returns the current underlying (e.g., DAI's) balance together with
+   * the invested amount (if DAI is invested elsewhere by the strategy).
+  */
+  function underlyingBalanceWithInvestment() view public returns (uint256) {
+    if (address(strategy()) == address(0)) {
+      // initial state, when not set
+      return underlyingBalanceInVault();
+    }
+    return underlyingBalanceInVault().add(IStrategy(strategy()).investedUnderlyingBalance());
+  }
+
+  function getPricePerFullShare() public view returns (uint256) {
+    return totalSupply() == 0
+        ? underlyingUnit()
+        : underlyingUnit().mul(underlyingBalanceWithInvestment()).div(totalSupply());
+  }
+
+  /* get the user's share (in underlying)
+  */
+  function underlyingBalanceWithInvestmentForHolder(address holder) view external returns (uint256) {
+    if (totalSupply() == 0) {
+      return 0;
+    }
+    return underlyingBalanceWithInvestment()
+        .mul(balanceOf(holder))
+        .div(totalSupply());
+  }
+
+  function nextStrategy() public view returns (address) {
+    return _nextStrategy();
+  }
+
+  function nextStrategyTimestamp() public view returns (uint256) {
+    return _nextStrategyTimestamp();
+  }
+
+  function canUpdateStrategy(address _strategy) public view returns (bool) {
+    bool isStrategyNotSetYet = strategy() == address(0);
+    bool hasTimelockPassed = block.timestamp > nextStrategyTimestamp() && nextStrategyTimestamp() != 0;
+    return isStrategyNotSetYet || (_strategy == nextStrategy() && hasTimelockPassed);
+  }
+
+  /**
+  * Indicates that the strategy update will happen in the future
+  */
+  function announceStrategyUpdate(address _strategy) public onlyControllerOrGovernance {
+    // records a new timestamp
+    uint256 when = block.timestamp.add(nextImplementationDelay());
+    _setNextStrategyTimestamp(when);
+    _setNextStrategy(_strategy);
+    emit StrategyAnnounced(_strategy, when);
+  }
+
+  /**
+  * Finalizes (or cancels) the strategy update by resetting the data
+  */
+  function finalizeStrategyUpdate() public onlyControllerOrGovernance {
+    _setNextStrategyTimestamp(0);
+    _setNextStrategy(address(0));
+  }
+
+  function setStrategy(address _strategy) public onlyControllerOrGovernance {
+    require(canUpdateStrategy(_strategy),
+      "The strategy exists and switch timelock did not elapse yet");
+    require(_strategy != address(0), "new _strategy cannot be empty");
+    require(IStrategy(_strategy).underlying() == address(underlying()), "Vault underlying must match Strategy underlying");
+    require(IStrategy(_strategy).vault() == address(this), "the strategy does not belong to this vault");
+
+    emit StrategyChanged(_strategy, strategy());
+    if (address(_strategy) != address(strategy())) {
+      if (address(strategy()) != address(0)) { // if the original strategy (no underscore) is defined
+        IERC20Upgradeable(underlying()).safeApprove(address(strategy()), 0);
+        IStrategy(strategy()).withdrawAllToVault();
+      }
+      _setStrategy(_strategy);
+      IERC20Upgradeable(underlying()).safeApprove(address(strategy()), 0);
+      IERC20Upgradeable(underlying()).safeApprove(address(strategy()), uint256(~0));
+    }
+    finalizeStrategyUpdate();
+  }
+
+  function setVaultFractionToInvest(uint256 numerator, uint256 denominator) external onlyGovernance {
+    require(denominator > 0, "denominator must be greater than 0");
+    require(numerator <= denominator, "denominator must be greater than or equal to the numerator");
+    _setVaultFractionToInvestNumerator(numerator);
+    _setVaultFractionToInvestDenominator(denominator);
+  }
+
+  function rebalance() external onlyControllerOrGovernance {
+    withdrawAll();
+    invest();
+  }
+
+  function availableToInvestOut() public view returns (uint256) {
+    uint256 wantInvestInTotal = underlyingBalanceWithInvestment()
+        .mul(vaultFractionToInvestNumerator())
+        .div(vaultFractionToInvestDenominator());
+    uint256 alreadyInvested = IStrategy(strategy()).investedUnderlyingBalance();
+    if (alreadyInvested >= wantInvestInTotal) {
+      return 0;
+    } else {
+      uint256 remainingToInvest = wantInvestInTotal.sub(alreadyInvested);
+      return remainingToInvest <= underlyingBalanceInVault()
+        // TODO: we think that the "else" branch of the ternary operation is not
+        // going to get hit
+        ? remainingToInvest : underlyingBalanceInVault();
+    }
+  }
+
+  function invest() internal whenStrategyDefined {
+    uint256 availableAmount = availableToInvestOut();
+    if (availableAmount > 0) {
+      IERC20Upgradeable(underlying()).safeTransfer(address(strategy()), availableAmount);
+      emit Invest(availableAmount);
+    }
+  }
+
+  /*
+  * Allows for depositing the underlying asset in exchange for shares.
+  * Approval is assumed.
+  */
+  function deposit(uint256 amount) external nonReentrant defense {
+    _deposit(amount, msg.sender, msg.sender);
+  }
+
+  /*
+  * Allows for depositing the underlying asset in exchange for shares
+  * assigned to the holder.
+  * This facilitates depositing for someone else (using DepositHelper)
+  */
+  function depositFor(uint256 amount, address holder) public nonReentrant defense {
+    _deposit(amount, msg.sender, holder);
+  }
+
+  function withdraw(uint256 shares) external nonReentrant defense {
+    _withdraw(shares, msg.sender, msg.sender);
+  }
+
+  function withdrawAll() public onlyControllerOrGovernance whenStrategyDefined {
+    IStrategy(strategy()).withdrawAllToVault();
+  }
+
+  function _deposit(uint256 amount, address sender, address beneficiary) internal {
+    require(amount > 0, "Cannot deposit 0");
+    require(beneficiary != address(0), "holder must be defined");
+
+    if (address(strategy()) != address(0)) {
+      require(IStrategy(strategy()).depositArbCheck(), "Too much arb");
+    }
+
+    uint256 toMint = totalSupply() == 0
+        ? amount
+        : amount.mul(totalSupply()).div(underlyingBalanceWithInvestment());
+    _mint(beneficiary, toMint);
+
+    IERC20Upgradeable(underlying()).safeTransferFrom(sender, address(this), amount);
+
+    // update the contribution amount for the beneficiary
+    emit Deposit(sender, beneficiary, amount, toMint);
+  }
+
+  function _withdraw(uint256 numberOfShares, address receiver, address owner) internal {
+    require(totalSupply() > 0, "Vault has no shares");
+    require(numberOfShares > 0, "numberOfShares must be greater than 0");
+    uint256 totalSupply = totalSupply();
+
+    address sender = msg.sender;
+      if (sender != owner) {
+        uint256 currentAllowance = allowance(owner, sender);
+        if (currentAllowance != uint(-1)) {
+          require(currentAllowance >= numberOfShares, "ERC20: transfer amount exceeds allowance");
+          _approve(owner, sender, currentAllowance - numberOfShares);
+        }
+      }
+    _burn(owner, numberOfShares);
+
+    uint256 underlyingAmountToWithdraw = underlyingBalanceWithInvestment()
+        .mul(numberOfShares)
+        .div(totalSupply);
+    if (underlyingAmountToWithdraw > underlyingBalanceInVault()) {
+      // withdraw everything from the strategy to accurately check the share value
+      if (numberOfShares == totalSupply) {
+        IStrategy(strategy()).withdrawAllToVault();
+      } else {
+        uint256 missing = underlyingAmountToWithdraw.sub(underlyingBalanceInVault());
+        IStrategy(strategy()).withdrawToVault(missing);
+      }
+      // recalculate to improve accuracy
+      underlyingAmountToWithdraw = MathUpgradeable.min(underlyingBalanceWithInvestment()
+          .mul(numberOfShares)
+          .div(totalSupply), underlyingBalanceInVault());
+    }
+
+    IERC20Upgradeable(underlying()).safeTransfer(receiver, underlyingAmountToWithdraw);
+
+    // update the withdrawal amount for the holder
+    emit Withdraw(sender, receiver, owner, underlyingAmountToWithdraw, numberOfShares);
+  }
+
+  /**
+  * Schedules an upgrade for this vault's proxy.
+  */
+  function scheduleUpgrade(address impl) public onlyGovernance {
+    _setNextImplementation(impl);
+    _setNextImplementationTimestamp(block.timestamp.add(nextImplementationDelay()));
+  }
+
+  function shouldUpgrade() external view override returns (bool, address) {
+    return (
+      nextImplementationTimestamp() != 0
+        && block.timestamp > nextImplementationTimestamp()
+        && nextImplementation() != address(0),
+      nextImplementation()
+    );
+  }
+
+  function finalizeUpgrade() external override onlyGovernance {
+    _setNextImplementation(address(0));
+    _setNextImplementationTimestamp(0);
+    ReentrancyGuardUpgradeable._setNotEntered(_NOT_ENTERED_SLOT, true);
+  }
+}