Rocket Pool Vault

contracts/interfaces/vaults/IVault.sol

@@ -12,8 +12,8 @@ interface IVault {
     /**
      * @dev Deposits LP token directly into vault
      *
-     * @param user The user depositing 
      * @param amount The amount of LP tokens to deposit
+     * @param user The user depositing 
      */
     function depositLpToken(uint256 amount, address user) external;
 

contracts/interfaces/vaults/RocketVaultInterface.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.8.0;
+
+// SPDX-License-Identifier: GPL-3.0-only
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
+
+interface RocketVaultInterface {
+    function balanceOf(string memory _networkContractName) external view returns (uint256);
+    function depositEther() external payable;
+    function withdrawEther(uint256 _amount) external;
+    function depositToken(string memory _networkContractName, IERC20 _tokenAddress, uint256 _amount) external;
+    function withdrawToken(address _withdrawalAddress, IERC20 _tokenAddress, uint256 _amount) external;
+    function balanceOfToken(string memory _networkContractName, IERC20 _tokenAddress) external view returns (uint256);
+    function transferToken(string memory _networkContractName, IERC20 _tokenAddress, uint256 _amount) external;
+    function burnToken(ERC20Burnable _tokenAddress, uint256 _amount) external;
+}

contracts/vaults/RocketPoolVault.sol

@@ -5,6 +5,7 @@ import { BaseVault } from "./BaseVault.sol";
 import { RocketDepositPoolInterface } from "../interfaces/vaults/RocketDepositPoolInterface.sol";
 import { RocketTokenRETHInterface } from "../interfaces/vaults/RocketTokenRETHInterface.sol";
 import { RocketStorageInterface } from "../interfaces/vaults/RocketStorageInterface.sol";
+import { RocketVaultInterface } from "../interfaces/vaults/RocketVaultInterface.sol";
 
 contract RocketVault is BaseVault {
     // stores state for Rocket Protocol
@@ -43,9 +44,6 @@ contract RocketVault is BaseVault {
         // Load contracts
         address rethAddress = rocketStorage.getAddress(keccak256(abi.encodePacked("contract.address", "rocketETHToken")));
         RocketTokenRETHInterface rETH = RocketTokenRETHInterface(rethAddress);
-
-        // check that rocketVault has enough ETH to handle withdrawal
-        uint256 amountToWithdraw = rETH.getEthValue(lpTokenAmount);
 
         // Redeem rETH for ETH and send to recipient
         uint256 balanceBefore = address(this).balance;
@@ -78,18 +76,20 @@ contract RocketVault is BaseVault {
     }
 
     function getAmountETH(uint256 lpTokenAmount) external view override returns (uint256) {
-        // Load rocketVault address and rETH contract
-        address rocketVault = rocketStorage.getAddress(keccak256(abi.encodePacked("contract.address", "rocketVault")));
+        // Load rocketVault and rETH contracts
+        address rocketVaultAddress = rocketStorage.getAddress(keccak256(abi.encodePacked("contract.address", "rocketVault")));
+        RocketVaultInterface rocketVault = RocketVaultInterface(rocketVaultAddress);
         address rethAddress = rocketStorage.getAddress(keccak256(abi.encodePacked("contract.address", "rocketETHToken")));
         RocketTokenRETHInterface rETH = RocketTokenRETHInterface(rethAddress);
 
         uint256 ethAmount = rETH.getEthValue(lpTokenAmount);
 
         // check if rocket vault has enough to withdraw, if not return rocket vault balance 
-        if (rocketVault.balance >= ethAmount) {
+        uint256 vaultBalance = rocketVault.balanceOf("rocketDepositPool");
+        if (vaultBalance >= ethAmount) {
             return ethAmount;
         } else {
-            return rocketVault.balance;
+            return vaultBalance;
         }
     }
 

hardhat.config.js

@@ -5,7 +5,17 @@ require("hardhat-deploy-ethers");
 require("hardhat-gas-reporter");
 require("dotenv").config();
 
+const MAINNET_URL = process.env.MAINNET_URL ? process.env.MAINNET_URL : "";
+
 module.exports = {
+  networks: {
+    hardhat: {
+      forking: {
+        url: MAINNET_URL,
+        enabled: true,
+      },
+    },
+  },
   solidity: {
     version: "0.8.4",
     settings: {

test/fixture.js

@@ -101,15 +101,28 @@ const fixture = deployments.createFixture(async () => {
   // create vault names
   const vaultNames = {
     empty: "0xeeeeeeeeeeeeeeeeeeeeeeee",
+    rocketVault: "0xeeeeeeeeeeeeeeeeeeeeeeed"
   };
 
+  // rocket pool addresses for deployment
+  const rocketAddresses = {
+    rocketStorage: "0x1d8f8f00cfa6758d7bE78336684788Fb0ee0Fa46"
+  }
+
   // create and register vault
   const EmptyVault = await ethers.getContractFactory("EmptyVault");
   const emptyVault = await EmptyVault.deploy(diamond.address);
   await emptyVault.deployed();
   tx = await vaultManagement.registerVault(vaultNames.empty, emptyVault.address);
   await tx.wait();
 
+  // create and register rocket vault
+  const RocketVault = await ethers.getContractFactory("RocketVault");
+  const rocketVault = await RocketVault.deploy(diamond.address, rocketAddresses.rocketStorage);
+  await rocketVault.deployed();
+  tx = await vaultManagement.registerVault(vaultNames.rocketVault, rocketVault.address);
+  await tx.wait();
+
   return {
     diamond,
     diamondCut,

test/vaults/RocketVault.js

@@ -0,0 +1,41 @@
+const { ethers } = require("hardhat");
+const { expect } = require("chai");
+
+const { fixture } = require("../fixture");
+
+describe("Rocket Vault", async () => {
+  // fixture values
+  let deployer, user;
+  let vaultAccounting;
+  let vaultManagement;
+  let vaultNames;
+
+  // vault parameters
+  let depositAmount;
+  let expectedEthAmount;
+  let expectedLpToken;
+  let expectedLpTokenAmount;
+  let rocketVault;
+
+  beforeEach(async () => {
+    // initialize fixture values
+    ({ vaultAccounting, vaultManagement, vaultNames } = await fixture());
+    [deployer, user] = await ethers.getSigners();
+
+    // initialize vault parameters
+    depositAmount = ethers.utils.parseEther("1.0");
+    expectedEthAmount = ethers.utils.parseEther("1.0");
+    expectedLpToken = "0xae78736Cd615f374D3085123A210448E74Fc6393"; // rETH token address
+    rocketVault = await ethers.getContractAt("IVault", await vaultManagement.getVault(vaultNames.rocketVault)); 
+    expectedLpTokenAmount = await rocketVault.getAmountLpTokens(depositAmount); //gets rETH amount equivalent to 1 ETH
+  });
+
+  it("Should reflect correct conversion from lp tokens to ETH", async () => {
+    expect(await rocketVault.getAmountETH(expectedLpTokenAmount)).to.be.equal(expectedEthAmount);
+  });
+
+  it("Should reflect correct conversion from ETH to lp tokens", async () => {
+    expect(await rocketVault.getAmountLpTokens(expectedEthAmount)).to.be.equal(expectedLpTokenAmount);
+  });
+
+});