diff --git a/lib/grove-address-registry b/lib/grove-address-registry index d5b15a87..f47084ed 160000 --- a/lib/grove-address-registry +++ b/lib/grove-address-registry @@ -1 +1 @@ -Subproject commit d5b15a8748a701acb5f2367aca7a378e1c8b8ff0 +Subproject commit f47084ed8b2d891dc9a5bb92db0427530390d20b diff --git a/src/MainnetController.sol b/src/MainnetController.sol index 31f07900..a430c1de 100644 --- a/src/MainnetController.sol +++ b/src/MainnetController.sol @@ -9,7 +9,7 @@ import { AccessControl } from "openzeppelin-contracts/contracts/access/AccessCon import { IERC20 } from "openzeppelin-contracts/contracts/interfaces/IERC20.sol"; import { IERC4626 } from "openzeppelin-contracts/contracts/interfaces/IERC4626.sol"; -import { Ethereum } from "spark-address-registry/Ethereum.sol"; +import { Ethereum } from "grove-address-registry/Ethereum.sol"; import { IALMProxy } from "./interfaces/IALMProxy.sol"; import { ICCTPLike } from "./interfaces/CCTPInterfaces.sol"; diff --git a/test/avalanche-fork/Centrifuge.t.sol b/test/grove-avalanche-fork/Centrifuge.t.sol similarity index 100% rename from test/avalanche-fork/Centrifuge.t.sol rename to test/grove-avalanche-fork/Centrifuge.t.sol diff --git a/test/avalanche-fork/ForkTestBase.t.sol b/test/grove-avalanche-fork/ForkTestBase.t.sol similarity index 100% rename from test/avalanche-fork/ForkTestBase.t.sol rename to test/grove-avalanche-fork/ForkTestBase.t.sol diff --git a/test/mainnet-fork/4626Calls.t.sol b/test/grove-mainnet-fork/4626Calls.t.sol similarity index 99% rename from test/mainnet-fork/4626Calls.t.sol rename to test/grove-mainnet-fork/4626Calls.t.sol index d5985e9c..1e96dbc3 100644 --- a/test/mainnet-fork/4626Calls.t.sol +++ b/test/grove-mainnet-fork/4626Calls.t.sol @@ -19,7 +19,7 @@ contract SUSDSTestBase is ForkTestBase { bytes32 depositKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDS); bytes32 withdrawKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_4626_WITHDRAW(), Ethereum.SUSDS); - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(depositKey, 5_000_000e18, uint256(1_000_000e18) / 4 hours); rateLimits.setRateLimitData(withdrawKey, 5_000_000e18, uint256(1_000_000e18) / 4 hours); vm.stopPrank(); @@ -199,7 +199,7 @@ contract MainnetControllerRedeemERC4626FailureTests is SUSDSTestBase { function test_redeemERC4626_zeroMaxAmount() external { // Longer setup because rate limit revert is at the end of the function - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData( RateLimitHelpers.makeAssetKey( mainnetController.LIMIT_4626_WITHDRAW(), diff --git a/test/mainnet-fork/Aave.t.sol b/test/grove-mainnet-fork/Aave.t.sol similarity index 98% rename from test/mainnet-fork/Aave.t.sol rename to test/grove-mainnet-fork/Aave.t.sol index 8f3769ff..5363e41a 100644 --- a/test/mainnet-fork/Aave.t.sol +++ b/test/grove-mainnet-fork/Aave.t.sol @@ -20,7 +20,7 @@ contract AaveV3MainMarketBaseTest is ForkTestBase { function setUp() public override { super.setUp(); - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData( RateLimitHelpers.makeAssetKey( @@ -163,7 +163,7 @@ contract AaveV3MainMarketWithdrawFailureTests is AaveV3MainMarketBaseTest { function test_withdrawAave_zeroMaxAmount() external { // Longer setup because rate limit revert is at the end of the function - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData( RateLimitHelpers.makeAssetKey( mainnetController.LIMIT_AAVE_WITHDRAW(), @@ -265,7 +265,7 @@ contract AaveV3MainMarketWithdrawSuccessTests is AaveV3MainMarketBaseTest { mainnetController.LIMIT_AAVE_WITHDRAW(), ATOKEN_USDS ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setUnlimitedRateLimitData(key); deal(Ethereum.USDS, address(almProxy), 1_000_000e18); @@ -345,7 +345,7 @@ contract AaveV3MainMarketWithdrawSuccessTests is AaveV3MainMarketBaseTest { mainnetController.LIMIT_AAVE_WITHDRAW(), ATOKEN_USDC ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setUnlimitedRateLimitData(key); deal(Ethereum.USDC, address(almProxy), 1_000_000e6); diff --git a/test/mainnet-fork/Approve.t.sol b/test/grove-mainnet-fork/Approve.t.sol similarity index 98% rename from test/mainnet-fork/Approve.t.sol rename to test/grove-mainnet-fork/Approve.t.sol index 35a160a4..d527e249 100644 --- a/test/mainnet-fork/Approve.t.sol +++ b/test/grove-mainnet-fork/Approve.t.sol @@ -126,7 +126,7 @@ contract MainnetControllerApproveSuccessTests is ApproveTestBase { super.setUp(); MainnetControllerHarness harnessCode = new MainnetControllerHarness( - SPARK_PROXY, + GROVE_PROXY, address(mainnetController.proxy()), address(mainnetController.rateLimits()), address(mainnetController.vault()), @@ -197,7 +197,7 @@ contract ForeignControllerApproveSuccessTests is ApproveTestBase { // NOTE: This etching setup is necessary to get coverage to work ForeignController foreignController = new ForeignController( - SPARK_PROXY, + GROVE_PROXY, address(almProxy), makeAddr("rateLimits"), makeAddr("psm"), @@ -206,7 +206,7 @@ contract ForeignControllerApproveSuccessTests is ApproveTestBase { ); ForeignControllerHarness harnessCode = new ForeignControllerHarness( - SPARK_PROXY, + GROVE_PROXY, address(almProxy), makeAddr("rateLimits"), makeAddr("psm"), @@ -215,7 +215,7 @@ contract ForeignControllerApproveSuccessTests is ApproveTestBase { ); // Allow the foreign controller to call the ALMProxy - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); almProxy.grantRole(almProxy.CONTROLLER(), address(foreignController)); vm.stopPrank(); diff --git a/test/mainnet-fork/Attacks.t.sol b/test/grove-mainnet-fork/Attacks.t.sol similarity index 100% rename from test/mainnet-fork/Attacks.t.sol rename to test/grove-mainnet-fork/Attacks.t.sol diff --git a/test/mainnet-fork/Buidl.t.sol b/test/grove-mainnet-fork/Buidl.t.sol similarity index 97% rename from test/mainnet-fork/Buidl.t.sol rename to test/grove-mainnet-fork/Buidl.t.sol index bccfb163..f5bd9ed1 100644 --- a/test/mainnet-fork/Buidl.t.sol +++ b/test/grove-mainnet-fork/Buidl.t.sol @@ -42,7 +42,7 @@ contract MainnetControllerDepositBUIDLFailureTests is MainnetControllerBUIDLTest address(buidlDeposit) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_000_000e6, uint256(1_000_000e6) / 1 days); deal(address(usdc), address(almProxy), 1_000_000e6); @@ -65,7 +65,7 @@ contract MainnetControllerDepositBUIDLSuccessTests is MainnetControllerBUIDLTest address(buidlDeposit) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_000_000e6, uint256(1_000_000e6) / 1 days); deal(address(usdc), address(almProxy), 1_000_000e6); diff --git a/test/mainnet-fork/Centrifuge.t.sol b/test/grove-mainnet-fork/Centrifuge.t.sol similarity index 98% rename from test/mainnet-fork/Centrifuge.t.sol rename to test/grove-mainnet-fork/Centrifuge.t.sol index 477e6502..8bca3a62 100644 --- a/test/mainnet-fork/Centrifuge.t.sol +++ b/test/grove-mainnet-fork/Centrifuge.t.sol @@ -105,7 +105,7 @@ contract MainnetControllerRequestDepositERC7540FailureTests is CentrifugeTestBas } function test_requestDepositERC7540_rateLimitBoundary() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData( RateLimitHelpers.makeAssetKey( mainnetController.LIMIT_7540_DEPOSIT(), @@ -144,7 +144,7 @@ contract MainnetControllerRequestDepositERC7540SuccessTests is CentrifugeTestBas address(jTreasuryVault) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_000_000e6, uint256(1_000_000e6) / 1 days); } @@ -211,7 +211,7 @@ contract MainnetControllerClaimDepositERC7540SuccessTests is CentrifugeTestBase address(jTreasuryVault) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_500_000e6, uint256(1_500_000e6) / 1 days); } @@ -360,7 +360,7 @@ contract MainnetControllerCancelCentrifugeDepositSuccessTests is CentrifugeTestB address(jTreasuryVault) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_000_000e6, uint256(1_000_000e6) / 1 days); } @@ -416,7 +416,7 @@ contract MainnetControllerClaimCentrifugeCancelDepositSuccessTests is Centrifuge address(jTreasuryVault) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_000_000e6, uint256(1_000_000e6) / 1 days); } @@ -490,7 +490,7 @@ contract MainnetControllerRequestRedeemERC7540FailureTests is CentrifugeTestBase } function test_requestRedeemERC7540_rateLimitsBoundary() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData( RateLimitHelpers.makeAssetKey( mainnetController.LIMIT_7540_REDEEM(), @@ -536,7 +536,7 @@ contract MainnetControllerRequestRedeemERC7540SuccessTests is CentrifugeTestBase address(jTreasuryVault) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_000_000e6, uint256(1_000_000e6) / 1 days); } @@ -605,7 +605,7 @@ contract MainnetControllerClaimRedeemERC7540SuccessTests is CentrifugeTestBase { address(jTreasuryVault) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 2_000_000e6, uint256(2_000_000e6) / 1 days); } @@ -770,7 +770,7 @@ contract MainnetControllerCancelCentrifugeRedeemRequestSuccessTests is Centrifug address(jTreasuryVault) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_000_000e6, uint256(1_000_000e6) / 1 days); } @@ -830,7 +830,7 @@ contract MainnetControllerClaimCentrifugeCancelRedeemRequestSuccessTests is Cent address(jTreasuryVault) ); - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(key, 1_000_000e6, uint256(1_000_000e6) / 1 days); } diff --git a/test/mainnet-fork/CentrifugeV3.t.sol b/test/grove-mainnet-fork/CentrifugeV3.t.sol similarity index 98% rename from test/mainnet-fork/CentrifugeV3.t.sol rename to test/grove-mainnet-fork/CentrifugeV3.t.sol index f83b147e..78884f02 100644 --- a/test/mainnet-fork/CentrifugeV3.t.sol +++ b/test/grove-mainnet-fork/CentrifugeV3.t.sol @@ -60,7 +60,7 @@ contract MainnetControllerTransferSharesCentrifugeFailureTests is CentrifugeTest } function test_transferSharesCentrifuge_rateLimitedBoundary() external { - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); bytes32 target = bytes32(uint256(uint160(makeAddr("centrifugeRecipient")))); @@ -100,7 +100,7 @@ contract MainnetControllerTransferSharesCentrifugeFailureTests is CentrifugeTest } function test_transferSharesCentrifuge_invalidCentrifugeId() external { - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData( keccak256(abi.encode( @@ -142,7 +142,7 @@ contract MainnetControllerTransferSharesCentrifugeSuccessTests is CentrifugeTest ); function test_transferSharesCentrifuge() external { - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); bytes32 target = bytes32(uint256(uint160(makeAddr("centrifugeRecipient")))); diff --git a/test/mainnet-fork/Curve.t.sol b/test/grove-mainnet-fork/Curve.t.sol similarity index 98% rename from test/mainnet-fork/Curve.t.sol rename to test/grove-mainnet-fork/Curve.t.sol index cfb68a29..f765e7f5 100644 --- a/test/mainnet-fork/Curve.t.sol +++ b/test/grove-mainnet-fork/Curve.t.sol @@ -26,14 +26,14 @@ contract CurveTestBase is ForkTestBase { curveSwapKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_SWAP(), CURVE_POOL); curveWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_WITHDRAW(), CURVE_POOL); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData(curveDepositKey, 2_000_000e18, uint256(2_000_000e18) / 1 days); rateLimits.setRateLimitData(curveSwapKey, 1_000_000e18, uint256(1_000_000e18) / 1 days); rateLimits.setRateLimitData(curveWithdrawKey, 3_000_000e18, uint256(3_000_000e18) / 1 days); vm.stopPrank(); // Set a higher slippage to allow for successes - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0.98e18); } @@ -87,7 +87,7 @@ contract MainnetControllerAddLiquidityCurveFailureTests is CurveTestBase { uint256 minLpAmount = 1_950_000e18; - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0); vm.prank(relayer); @@ -141,7 +141,7 @@ contract MainnetControllerAddLiquidityCurveFailureTests is CurveTestBase { function test_addLiquidityCurve_zeroMaxAmount() public { bytes32 curveDeposit = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_DEPOSIT(), CURVE_POOL); - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(curveDeposit, 0, 0); uint256[] memory amounts = new uint256[](2); @@ -254,7 +254,7 @@ contract MainnetControllerAddLiquiditySuccessTests is CurveTestBase { function test_addLiquidityCurve_swapRateLimit() public { // Set a higher slippage to allow for successes - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0.7e18); deal(address(usdc), address(almProxy), 1_000_000e6); @@ -310,7 +310,7 @@ contract MainnetControllerAddLiquiditySuccessTests is CurveTestBase { function testFuzz_addLiquidityCurve_swapRateLimit(uint256 usdcAmount, uint256 usdtAmount) public { // Set slippage to be zero and unlimited rate limits for purposes of this test // Not using actual unlimited rate limit because need to get swap amount to be reduced. - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 1); // 1e-16% rateLimits.setUnlimitedRateLimitData(curveDepositKey); rateLimits.setUnlimitedRateLimitData(curveWithdrawKey); @@ -386,7 +386,7 @@ contract MainnetControllerRemoveLiquidityCurveFailureTests is CurveTestBase { uint256 lpReturn = 1_980_000e18; - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0); vm.prank(relayer); @@ -439,7 +439,7 @@ contract MainnetControllerRemoveLiquidityCurveFailureTests is CurveTestBase { function test_removeLiquidityCurve_zeroMaxAmount() public { bytes32 curveWithdraw = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_WITHDRAW(), CURVE_POOL); - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(curveWithdraw, 0, 0); uint256 lpTokensReceived = _addLiquidity(1_000_000e6, 1_000_000e6); @@ -473,7 +473,7 @@ contract MainnetControllerRemoveLiquidityCurveFailureTests is CurveTestBase { bytes32 curveWithdraw = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_WITHDRAW(), CURVE_POOL); // Set to below boundary - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(curveWithdraw, totalWithdrawn - 1, totalWithdrawn / 1 days); vm.prank(relayer); @@ -481,7 +481,7 @@ contract MainnetControllerRemoveLiquidityCurveFailureTests is CurveTestBase { mainnetController.removeLiquidityCurve(CURVE_POOL, lpTokensReceived, minWithdrawAmounts); // Set to boundary - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(curveWithdraw, totalWithdrawn, totalWithdrawn / 1 days); vm.prank(relayer); @@ -598,7 +598,7 @@ contract MainnetControllerSwapCurveFailureTests is CurveTestBase { } function test_swapCurve_slippageNotSet() public { - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0); vm.prank(relayer); @@ -635,7 +635,7 @@ contract MainnetControllerSwapCurveFailureTests is CurveTestBase { function test_swapCurve_zeroMaxAmount() public { bytes32 curveSwap = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_SWAP(), CURVE_POOL); - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(curveSwap, 0, 0); vm.prank(relayer); @@ -664,7 +664,7 @@ contract MainnetControllerSwapCurveSuccessTests is CurveTestBase { _addLiquidity(1_000_000e6, 1_000_000e6); skip(1 days); // Recharge swap rate limit from deposit - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0.999e18); // 0.1% uint256 startingUsdtBalance = usdt.balanceOf(CURVE_POOL); @@ -705,7 +705,7 @@ contract MainnetControllerSwapCurveSuccessTests is CurveTestBase { contract MainnetControllerGetVirtualPriceStressTests is CurveTestBase { function test_getVirtualPrice_stressTest() public { - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setUnlimitedRateLimitData(curveDepositKey); rateLimits.setUnlimitedRateLimitData(curveSwapKey); rateLimits.setUnlimitedRateLimitData(curveWithdrawKey); @@ -719,7 +719,7 @@ contract MainnetControllerGetVirtualPriceStressTests is CurveTestBase { deal(address(usdc), address(almProxy), 100_000_000e6); - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 1); // 1e-16% // Perform a massive swap to stress the virtual price @@ -785,14 +785,14 @@ contract MainnetController3PoolSwapRateLimitTest is ForkTestBase { curveSwapKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_SWAP(), CURVE_POOL); curveWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_WITHDRAW(), CURVE_POOL); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData(curveDepositKey, 5_000_000e18, uint256(5_000_000e18) / 1 days); rateLimits.setRateLimitData(curveSwapKey, 5_000_000e18, uint256(5_000_000e18) / 1 days); rateLimits.setRateLimitData(curveWithdrawKey, 5_000_000e18, uint256(5_000_000e18) / 1 days); vm.stopPrank(); // Set a higher slippage to allow for successes - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0.001e18); } @@ -860,14 +860,14 @@ contract MainnetControllerSUsdsUsdtSwapRateLimitTest is ForkTestBase { curveSwapKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_SWAP(), CURVE_POOL); curveWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_WITHDRAW(), CURVE_POOL); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData(curveDepositKey, 5_000_000e18, uint256(5_000_000e18) / 1 days); rateLimits.setRateLimitData(curveSwapKey, 5_000_000e18, uint256(5_000_000e18) / 1 days); rateLimits.setRateLimitData(curveWithdrawKey, 5_000_000e18, uint256(5_000_000e18) / 1 days); vm.stopPrank(); // Set a higher slippage to allow for successes - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0.01e18); // Seed the pool with some liquidity to be able to perform the swap @@ -938,7 +938,7 @@ contract MainnetControllerE2ECurveUsdtUsdcPoolTest is CurveTestBase { function test_e2e_addSwapAndRemoveLiquidityCurve() public { // Set a higher slippage to allow for successes - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0.95e18); deal(address(usdc), address(almProxy), 1_000_000e6); @@ -1072,14 +1072,14 @@ contract MainnetControllerE2ECurveSUsdsUsdtPoolTest is ForkTestBase { curveSwapKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_SWAP(), CURVE_POOL); curveWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_CURVE_WITHDRAW(), CURVE_POOL); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData(curveDepositKey, 2_000_000e18, uint256(2_000_000e18) / 1 days); rateLimits.setRateLimitData(curveSwapKey, 1_000_000e18, uint256(1_000_000e18) / 1 days); rateLimits.setRateLimitData(curveWithdrawKey, 3_000_000e18, uint256(3_000_000e18) / 1 days); vm.stopPrank(); // Set a higher slippage to allow for successes - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); mainnetController.setMaxSlippage(CURVE_POOL, 0.95e18); } diff --git a/test/mainnet-fork/DaiUsds.t.sol b/test/grove-mainnet-fork/DaiUsds.t.sol similarity index 100% rename from test/mainnet-fork/DaiUsds.t.sol rename to test/grove-mainnet-fork/DaiUsds.t.sol diff --git a/test/mainnet-fork/Deploy.t.sol b/test/grove-mainnet-fork/Deploy.t.sol similarity index 92% rename from test/mainnet-fork/Deploy.t.sol rename to test/grove-mainnet-fork/Deploy.t.sol index ea57fd5f..eb6fd895 100644 --- a/test/mainnet-fork/Deploy.t.sol +++ b/test/grove-mainnet-fork/Deploy.t.sol @@ -12,7 +12,7 @@ contract MainnetControllerDeploySuccessTests is ForkTestBase { // Perform new deployments against existing fork environment ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull({ - admin : SPARK_PROXY, + admin : GROVE_PROXY, vault : vault, psm : PSM, daiUsds : DAI_USDS, @@ -23,10 +23,10 @@ contract MainnetControllerDeploySuccessTests is ForkTestBase { MainnetController newController = MainnetController(controllerInst.controller); RateLimits newRateLimits = RateLimits(controllerInst.rateLimits); - assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); + assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, GROVE_PROXY), true); assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, address(this)), false); // Deployer never gets admin - assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); + assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, GROVE_PROXY), true); assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, address(this)), false); // Deployer never gets admin _assertControllerInitState(newController, address(newAlmProxy), address(newRateLimits), vault, buffer); @@ -36,7 +36,7 @@ contract MainnetControllerDeploySuccessTests is ForkTestBase { // Perform new deployments against existing fork environment MainnetController newController = MainnetController(MainnetControllerDeploy.deployController({ - admin : SPARK_PROXY, + admin : GROVE_PROXY, almProxy : address(almProxy), rateLimits : address(rateLimits), vault : vault, @@ -49,7 +49,7 @@ contract MainnetControllerDeploySuccessTests is ForkTestBase { } function _assertControllerInitState(MainnetController controller, address almProxy, address rateLimits, address vault, address buffer) internal view { - assertEq(controller.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); + assertEq(controller.hasRole(DEFAULT_ADMIN_ROLE, GROVE_PROXY), true); assertEq(controller.hasRole(DEFAULT_ADMIN_ROLE, address(this)), false); assertEq(address(controller.proxy()), almProxy); diff --git a/test/mainnet-fork/Ethena.t.sol b/test/grove-mainnet-fork/Ethena.t.sol similarity index 98% rename from test/mainnet-fork/Ethena.t.sol rename to test/grove-mainnet-fork/Ethena.t.sol index 6e7994b8..f90b608e 100644 --- a/test/mainnet-fork/Ethena.t.sol +++ b/test/grove-mainnet-fork/Ethena.t.sol @@ -97,7 +97,7 @@ contract MainnetControllerPrepareUSDeMintFailureTests is EthenaTestBase { } function test_prepareUSDeMint_zeroMaxAmount() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(mainnetController.LIMIT_USDE_MINT(), 0, 0); vm.stopPrank(); @@ -107,7 +107,7 @@ contract MainnetControllerPrepareUSDeMintFailureTests is EthenaTestBase { } function test_prepareUSDeMint_rateLimitBoundary() external { - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData( mainnetController.LIMIT_USDE_MINT(), 100e6, @@ -134,7 +134,7 @@ contract MainnetControllerPrepareUSDeMintSuccessTests is EthenaTestBase { key = mainnetController.LIMIT_USDE_MINT(); - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(key, 5_000_000e6, uint256(1_000_000e6) / 4 hours); } @@ -179,7 +179,7 @@ contract MainnetControllerPrepareUSDeBurnFailureTests is EthenaTestBase { } function test_prepareUSDeBurn_zeroMaxAmount() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(mainnetController.LIMIT_USDE_BURN(), 0, 0); vm.stopPrank(); @@ -189,7 +189,7 @@ contract MainnetControllerPrepareUSDeBurnFailureTests is EthenaTestBase { } function test_prepareUSDeBurn_rateLimitBoundary() external { - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData( mainnetController.LIMIT_USDE_BURN(), 100e18, @@ -216,7 +216,7 @@ contract MainnetControllerPrepareUSDeBurnSuccessTests is EthenaTestBase { key = mainnetController.LIMIT_USDE_BURN(); - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(key, 5_000_000e18, uint256(1_000_000e18) / 4 hours); } @@ -261,7 +261,7 @@ contract MainnetControllerCooldownAssetsSUSDeFailureTests is EthenaTestBase { } function test_cooldownAssetsSUSDe_zeroMaxAmount() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(mainnetController.LIMIT_SUSDE_COOLDOWN(), 0, 0); vm.stopPrank(); @@ -274,7 +274,7 @@ contract MainnetControllerCooldownAssetsSUSDeFailureTests is EthenaTestBase { // For success case (exchange rate is more than 1:1) deal(address(susde), address(almProxy), 100e18); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData( mainnetController.LIMIT_SUSDE_COOLDOWN(), 100e18, @@ -309,7 +309,7 @@ contract MainnetControllerCooldownAssetsSUSDeSuccessTests is EthenaTestBase { key = mainnetController.LIMIT_SUSDE_COOLDOWN(); - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(key, 5_000_000e18, uint256(1_000_000e18) / 4 hours); } @@ -372,7 +372,7 @@ contract MainnetControllerCooldownSharesSUSDeFailureTests is EthenaTestBase { function test_cooldownSharesSUSDe_zeroMaxAmount() external { deal(address(susde), address(almProxy), 100e18); // To get past call - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(mainnetController.LIMIT_SUSDE_COOLDOWN(), 0, 0); vm.stopPrank(); @@ -384,7 +384,7 @@ contract MainnetControllerCooldownSharesSUSDeFailureTests is EthenaTestBase { function test_cooldownSharesSUSDe_rateLimitBoundary() external { deal(address(susde), address(almProxy), 100e18); // For success case - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData( mainnetController.LIMIT_SUSDE_COOLDOWN(), 100e18, @@ -426,7 +426,7 @@ contract MainnetControllerCooldownSharesSUSDeSuccessTests is EthenaTestBase { key = mainnetController.LIMIT_SUSDE_COOLDOWN(); - vm.prank(SPARK_PROXY); + vm.prank(GROVE_PROXY); rateLimits.setRateLimitData(key, 5_000_000e18, uint256(1_000_000e18) / 4 hours); } @@ -503,7 +503,7 @@ contract MainnetControllerUnstakeSUSDeFailureTests is EthenaTestBase { // Exchange rate greater than 1:1 deal(address(susde), address(almProxy), 100e18); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData( mainnetController.LIMIT_SUSDE_COOLDOWN(), 100e18, @@ -532,7 +532,7 @@ contract MainnetControllerUnstakeSUSDeSuccessTests is EthenaTestBase { function test_unstakeSUSDe() external { // Setting higher rate limit so shares can be used for cooldown - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setRateLimitData( mainnetController.LIMIT_SUSDE_COOLDOWN(), 1000e18, @@ -577,7 +577,7 @@ contract MainnetControllerEthenaE2ETests is EthenaTestBase { function setUp() public override { super.setUp(); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); burnKey = mainnetController.LIMIT_USDE_BURN(); cooldownKey = mainnetController.LIMIT_SUSDE_COOLDOWN(); diff --git a/test/grove-mainnet-fork/ForkTestBase.t.sol b/test/grove-mainnet-fork/ForkTestBase.t.sol new file mode 100644 index 00000000..45d0c9ac --- /dev/null +++ b/test/grove-mainnet-fork/ForkTestBase.t.sol @@ -0,0 +1,309 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity ^0.8.21; + +import "dss-test/DssTest.sol"; + +import { AllocatorInit, AllocatorIlkConfig } from "dss-allocator/deploy/AllocatorInit.sol"; + +import { + AllocatorIlkInstance, + AllocatorSharedInstance +} from "dss-allocator/deploy/AllocatorInstances.sol"; + +import { AllocatorDeploy } from "dss-allocator/deploy/AllocatorDeploy.sol"; + +import { IERC20 } from "forge-std/interfaces/IERC20.sol"; +import { IERC4626 } from "forge-std/interfaces/IERC4626.sol"; + +import { ISUsds } from "sdai/src/ISUsds.sol"; + +import { Ethereum } from "grove-address-registry/Ethereum.sol"; + +import { Bridge } from "xchain-helpers/testing/Bridge.sol"; +import { CCTPForwarder } from "xchain-helpers/forwarders/CCTPForwarder.sol"; +import { Domain, DomainHelpers } from "xchain-helpers/testing/Domain.sol"; + +import { MainnetControllerDeploy } from "../../deploy/ControllerDeploy.sol"; +import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; + +import { MainnetControllerInit as Init } from "../../deploy/MainnetControllerInit.sol"; + +import { ALMProxy } from "../../src/ALMProxy.sol"; +import { RateLimits } from "../../src/RateLimits.sol"; +import { MainnetController } from "../../src/MainnetController.sol"; + +import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; + +interface IChainlogLike { + function getAddress(bytes32) external view returns (address); +} + +interface IBufferLike { + function approve(address, address, uint256) external; +} + +interface ISUSDELike is IERC4626 { + function cooldownAssets(uint256 usdeAmount) external; + function cooldownShares(uint256 susdeAmount) external; + function unstake(address receiver) external; + function silo() external view returns(address); +} + +interface IPSMLike { + function bud(address) external view returns (uint256); + function pocket() external view returns (address); + function kiss(address) external; + function rush() external view returns (uint256); +} + +interface IVaultLike { + function rely(address) external; + function wards(address) external returns (uint256); +} + +contract ForkTestBase is DssTest { + + using DomainHelpers for *; + + /**********************************************************************************************/ + /*** Constants/state variables ***/ + /**********************************************************************************************/ + + bytes32 constant ilk = "ILK-A"; + bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; + + bytes32 constant PSM_ILK = 0x4c4954452d50534d2d555344432d410000000000000000000000000000000000; + + uint256 constant INK = 1e12 * 1e18; // Ink initialization amount + uint256 constant SEVEN_PCT_APY = 1.000000002145441671308778766e27; // 7% APY (current DSR) + uint256 constant EIGHT_PCT_APY = 1.000000002440418608258400030e27; // 8% APY (current DSR + 1%) + + address freezer = Ethereum.ALM_FREEZER; + address relayer = Ethereum.ALM_RELAYER; + + address backstopRelayer = makeAddr("backstopRelayer"); // TODO: Replace with real backstop + + bytes32 CONTROLLER; + bytes32 FREEZER; + bytes32 RELAYER; + + /**********************************************************************************************/ + /*** Mainnet addresses/constants ***/ + /**********************************************************************************************/ + + address constant LOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; + + address constant CCTP_MESSENGER = Ethereum.CCTP_TOKEN_MESSENGER; + address constant DAI_USDS = Ethereum.DAI_USDS; + address constant ETHENA_MINTER = Ethereum.ETHENA_MINTER; + address constant PAUSE_PROXY = Ethereum.PAUSE_PROXY; + address constant PSM = Ethereum.PSM; + address constant GROVE_PROXY = Ethereum.GROVE_PROXY; + + IERC20 constant dai = IERC20(Ethereum.DAI); + IERC20 constant usdc = IERC20(Ethereum.USDC); + IERC20 constant usde = IERC20(Ethereum.USDE); + IERC20 constant usds = IERC20(Ethereum.USDS); + IERC20 constant usdt = IERC20(Ethereum.USDT); + ISUsds constant susds = ISUsds(Ethereum.SUSDS); + + ISUSDELike constant susde = ISUSDELike(Ethereum.SUSDE); + + IPSMLike constant psm = IPSMLike(PSM); + + address POCKET; + address USDS_JOIN; + + DssInstance dss; // Mainnet DSS + + /**********************************************************************************************/ + /*** ALM system and allocation system deployments ***/ + /**********************************************************************************************/ + + ALMProxy almProxy; + RateLimits rateLimits; + MainnetController mainnetController; + + address buffer; + address vault; + + /**********************************************************************************************/ + /*** Bridging setup ***/ + /**********************************************************************************************/ + + Bridge bridge; + Domain source; + Domain destination; + + /**********************************************************************************************/ + /*** Cached mainnet state variables ***/ + /**********************************************************************************************/ + + uint256 DAI_BAL_PSM; + uint256 DAI_SUPPLY; + uint256 USDC_BAL_PSM; + uint256 USDC_SUPPLY; + uint256 USDS_SUPPLY; + uint256 USDS_BAL_SUSDS; + uint256 VAT_DAI_USDS_JOIN; + + /**********************************************************************************************/ + /*** Test setup ***/ + /**********************************************************************************************/ + + function setUp() public virtual { + + /*** Step 1: Set up environment, cast addresses ***/ + + source = getChain("mainnet").createSelectFork(_getBlock()); + + dss = MCD.loadFromChainlog(LOG); + + USDS_JOIN = IChainlogLike(LOG).getAddress("USDS_JOIN"); + POCKET = IChainlogLike(LOG).getAddress("MCD_LITE_PSM_USDC_A_POCKET"); + + DAI_BAL_PSM = dai.balanceOf(PSM); + DAI_SUPPLY = dai.totalSupply(); + USDC_BAL_PSM = usdc.balanceOf(POCKET); + USDC_SUPPLY = usdc.totalSupply(); + USDS_SUPPLY = usds.totalSupply(); + USDS_BAL_SUSDS = usds.balanceOf(address(susds)); + VAT_DAI_USDS_JOIN = dss.vat.dai(USDS_JOIN); + + /*** Step 2: Deploy and configure allocation system ***/ + + AllocatorSharedInstance memory sharedInst + = AllocatorDeploy.deployShared(address(this), Ethereum.PAUSE_PROXY); + + AllocatorIlkInstance memory ilkInst = AllocatorDeploy.deployIlk({ + deployer : address(this), + owner : Ethereum.PAUSE_PROXY, + roles : sharedInst.roles, + ilk : ilk, + usdsJoin : USDS_JOIN + }); + + AllocatorIlkConfig memory ilkConfig = AllocatorIlkConfig({ + ilk : ilk, + duty : EIGHT_PCT_APY, + maxLine : 100_000_000 * RAD, + gap : 10_000_000 * RAD, + ttl : 6 hours, + allocatorProxy : Ethereum.GROVE_PROXY, + ilkRegistry : IChainlogLike(LOG).getAddress("ILK_REGISTRY") + }); + + vm.startPrank(Ethereum.PAUSE_PROXY); + AllocatorInit.initShared(dss, sharedInst); + AllocatorInit.initIlk(dss, sharedInst, ilkInst, ilkConfig); + vm.stopPrank(); + + buffer = ilkInst.buffer; + vault = ilkInst.vault; + + /*** Step 3: Deploy ALM system ***/ + + ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull({ + admin : Ethereum.GROVE_PROXY, + vault : ilkInst.vault, + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER + }); + + almProxy = ALMProxy(payable(controllerInst.almProxy)); + rateLimits = RateLimits(controllerInst.rateLimits); + mainnetController = MainnetController(controllerInst.controller); + + CONTROLLER = almProxy.CONTROLLER(); + FREEZER = mainnetController.FREEZER(); + RELAYER = mainnetController.RELAYER(); + + address[] memory relayers = new address[](1); + relayers[0] = relayer; + + Init.ConfigAddressParams memory configAddresses + = Init.ConfigAddressParams({ + freezer : freezer, + relayers : relayers, + oldController : address(0) + }); + + Init.CheckAddressParams memory checkAddresses + = Init.CheckAddressParams({ + admin : Ethereum.GROVE_PROXY, + proxy : address(almProxy), + rateLimits : address(rateLimits), + vault : address(vault), + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER + }); + + Init.LayerZeroRecipient[] memory layerZeroRecipients = new Init.LayerZeroRecipient[](0); + + Init.MintRecipient[] memory mintRecipients = new Init.MintRecipient[](1); + + mintRecipients[0] = Init.MintRecipient({ + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_AVALANCHE, + mintRecipient : bytes32(uint256(uint160(makeAddr("avalancheAlmProxy")))) + }); + + // Step 4: Initialize through Sky governance (Sky spell payload) + + vm.prank(Ethereum.PAUSE_PROXY); + Init.pauseProxyInitAlmSystem(Ethereum.PSM, controllerInst.almProxy); + + // Step 5: Initialize through Grove governance (Grove spell payload) + + vm.startPrank(Ethereum.GROVE_PROXY); + + Init.initAlmSystem( + vault, + address(usds), + controllerInst, + configAddresses, + checkAddresses, + mintRecipients, + layerZeroRecipients + ); + + mainnetController.grantRole(mainnetController.RELAYER(), backstopRelayer); + + uint256 usdsMaxAmount = 5_000_000e18; + uint256 usdsSlope = uint256(1_000_000e18) / 4 hours; + uint256 usdcMaxAmount = 5_000_000e6; + uint256 usdcSlope = uint256(1_000_000e6) / 4 hours; + + bytes32 domainKeyAvalanche = RateLimitHelpers.makeDomainKey( + mainnetController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_AVALANCHE + ); + + // NOTE: Using minimal config for test base setup + rateLimits.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), usdsMaxAmount, usdsSlope); + rateLimits.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), usdcMaxAmount, usdcSlope); + rateLimits.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), usdcMaxAmount, usdcSlope); + rateLimits.setRateLimitData(domainKeyAvalanche, usdcMaxAmount, usdcSlope); + + vm.stopPrank(); + + /*** Step 6: Label addresses ***/ + + vm.label(buffer, "buffer"); + vm.label(address(susds), "susds"); + vm.label(address(usdc), "usdc"); + vm.label(address(usds), "usds"); + vm.label(vault, "vault"); + } + + // Default configuration for the fork, can be overridden in inheriting tests + function _getBlock() internal virtual pure returns (uint256) { + return 20917850; // October 7, 2024 + } + + function _absSubtraction(uint256 a, uint256 b) internal pure returns (uint256) { + return a > b ? a - b : b - a; + } + +} diff --git a/test/mainnet-fork/InitAndUpgrade.t.sol b/test/grove-mainnet-fork/InitAndUpgrade.t.sol similarity index 94% rename from test/mainnet-fork/InitAndUpgrade.t.sol rename to test/grove-mainnet-fork/InitAndUpgrade.t.sol index 4485b6bc..1e8f6596 100644 --- a/test/mainnet-fork/InitAndUpgrade.t.sol +++ b/test/grove-mainnet-fork/InitAndUpgrade.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity >=0.8.0; -import "test/mainnet-fork/ForkTestBase.t.sol"; +import "test/grove-mainnet-fork/ForkTestBase.t.sol"; import { IRateLimits } from "src/interfaces/IRateLimits.sol"; @@ -81,7 +81,7 @@ contract MainnetControllerInitAndUpgradeTestBase is ForkTestBase { }); checkAddresses = Init.CheckAddressParams({ - admin : Ethereum.SPARK_PROXY, + admin : Ethereum.GROVE_PROXY, proxy : address(almProxy), rateLimits : address(rateLimits), vault : address(vault), @@ -137,7 +137,7 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU // are already deployed. This is technically possible to do and works in the same way, it was // done also for make testing easier. mainnetController = MainnetController(MainnetControllerDeploy.deployController({ - admin : Ethereum.SPARK_PROXY, + admin : Ethereum.GROVE_PROXY, almProxy : address(almProxy), rateLimits : address(rateLimits), vault : address(vault), @@ -160,9 +160,9 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU }); // Admin will be calling the library from its own address - vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); + vm.etch(GROVE_PROXY, address(new LibraryWrapper()).code); - wrapper = LibraryWrapper(SPARK_PROXY); + wrapper = LibraryWrapper(GROVE_PROXY); } function _getBlock() internal pure override returns (uint256) { @@ -174,8 +174,8 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU /**********************************************************************************************/ function test_initAlmSystem_incorrectAdminAlmProxy() external { - vm.prank(SPARK_PROXY); - almProxy.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); + vm.prank(GROVE_PROXY); + almProxy.revokeRole(DEFAULT_ADMIN_ROLE, GROVE_PROXY); vm.expectRevert("MainnetControllerInit/incorrect-admin-almProxy"); wrapper.initAlmSystem( @@ -190,8 +190,8 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU } function test_initAlmSystem_incorrectAdminRateLimits() external { - vm.prank(SPARK_PROXY); - rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); + vm.prank(GROVE_PROXY); + rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, GROVE_PROXY); vm.expectRevert("MainnetControllerInit/incorrect-admin-rateLimits"); wrapper.initAlmSystem( @@ -206,8 +206,8 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU } function test_initAlmSystem_upgradeController_incorrectAdminController() external { - vm.prank(SPARK_PROXY); - mainnetController.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); + vm.prank(GROVE_PROXY); + mainnetController.revokeRole(DEFAULT_ADMIN_ROLE, GROVE_PROXY); _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-controller")); } @@ -218,14 +218,14 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU function test_initAlmSystem_upgradeController_incorrectAlmProxy() external { // Deploy new address that will not EVM revert on OZ ACL check - controllerInst.almProxy = address(new ALMProxy(SPARK_PROXY)); + controllerInst.almProxy = address(new ALMProxy(GROVE_PROXY)); _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-almProxy")); } function test_initAlmSystem_upgradeController_incorrectRateLimits() external { // Deploy new address that will not EVM revert on OZ ACL check - controllerInst.rateLimits = address(new RateLimits(SPARK_PROXY)); + controllerInst.rateLimits = address(new RateLimits(GROVE_PROXY)); _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-rateLimits")); } @@ -276,7 +276,7 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU configAddresses.oldController = oldController; // Revoke the old controller address in ALM proxy - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); vm.stopPrank(); @@ -295,7 +295,7 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU configAddresses.oldController = oldController; // Revoke the old controller address in rate limits - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); vm.stopPrank(); @@ -355,7 +355,7 @@ contract MainnetControllerInitAlmSystemSuccessTests is MainnetControllerInitAndU super.setUp(); controllerInst = MainnetControllerDeploy.deployFull( - Ethereum.SPARK_PROXY, + Ethereum.GROVE_PROXY, address(vault), Ethereum.PSM, Ethereum.DAI_USDS, @@ -377,9 +377,9 @@ contract MainnetControllerInitAlmSystemSuccessTests is MainnetControllerInitAndU layerZeroRecipients.push(layerZeroRecipients_[0]); // Admin will be calling the library from its own address - vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); + vm.etch(GROVE_PROXY, address(new LibraryWrapper()).code); - wrapper = LibraryWrapper(SPARK_PROXY); + wrapper = LibraryWrapper(GROVE_PROXY); } function _getBlock() internal pure override returns (uint256) { @@ -399,7 +399,7 @@ contract MainnetControllerInitAlmSystemSuccessTests is MainnetControllerInitAndU assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 0); assertEq(usds.allowance(buffer, controllerInst.almProxy), 0); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); wrapper.initAlmSystem( address(vault), address(usds), @@ -484,7 +484,7 @@ contract MainnetControllerUpgradeControllerSuccessTests is MainnetControllerInit layerZeroRecipients.push(layerZeroRecipients_[0]); newController = MainnetController(MainnetControllerDeploy.deployController({ - admin : Ethereum.SPARK_PROXY, + admin : Ethereum.GROVE_PROXY, almProxy : address(almProxy), rateLimits : address(rateLimits), vault : address(vault), @@ -502,9 +502,9 @@ contract MainnetControllerUpgradeControllerSuccessTests is MainnetControllerInit configAddresses.oldController = address(mainnetController); // Revoke from old controller // Admin will be calling the library from its own address - vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); + vm.etch(GROVE_PROXY, address(new LibraryWrapper()).code); - wrapper = LibraryWrapper(SPARK_PROXY); + wrapper = LibraryWrapper(GROVE_PROXY); } function _getBlock() internal pure override returns (uint256) { @@ -524,7 +524,7 @@ contract MainnetControllerUpgradeControllerSuccessTests is MainnetControllerInit assertEq(newController.mintRecipients(mintRecipients[0].domain), bytes32(0)); assertEq(newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), bytes32(0)); - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); wrapper.upgradeController( controllerInst, configAddresses, diff --git a/test/mainnet-fork/Maple.t.sol b/test/grove-mainnet-fork/Maple.t.sol similarity index 98% rename from test/mainnet-fork/Maple.t.sol rename to test/grove-mainnet-fork/Maple.t.sol index 3e162f42..2f2c9294 100644 --- a/test/mainnet-fork/Maple.t.sol +++ b/test/grove-mainnet-fork/Maple.t.sol @@ -51,7 +51,7 @@ contract MapleTestBase is ForkTestBase { depositKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_4626_DEPOSIT(), address(syrup)); redeemKey = RateLimitHelpers.makeAssetKey(mainnetController.LIMIT_MAPLE_REDEEM(), address(syrup)); - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(depositKey, 1_000_000e6, uint256(1_000_000e6) / 1 days); rateLimits.setRateLimitData(redeemKey, 1_000_000e6, uint256(1_000_000e6) / 1 days); vm.stopPrank(); @@ -104,7 +104,7 @@ contract MainnetControllerDepositERC4626MapleFailureTests is MapleTestBase { } function test_depositERC4626_maple_zeroMaxAmount() external { - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(depositKey, 0, 0); vm.prank(relayer); @@ -169,7 +169,7 @@ contract MainnetControllerRequestMapleRedemptionFailureTests is MapleTestBase { } function test_requestMapleRedemption_zeroMaxAmount() external { - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(redeemKey, 0, 0); vm.prank(relayer); @@ -178,7 +178,7 @@ contract MainnetControllerRequestMapleRedemptionFailureTests is MapleTestBase { } function test_requestMapleRedemption_rateLimitBoundary() external { - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(depositKey, 5_000_000e6, uint256(1_000_000e6) / 1 days); deal(address(usdc), address(almProxy), 5_000_000e6); @@ -274,7 +274,7 @@ contract MainnetControllerMapleE2ETests is MapleTestBase { function test_e2e_mapleDepositAndRedeem() external { // Increase withdraw rate limit so interest can be accrued - vm.prank(Ethereum.SPARK_PROXY); + vm.prank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(redeemKey, 2_000_000e6, uint256(1_000_000e6) / 1 days); deal(address(usdc), address(almProxy), 1_000_000e6); diff --git a/test/mainnet-fork/PsmCalls.t.sol b/test/grove-mainnet-fork/PsmCalls.t.sol similarity index 99% rename from test/mainnet-fork/PsmCalls.t.sol rename to test/grove-mainnet-fork/PsmCalls.t.sol index 8a708bd7..2c33b199 100644 --- a/test/mainnet-fork/PsmCalls.t.sol +++ b/test/grove-mainnet-fork/PsmCalls.t.sol @@ -20,7 +20,7 @@ contract MainnetControllerSwapUSDSToUSDCFailureTests is ForkTestBase { } function test_swapUSDSToUSDC_zeroMaxAmount() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), 0, 0); vm.stopPrank(); @@ -85,7 +85,7 @@ contract MainnetControllerSwapUSDSToUSDCTests is ForkTestBase { } function test_swapUSDSToUSDC_rateLimited() external { - vm.startPrank(SPARK_PROXY); + vm.startPrank(GROVE_PROXY); rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDS_MINT()); vm.stopPrank(); @@ -136,7 +136,7 @@ contract MainnetControllerSwapUSDCToUSDSFailureTests is ForkTestBase { } function test_swapUSDCToUSDS_zeroMaxAmount() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), 0, 0); vm.stopPrank(); diff --git a/test/mainnet-fork/VaultCalls.t.sol b/test/grove-mainnet-fork/VaultCalls.t.sol similarity index 98% rename from test/mainnet-fork/VaultCalls.t.sol rename to test/grove-mainnet-fork/VaultCalls.t.sol index 519f5b5f..6d1daa48 100644 --- a/test/mainnet-fork/VaultCalls.t.sol +++ b/test/grove-mainnet-fork/VaultCalls.t.sol @@ -15,7 +15,7 @@ contract MainnetControllerMintUSDSFailureTests is ForkTestBase { } function test_mintUSDS_zeroMaxAmount() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), 0, 0); vm.stopPrank(); @@ -108,7 +108,7 @@ contract MainnetControllerBurnUSDSFailureTests is ForkTestBase { } function test_burnUSDS_zeroMaxAmount() external { - vm.startPrank(Ethereum.SPARK_PROXY); + vm.startPrank(Ethereum.GROVE_PROXY); rateLimits.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), 0, 0); vm.stopPrank(); diff --git a/test/base-fork/Aave.t.sol b/test/spark-base-fork/Aave.t.sol similarity index 100% rename from test/base-fork/Aave.t.sol rename to test/spark-base-fork/Aave.t.sol diff --git a/test/base-fork/Deploy.t.sol b/test/spark-base-fork/Deploy.t.sol similarity index 100% rename from test/base-fork/Deploy.t.sol rename to test/spark-base-fork/Deploy.t.sol diff --git a/test/base-fork/ForkTestBase.t.sol b/test/spark-base-fork/ForkTestBase.t.sol similarity index 100% rename from test/base-fork/ForkTestBase.t.sol rename to test/spark-base-fork/ForkTestBase.t.sol diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/spark-base-fork/InitAndUpgrade.t.sol similarity index 99% rename from test/base-fork/InitAndUpgrade.t.sol rename to test/spark-base-fork/InitAndUpgrade.t.sol index 371750b8..8c3ac843 100644 --- a/test/base-fork/InitAndUpgrade.t.sol +++ b/test/spark-base-fork/InitAndUpgrade.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity >=0.8.0; -import "../../test/base-fork/ForkTestBase.t.sol"; +import "../../test/spark-base-fork/ForkTestBase.t.sol"; import { CCTPForwarder } from "xchain-helpers/forwarders/CCTPForwarder.sol"; diff --git a/test/base-fork/Morpho.t.sol b/test/spark-base-fork/Morpho.t.sol similarity index 100% rename from test/base-fork/Morpho.t.sol rename to test/spark-base-fork/Morpho.t.sol diff --git a/test/base-fork/MorphoAllocations.t.sol b/test/spark-base-fork/MorphoAllocations.t.sol similarity index 100% rename from test/base-fork/MorphoAllocations.t.sol rename to test/spark-base-fork/MorphoAllocations.t.sol diff --git a/test/base-fork/PsmCalls.t.sol b/test/spark-base-fork/PsmCalls.t.sol similarity index 100% rename from test/base-fork/PsmCalls.t.sol rename to test/spark-base-fork/PsmCalls.t.sol diff --git a/test/mainnet-fork/CCTPCalls.t.sol b/test/spark-mainnet-fork/CCTPCalls.t.sol similarity index 100% rename from test/mainnet-fork/CCTPCalls.t.sol rename to test/spark-mainnet-fork/CCTPCalls.t.sol diff --git a/test/mainnet-fork/ForkTestBase.t.sol b/test/spark-mainnet-fork/ForkTestBase.t.sol similarity index 100% rename from test/mainnet-fork/ForkTestBase.t.sol rename to test/spark-mainnet-fork/ForkTestBase.t.sol diff --git a/test/mainnet-fork/LayerZero.t.sol b/test/spark-mainnet-fork/LayerZero.t.sol similarity index 100% rename from test/mainnet-fork/LayerZero.t.sol rename to test/spark-mainnet-fork/LayerZero.t.sol