Vip 7 Dai PSM

contracts/test/integration/IntegrationTestPriceBoundPSMDai.t.sol

@@ -0,0 +1,340 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.4;
+
+import {ERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {MockPCVDepositV2} from "../../mock/MockPCVDepositV2.sol";
+import {IPCVDeposit} from "../../pcv/IPCVDeposit.sol";
+import {MockERC20} from "../../mock/MockERC20.sol";
+import {OraclePassThrough} from "../../oracle/OraclePassThrough.sol";
+import {ScalingPriceOracle} from "../../oracle/ScalingPriceOracle.sol";
+import {MockScalingPriceOracle} from "../../mock/MockScalingPriceOracle.sol";
+import {ICore} from "../../core/ICore.sol";
+import {Core} from "../../core/Core.sol";
+import {IVolt, Volt} from "../../volt/Volt.sol";
+import {PriceBoundPSM, PegStabilityModule} from "../../peg/PriceBoundPSM.sol";
+import {getCore, getMainnetAddresses, VoltTestAddresses} from "../unit/utils/Fixtures.sol";
+import {ERC20CompoundPCVDeposit} from "../../pcv/compound/ERC20CompoundPCVDeposit.sol";
+import {Vm} from "./../unit/utils/Vm.sol";
+import {DSTest} from "./../unit/utils/DSTest.sol";
+import {MainnetAddresses} from "./fixtures/MainnetAddresses.sol";
+import {Constants} from "../../Constants.sol";
+
+contract IntegrationTestPriceBoundPSMDaiTest is DSTest {
+    using SafeCast for *;
+    PriceBoundPSM private psm;
+    ICore private core = ICore(MainnetAddresses.CORE);
+    IVolt private volt = IVolt(MainnetAddresses.VOLT);
+    IVolt private dai = IVolt(MainnetAddresses.DAI);
+    IVolt private underlyingToken = dai;
+
+    MockPCVDepositV2 public pcvDeposit;
+
+    /// ------------ Minting and RateLimited System Params ------------
+
+    uint256 public constant mintAmount = 10_000_000e18;
+    uint256 public constant mintAmountPSM = 10_000_000e18;
+    uint256 public constant bufferCap = 10_000_000e18;
+    uint256 public constant individualMaxBufferCap = 5_000_000e18;
+    uint256 public constant rps = 10_000e18;
+
+    /// ------------ Oracle System Params ------------
+
+    /// @notice prices during test will increase 1% monthly
+    int256 public constant monthlyChangeRateBasisPoints = 100;
+    uint256 public constant maxDeviationThresholdBasisPoints = 1_000;
+
+    /// @notice Oracle Pass Through contract
+    OraclePassThrough public oracle =
+        OraclePassThrough(MainnetAddresses.ORACLE_PASS_THROUGH);
+
+    Vm public constant vm = Vm(HEVM_ADDRESS);
+
+    uint256 voltFloorPrice = 9_000; /// 1 volt for .9 dai is the max allowable price
+    uint256 voltCeilingPrice = 10_000; /// 1 volt for 1 dai is the minimum price
+
+    function setUp() public {
+        PegStabilityModule.OracleParams memory oracleParams;
+
+        pcvDeposit = new MockPCVDepositV2(
+            address(core),
+            address(underlyingToken),
+            0,
+            0
+        );
+
+        oracleParams = PegStabilityModule.OracleParams({
+            coreAddress: address(core),
+            oracleAddress: address(oracle),
+            backupOracle: address(0),
+            decimalsNormalizer: 0,
+            doInvert: true
+        });
+
+        /// create PSM
+        psm = new PriceBoundPSM(
+            voltFloorPrice,
+            voltCeilingPrice,
+            oracleParams,
+            0,
+            0,
+            10_000_000_000e18,
+            10_000e18,
+            10_000_000e18,
+            IERC20(address(dai)),
+            pcvDeposit
+        );
+
+        vm.startPrank(MainnetAddresses.DAI_USDC_USDT_CURVE_POOL);
+        dai.transfer(address(this), mintAmount);
+        dai.transfer(address(psm), mintAmount * 2);
+        vm.stopPrank();
+
+        vm.startPrank(MainnetAddresses.GOVERNOR);
+
+        /// grant the PSM the PCV Controller role
+        core.grantMinter(MainnetAddresses.GOVERNOR);
+        /// mint VOLT to the user
+        volt.mint(address(psm), mintAmount);
+        volt.mint(address(this), mintAmount);
+        vm.stopPrank();
+    }
+
+    /// @notice PSM inverts price
+    function testDoInvert() public {
+        assertTrue(psm.doInvert());
+    }
+
+    /// @notice PSM is set up correctly and view functions are working
+    function testGetRedeemAmountOut(uint128 amountVoltIn) public {
+        uint256 currentPegPrice = oracle.getCurrentOraclePrice();
+
+        uint256 amountOut = (amountVoltIn * currentPegPrice) / 1e18;
+
+        assertApproxEq(
+            psm.getRedeemAmountOut(amountVoltIn).toInt256(),
+            amountOut.toInt256(),
+            0
+        );
+    }
+
+    /// @notice PSM is set up correctly and view functions are working
+    function testGetMaxMintAmountOut() public {
+        uint256 startingBalance = volt.balanceOf(address(psm));
+        assertEq(psm.getMaxMintAmountOut(), bufferCap + startingBalance);
+
+        vm.startPrank(MainnetAddresses.GOVERNOR);
+        volt.mint(address(psm), mintAmount);
+        vm.stopPrank();
+
+        assertEq(
+            psm.getMaxMintAmountOut(),
+            bufferCap + mintAmount + startingBalance
+        );
+    }
+
+    /// @notice PSM is set up correctly and view functions are working
+    function testGetMintAmountOut() public {
+        uint256 currentPegPrice = oracle.getCurrentOraclePrice();
+
+        uint256 amountOut = (mintAmount * 1e18) / currentPegPrice;
+
+        assertApproxEq(
+            psm.getMintAmountOut(mintAmount).toInt256(),
+            amountOut.toInt256(),
+            0
+        );
+    }
+
+    /// @notice pcv deposit receives underlying token on mint
+    function testSwapUnderlyingForVoltAfterPriceIncrease() public {
+        uint256 amountStableIn = 101_000;
+        uint256 amountVoltOut = psm.getMintAmountOut(amountStableIn);
+
+        underlyingToken.approve(address(psm), amountStableIn);
+        psm.mint(address(this), amountStableIn, amountVoltOut);
+
+        uint256 endingUserVoltBalance = volt.balanceOf(address(this));
+        uint256 endingPSMUnderlyingBalance = underlyingToken.balanceOf(
+            address(psm)
+        );
+
+        assertEq(endingPSMUnderlyingBalance, amountStableIn + mintAmount * 2);
+        assertEq(endingUserVoltBalance, mintAmount + amountVoltOut);
+    }
+
+    /// @notice pcv deposit receives underlying token on mint
+    function testSwapUnderlyingForVolt() public {
+        uint256 userStartingVoltBalance = volt.balanceOf(address(this));
+        uint256 minAmountOut = psm.getMintAmountOut(mintAmount);
+
+        underlyingToken.approve(address(psm), mintAmount);
+        uint256 amountVoltOut = psm.mint(
+            address(this),
+            mintAmount,
+            minAmountOut
+        );
+
+        uint256 endingUserVOLTBalance = volt.balanceOf(address(this));
+        uint256 endingPSMUnderlyingBalance = underlyingToken.balanceOf(
+            address(psm)
+        );
+
+        assertEq(
+            endingUserVOLTBalance,
+            amountVoltOut + userStartingVoltBalance
+        );
+        assertApproxEq(
+            endingPSMUnderlyingBalance.toInt256(),
+            (mintAmount + mintAmount * 2).toInt256(),
+            0
+        ); /// allow 1 basis point of error
+    }
+
+    /// @notice pcv deposit gets depleted on redeem
+    function testSwapVoltForUnderlying() public {
+        uint256 startingUserUnderlyingBalance = underlyingToken.balanceOf(
+            address(this)
+        );
+        volt.approve(address(psm), mintAmount);
+        uint256 amountOut = psm.redeem(address(this), mintAmount, mintAmount);
+
+        uint256 endingUserVOLTBalance = volt.balanceOf(address(this));
+        uint256 endingUserUnderlyingBalance = underlyingToken.balanceOf(
+            address(this)
+        );
+        uint256 endingPSMUnderlyingBalance = underlyingToken.balanceOf(
+            address(psm)
+        );
+
+        assertEq(endingPSMUnderlyingBalance, mintAmount * 2 - amountOut);
+        assertEq(endingUserVOLTBalance, 0);
+        assertEq(
+            endingUserUnderlyingBalance,
+            startingUserUnderlyingBalance + amountOut
+        );
+    }
+
+    /// @notice redeem fails without approval
+    function testSwapVoltForUnderlyingFailsWithoutApproval() public {
+        vm.expectRevert(bytes("ERC20: transfer amount exceeds allowance"));
+
+        psm.redeem(address(this), mintAmount, mintAmount);
+    }
+
+    /// @notice mint fails without approval
+    function testSwapUnderlyingForVoltFailsWithoutApproval() public {
+        vm.expectRevert(bytes("Dai/insufficient-allowance"));
+
+        psm.mint(address(this), mintAmount, 0);
+    }
+
+    /// @notice withdraw erc20 fails without correct permissions
+    function testERC20WithdrawFailure() public {
+        vm.expectRevert(bytes("CoreRef: Caller is not a PCV controller"));
+
+        psm.withdrawERC20(address(underlyingToken), address(this), 100);
+    }
+
+    /// @notice withdraw erc20 succeeds with correct permissions
+    function testERC20WithdrawSuccess() public {
+        vm.prank(MainnetAddresses.GOVERNOR);
+        core.grantPCVController(address(this));
+
+        uint256 startingBalance = underlyingToken.balanceOf(address(this));
+        psm.withdrawERC20(address(underlyingToken), address(this), mintAmount);
+        uint256 endingBalance = underlyingToken.balanceOf(address(this));
+
+        assertEq(endingBalance - startingBalance, mintAmount);
+    }
+
+    /// @notice set global rate limited minter fails when caller is governor and new address is 0
+    function testSetPCVDepositFailureZeroAddress() public {
+        vm.startPrank(MainnetAddresses.GOVERNOR);
+
+        vm.expectRevert(
+            bytes("PegStabilityModule: Invalid new surplus target")
+        );
+        psm.setSurplusTarget(IPCVDeposit(address(0)));
+
+        vm.stopPrank();
+    }
+
+    /// @notice set PCV deposit fails when caller is governor and new address is 0
+    function testSetPCVDepositFailureNonGovernor() public {
+        vm.expectRevert(
+            bytes("CoreRef: Caller is not a governor or contract admin")
+        );
+        psm.setSurplusTarget(IPCVDeposit(address(0)));
+    }
+
+    /// @notice set PCV Deposit succeeds when caller is governor and underlying tokens match
+    function testSetPCVDepositSuccess() public {
+        vm.startPrank(MainnetAddresses.GOVERNOR);
+
+        MockPCVDepositV2 newPCVDeposit = new MockPCVDepositV2(
+            address(core),
+            address(underlyingToken),
+            0,
+            0
+        );
+
+        psm.setSurplusTarget(IPCVDeposit(address(newPCVDeposit)));
+
+        vm.stopPrank();
+
+        assertEq(address(newPCVDeposit), address(psm.surplusTarget()));
+    }
+
+    /// @notice set mint fee succeeds
+    function testSetMintFeeSuccess() public {
+        vm.prank(MainnetAddresses.GOVERNOR);
+        psm.setMintFee(100);
+
+        assertEq(psm.mintFeeBasisPoints(), 100);
+    }
+
+    /// @notice set mint fee fails unauthorized
+    function testSetMintFeeFailsWithoutCorrectRoles() public {
+        vm.expectRevert(
+            bytes("CoreRef: Caller is not a governor or contract admin")
+        );
+
+        psm.setMintFee(100);
+    }
+
+    /// @notice set redeem fee succeeds
+    function testSetRedeemFeeSuccess() public {
+        vm.prank(MainnetAddresses.GOVERNOR);
+        psm.setRedeemFee(100);
+
+        assertEq(psm.redeemFeeBasisPoints(), 100);
+    }
+
+    /// @notice set redeem fee fails unauthorized
+    function testSetRedeemFeeFailsWithoutCorrectRoles() public {
+        vm.expectRevert(
+            bytes("CoreRef: Caller is not a governor or contract admin")
+        );
+
+        psm.setRedeemFee(100);
+    }
+
+    /// @notice redeem fails when paused
+    function testRedeemFailsWhenPaused() public {
+        vm.prank(MainnetAddresses.GOVERNOR);
+        psm.pauseRedeem();
+
+        vm.expectRevert(bytes("PegStabilityModule: Redeem paused"));
+        psm.redeem(address(this), 100, 100);
+    }
+
+    /// @notice mint fails when paused
+    function testMintFailsWhenPaused() public {
+        vm.prank(MainnetAddresses.GOVERNOR);
+        psm.pauseMint();
+
+        vm.expectRevert(bytes("PegStabilityModule: Minting paused"));
+        psm.mint(address(this), 100, 100);
+    }
+}

contracts/test/integration/fixtures/MainnetAddresses.sol

@@ -80,6 +80,8 @@ library MainnetAddresses {
         0xAe2D4617c862309A3d75A0fFB358c7a5009c673F;
     address public constant FEI = 0x956F47F50A910163D8BF957Cf5846D573E7f87CA;
 
+    address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+
     // ---------- CHAINLINK ADDRESSES ----------
 
     address public constant CHAINLINK_ORACLE_ADDRESS =
@@ -89,4 +91,9 @@ library MainnetAddresses {
 
     address public constant RARI_VOLT_PCV_DEPOSIT =
         0xFeBDf448C8484834bb399d930d7E1bdC773E23bA;
+
+    // ---------- CURVE ADDRESSES ----------
+
+    address public constant DAI_USDC_USDT_CURVE_POOL =
+        0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7;
 }