feat: Initial fork testing

.env.example

@@ -2,6 +2,8 @@
 MAINNET_DEPLOYER_KEY=
 TESTNET_DEPLOYER_KEY=
 
+ARCHIVE_NODE_FORK=
+
 # Contract verification api keys
 ETHERSCAN_API_KEY=
 BSCSCAN_API_KEY= 

.github/workflows/CI.yml

@@ -1,20 +1,21 @@
-name: CI
+name: tests
 
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
 
 jobs:
   test:
     strategy:
       matrix:
-        node: ['12.x', '14.x']
+        node: ['12.x']
         os: [ubuntu-latest]
 
     runs-on: ${{ matrix.os }}
-
+    env:
+      ARCHIVE_NODE_FORK: ${{ secrets.ARCHIVE_NODE_FORK }}
     steps:
       - uses: actions/checkout@v1
       - uses: actions/setup-node@v1
@@ -23,13 +24,14 @@ jobs:
 
       - run: npm install -g yarn
 
-      - id: yarn-cache
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-      - uses: actions/cache@v1
-        with:
-          path: ${{ steps.yarn-cache.outputs.dir }}
-          key: ${{ matrix.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ matrix.os }}-yarn-
+      # - id: yarn-cache
+      #   run: echo "::set-output name=dir::$(yarn cache dir)"
+      # - uses: actions/cache@v1
+      #   with:
+      #     path: ${{ steps.yarn-cache.outputs.dir }}
+      #     key: ${{ matrix.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+      #     restore-keys: |
+      #       ${{ matrix.os }}-yarn-
       - run: yarn
-      - run: yarn test
+      - run: yarn audit --groups dependencies
+      - run: yarn test:ci

contracts/BaseStrategy.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.6;
 
-import "@openzeppelin/contracts/token/ERC20/Utils/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
-import "@openzeppelin/contracts/Security/Pausable.sol";
-import "@openzeppelin/contracts/Utils/Math/SafeMath.sol";
-import "@openzeppelin/contracts/Utils/Math/Math.sol";
-import "@openzeppelin/contracts/Security/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/security/Pausable.sol";
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
+import "@openzeppelin/contracts/utils/math/Math.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
 
 import "./libs/IStrategyBanana.sol";
 import "./libs/IUniPair.sol";
@@ -24,7 +24,7 @@ abstract contract BaseStrategy is Ownable, ReentrancyGuard, Pausable {
     address public usdAddress;
     address public bananaAddress;
     // Wrapped native token address (WBNB/WMATIC)
-    address public wNativeAdress = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;
+    address public wNativeAdress = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
 
     address public rewardAddress = 0x4EB6b0A7543508f6EbD81c2E9c7cA7A471475e73;
     address public withdrawFeeAddress = 0x4EB6b0A7543508f6EbD81c2E9c7cA7A471475e73;

contracts/Strategy4Belt.sol

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.6;
+
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "./libs/IBeltLP.sol";
+import "./libs/IMasterBelt.sol";
+import "./BaseStrategySingle.sol";
+
+// https://bscscan.com/address/0x5df9ce05ea92af1ea324996d12f139847af3dfc7#code
+contract Strategy4Belt is BaseStrategySingle, Initializable {
+    using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+
+    // Third party contracts
+    address public masterBelt; // address(0xD4BbC80b9B102b77B21A06cb77E954049605E6c1);
+    address public beltLP;   // address(0x9cb73F20164e399958261c289Eb5F9846f4D1404);
+    uint256 public pid; // 3
+
+    /**
+        address[8] _configAddresses,
+        _configAddresses[0] _vaultChefAddress,
+        _configAddresses[1] _masterBelt,
+        _configAddresses[2] _uniRouterAddress,
+        _configAddresses[3]  _wantAddress,
+        _configAddress[4]  _earnedAddress
+        _configAddress[5]  _usdAddress
+        _configAddress[6]  _bananaAddress
+        _configAddress[7]  _beltLp
+    */
+    function initialize(
+        address[8] memory _configAddresses,
+        address[] memory _earnedToWnativePath,
+        address[] memory _earnedToUsdPath,
+        address[] memory _earnedToBananaPath,
+        uint256 _pid
+    ) external initializer {
+
+        govAddress = msg.sender;
+        vaultChefAddress = _configAddresses[0];
+        masterBelt = _configAddresses[1];
+        uniRouterAddress = _configAddresses[2];
+        beltLP = _configAddresses[7];
+
+        wantAddress = _configAddresses[3];
+
+        pid = _pid;
+        earnedAddress = _configAddresses[4];
+        usdAddress = _configAddresses[5];
+        bananaAddress = _configAddresses[6];
+
+        earnedToWnativePath = _earnedToWnativePath;
+        earnedToUsdPath = _earnedToUsdPath;
+        earnedToBananaPath = _earnedToBananaPath;
+
+        transferOwnership(vaultChefAddress);
+
+        _resetAllowances();
+    }
+
+    // puts the funds to work
+    function _vaultDeposit(uint256 _amount) internal override {
+        IMasterBelt(masterBelt).deposit(pid, _amount);
+    }
+
+    function _vaultWithdraw(uint256 _amount) internal override {
+        IMasterBelt(masterBelt).withdraw(pid, _amount);
+    }
+
+    function _vaultHarvest() internal override {
+        IMasterBelt(masterBelt).deposit(pid, 0);
+    }
+
+    function earn() external override nonReentrant whenNotPaused { 
+        _earn(_msgSender());
+    }
+
+    function earn(address _to) external override nonReentrant whenNotPaused {
+        _earn(_to);
+    }
+
+    function _earn(address _to) internal { 
+        _vaultHarvest();
+        uint256 earnedAmt = IERC20(earnedAddress).balanceOf(address(this));
+
+        if (earnedAmt > 0) {
+            earnedAmt = distributeFees(earnedAmt, _to);
+            earnedAmt = distributeRewards(earnedAmt);
+            earnedAmt = buyBack(earnedAmt);
+
+            // Converts farm tokens into want tokens and farms
+            _addLiquidity();
+            _farm();
+
+            lastEarnBlock = block.number;
+        }
+    }
+
+    // Adds liquidity to AMM and gets more LP tokens.
+    function _addLiquidity() internal {
+        uint256 autoBal = IERC20(earnedAddress).balanceOf(address(this));
+        _safeSwap(
+            autoBal,
+            earnedToUsdPath,
+            address(this)
+        );
+
+        uint256 busdBal = IERC20(usdAddress).balanceOf(address(this));
+        uint256[4] memory uamounts = [0, 0, 0, busdBal];
+        IBeltLP(beltLP).add_liquidity(uamounts, 0);
+    }
+
+    // calculate the total underlaying 'want' held by the strat.
+    function wantLockedTotal() public override view returns (uint256) {
+        return balanceOfWant().add(vaultSharesTotal());
+    }
+
+    // it calculates how much 'want' this contract holds.
+    function balanceOfWant() public view returns (uint256) {
+        return IERC20(wantAddress).balanceOf(address(this));
+    }
+
+    // it calculates how much 'want' the strategy has working in the farm.
+    function vaultSharesTotal() public override view returns (uint256) {
+        (uint256 amount,) = IMasterBelt(masterBelt).userInfo(pid, address(this));
+        return amount;
+        // return IMasterBelt(masterBelt).stakedWantTokens(pid, address(this));
+    }
+
+    // pauses deposits and withdraws all funds from third party systems.
+    function _emergencyVaultWithdraw() internal override {
+        IMasterBelt(masterBelt).emergencyWithdraw(pid);
+    }
+
+    function _resetAllowances() internal override {
+        IERC20(wantAddress).safeApprove(masterBelt, uint256(0));
+        IERC20(wantAddress).safeApprove(masterBelt, type(uint256).max);
+
+        IERC20(earnedAddress).safeApprove(uniRouterAddress, uint256(0));
+        IERC20(earnedAddress).safeApprove(uniRouterAddress, type(uint256).max);
+
+        IERC20(usdAddress).safeApprove(beltLP, uint256(0));
+        IERC20(usdAddress).safeApprove(beltLP, type(uint256).max);
+    }
+
+    function _removeAllowances() internal {
+        IERC20(wantAddress).safeApprove(masterBelt, 0);
+        IERC20(earnedAddress).safeApprove(uniRouterAddress, 0);
+        IERC20(usdAddress).safeApprove(beltLP, 0);
+    }
+
+    function _beforeDeposit(address _to) internal override {
+
+    }
+
+    function _beforeWithdraw(address _to) internal override {
+
+    }
+}

contracts/StrategyAutoBeltToken.sol

@@ -40,14 +40,14 @@ contract StrategyAutoBeltToken is BaseStrategySingle, Initializable {
         vaultChefAddress = _configAddresses[0];
         autoFarm = _configAddresses[1];
         uniRouterAddress = _configAddresses[2];
-        oToken = _configAddresses[7];
 
         wantAddress = _configAddresses[3];
 
         pid = _pid;
         earnedAddress = _configAddresses[4];
         usdAddress = _configAddresses[5];
         bananaAddress = _configAddresses[6];
+        oToken = _configAddresses[7];
 
         earnedToWnativePath = _earnedToWnativePath;
         earnedToUsdPath = _earnedToUsdPath;

contracts/StrategyBeltToken.sol

@@ -86,7 +86,7 @@ contract StrategyBeltToken is BaseStrategy, Initializable {
             earnedAmt = buyBack(earnedAmt);
 
             if (earnedAddress != oToken) {
-                // Swap earned to token0
+                // Swap earned to token which can be swapped to beltToken
                 _safeSwap(
                     earnedAmt,
                     earnedToWantPath,
@@ -143,7 +143,7 @@ contract StrategyBeltToken is BaseStrategy, Initializable {
             masterBelt,
             type(uint256).max
         );
-
+ 
         IERC20(earnedAddress).safeApprove(uniRouterAddress, uint256(0));
         IERC20(earnedAddress).safeIncreaseAllowance(
             uniRouterAddress,

contracts/VaultApe.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.6;
 
-import "@openzeppelin/contracts/token/ERC20/Utils/SafeERC20.sol";
-import "@openzeppelin/contracts/Utils/structs/EnumerableSet.sol";
-import "@openzeppelin/contracts/Security/ReentrancyGuard.sol";
-import "@openzeppelin/contracts/Utils/Math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
 
 import "./libs/IStrategy.sol";

contracts/VaultApeWhitelist.sol

@@ -2,9 +2,9 @@
 pragma solidity 0.8.6;
 
 import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
-import "@openzeppelin/contracts/token/ERC20/Utils/SafeERC20.sol";
-import "@openzeppelin/contracts/Security/ReentrancyGuard.sol";
-import "@openzeppelin/contracts/Utils/Math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 

contracts/libs/IMasterBelt.sol

@@ -0,0 +1,74 @@
+interface IMasterBelt {
+    function owner() external view returns (address);
+
+    function BELT() external returns (address);
+
+    function burnAddress() external returns (address);
+
+    function ownerBELTReward() external returns (uint256);
+
+    function BELTPerBlock() external returns (uint256);
+
+    function startBlock() external returns (uint256);
+
+    function poolInfo(uint256)
+        external
+        returns (
+            address want,
+            uint256 allocPoint,
+            uint256 lastRewardBlock,
+            uint256 accBELTPerShare,
+            address strat
+        );
+
+    function userInfo(uint256, address)
+        external
+        view
+        returns (uint256 shares, uint256 rewardDebt);
+
+    function totalAllocPoint() external returns (uint256);
+
+    function poolLength() external view returns (uint256);
+
+    function add(
+        uint256 _allocPoint,
+        address _want,
+        bool _withUpdate,
+        address _strat
+    ) external;
+
+    function set(
+        uint256 _pid,
+        uint256 _allocPoint,
+        bool _withUpdate
+    ) external;
+
+    function getMultiplier(uint256 _from, uint256 _to)
+        external
+        view
+        returns (uint256);
+
+    function pendingBELT(uint256 _pid, address _user)
+        external
+        view
+        returns (uint256);
+
+    function stakedWantTokens(uint256 _pid, address _user)
+        external
+        view
+        returns (uint256);
+
+    function massUpdatePools() external;
+
+    function updatePool(uint256 _pid) external;
+
+    function deposit(uint256 _pid, uint256 _wantAmt) external;
+
+    function withdraw(uint256 _pid, uint256 _wantAmt) external;
+
+    function withdrawAll(uint256 _pid) external;
+
+    function emergencyWithdraw(uint256 _pid) external;
+
+    function inCaseTokensGetStuck(address _token, uint256 _amount) external;
+}

contracts/libs/IUniPair.sol

@@ -4,4 +4,6 @@ pragma solidity 0.8.6;
 interface IUniPair {
     function token0() external view returns (address);
     function token1() external view returns (address);
+    function transfer(address to, uint value) external returns (bool);
+    function balanceOf(address owner) external view returns (uint);
 }