[WIP] Beefy support

addresses/arbitrumone/beefy_depository_impl.json

@@ -0,0 +1,5 @@
+
+    {
+        "depositoryImpl": "0x56b9d976870784b9DEbd37b44B286f9D88f2f059"
+    }
+

addresses/arbitrumone/beefy_wrapper_factory.json

@@ -0,0 +1,6 @@
+
+    {
+      "wrapperFactory" : "0x1D1089968172B853975865c711E848bdcb44E7CC"
+    }
+
+

addresses/arbitrumone/core_beefy.json

@@ -0,0 +1,8 @@
+
+  {
+    "controller": "0x7a348A49B696aEB427aB0c1643890663a270BaC3",
+    "router": "0x9b7301052fcaE3EdBa276F9429428aB568018F4B",
+    "uxd": "0x2856806C1C373F79D06897AE88948224458d035C"
+  }
+
+

addresses/arbitrumone/curve_adapter.json

@@ -0,0 +1,6 @@
+
+  {
+    "curveAdapter": "0x7f5F2c30fE331D305739Fb8D9997b72A07532d93"
+  }
+
+

addresses/arbitrumone/depositories.json

@@ -1,6 +1,7 @@
 
   {
-    "rageTrade": "0xE1C92575BC45974Afe332a70045Dbb364A13E518"
+      "rageTrade": "0xE1C92575BC45974Afe332a70045Dbb364A13E518",
+      "beefyFinance": "0x1c619B6859607e6C14933721FB81D22C9885ce7d"
   }
 
 

config/arbitrumgoerli.config.ts

@@ -12,7 +12,9 @@ export const config: ArbitrumConfig = {
         }
     },
     contracts: {
-        RageGmxSeniorVault: "0x8E6E5759Da804E63aCbed35fBbF9d9f9b8eeD8f8"
+        RageGmxSeniorVault: "0x8E6E5759Da804E63aCbed35fBbF9d9f9b8eeD8f8",
+        BeefyVaultUsdcUsdt: "",
+        Curve2PoolUsdcUsdt: ""
     },
     addresses: {
         Deployer: "0x3382Bb7214c109f12Ffe8aA9C39BAf7eDB991427",
@@ -21,6 +23,7 @@ export const config: ArbitrumConfig = {
     },
     tokens: {
         USDC: "0x6775842AE82BF2F0f987b10526768Ad89d79536E",
+        USDT: "",
         WETH: "0xe39Ab88f8A4777030A534146A9Ca3B52bd5D43A3"
     },
     layerZero: {

config/arbitrumone.config.ts

@@ -13,7 +13,9 @@ export const config: ArbitrumConfig = {
         }
     },
     contracts: {
-        RageGmxSeniorVault: "0xf9305009FbA7E381b3337b5fA157936d73c2CF36"
+        RageGmxSeniorVault: "0xf9305009FbA7E381b3337b5fA157936d73c2CF36",
+        BeefyVaultUsdcUsdt: "0xEc7c0205a6f426c2Cb1667d783B5B4fD2f875434",
+        Curve2PoolUsdcUsdt: "0x7f90122BF0700F9E7e1F688fe926940E8839F353",
     },
     addresses: {
         Deployer: "0x96223b32A75a22de7c192A1b99366c7eD12c1649",
@@ -22,6 +24,7 @@ export const config: ArbitrumConfig = {
     },
     tokens: {
         USDC: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+        USDT: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
         WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"
     },
     layerZero: {

config/configs.ts

@@ -7,7 +7,7 @@ export interface LzConfig {
     current: LzPair
     ethereum: LzPair
     optimism: LzPair
-    arbitrum: LzPair 
+    arbitrum: LzPair
 }
 
 export interface GovernorParams {
@@ -75,10 +75,13 @@ export interface ArbitrumConfig {
     }
     tokens: {
         USDC: string
+        USDT: string
         WETH: string
     },
     contracts: {
-        RageGmxSeniorVault: string 
+        RageGmxSeniorVault: string
+        BeefyVaultUsdcUsdt: string
+        Curve2PoolUsdcUsdt: string
     },
     layerZero: LzConfig
 }

config/contracts.ts

@@ -4,14 +4,10 @@ export interface CoreContracts {
     uxd: string
 }
 
-export interface Depositories {
-    perpetualProtocol?: string
-    rageTrade?: string
-}
-
 export interface Depositories {
     perpetualProtocol?: string;
     rageTrade?: string
+    beefyFinance?: string
 }
 
 export interface GovernanceContracts {
@@ -34,4 +30,8 @@ export interface DepositoryImplContract {
 
 export interface PerpPeriphery {
     accountProxy: string;
+}
+
+export interface Adapters {
+    curveAdapter: string
 }

config/goerli.config.ts

@@ -37,4 +37,4 @@ export const config: EthereumConfig = {
             endpoint: "0x6aB5Ae6822647046626e83ee6dB8187151E1d5ab"
         }
     }
-}
+}

contracts/external/beefy/BeefyVaultV7.sol

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+import "./IStrategyV7.sol";
+
+/**
+ * @dev Implementation of a vault to deposit funds for yield optimizing.
+ * This is the contract that receives funds and that users interface with.
+ * The yield optimizing strategy itself is implemented in a separate 'Strategy.sol' contract.
+ */
+contract BeefyVaultV7 is
+    ERC20Upgradeable,
+    OwnableUpgradeable,
+    ReentrancyGuardUpgradeable
+{
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    struct StratCandidate {
+        address implementation;
+        uint256 proposedTime;
+    }
+
+    // The last proposed strategy to switch to.
+    StratCandidate public stratCandidate;
+    // The strategy currently in use by the vault.
+    IStrategyV7 public strategy;
+    // The minimum time it has to pass before a strat candidate can be approved.
+    uint256 public approvalDelay;
+
+    event NewStratCandidate(address implementation);
+    event UpgradeStrat(address implementation);
+
+    /**
+     * @dev Sets the value of {token} to the token that the vault will
+     * hold as underlying value. It initializes the vault's own 'moo' token.
+     * This token is minted when someone does a deposit. It is burned in order
+     * to withdraw the corresponding portion of the underlying assets.
+     * @param _strategy the address of the strategy.
+     * @param _name the name of the vault token.
+     * @param _symbol the symbol of the vault token.
+     * @param _approvalDelay the delay before a new strat can be approved.
+     */
+    function initialize(
+        IStrategyV7 _strategy,
+        string memory _name,
+        string memory _symbol,
+        uint256 _approvalDelay
+    ) public initializer {
+        __ERC20_init(_name, _symbol);
+        __Ownable_init();
+        __ReentrancyGuard_init();
+        strategy = _strategy;
+        approvalDelay = _approvalDelay;
+    }
+
+    function want() public view returns (IERC20Upgradeable) {
+        return IERC20Upgradeable(strategy.want());
+    }
+
+    /**
+     * @dev It calculates the total underlying value of {token} held by the system.
+     * It takes into account the vault contract balance, the strategy contract balance
+     *  and the balance deployed in other contracts as part of the strategy.
+     */
+    function balance() public view returns (uint256) {
+        return
+            want().balanceOf(address(this)) + IStrategyV7(strategy).balanceOf();
+    }
+
+    /**
+     * @dev Custom logic in here for how much the vault allows to be borrowed.
+     * We return 100% of tokens for now. Under certain conditions we might
+     * want to keep some of the system funds at hand in the vault, instead
+     * of putting them to work.
+     */
+    function available() public view returns (uint256) {
+        return want().balanceOf(address(this));
+    }
+
+    /**
+     * @dev Function for various UIs to display the current value of one of our yield tokens.
+     * Returns an uint256 with 18 decimals of how much underlying asset one vault share represents.
+     */
+    function getPricePerFullShare() public view returns (uint256) {
+        return totalSupply() == 0 ? 1e18 : (balance() * 1e18) / totalSupply();
+    }
+
+    /**
+     * @dev A helper function to call deposit() with all the sender's funds.
+     */
+    function depositAll() external {
+        deposit(want().balanceOf(msg.sender));
+    }
+
+    /**
+     * @dev The entrypoint of funds into the system. People deposit with this function
+     * into the vault. The vault is then in charge of sending funds into the strategy.
+     */
+    function deposit(uint256 _amount) public nonReentrant {
+        strategy.beforeDeposit();
+
+        uint256 _pool = balance();
+        want().safeTransferFrom(msg.sender, address(this), _amount);
+        earn();
+        uint256 _after = balance();
+        _amount = _after - _pool; // Additional check for deflationary tokens
+        uint256 shares = 0;
+        if (totalSupply() == 0) {
+            shares = _amount;
+        } else {
+            shares = (_amount * totalSupply()) / _pool;
+        }
+        _mint(msg.sender, shares);
+    }
+
+    /**
+     * @dev Function to send funds into the strategy and put them to work. It's primarily called
+     * by the vault's deposit() function.
+     */
+    function earn() public {
+        uint256 _bal = available();
+        want().safeTransfer(address(strategy), _bal);
+        strategy.deposit();
+    }
+
+    /**
+     * @dev A helper function to call withdraw() with all the sender's funds.
+     */
+    function withdrawAll() external {
+        withdraw(balanceOf(msg.sender));
+    }
+
+    /**
+     * @dev Function to exit the system. The vault will withdraw the required tokens
+     * from the strategy and pay up the token holder. A proportional number of IOU
+     * tokens are burned in the process.
+     */
+    function withdraw(uint256 _shares) public {
+        uint256 r = (balance() * _shares) / totalSupply();
+        _burn(msg.sender, _shares);
+
+        uint256 b = want().balanceOf(address(this));
+        if (b < r) {
+            uint256 _withdraw = r - b;
+            strategy.withdraw(_withdraw);
+            uint256 _after = want().balanceOf(address(this));
+            uint256 _diff = _after - b;
+            if (_diff < _withdraw) {
+                r = b + _diff;
+            }
+        }
+
+        want().safeTransfer(msg.sender, r);
+    }
+
+    /**
+     * @dev Sets the candidate for the new strat to use with this vault.
+     * @param _implementation The address of the candidate strategy.
+     */
+    function proposeStrat(address _implementation) public onlyOwner {
+        require(
+            address(this) == IStrategyV7(_implementation).vault(),
+            "Proposal not valid for this Vault"
+        );
+        require(
+            want() == IStrategyV7(_implementation).want(),
+            "Different want"
+        );
+        stratCandidate = StratCandidate({
+            implementation: _implementation,
+            proposedTime: block.timestamp
+        });
+
+        emit NewStratCandidate(_implementation);
+    }
+
+    /**
+     * @dev It switches the active strat for the strat candidate. After upgrading, the
+     * candidate implementation is set to the 0x00 address, and proposedTime to a time
+     * happening in +100 years for safety.
+     */
+
+    function upgradeStrat() public onlyOwner {
+        require(
+            stratCandidate.implementation != address(0),
+            "There is no candidate"
+        );
+        require(
+            stratCandidate.proposedTime + approvalDelay < block.timestamp,
+            "Delay has not passed"
+        );
+
+        emit UpgradeStrat(stratCandidate.implementation);
+
+        strategy.retireStrat();
+        strategy = IStrategyV7(stratCandidate.implementation);
+        stratCandidate.implementation = address(0);
+        stratCandidate.proposedTime = 5000000000;
+
+        earn();
+    }
+
+    /**
+     * @dev Rescues random funds stuck that the strat can't handle.
+     * @param _token address of the token to rescue.
+     */
+    function inCaseTokensGetStuck(address _token) external onlyOwner {
+        require(_token != address(want()), "!token");
+
+        uint256 amount = IERC20Upgradeable(_token).balanceOf(address(this));
+        IERC20Upgradeable(_token).safeTransfer(msg.sender, amount);
+    }
+}