fixes

Author: belbix

.github/workflows/test.yml

@@ -0,0 +1,35 @@
+name: Unit tests + coverage
+
+on:
+  push:
+    branches:
+      - master
+      - release-*
+  pull_request: { }
+  workflow_dispatch: { }
+
+jobs:
+
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 14.x
+      - uses: actions/cache@v2
+        id: cache
+        with:
+          path: '**/node_modules'
+          key: npm-v2-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: npm-v2-
+      - run: npm ci
+        if: steps.cache.outputs.cache-hit != 'true'
+      - run: npm run coverage
+        env:
+          NODE_OPTIONS: --max_old_space_size=4096
+          TETU_ETH_RPC_URL: ${{secrets.TETU_ETH_RPC_URL}}
+          TETU_HARDHAT_CHAIN_ID: ${{secrets.TETU_HARDHAT_CHAIN_ID}}
+      - uses: codecov/codecov-action@v2

README.md

@@ -1,6 +1,6 @@
 # <img src="tetu_contracts.svg" alt="Tetu.io">
 
-[![codecov](https://codecov.io/gh/tetu-io/tetu-strategies-matic/branch/master/graph/badge.svg?token=FJ38EG24U7)](https://codecov.io/gh/tetu-io/tetu-strategies-matic)
+[![codecov](https://codecov.io/gh/tetu-io/tetu-strategies-ethereum/branch/master/graph/badge.svg?token=WlCryAlpoR)](https://codecov.io/gh/tetu-io/tetu-strategies-ethereum)
 
 ## Links
 

contracts/test/PriceCalculator.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+pragma solidity 0.8.4;
+
+import "../third_party/balancer/ISmartWalletChecker.sol";
+
+contract SmartWalletCheckerStub is ISmartWalletChecker {
+
+  function check(address) external pure override returns (bool) {
+    return true;
+  }
+}

contracts/test/SmartWalletCheckerStub.sol

@@ -13,7 +13,7 @@ export class EthAddresses {
   public static DAI_TOKEN = "0x6b175474e89094c44da98b954eedeac495271d0f".toLowerCase();
   public static USDT_TOKEN = "0xdac17f958d2ee523a2206206994597c13d831ec7".toLowerCase();
   public static WBTC_TOKEN = "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599".toLowerCase();
-  public static TETU_TOKEN = "0xa0246c9032bc3a600820415ae600c6388619a14d".toLowerCase(); // todo temporally FARM
+  public static TETU_TOKEN = "0x4f851750a3e6f80f1E1f89C67B56960Bfc29A934".toLowerCase();
   public static veBAL_TOKEN = "0xC128a9954e6c874eA3d62ce62B468bA073093F25".toLowerCase();
 
 

scripts/addresses/EthAddresses.ts

@@ -26,15 +26,17 @@ import {
   IRewardToken__factory,
   ISmartVault,
   ISmartVault__factory,
-  IStrategy, IStrategy__factory,
+  IStrategy,
   IStrategySplitter,
   IStrategySplitter__factory,
   IVaultController,
   IVaultController__factory,
+  NoopStrategy, PriceCalculator,
   TetuProxyControlled,
   TetuProxyControlled__factory,
 } from "../../typechain";
 import {EthAddresses} from "../addresses/EthAddresses";
+import {expect} from "chai";
 
 // tslint:disable-next-line:no-var-requires
 const hre = require("hardhat");
@@ -480,9 +482,23 @@ export class DeployerUtilsLocal {
       throw Error('No config for ' + net.chainId);
     }
 
-    const ps = ISmartVault__factory.connect(core.psVault, signer);
-    // const str = await ps.strategy();
-    const str = Misc.ZERO_ADDRESS; // todo
+    let psAdr = core.psVault;
+
+    if (psAdr === Misc.ZERO_ADDRESS) {
+      const [vaultLogic, psVault, strategy] = await DeployerUtilsLocal.deployDefaultNoopStrategyAndVault(
+        signer,
+        IController__factory.connect(core.controller, signer),
+        IVaultController__factory.connect(core.vaultController, signer),
+        core.rewardToken,
+        Misc.ZERO_ADDRESS
+      );
+      await RunHelper.runAndWait(() => IController__factory.connect(core.controller, signer)
+        .setPsVault(psVault.address));
+      psAdr = psVault.address;
+    }
+
+    const ps = ISmartVault__factory.connect(psAdr, signer);
+    const str = await ps.strategy();
     return new CoreContractsWrapper(
       IController__factory.connect(core.controller, signer),
       '',
@@ -506,15 +522,45 @@ export class DeployerUtilsLocal {
 
   }
 
+  public static async deployPriceCalculatorEthereum(signer: SignerWithAddress, controller: string, wait = false): Promise<[PriceCalculator, TetuProxyControlled, PriceCalculator]> {
+    const logic = await DeployerUtilsLocal.deployContract(signer, "PriceCalculator") as PriceCalculator;
+    const proxy = await DeployerUtilsLocal.deployContract(signer, "TetuProxyControlled", logic.address) as TetuProxyControlled;
+    const calculator = logic.attach(proxy.address) as PriceCalculator;
+    await calculator.initialize(controller);
+
+    await RunHelper.runAndWait(() => calculator.addKeyTokens([
+      EthAddresses.USDC_TOKEN,
+      EthAddresses.WETH_TOKEN,
+      EthAddresses.DAI_TOKEN,
+      EthAddresses.USDT_TOKEN,
+      EthAddresses.WBTC_TOKEN,
+    ]), true, wait);
+
+    await RunHelper.runAndWait(() => calculator.setDefaultToken(EthAddresses.USDC_TOKEN), true, wait);
+    await RunHelper.runAndWait(() => calculator.addSwapPlatform(EthAddresses.UNISWAP_FACTORY, "Uniswap V2"), true, wait);
+
+    expect(await calculator.keyTokensSize()).is.not.eq(0);
+    return [calculator, proxy, logic];
+  }
+
   public static async getToolsAddressesWrapper(signer: SignerWithAddress): Promise<ToolsContractsWrapper> {
     const net = await ethers.provider.getNetwork();
     log.info('network ' + net.chainId);
     const tools = Addresses.TOOLS.get(net.chainId + '');
     if (!tools) {
       throw Error('No config for ' + net.chainId);
     }
+
+    let calc = tools.calculator;
+
+    if (calc === Misc.ZERO_ADDRESS) {
+      const core = await Addresses.CORE.get(net.chainId + '');
+      const calcCtr = (await DeployerUtilsLocal.deployPriceCalculatorEthereum(signer, core?.controller || ''))[0];
+      calc = calcCtr.address;
+    }
+
     return new ToolsContractsWrapper(
-      IPriceCalculator__factory.connect(tools.calculator, signer),
+      IPriceCalculator__factory.connect(calc, signer),
     );
 
   }

scripts/deploy/DeployerUtilsLocal.ts

@@ -1,6 +1,11 @@
 import {ethers} from "hardhat";
-import {ERC20__factory, IERC721Enumerable__factory, IWmatic, IWmatic__factory} from "../typechain";
-import {BigNumber, utils} from "ethers";
+import {
+  ERC20__factory,
+  IERC721Enumerable__factory,
+  IRewardToken__factory,
+  IWmatic__factory
+} from "../typechain";
+import {BigNumber} from "ethers";
 import {SignerWithAddress} from "@nomiclabs/hardhat-ethers/signers";
 import chai from "chai";
 import chaiAsPromised from "chai-as-promised";
@@ -95,13 +100,22 @@ export class TokenUtils {
 
   public static async getToken(token: string, to: string, amount?: BigNumber) {
     const start = Date.now();
-    console.log('transfer token from biggest holder', token, amount?.toString());
 
     if (token.toLowerCase() === await DeployerUtilsLocal.getNetworkTokenAddress()) {
+      console.log('mint weth');
       await IWmatic__factory.connect(token, await DeployerUtilsLocal.impersonate(to)).deposit({value: amount});
       return amount;
     }
 
+    if (token.toLowerCase() === EthAddresses.TETU_TOKEN) {
+      console.log('mint tetu');
+      const minter = await DeployerUtilsLocal.impersonate('0x765277EebeCA2e31912C9946eAe1021199B39C61');
+      await IRewardToken__factory.connect(token, minter).mint(to, amount || parseUnits('100000000'));
+      return amount;
+    }
+
+    console.log('transfer token from biggest holder', token, amount?.toString());
+
     const holder = TokenUtils.TOKEN_HOLDERS.get(token.toLowerCase()) as string;
     if (!holder) {
       throw new Error('Please add holder for ' + token);

test/TokenUtils.ts

@@ -12,7 +12,6 @@ import {TokenUtils} from "./TokenUtils";
 import {SignerWithAddress} from "@nomiclabs/hardhat-ethers/signers";
 import {expect} from "chai";
 import {RunHelper} from "../scripts/utils/tools/RunHelper";
-import {MintHelperUtils} from "./MintHelperUtils";
 import {CoreContractsWrapper} from "./CoreContractsWrapper";
 import {DeployerUtilsLocal} from "../scripts/deploy/DeployerUtilsLocal";
 import {Misc} from "../scripts/utils/tools/Misc";
@@ -185,69 +184,6 @@ export class UniswapUtils {
     return [tokenStacked, oppositeToken, oppositeTokenStacked, price];
   }
 
-  public static async createPairForRewardToken(
-    signer: SignerWithAddress,
-    core: CoreContractsWrapper,
-    amount: string
-  ) {
-    const usdc = await DeployerUtilsLocal.getUSDCAddress();
-    await TokenUtils.getToken(usdc, signer.address, utils.parseUnits(amount, 6))
-    const rewardTokenAddress = core.rewardToken.address;
-
-    const usdcBal = await TokenUtils.balanceOf(usdc, signer.address);
-    console.log('USDC bought', usdcBal.toString());
-    expect(+utils.formatUnits(usdcBal, 6)).is.greaterThanOrEqual(+amount);
-
-    await MintHelperUtils.mint(core.controller, core.announcer, (+amount * 2).toString(), signer.address);
-
-    const tokenBal = await TokenUtils.balanceOf(rewardTokenAddress, signer.address);
-    console.log('Token minted', tokenBal.toString());
-    expect(+utils.formatUnits(tokenBal, 18)).is.greaterThanOrEqual(+amount);
-
-    const factory = await DeployerUtilsLocal.getDefaultNetworkFactory();
-    const lp = await UniswapUtils.addLiquidity(
-      signer,
-      rewardTokenAddress,
-      usdc,
-      utils.parseUnits(amount, 18).toString(),
-      utils.parseUnits(amount, 6).toString(),
-      factory,
-      await DeployerUtilsLocal.getRouterByFactory(factory)
-    );
-    await core.feeRewardForwarder.addLargestLps([core.rewardToken.address], [lp]);
-    return lp;
-  }
-
-  public static async createPairForRewardTokenWithBuy(
-    signer: SignerWithAddress,
-    core: CoreContractsWrapper,
-    amount: string
-  ) {
-    const usdc = await DeployerUtilsLocal.getUSDCAddress();
-    await TokenUtils.getToken(usdc, signer.address, utils.parseUnits(amount, 6))
-    const rewardTokenAddress = core.rewardToken.address;
-
-    const usdcBal = await TokenUtils.balanceOf(usdc, signer.address);
-    console.log('USDC bought', usdcBal.toString());
-    expect(+utils.formatUnits(usdcBal, 6)).is.greaterThanOrEqual(+amount);
-
-    await MintHelperUtils.mint(core.controller, core.announcer, amount, signer.address);
-
-    const tokenBal = await TokenUtils.balanceOf(rewardTokenAddress, signer.address);
-    console.log('Token minted', tokenBal.toString());
-    expect(+utils.formatUnits(tokenBal, 18)).is.greaterThanOrEqual(+amount);
-
-    return UniswapUtils.addLiquidity(
-      signer,
-      rewardTokenAddress,
-      usdc,
-      utils.parseUnits(amount, 18).toString(),
-      utils.parseUnits(amount, 6).toString(),
-      await DeployerUtilsLocal.getDefaultNetworkFactory(),
-      await DeployerUtilsLocal.getRouterByFactory(await DeployerUtilsLocal.getDefaultNetworkFactory())
-    );
-  }
-
   public static async createTetuUsdc(
     signer: SignerWithAddress,
     core: CoreContractsWrapper,
@@ -260,13 +196,7 @@ export class UniswapUtils {
     const usdcBal = await TokenUtils.balanceOf(usdc, signer.address);
     console.log('USDC bought', usdcBal.toString());
     expect(+utils.formatUnits(usdcBal, 6)).is.greaterThanOrEqual(+amount);
-
-    if (tetu === await DeployerUtilsLocal.getTETUAddress()) {
-      await TokenUtils.getToken(tetu, signer.address, utils.parseUnits(amount));
-    } else {
-      await MintHelperUtils.mint(core.controller, core.announcer, amount, signer.address);
-    }
-
+    await TokenUtils.getToken(tetu, signer.address, utils.parseUnits(amount));
 
     const tokenBal = await TokenUtils.balanceOf(tetu, signer.address);
     console.log('Token minted', tokenBal.toString());

test/UniswapUtils.ts

@@ -50,7 +50,7 @@ export class StrategyTestUtils {
     const strategy = data[2] as IStrategy;
 
     const rewardTokenLp = await UniswapUtils.createTetuUsdc(
-      signer, core, "1000000"
+      signer, core, "10000"
     );
     log.info("LP created");
 

test/strategies/FoldingDoHardWork.ts

@@ -14,8 +14,9 @@ import {
 } from "../../../typechain";
 import {VaultUtils} from "../../VaultUtils";
 import {defaultAbiCoder} from "@ethersproject/abi";
-import {parseUnits} from "ethers/lib/utils";
+import {formatUnits, parseUnits} from "ethers/lib/utils";
 import {TimeUtils} from "../../TimeUtils";
+import {Misc} from "../../../scripts/utils/tools/Misc";
 
 const {expect} = chai;
 chai.use(chaiAsPromised);
@@ -50,6 +51,9 @@ export class BalStakingDoHardWork extends DoHardWorkLoopBase {
     const depositorAdr = await StrategyBalStaking__factory.connect(this.strategy.address, this.signer).depositor()
     const depositor = BalDepositor__factory.connect(depositorAdr, this.signer);
 
+    const ethBalance0 = await TokenUtils.balanceOf(EthAddresses.WETH_TOKEN, this.signer.address);
+    await TokenUtils.transfer(EthAddresses.WETH_TOKEN, this.signer, Misc.ZERO_ADDRESS, ethBalance0.toString());
+
     await IBVault__factory.connect(EthAddresses.BALANCER_VAULT, this.signer).exitPool(
       EthAddresses.BALANCER_BAL_WETH_ID,
       this.signer.address,
@@ -64,13 +68,20 @@ export class BalStakingDoHardWork extends DoHardWorkLoopBase {
 
     const balBalance = await TokenUtils.balanceOf(EthAddresses.BAL_TOKEN, this.signer.address);
     const ethBalance = await TokenUtils.balanceOf(EthAddresses.WETH_TOKEN, this.signer.address);
-    console.log('balBalance', balBalance.toString());
-    console.log('ethBalance', ethBalance.toString());
+    console.log('balBalance', formatUnits(balBalance));
+    console.log('ethBalance', formatUnits(ethBalance));
     await TokenUtils.transfer(EthAddresses.BAL_TOKEN, this.signer, depositorAdr, balBalance.toString());
     await TokenUtils.transfer(EthAddresses.WETH_TOKEN, this.signer, depositorAdr, ethBalance.toString());
 
     await depositor.depositBridgedAssets('0x');
 
+    const balBalance1 = await TokenUtils.balanceOf(EthAddresses.BAL_TOKEN, depositor.address);
+    const ethBalance1 = await TokenUtils.balanceOf(EthAddresses.WETH_TOKEN, depositor.address);
+    console.log('balBalance1', formatUnits(balBalance1));
+    console.log('ethBalance1', formatUnits(ethBalance1));
+    expect(balBalance1).eq(0);
+    expect(ethBalance1).eq(0);
+
     const depositorBalance = await this.vault.underlyingBalanceWithInvestmentForHolder(depositor.address);
     expect(+utils.formatUnits(depositorBalance)).is.approximately(+utils.formatUnits(this.userDeposited.div(2)), +utils.formatUnits(this.userDeposited.div(2)) * 0.00001);