Forked Deployments and V1 Vault Fixture Logic

foundry.toml

@@ -1,7 +1,7 @@
 [profile.default]
 optimizer_runs = 1000000
 verbosity = 1
-solc = "0.8.19"
+solc = "0.8.20"
 
 [fuzz]
 runs = 256

script/DeployLeveragedEthMainnet.s.sol

@@ -1,73 +1,38 @@
 // SPDX-License-Identifier: AGPL-3.0
 pragma solidity ^0.8.13;
 
-import {CREATE3Script} from "./base/CREATE3Script.sol";
-import {ERC20} from "solmate/tokens/ERC20.sol";
-import {WETH} from "solmate/tokens/WETH.sol";
-import {IPool} from "aave-v3/interfaces/IPool.sol";
-import {IAToken} from "aave-v3/interfaces/IAToken.sol";
-import {IPoolDataProvider} from "aave-v3/interfaces/IPoolDataProvider.sol";
+import "forge-std/console2.sol";
 
-import {Constants as C} from "../src/lib/Constants.sol";
-import {ICurvePool} from "../src/interfaces/curve/ICurvePool.sol";
-import {ILido} from "../src/interfaces/lido/ILido.sol";
-import {IwstETH} from "../src/interfaces/lido/IwstETH.sol";
-import {AggregatorV3Interface} from "../src/interfaces/chainlink/AggregatorV3Interface.sol";
-import {IVault} from "../src/interfaces/balancer/IVault.sol";
-import {ISwapRouter} from "../src/interfaces/uniswap/ISwapRouter.sol";
+import {DeployLeveragedEth} from "./base/DeployLeveragedEth.sol";
 import {scWETH} from "../src/steth/scWETH.sol";
 import {scUSDC} from "../src/steth/scUSDC.sol";
 import {sc4626} from "../src/sc4626.sol";
-import {MainnetDeployBase} from "./base/MainnetDeployBase.sol";
+import {Constants as C} from "../src/lib/Constants.sol";
+import {ISwapRouter} from "../src/interfaces/uniswap/ISwapRouter.sol";
 
-contract DeployScript is MainnetDeployBase {
-    function run() external returns (scWETH scWeth, scUSDC scUsdc) {
-        vm.startBroadcast(deployerPrivateKey);
+contract DeployScript is DeployLeveragedEth {
+    function run() external {
+        _deploy();
 
-        scWETH.ConstructorParams memory scWethParams = scWETH.ConstructorParams({
-            admin: deployerAddress,
-            keeper: keeper,
-            targetLtv: 0.7e18,
-            slippageTolerance: 0.99e18,
-            aavePool: IPool(C.AAVE_V3_POOL),
-            aaveAwstEth: IAToken(C.AAVE_V3_AWSTETH_TOKEN),
-            aaveVarDWeth: ERC20(C.AAVE_V3_VAR_DEBT_WETH_TOKEN),
-            curveEthStEthPool: ICurvePool(C.CURVE_ETH_STETH_POOL),
-            stEth: ILido(C.STETH),
-            wstEth: IwstETH(C.WSTETH),
-            weth: WETH(payable(C.WETH)),
-            stEthToEthPriceFeed: AggregatorV3Interface(C.CHAINLINK_STETH_ETH_PRICE_FEED),
-            balancerVault: IVault(C.BALANCER_VAULT)
-        });
+        _postDeployment();
+    }
 
-        scWeth = new scWETH(scWethParams);
+    function _postDeployment() internal {
+        vm.startBroadcast(deployerPrivateKey);
 
+        // scWETH
         weth.deposit{value: 0.01 ether}(); // wrap 0.01 ETH into WETH
+        console2.log("eth deposited for weth");
         _deposit(scWeth, 0.01 ether); // 0.01 WETH
+        console2.log("weth deposited into wethContract");
 
-        _transferAdminRoleToMultisig(scWeth, deployerAddress);
-
-        scUSDC.ConstructorParams memory scUsdcParams = scUSDC.ConstructorParams({
-            admin: deployerAddress,
-            keeper: keeper,
-            scWETH: scWeth,
-            usdc: usdc,
-            weth: WETH(payable(C.WETH)),
-            aavePool: IPool(C.AAVE_V3_POOL),
-            aavePoolDataProvider: IPoolDataProvider(C.AAVE_V3_POOL_DATA_PROVIDER),
-            aaveAUsdc: IAToken(C.AAVE_V3_AUSDC_TOKEN),
-            aaveVarDWeth: ERC20(C.AAVE_V3_VAR_DEBT_WETH_TOKEN),
-            uniswapSwapRouter: ISwapRouter(C.UNISWAP_V3_SWAP_ROUTER),
-            chainlinkUsdcToEthPriceFeed: AggregatorV3Interface(C.CHAINLINK_USDC_ETH_PRICE_FEED),
-            balancerVault: IVault(C.BALANCER_VAULT)
-        });
-
-        scUsdc = new scUSDC(scUsdcParams);
-
+        // scUSDC
+        weth.deposit{value: 0.01 ether}();
+        console2.log("eth deposited for weth to swap for usdc");
         _swapWethForUsdc(0.01 ether);
+        console2.log("eth swapped for USDC");
         _deposit(scUsdc, usdc.balanceOf(address(deployerAddress))); // 0.01 ether worth of USDC
-
-        _transferAdminRoleToMultisig(scUsdc, deployerAddress);
+        console2.log("usdc deposited into usdcContract");
 
         vm.stopBroadcast();
     }

script/DeployLeveragedEthTestnet.s.sol

@@ -1,19 +1,128 @@
 // SPDX-License-Identifier: AGPL-3.0
 pragma solidity ^0.8.13;
 
+import "forge-std/console2.sol";
+import "forge-std/Test.sol";
+import "forge-std/StdStorage.sol";
+
 import {DeployLeveragedEth} from "./base/DeployLeveragedEth.sol";
 import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
 import {MockWETH} from "../test/mocks/MockWETH.sol";
 import {MockUSDC} from "../test/mocks/MockUSDC.sol";
-import {GoerliConstants as C} from "../src/lib/GoerliConstants.sol";
+import {Constants as C} from "../src/lib/Constants.sol";
+import {ERC20} from "solmate/tokens/ERC20.sol";
+import {sc4626} from "../src/sc4626.sol";
+import {scWETH} from "../src/steth/scWETH.sol";
+import {scUSDC} from "../src/steth/scUSDC.sol";
 
-contract DeployScript is DeployLeveragedEth {
-    function deployMockTokens() internal override {
-        weth = MockWETH(payable(C.WETH));
-        usdc = MockUSDC(C.USDC);
-    }
+contract DeployScript is DeployLeveragedEth, Test {
+    using stdStorage for StdStorage;
+
+    uint256 public constant INITIAL_WETH_DEPOSIT = 10e18;
+    uint256 public constant INITIAL_WETH_WITHDRAW = 1e18;
+    uint256 public constant INITIAL_USDC_DEPOSIT = 100e6;
+    uint256 public constant INITIAL_USDC_WITHDRAW = 1e6;
+    uint256 public constant INITIAL_WETH_FUNDING = 100e18;
+    uint256 public constant INITIAL_USDC_FUNDING = 10000e6;
 
     function run() external {
-        deploy();
+        _deploy();
+        _fixtures();
+    }
+
+    function _fixtures() internal {
+        console2.log("\nexecuting steth fixtures");
+
+        _fund();
+
+        _deposit(weth, scWeth, alice, address(scWeth), INITIAL_WETH_DEPOSIT);
+        _deposit(weth, scWeth, bob, address(scWeth), INITIAL_WETH_DEPOSIT);
+        _deposit(usdc, scUsdc, alice, address(scUsdc), INITIAL_USDC_DEPOSIT);
+        _deposit(usdc, scUsdc, bob, address(scUsdc), INITIAL_USDC_DEPOSIT);
+
+        _rebalance(scWeth);
+
+        // double rebalance passes
+        _rebalance(scUsdc);
+        _rebalance(scUsdc);
+
+        _redeem(scWeth, alice);
+        _redeem(scWeth, bob);
+
+        _redeem(scUsdc, alice);
+        _redeem(scUsdc, bob);
+
+        _deposit(weth, scWeth, alice, address(scWeth), INITIAL_WETH_DEPOSIT);
+        _deposit(weth, scWeth, bob, address(scWeth), INITIAL_WETH_DEPOSIT);
+        _deposit(usdc, scUsdc, alice, address(scUsdc), INITIAL_USDC_DEPOSIT);
+        _deposit(usdc, scUsdc, bob, address(scUsdc), INITIAL_USDC_DEPOSIT);
+
+        _profit(); // create scUsdc profit scenario
+    }
+
+    function _fund() internal {
+        console2.log("funding");
+
+        // Dole out ETH
+        deal(alice, INITIAL_WETH_FUNDING);
+        deal(bob, INITIAL_WETH_FUNDING);
+        deal(keeper, INITIAL_WETH_FUNDING);
+
+        // Dole out WETH
+        deal(address(weth), INITIAL_WETH_FUNDING * 2);
+        deal(address(weth), alice, INITIAL_WETH_FUNDING);
+        deal(address(weth), bob, INITIAL_WETH_FUNDING);
+
+        // Dole out USDC
+        deal(address(usdc), alice, INITIAL_USDC_FUNDING);
+        deal(address(usdc), bob, INITIAL_USDC_FUNDING);
+    }
+
+    function _deposit(ERC20 _asset, sc4626 _vault, address _from, address _to, uint256 _amount) internal {
+        console2.log("depositing", _from);
+
+        vm.startPrank(_from);
+        _asset.approve(address(_to), type(uint256).max);
+        _vault.deposit(_amount, _from);
+        vm.stopPrank();
+    }
+
+    function _rebalance(scWETH _vault) internal {
+        console2.log("rebalancing scWETH");
+
+        vm.startPrank(keeper);
+        _vault.harvest();
+        vm.stopPrank();
+    }
+
+    function _rebalance(scUSDC _vault) internal {
+        console2.log("rebalancing scUsdc");
+
+        vm.startPrank(keeper);
+        _vault.rebalance();
+        vm.stopPrank();
+    }
+
+    function _profit() internal {
+        console2.log("generate profit for scUsdc vault");
+
+        console2.log("scUsdc profit before", scUsdc.getProfit());
+        deal(address(weth), address(scWeth), INITIAL_WETH_FUNDING);
+        console2.log("scUsdc profit after", scUsdc.getProfit());
+    }
+
+    function _redeem(scWETH _vault, address _redeemer) internal {
+        console2.log("redeeming scWETh", _redeemer);
+
+        uint256 sharesToRedeem = _vault.convertToShares(INITIAL_WETH_WITHDRAW);
+        vm.prank(_redeemer);
+        _vault.redeem(sharesToRedeem, _redeemer, _redeemer);
+    }
+
+    function _redeem(scUSDC _vault, address _redeemer) internal {
+        console2.log("redeeming scUsdc", _redeemer);
+
+        vm.prank(_redeemer);
+        _vault.withdraw(INITIAL_USDC_WITHDRAW, _redeemer, _redeemer);
     }
 }