ITetuVaultV2: remove insurance, initInsurance

tetu-io · Jul 3, 2024 · b1f84d8 · b1f84d8
1 parent d27aaf4
commit b1f84d8
Show file tree

Hide file tree

Showing 8 changed files with 83 additions and 134 deletions.
diff --git a/contracts/interfaces/IStrategyV2.sol b/contracts/interfaces/IStrategyV2.sol
@@ -22,17 +22,17 @@ interface IStrategyV2 {
   /// @dev Usually, indicate that claimable rewards have reasonable amount.
   function isReadyToHardWork() external view returns (bool);
 
-  /// @return strategyLoss Loss should be covered from Insurance
+  /// @return strategyLoss Loss should be checked and emited
   function withdrawAllToSplitter() external returns (uint strategyLoss);
 
-  /// @return strategyLoss Loss should be covered from Insurance
+  /// @return strategyLoss Loss should be checked and emited
   function withdrawToSplitter(uint amount) external returns (uint strategyLoss);
 
   /// @notice Stakes everything the strategy holds into the reward pool.
   /// @param amount_ Amount transferred to the strategy balance just before calling this function
   /// @param updateTotalAssetsBeforeInvest_ Recalculate total assets amount before depositing.
   ///                                       It can be false if we know exactly, that the amount is already actual.
-  /// @return strategyLoss Loss should be covered from Insurance
+  /// @return strategyLoss Loss should be checked and emited
   function investAll(
     uint amount_,
     bool updateTotalAssetsBeforeInvest_

diff --git a/contracts/interfaces/ITetuVaultV2.sol b/contracts/interfaces/ITetuVaultV2.sol
@@ -1,17 +1,13 @@
 // SPDX-License-Identifier: MIT
-
 pragma solidity 0.8.17;
 
-import "./IVaultInsurance.sol";
 import "./IERC20.sol";
 import "./ISplitter.sol";
 
 interface ITetuVaultV2 {
 
   function splitter() external view returns (ISplitter);
 
-  function insurance() external view returns (IVaultInsurance);
-
   function init(
     address controller_,
     IERC20 _asset,
@@ -23,6 +19,4 @@ interface ITetuVaultV2 {
 
   function setSplitter(address _splitter) external;
 
-  function initInsurance(IVaultInsurance _insurance) external;
-
 }
diff --git a/contracts/vault/TetuVaultV2.sol b/contracts/vault/TetuVaultV2.sol
@@ -39,8 +39,6 @@ contract TetuVaultV2 is ERC4626Upgradeable, ControllableV3, ITetuVaultV2 {
   ISplitter public splitter;
   /// @dev Connected gauge for stakeless rewards
   IGauge public gauge;
-  /// @dev Dedicated contract for holding insurance for covering share price loss.
-  IVaultInsurance public override insurance;
   /// @dev Percent of assets that will always stay in this vault.
   uint public buffer;
 
@@ -129,15 +127,6 @@ contract TetuVaultV2 is ERC4626Upgradeable, ControllableV3, ITetuVaultV2 {
     );
   }
 
-  function initInsurance(IVaultInsurance _insurance) external override {
-    require(address(insurance) == address(0), "INITED");
-    _requireInterface(address(_insurance), InterfaceIds.I_VAULT_INSURANCE);
-
-    require(_insurance.vault() == address(this), "!VAULT");
-    require(_insurance.asset() == address(_asset), "!ASSET");
-    insurance = _insurance;
-  }
-
   // *************************************************************
   //                      GOV ACTIONS
   // *************************************************************

diff --git a/contracts/vault/VaultFactory.sol b/contracts/vault/VaultFactory.sol
@@ -15,6 +15,13 @@ import "../lib/InterfaceIds.sol";
 /// @author belbix
 contract VaultFactory is TetuERC165 {
 
+  // *************************************************************
+  //                        CONSTANTS
+  // *************************************************************
+
+  /// @dev Version of this contract. Adjust manually on each code modification.
+  string public constant FACTORY_VERSION = "2.0.0";
+
   // *************************************************************
   //                        VARIABLES
   // *************************************************************
@@ -45,7 +52,6 @@ contract VaultFactory is TetuERC165 {
     uint buffer,
     address vaultProxy,
     address vaultLogic,
-    address insurance,
     address splitterProxy,
     address splitterLogic
   );
@@ -141,12 +147,6 @@ contract VaultFactory is TetuERC165 {
       gauge,
       buffer
     );
-    // clone insurance
-    VaultInsurance insurance = new VaultInsurance();
-    // init insurance
-    insurance.init(vaultProxy, address(asset));
-    // set insurance to vault
-    ITetuVaultV2(vaultProxy).initInsurance(insurance);
 
     // clone splitter
     address splitterProxy = address(new ProxyControlled());
@@ -169,7 +169,6 @@ contract VaultFactory is TetuERC165 {
       buffer,
       vaultProxy,
       vaultLogic,
-      address(insurance),
       splitterProxy,
       splitterLogic
     );

diff --git a/scripts/utils/DeployerUtils.ts b/scripts/utils/DeployerUtils.ts
@@ -267,9 +267,9 @@ export class DeployerUtils {
       gauge,
       buffer,
     );
-    const insurance = await DeployerUtils.deployContract(signer, 'VaultInsurance') as VaultInsurance;
-    await insurance.init(vault.address, asset);
-    await vault.initInsurance(insurance.address);
+    // const insurance = await DeployerUtils.deployContract(signer, 'VaultInsurance') as VaultInsurance;
+    // await insurance.init(vault.address, asset);
+    // await vault.initInsurance(insurance.address);
     return vault;
   }
 

diff --git a/test/vault/SplitterForBaseStrategyV3Tests.ts b/test/vault/SplitterForBaseStrategyV3Tests.ts
@@ -500,33 +500,30 @@ describe("SplitterForBaseStrategyV3Tests", function () {
       await expect(vault.withdrawAll()).revertedWith("SS: Loss too high");
     });
 
-    it("withdraw all with slippage covering from insurance test", async () => {
+    it("withdraw all with slippage test", async () => {
       await vault.deposit(1000, signer.address);
       await strategy2.setSlippage(300);
       await vault.withdrawAll()
     });
 
-    it("withdraw all with slippage NOT covering from insurance not enough revert", async () => {
+    it("withdraw all with slippage not enough revert", async () => {
       await vault.deposit(1000, signer.address);
       await strategy2.setSlippage(600);
-      // await vault.setFees(0, 250)
       await expect(vault.withdrawAll()).revertedWith("SS: Loss too hig");
     });
 
-    it("withdraw with 100% slippage NOT covering from insurance test", async () => {
+    it("withdraw with 100% slippage test", async () => {
       await strategy2.setUseTrueExpectedWithdraw(true);
       await strategy2.setSlippage(10);
-      // await vault.setFees(1_000, 1_000)
       await vault.deposit(10_000_000, signer.address)
       await vault.withdraw(1000, signer.address, signer.address)
       await strategy2.setSlippage(1_000);
       await expect(vault.withdraw(1000, signer.address, signer.address)).revertedWith('SB: Too high');
     });
 
     // todo probably need to fix
-    it("withdraw all with 100% slippage covering from insurance test", async () => {
+    it("withdraw all with 100% slippage test", async () => {
       await vault.redeem(900, signer.address, signer.address)
-
       await vault.deposit(1000_000, signer.address)
       await vault.withdrawAll();
       await vault.deposit(10000, signer.address)
@@ -558,10 +555,9 @@ describe("SplitterForBaseStrategyV3Tests", function () {
       await vault.withdraw(99, signer.address, signer.address,);
     });
 
-    it("withdraw with slippage covering from insurance test", async () => {
+    it("withdraw with slippage test", async () => {
       await vault.deposit(1000, signer.address);
       await strategy2.setSlippage(1_000);
-      // await vault.setFees(0, 1_000)
       await vault.withdraw(99, signer.address, signer.address,);
     });
 
@@ -663,14 +659,13 @@ describe("SplitterForBaseStrategyV3Tests", function () {
 
     it("rebalance with negative totalAssetsDelta", async () => {
       expect(await vault.sharePrice()).eq(1000000);
-      await usdc.mint(await vault.insurance(), 1000_000);
       await splitter.setAPRs([strategy.address], [200]);
 
       await vault.deposit(1000_000, signer.address);
       await strategy2.setSlippage(25);
       await splitter.rebalance(100, 30);
 
-      expect(await vault.totalAssets()).eq(2000000);
+      expect(await vault.totalAssets()).eq(1999750);
     });
   });
 
@@ -762,47 +757,47 @@ describe("SplitterForBaseStrategyV3Tests", function () {
     describe("with totalAssetsDelta != 0", async () => {
       describe("investAll", () => {
         it("should cover expected loss if totalAssets-after is less than totalAssets-before", async () => {
-          const insurance = await vault.insurance();
+          // const insurance = await vault.insurance();
           await splitter.addStrategies([strategy.address], [100], [0]);
 
-          await usdc.mint(insurance, 500_000);
-          const insuranceBefore = await usdc.balanceOf(insurance);
+          // await usdc.mint(insurance, 500_000);
+          // const insuranceBefore = await usdc.balanceOf(insurance);
           await strategy.setSlippageDeposit(100);
           await vault.deposit(1000_000, signer.address);
-          const insuranceAfter = await usdc.balanceOf(insurance);
+          // const insuranceAfter = await usdc.balanceOf(insurance);
 
-          expect(insuranceAfter).eq(insuranceBefore.sub(1000));
+          // expect(insuranceAfter).eq(insuranceBefore.sub(1000));
         });
         it("should not use insurance if totalAssets-after is greater than totalAssets-before", async () => {
-          const insurance = await vault.insurance();
+          // const insurance = await vault.insurance();
           await splitter.addStrategies([strategy.address], [100], [0]);
 
-          await usdc.mint(insurance, 500);
-          const insuranceBefore = await usdc.balanceOf(insurance);
+          // await usdc.mint(insurance, 500);
+          // const insuranceBefore = await usdc.balanceOf(insurance);
           await strategy.setTotalAssetsDelta(-30);
           await vault.deposit(1000, signer.address);
-          const insuranceAfter = await usdc.balanceOf(insurance);
+          // const insuranceAfter = await usdc.balanceOf(insurance);
 
-          expect(insuranceAfter.eq(insuranceBefore)).eq(true);
+          // expect(insuranceAfter.eq(insuranceBefore)).eq(true);
         });
       });
       describe("withdrawToVault", () => {
         it.skip("should cover expected loss if totalAssets-after is less than totalAssets-before", async () => {
-          const insurance = await vault.insurance();
+          // const insurance = await vault.insurance();
           await splitter.addStrategies([strategy.address], [100], [0]);
 
-          await usdc.mint(insurance, 50000);
+          // await usdc.mint(insurance, 50000);
           await vault.deposit(100000, signer.address);
           // await vault.setFees(0, 200)
 
-          const insuranceBefore = await usdc.balanceOf(insurance);
+          // const insuranceBefore = await usdc.balanceOf(insurance);
           await strategy.setSlippage(100);
           await vault.withdraw(50000, signer.address, signer.address);
-          const insuranceAfter = await usdc.balanceOf(insurance);
+          // const insuranceAfter = await usdc.balanceOf(insurance);
 
-          expect(insuranceAfter).eq(49950);
+          // expect(insuranceAfter).eq(49950);
         });
-        it("should not use insurance if totalAssets-after is greater than totalAssets-before", async () => {
+        /*it("should not use ance if totalAssets-after is greater than totalAssets-before", async () => {
           const insurance = await vault.insurance();
           await splitter.addStrategies([strategy.address], [100], [0]);
 
@@ -815,25 +810,25 @@ describe("SplitterForBaseStrategyV3Tests", function () {
           const insuranceAfter = await usdc.balanceOf(insurance);
 
           expect(insuranceAfter.eq(insuranceBefore)).eq(true);
-        });
+        });*/
       });
       describe("withdrawAll", () => {
         it("should cover expected loss if totalAssets-after is less than totalAssets-before", async () => {
-          const insurance = await vault.insurance();
+          // const insurance = await vault.insurance();
           await splitter.addStrategies([strategy.address], [100], [0]);
 
-          await usdc.mint(insurance, 5000_000);
+          // await usdc.mint(insurance, 5000_000);
           await vault.deposit(10_000_000, signer.address);
           await vault.connect(await Misc.impersonate('0xdEad000000000000000000000000000000000000')).transfer(signer.address, await vault.balanceOf('0xdEad000000000000000000000000000000000000'));
 
-          const insuranceBefore = await usdc.balanceOf(insurance);
+          // const insuranceBefore = await usdc.balanceOf(insurance);
           await strategy.setSlippage(100);
           await vault.withdrawAll();
-          const insuranceAfter = await usdc.balanceOf(insurance);
+          // const insuranceAfter = await usdc.balanceOf(insurance);
 
           // console.log("insuranceBefore", insuranceBefore);
           // console.log("insuranceAfter", insuranceAfter);
-          expect(insuranceAfter).eq(insuranceBefore.sub(10000));
+          // expect(insuranceAfter).eq(insuranceBefore.sub(10000));
         });
         // it("should not use insurance if totalAssets-after is greater than totalAssets-before", async () => {
         //   const insurance = await vault.insurance();
@@ -854,7 +849,7 @@ describe("SplitterForBaseStrategyV3Tests", function () {
   });
 
   it("should not withdraw when MockStrategyV3 has UseTrueExpectedWithdraw enabled, but in real slippage exist", async () => {
-    const insurance = await vault.insurance();
+    // const insurance = await vault.insurance();
 
     await strategy.init(controller.address, splitter.address);
     await splitter.addStrategies([strategy.address], [100], [0]);
@@ -881,9 +876,9 @@ describe("SplitterForBaseStrategyV3Tests", function () {
 
     await expect(vault.withdrawAll()).revertedWith('SB: Too high')
 
-    const insuranceAfter = await usdc.balanceOf(insurance);
+    // const insuranceAfter = await usdc.balanceOf(insurance);
     // console.log('insuranceAfter', insuranceAfter)
-    expect(insuranceAfter).eq(0);
+    // expect(insuranceAfter).eq(0);
 
     expect(sharePriceBefore).eq(await vault.sharePrice());
   });