Fishydai - ftm dai bridge strats

.gitignore

@@ -8,3 +8,5 @@ reports/
 
 # Node/npm
 node_modules/
+@openzeppelin
+@yearnvaults

brownie-config.yml

@@ -5,14 +5,14 @@ networks:
 autofetch_sources: True
 
 dependencies:
-  - iearn-finance/yearn-vaults@0.3.5
+  - iearn-finance/yearn-vaults@0.4.3
   - OpenZeppelin/openzeppelin-contracts@3.1.0
 
 compiler:
   solc:
     version: 0.6.12
     remappings:
-      - "@yearnvaults=iearn-finance/yearn-vaults@0.3.5"
+      - "@yearnvaults=iearn-finance/yearn-vaults@0.4.3"
       - "@openzeppelin=OpenZeppelin/openzeppelin-contracts@3.1.0"
 
 reports:

contracts/GenericEthStrategy.sol

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import {BaseStrategy, StrategyParams} from "@yearnvaults/contracts/BaseStrategy.sol";
+import {
+    SafeERC20,
+    SafeMath,
+    IERC20,
+    Address
+} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "@openzeppelin/contracts/math/Math.sol";
+
+
+contract Strategy is BaseStrategy {
+    using SafeERC20 for IERC20;
+    using Address for address;
+    using SafeMath for uint256;
+
+    address public bridge;
+    uint256 public pendingProfit;
+    uint256 public minSend;
+    uint256 public maxSend;
+
+    bool public fourthreeprotection;
+
+    constructor(address _vault, address _bridge, uint256 _minSend, uint256 _maxSend) public BaseStrategy(_vault) {
+
+        bridge = _bridge;
+        minSend = _minSend;
+        maxSend = _maxSend;
+    }
+
+    function name() external view override returns (string memory) {
+        return "BridgeStrategy";
+    }
+
+    function delegatedAssets() external view override returns (uint256) {
+        return totalDebt();
+    }
+
+    function estimatedTotalAssets() public view override returns (uint256) {
+        return totalDebt().add(pendingProfit);
+    }
+
+    function totalDebt() public view returns (uint256) {
+        return vault.strategies(address(this)).totalDebt;
+    }
+
+    function _wantBalance() internal view returns (uint256){
+        return IERC20(want).balanceOf(address(this));
+    }
+
+    function setBridge(address _bridge) external onlyGovernance {
+        bridge = _bridge;
+    }
+
+    function setMinSend(uint256 _minSend) external onlyEmergencyAuthorized {
+        minSend = _minSend;
+    }
+
+    function setMaxSend(uint256 _maxSend) external onlyEmergencyAuthorized {
+        maxSend = _maxSend;
+    }
+
+    function setFourThreeProtection(bool _protection) external onlyEmergencyAuthorized {
+        fourthreeprotection = _protection;
+    }
+
+    function setPendingProfit(uint256 _pendingProfit) external onlyEmergencyAuthorized {
+        pendingProfit = _pendingProfit;
+    }
+
+    function prepareReturn(uint256 _debtOutstanding)
+        internal
+        override
+        returns (
+            uint256 _profit,
+            uint256 _loss,
+            uint256 _debtPayment
+        )
+    {
+        uint256 wantBal = _wantBalance();
+
+        if(wantBal == 0){
+            return (0,0,0);
+        }
+
+        _debtPayment = Math.min(wantBal, _debtOutstanding);
+
+        wantBal = wantBal.sub(_debtPayment);
+
+        if(pendingProfit > 0 && wantBal > 0){
+            _profit = Math.min(pendingProfit, wantBal);
+            pendingProfit = pendingProfit.sub(_profit);
+        }
+
+    }
+
+    function adjustPosition(uint256 _debtOutstanding) internal override {
+        if (emergencyExit) {
+            return;
+        }
+
+        uint256 balance = _wantBalance();
+        if (_debtOutstanding >= balance) {
+            return;
+        }
+        balance = balance.sub(_debtOutstanding);
+
+        if(balance > minSend){
+            want.safeTransfer(bridge, Math.min(balance, maxSend));
+        }
+
+
+    }
+
+    function liquidateAllPositions()
+        internal
+        override
+        returns (uint256 _amountFreed)
+    {
+
+        liquidatePosition(type(uint256).max);
+        _amountFreed = _wantBalance();
+        require(_amountFreed >= totalDebt(), "Money in bridge");
+    }
+
+    //we dont use this as harvest trigger is overriden
+    function ethToWant(uint256 _amtInWei)
+        public
+        view
+        override
+        returns (uint256)
+    {
+        return(_amtInWei);
+    }
+
+    //should never really be called as we keep late in queue
+    function liquidatePosition(uint256 _amountNeeded)
+        internal
+        override
+        returns (uint256 _liquidatedAmount, uint256 _loss)
+    {
+        uint256 totalAssets = _wantBalance();
+        _liquidatedAmount = Math.min(totalAssets, _amountNeeded);
+
+        //sub 43 protection
+        if(fourthreeprotection){
+            require(_amountNeeded == _liquidatedAmount, "fourthreeprotection");
+        }
+    }
+
+    //simplified harvest function
+    function harvestTrigger(uint256 gasCost) public override view returns (bool) {
+
+        StrategyParams memory params = vault.strategies(address(this));
+
+        // Should not trigger if strategy is not activated
+        if (params.activation == 0) return false;
+
+        // Check for profits and losses
+        uint256 wantBal = _wantBalance();
+        bool harvest;
+        if(wantBal > debtThreshold){
+            harvest = vault.debtOutstanding() >= debtThreshold;
+            harvest = pendingProfit >= debtThreshold;
+        }
+
+        return harvest;
+    }
+
+
+    function prepareMigration(address _newStrategy) internal override {}
+
+    function protectedTokens()
+        internal
+        view
+        override
+        returns (address[] memory)
+    {}
+}