From 45e1f6eb535ceddb77ea546919b30528bf092b5c Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Wed, 18 Dec 2024 15:08:04 -0500 Subject: [PATCH 01/33] feat: refactor init scripts, starting point --- deploy/ControllerInit.sol | 2 +- deploy/ForeignControllerInit.sol | 180 ++++++++++++++++++++++++++++ deploy/MainnetControllerInit.sol | 196 +++++++++++++++++++++++++++++++ 3 files changed, 377 insertions(+), 1 deletion(-) create mode 100644 deploy/ForeignControllerInit.sol create mode 100644 deploy/MainnetControllerInit.sol diff --git a/deploy/ControllerInit.sol b/deploy/ControllerInit.sol index 46ab465..3409975 100644 --- a/deploy/ControllerInit.sol +++ b/deploy/ControllerInit.sol @@ -341,4 +341,4 @@ library ForeignControllerInit { rateLimits.setRateLimitData(key, data.maxAmount, data.slope); } -} +} \ No newline at end of file diff --git a/deploy/ForeignControllerInit.sol b/deploy/ForeignControllerInit.sol new file mode 100644 index 0000000..11c7460 --- /dev/null +++ b/deploy/ForeignControllerInit.sol @@ -0,0 +1,180 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity >=0.8.0; + +import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; + +import { ForeignController } from "../src/ForeignController.sol"; +import { MainnetController } from "../src/MainnetController.sol"; +import { RateLimitHelpers } from "../src/RateLimitHelpers.sol"; + +import { IALMProxy } from "../src/interfaces/IALMProxy.sol"; +import { IRateLimits } from "../src/interfaces/IRateLimits.sol"; + +import { ControllerInstance } from "./ControllerInstance.sol"; + +interface IBufferLike { + function approve(address, address, uint256) external; +} + +interface IPSMLike { + function kiss(address) external; +} + +interface IPSM3Like { + function totalAssets() external view returns (uint256); + function totalShares() external view returns (uint256); + function usdc() external view returns (address); + function usds() external view returns (address); + function susds() external view returns (address); +} + +interface IVaultLike { + function rely(address) external; +} + +struct RateLimitData { + uint256 maxAmount; + uint256 slope; +} + +struct MintRecipient { + uint32 domain; + bytes32 mintRecipient; +} + +library ForeignControllerInit { + + struct AddressParams { + address admin; + address freezer; + address relayer; + address oldController; + address psm; + address cctpMessenger; + address usdc; + address usds; + address susds; + } + + bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; + + struct InitRateLimitData { + RateLimitData usdcDepositData; + RateLimitData usdcWithdrawData; + RateLimitData usdsDepositData; + RateLimitData usdsWithdrawData; + RateLimitData susdsDepositData; + RateLimitData susdsWithdrawData; + RateLimitData usdcToCctpData; + RateLimitData cctpToEthereumDomainData; + } + + function init( + AddressParams memory addresses, + ControllerInstance memory controllerInst, + InitRateLimitData memory data, + MintRecipient[] memory mintRecipients + ) + internal + { + IALMProxy almProxy = IALMProxy(controllerInst.almProxy); + IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); + + ForeignController controller = ForeignController(controllerInst.controller); + + require(almProxy.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-almProxy"); + require(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-rateLimits"); + require(controller.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-controller"); + + require(address(controller.proxy()) == controllerInst.almProxy, "ForeignControllerInit/incorrect-almProxy"); + require(address(controller.rateLimits()) == controllerInst.rateLimits, "ForeignControllerInit/incorrect-rateLimits"); + require(address(controller.psm()) == addresses.psm, "ForeignControllerInit/incorrect-psm"); + require(address(controller.usdc()) == addresses.usdc, "ForeignControllerInit/incorrect-usdc"); + require(address(controller.cctp()) == addresses.cctpMessenger, "ForeignControllerInit/incorrect-cctp"); + + require(controller.active(), "ForeignControllerInit/controller-not-active"); + + require(addresses.oldController != address(controller), "ForeignControllerInit/old-controller-is-new-controller"); + + IPSM3Like psm = IPSM3Like(addresses.psm); + + require(psm.totalAssets() >= 1e18, "ForeignControllerInit/psm-totalAssets-not-seeded"); + require(psm.totalShares() >= 1e18, "ForeignControllerInit/psm-totalShares-not-seeded"); + + require(psm.usdc() == addresses.usdc, "ForeignControllerInit/psm-incorrect-usdc"); + require(psm.usds() == addresses.usds, "ForeignControllerInit/psm-incorrect-usds"); + require(psm.susds() == addresses.susds, "ForeignControllerInit/psm-incorrect-susds"); + + // Step 1: Configure ACL permissions for controller and almProxy + + controller.grantRole(controller.FREEZER(), addresses.freezer); + controller.grantRole(controller.RELAYER(), addresses.relayer); + + almProxy.grantRole(almProxy.CONTROLLER(), address(controller)); + rateLimits.grantRole(rateLimits.CONTROLLER(), address(controller)); + + if (addresses.oldController != address(0)) { + require(almProxy.hasRole(almProxy.CONTROLLER(), addresses.oldController) == true, "ForeignControllerInit/old-controller-not-almProxy-controller"); + require(rateLimits.hasRole(rateLimits.CONTROLLER(), addresses.oldController) == true, "ForeignControllerInit/old-controller-not-rateLimits-controller"); + + almProxy.revokeRole(almProxy.CONTROLLER(), addresses.oldController); + rateLimits.revokeRole(rateLimits.CONTROLLER(), addresses.oldController); + } + + // Step 2: Configure all rate limits for controller + + bytes32 depositKey = controller.LIMIT_PSM_DEPOSIT(); + bytes32 withdrawKey = controller.LIMIT_PSM_WITHDRAW(); + + bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( + controller.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM + ); + + setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.usdc), rateLimits, data.usdcDepositData, "usdcDepositData", 6); + setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.usdc), rateLimits, data.usdcWithdrawData, "usdcWithdrawData", 6); + setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.usds), rateLimits, data.usdsDepositData, "usdsDepositData", 18); + setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.usds), rateLimits, data.usdsWithdrawData, "usdsWithdrawData", 18); + setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.susds), rateLimits, data.susdsDepositData, "susdsDepositData", 18); + setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.susds), rateLimits, data.susdsWithdrawData, "susdsWithdrawData", 18); + + setRateLimitData(controller.LIMIT_USDC_TO_CCTP(), rateLimits, data.usdcToCctpData, "usdcToCctpData", 6); + setRateLimitData(domainKeyEthereum, rateLimits, data.cctpToEthereumDomainData, "cctpToEthereumDomainData", 6); + + // Step 3: Configure the mint recipients on other domains + + for (uint256 i = 0; i < mintRecipients.length; i++) { + controller.setMintRecipient(mintRecipients[i].domain, mintRecipients[i].mintRecipient); + } + } + + function setRateLimitData( + bytes32 key, + IRateLimits rateLimits, + RateLimitData memory data, + string memory name, + uint256 decimals + ) + internal + { + // Handle setting an unlimited rate limit + if (data.maxAmount == type(uint256).max) { + require( + data.slope == 0, + string(abi.encodePacked("ForeignControllerInit/invalid-rate-limit-", name)) + ); + } + else { + require( + data.maxAmount <= 1e12 * (10 ** decimals), + string(abi.encodePacked("ForeignControllerInit/invalid-max-amount-precision-", name)) + ); + require( + data.slope <= 1e12 * (10 ** decimals) / 1 hours, + string(abi.encodePacked("ForeignControllerInit/invalid-slope-precision-", name)) + ); + } + rateLimits.setRateLimitData(key, data.maxAmount, data.slope); + } + +} diff --git a/deploy/MainnetControllerInit.sol b/deploy/MainnetControllerInit.sol new file mode 100644 index 0000000..3eb0132 --- /dev/null +++ b/deploy/MainnetControllerInit.sol @@ -0,0 +1,196 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity >=0.8.0; + +import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; + +import { ForeignController } from "../src/ForeignController.sol"; +import { MainnetController } from "../src/MainnetController.sol"; +import { RateLimitHelpers } from "../src/RateLimitHelpers.sol"; + +import { IALMProxy } from "../src/interfaces/IALMProxy.sol"; +import { IRateLimits } from "../src/interfaces/IRateLimits.sol"; + +import { ControllerInstance } from "./ControllerInstance.sol"; + +interface IBufferLike { + function approve(address, address, uint256) external; +} + +interface IPSMLike { + function kiss(address) external; +} + +interface IPSM3Like { + function totalAssets() external view returns (uint256); + function totalShares() external view returns (uint256); + function usdc() external view returns (address); + function usds() external view returns (address); + function susds() external view returns (address); +} + +interface IVaultLike { + function rely(address) external; +} + + + +// Move checks for almProxy and rateLimits to init +// Remove rate limits +// Change checks to only use constructor params + +library MainnetControllerInit { + + struct CheckAddressParams { + address proxy; + address rateLimits; + address vault; + address psm; + address daiUsds; + address cctp; + } + + struct ConfigAddressParams { + address freezer; + address relayer; + address oldController; + } + + struct MintRecipient { + uint32 domain; + bytes32 mintRecipient; + } + + bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; + + function initController( + ControllerInstance memory controllerInst, + ConfigAddressParams memory configAddresses, + CheckAddressParams memory checkAddresses, + MintRecipient[] memory mintRecipients + ) + internal + { + // Step 1: Perform controller sanity checks + + MainnetController newController = MainnetController(controllerInst.controller); + + require(newController.hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "MainnetControllerInit/incorrect-admin-controller"); + + require(address(newController.proxy()) == controllerInst.almProxy, "MainnetControllerInit/incorrect-almProxy"); + require(address(newController.rateLimits()) == controllerInst.rateLimits, "MainnetControllerInit/incorrect-rateLimits"); + + require(address(newController.vault()) == checkAddresses.vault, "MainnetControllerInit/incorrect-vault"); + require(address(newController.buffer()) == checkAddresses.buffer, "MainnetControllerInit/incorrect-buffer"); + require(address(newController.psm()) == checkAddresses.psm, "MainnetControllerInit/incorrect-psm"); + require(address(newController.daiUsds()) == checkAddresses.daiUsds, "MainnetControllerInit/incorrect-daiUsds"); + require(address(newController.cctp()) == checkAddresses.cctpMessenger, "MainnetControllerInit/incorrect-cctpMessenger"); + require(address(newController.dai()) == checkAddresses.dai, "MainnetControllerInit/incorrect-dai"); + require(address(newController.usdc()) == checkAddresses.usdc, "MainnetControllerInit/incorrect-usdc"); + require(address(newController.usds()) == checkAddresses.usds, "MainnetControllerInit/incorrect-usds"); + + require(newController.psmTo18ConversionFactor() == 1e12, "MainnetControllerInit/incorrect-psmTo18ConversionFactor"); + + require(newController.active(), "MainnetControllerInit/controller-not-active"); + + require(configAddresses.oldController != address(newController), "MainnetControllerInit/old-controller-is-new-controller"); + + // Step 2: Configure ACL permissions controller, almProxy, and rateLimits + + IALMProxy almProxy = IALMProxy(controllerInst.almProxy); + IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); + + newController.grantRole(newController.FREEZER(), configAddresses.freezer); + newController.grantRole(newController.RELAYER(), configAddresses.relayer); + + almProxy.grantRole(almProxy.CONTROLLER(), address(controller)); + rateLimits.grantRole(rateLimits.CONTROLLER(), address(controller)); + + // Step 3: Configure the mint recipients on other domains + + for (uint256 i = 0; i < mintRecipients.length; i++) { + newController.setMintRecipient(mintRecipients[i].domain, mintRecipients[i].mintRecipient); + } + } + + function transferControllerRoles(ControllerInstance memory controllerInst, address oldController) internal { + IALMProxy almProxy = IALMProxy(controllerInst.almProxy); + IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); + + if (oldController == address(0)) return; + + require(almProxy.hasRole(almProxy.CONTROLLER(), oldController), "MainnetControllerInit/old-controller-not-almProxy-controller"); + require(rateLimits.hasRole(rateLimits.CONTROLLER(), oldController), "MainnetControllerInit/old-controller-not-rateLimits-controller"); + + almProxy.revokeRole(almProxy.CONTROLLER(), oldController); + rateLimits.revokeRole(rateLimits.CONTROLLER(), oldController); + } + + function upgradeController( + ControllerInstance memory controllerInst, + ConfigAddressParams memory configAddresses, + CheckAddressParams memory checkAddresses, + MintRecipient[] memory mintRecipients + ) + internal + { + initController(controllerInst, configAddresses, checkAddresses, mintRecipients); + transferControllerRoles(controllerInst, configAddresses); + } + + function initAlmSystem( + ControllerInstance memory controllerInst, + ConfigAddressParams memory configAddresses, + CheckAddressParams memory checkAddresses, + MintRecipient[] memory mintRecipients + ) + internal + { + // Step 1: Do sanity checks outside of the controller + + require(IALMProxy(controllerInst.almProxy).hasRole(DEFAULT_ADMIN_ROLE, configAddresses.admin), "MainnetControllerInit/incorrect-admin-almProxy"); + require(IRateLimits(controllerInst.rateLimits).hasRole(DEFAULT_ADMIN_ROLE, configAddresses.admin), "MainnetControllerInit/incorrect-admin-rateLimits"); + + // Step 2: Initialize the controller + + initController(controllerInst, configAddresses, checkAddresses, mintRecipients); + + // Step 2: Configure almProxy within the allocation system + + IVaultLike(addresses.vault).rely(controllerInst.almProxy); + IBufferLike(addresses.buffer).approve(addresses.usds, controllerInst.almProxy, type(uint256).max); + } + + function pauseProxyInit(address psm, address almProxy) internal { + IPSMLike(psm).kiss(almProxy); // To allow using no fee functionality + } + + function setRateLimitData( + bytes32 key, + IRateLimits rateLimits, + RateLimitData memory data, + string memory name, + uint256 decimals + ) + internal + { + // Handle setting an unlimited rate limit + if (data.maxAmount == type(uint256).max) { + require( + data.slope == 0, + string(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-", name)) + ); + } + else { + require( + data.maxAmount <= 1e12 * (10 ** decimals), + string(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-", name)) + ); + require( + data.slope <= 1e12 * (10 ** decimals) / 1 hours, + string(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-", name)) + ); + } + rateLimits.setRateLimitData(key, data.maxAmount, data.slope); + } + +} \ No newline at end of file From bd90524b65b4a2cb2094b2ab5fd285eef922de4d Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 19 Dec 2024 11:14:09 -0500 Subject: [PATCH 02/33] test: create dedicated deploy file --- deploy/MainnetControllerInit.sol | 96 +- src/RateLimitHelpers.sol | 36 + test/mainnet-fork/Deploy.t.sol | 69 ++ test/mainnet-fork/DeployAndInit.t.sol | 1390 ++++++++++++------------- 4 files changed, 825 insertions(+), 766 deletions(-) create mode 100644 test/mainnet-fork/Deploy.t.sol diff --git a/deploy/MainnetControllerInit.sol b/deploy/MainnetControllerInit.sol index 3eb0132..216981a 100644 --- a/deploy/MainnetControllerInit.sol +++ b/deploy/MainnetControllerInit.sol @@ -1,11 +1,7 @@ // SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity >=0.8.0; -import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; - -import { ForeignController } from "../src/ForeignController.sol"; import { MainnetController } from "../src/MainnetController.sol"; -import { RateLimitHelpers } from "../src/RateLimitHelpers.sol"; import { IALMProxy } from "../src/interfaces/IALMProxy.sol"; import { IRateLimits } from "../src/interfaces/IRateLimits.sol"; @@ -20,27 +16,15 @@ interface IPSMLike { function kiss(address) external; } -interface IPSM3Like { - function totalAssets() external view returns (uint256); - function totalShares() external view returns (uint256); - function usdc() external view returns (address); - function usds() external view returns (address); - function susds() external view returns (address); -} - interface IVaultLike { + function buffer() external view returns (address); function rely(address) external; } - - -// Move checks for almProxy and rateLimits to init -// Remove rate limits -// Change checks to only use constructor params - library MainnetControllerInit { struct CheckAddressParams { + address admin; address proxy; address rateLimits; address vault; @@ -68,7 +52,7 @@ library MainnetControllerInit { CheckAddressParams memory checkAddresses, MintRecipient[] memory mintRecipients ) - internal + private // Not all, add underscores { // Step 1: Perform controller sanity checks @@ -79,18 +63,13 @@ library MainnetControllerInit { require(address(newController.proxy()) == controllerInst.almProxy, "MainnetControllerInit/incorrect-almProxy"); require(address(newController.rateLimits()) == controllerInst.rateLimits, "MainnetControllerInit/incorrect-rateLimits"); - require(address(newController.vault()) == checkAddresses.vault, "MainnetControllerInit/incorrect-vault"); - require(address(newController.buffer()) == checkAddresses.buffer, "MainnetControllerInit/incorrect-buffer"); - require(address(newController.psm()) == checkAddresses.psm, "MainnetControllerInit/incorrect-psm"); - require(address(newController.daiUsds()) == checkAddresses.daiUsds, "MainnetControllerInit/incorrect-daiUsds"); - require(address(newController.cctp()) == checkAddresses.cctpMessenger, "MainnetControllerInit/incorrect-cctpMessenger"); - require(address(newController.dai()) == checkAddresses.dai, "MainnetControllerInit/incorrect-dai"); - require(address(newController.usdc()) == checkAddresses.usdc, "MainnetControllerInit/incorrect-usdc"); - require(address(newController.usds()) == checkAddresses.usds, "MainnetControllerInit/incorrect-usds"); + require(address(newController.vault()) == checkAddresses.vault, "MainnetControllerInit/incorrect-vault"); + require(address(newController.psm()) == checkAddresses.psm, "MainnetControllerInit/incorrect-psm"); + require(address(newController.daiUsds()) == checkAddresses.daiUsds, "MainnetControllerInit/incorrect-daiUsds"); + require(address(newController.cctp()) == checkAddresses.cctp, "MainnetControllerInit/incorrect-cctp"); require(newController.psmTo18ConversionFactor() == 1e12, "MainnetControllerInit/incorrect-psmTo18ConversionFactor"); - - require(newController.active(), "MainnetControllerInit/controller-not-active"); + require(newController.active(), "MainnetControllerInit/controller-not-active"); require(configAddresses.oldController != address(newController), "MainnetControllerInit/old-controller-is-new-controller"); @@ -102,8 +81,8 @@ library MainnetControllerInit { newController.grantRole(newController.FREEZER(), configAddresses.freezer); newController.grantRole(newController.RELAYER(), configAddresses.relayer); - almProxy.grantRole(almProxy.CONTROLLER(), address(controller)); - rateLimits.grantRole(rateLimits.CONTROLLER(), address(controller)); + almProxy.grantRole(almProxy.CONTROLLER(), address(newController)); + rateLimits.grantRole(rateLimits.CONTROLLER(), address(newController)); // Step 3: Configure the mint recipients on other domains @@ -112,11 +91,11 @@ library MainnetControllerInit { } } - function transferControllerRoles(ControllerInstance memory controllerInst, address oldController) internal { + function revokeOldControllerRoles(ControllerInstance memory controllerInst, address oldController) private { IALMProxy almProxy = IALMProxy(controllerInst.almProxy); IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); - if (oldController == address(0)) return; + require(oldController != address(0), "MainnetControllerInit/old-controller-zero-address"); require(almProxy.hasRole(almProxy.CONTROLLER(), oldController), "MainnetControllerInit/old-controller-not-almProxy-controller"); require(rateLimits.hasRole(rateLimits.CONTROLLER(), oldController), "MainnetControllerInit/old-controller-not-rateLimits-controller"); @@ -131,66 +110,41 @@ library MainnetControllerInit { CheckAddressParams memory checkAddresses, MintRecipient[] memory mintRecipients ) - internal + private { initController(controllerInst, configAddresses, checkAddresses, mintRecipients); - transferControllerRoles(controllerInst, configAddresses); + revokeOldControllerRoles(controllerInst, configAddresses.oldController); } function initAlmSystem( + address vault, + address usds, ControllerInstance memory controllerInst, ConfigAddressParams memory configAddresses, CheckAddressParams memory checkAddresses, MintRecipient[] memory mintRecipients ) - internal + private { // Step 1: Do sanity checks outside of the controller - require(IALMProxy(controllerInst.almProxy).hasRole(DEFAULT_ADMIN_ROLE, configAddresses.admin), "MainnetControllerInit/incorrect-admin-almProxy"); - require(IRateLimits(controllerInst.rateLimits).hasRole(DEFAULT_ADMIN_ROLE, configAddresses.admin), "MainnetControllerInit/incorrect-admin-rateLimits"); + require(IALMProxy(controllerInst.almProxy).hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "MainnetControllerInit/incorrect-admin-almProxy"); + require(IRateLimits(controllerInst.rateLimits).hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "MainnetControllerInit/incorrect-admin-rateLimits"); // Step 2: Initialize the controller initController(controllerInst, configAddresses, checkAddresses, mintRecipients); - // Step 2: Configure almProxy within the allocation system + // Step 3: Configure almProxy within the allocation system - IVaultLike(addresses.vault).rely(controllerInst.almProxy); - IBufferLike(addresses.buffer).approve(addresses.usds, controllerInst.almProxy, type(uint256).max); - } + require(vault == checkAddresses.vault, "MainnetControllerInit/incorrect-vault"); - function pauseProxyInit(address psm, address almProxy) internal { - IPSMLike(psm).kiss(almProxy); // To allow using no fee functionality + IVaultLike(vault).rely(controllerInst.almProxy); + IBufferLike(IVaultLike(vault).buffer()).approve(usds, controllerInst.almProxy, type(uint256).max); } - function setRateLimitData( - bytes32 key, - IRateLimits rateLimits, - RateLimitData memory data, - string memory name, - uint256 decimals - ) - internal - { - // Handle setting an unlimited rate limit - if (data.maxAmount == type(uint256).max) { - require( - data.slope == 0, - string(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-", name)) - ); - } - else { - require( - data.maxAmount <= 1e12 * (10 ** decimals), - string(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-", name)) - ); - require( - data.slope <= 1e12 * (10 ** decimals) / 1 hours, - string(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-", name)) - ); - } - rateLimits.setRateLimitData(key, data.maxAmount, data.slope); + function pauseProxyInit(address psm, address almProxy) private { + IPSMLike(psm).kiss(almProxy); // To allow using no fee functionality } } \ No newline at end of file diff --git a/src/RateLimitHelpers.sol b/src/RateLimitHelpers.sol index 873e54c..e4f4817 100644 --- a/src/RateLimitHelpers.sol +++ b/src/RateLimitHelpers.sol @@ -1,8 +1,15 @@ // SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity ^0.8.21; +import { IRateLimits } from "../src/interfaces/IRateLimits.sol"; + library RateLimitHelpers { + struct RateLimitData { + uint256 maxAmount; + uint256 slope; + } + function makeAssetKey(bytes32 key, address asset) internal pure returns (bytes32) { return keccak256(abi.encode(key, asset)); } @@ -11,4 +18,33 @@ library RateLimitHelpers { return keccak256(abi.encode(key, domain)); } + function setRateLimitData( + bytes32 key, + IRateLimits rateLimits, + RateLimitData memory data, + string memory name, + uint256 decimals + ) + internal + { + // Handle setting an unlimited rate limit + if (data.maxAmount == type(uint256).max) { + require( + data.slope == 0, + string(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-", name)) + ); + } + else { + require( + data.maxAmount <= 1e12 * (10 ** decimals), + string(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-", name)) + ); + require( + data.slope <= 1e12 * (10 ** decimals) / 1 hours, + string(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-", name)) + ); + } + rateLimits.setRateLimitData(key, data.maxAmount, data.slope); + } + } diff --git a/test/mainnet-fork/Deploy.t.sol b/test/mainnet-fork/Deploy.t.sol new file mode 100644 index 0000000..dadb0f5 --- /dev/null +++ b/test/mainnet-fork/Deploy.t.sol @@ -0,0 +1,69 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity >=0.8.0; + +import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; +import { MainnetControllerDeploy } from "../../deploy/ControllerDeploy.sol"; + +import "./ForkTestBase.t.sol"; + +contract MainnetControllerDeploySuccessTests is ForkTestBase { + + function test_deployFull() external { + // Perform new deployments against existing fork environment + + ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull({ + admin : SPARK_PROXY, + vault : vault, + psm : PSM, + daiUsds : DAI_USDS, + cctp : CCTP_MESSENGER + }); + + ALMProxy newAlmProxy = ALMProxy(payable(controllerInst.almProxy)); + MainnetController newController = MainnetController(controllerInst.controller); + RateLimits newRateLimits = RateLimits(controllerInst.rateLimits); + + assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); + assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); + + _assertControllerInitState(newController, address(almProxy), address(rateLimits), vault, buffer); + } + + function test_deployController() external { + // Perform new deployments against existing fork environment + + MainnetController newController = MainnetController(MainnetControllerDeploy.deployController({ + admin : SPARK_PROXY, + almProxy : address(almProxy), + rateLimits : address(rateLimits), + vault : vault, + psm : PSM, + daiUsds : DAI_USDS, + cctp : CCTP_MESSENGER + })); + + _assertControllerInitState(newController, address(almProxy), address(rateLimits), vault, buffer); + } + + function _assertControllerInitState(MainnetController controller, address almProxy, address rateLimits, address vault, address buffer) internal view { + assertEq(controller.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); + + assertEq(address(controller.proxy()), almProxy); + assertEq(address(controller.rateLimits()), rateLimits); + assertEq(address(controller.vault()), vault); + assertEq(address(controller.buffer()), buffer); + assertEq(address(controller.psm()), Ethereum.PSM); + assertEq(address(controller.daiUsds()), Ethereum.DAI_USDS); + assertEq(address(controller.cctp()), Ethereum.CCTP_TOKEN_MESSENGER); + assertEq(address(controller.ethenaMinter()), Ethereum.ETHENA_MINTER); + assertEq(address(controller.susde()), Ethereum.SUSDE); + assertEq(address(controller.dai()), Ethereum.DAI); + assertEq(address(controller.usdc()), Ethereum.USDC); + assertEq(address(controller.usds()), Ethereum.USDS); + assertEq(address(controller.usde()), Ethereum.USDE); + + assertEq(controller.psmTo18ConversionFactor(), 1e12); + assertEq(controller.active(), true); + } + +} diff --git a/test/mainnet-fork/DeployAndInit.t.sol b/test/mainnet-fork/DeployAndInit.t.sol index 28c4344..dedf181 100644 --- a/test/mainnet-fork/DeployAndInit.t.sol +++ b/test/mainnet-fork/DeployAndInit.t.sol @@ -1,722 +1,722 @@ -// SPDX-License-Identifier: AGPL-3.0-or-later -pragma solidity >=0.8.0; - -import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; -import { MainnetControllerDeploy } from "../../deploy/ControllerDeploy.sol"; - -import { - MainnetControllerInit, - RateLimitData, - MintRecipient -} from "../../deploy/ControllerInit.sol"; - -import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; - -import "./ForkTestBase.t.sol"; - -// Necessary to get error message assertions to work -contract LibraryWrapper { - - function subDaoInitController( - MainnetControllerInit.AddressParams memory params, - ControllerInstance memory controllerInst, - MainnetControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) - external - { - MainnetControllerInit.subDaoInitController( - params, - controllerInst, - rateLimitData, - mintRecipients - ); - } - - function subDaoInitFull( - MainnetControllerInit.AddressParams memory params, - ControllerInstance memory controllerInst, - MainnetControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) - external - { - MainnetControllerInit.subDaoInitFull( - params, - controllerInst, - rateLimitData, - mintRecipients - ); - } - -} - -contract MainnetControllerDeployInitTestBase is ForkTestBase { - - function _getDefaultParams() - internal returns ( - MainnetControllerInit.AddressParams memory addresses, - MainnetControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) - { - addresses = MainnetControllerInit.AddressParams({ - admin : Ethereum.SPARK_PROXY, - freezer : freezer, - relayer : relayer, - oldController : address(0), - psm : Ethereum.PSM, - vault : vault, - buffer : buffer, - cctpMessenger : Ethereum.CCTP_TOKEN_MESSENGER, - dai : Ethereum.DAI, - daiUsds : Ethereum.DAI_USDS, - usdc : Ethereum.USDC, - usds : Ethereum.USDS, - susds : Ethereum.SUSDS - }); - - RateLimitData memory standardUsdsData = RateLimitData({ - maxAmount : 1_000_000e18, - slope : uint256(1_000_000e18) / 4 hours - }); - - RateLimitData memory usdsToUsdcData = RateLimitData({ - maxAmount : 2_000_000e6, - slope : uint256(2_000_000e6) / 4 hours - }); - - RateLimitData memory usdcToCctpData = RateLimitData({ - maxAmount : 3_000_000e6, - slope : uint256(3_000_000e6) / 4 hours - }); - - RateLimitData memory cctpToBaseDomainData = RateLimitData({ - maxAmount : 4_000_000e6, - slope : uint256(4_000_000e6) / 4 hours - }); - - rateLimitData = MainnetControllerInit.InitRateLimitData({ - usdsMintData : standardUsdsData, - usdsToUsdcData : usdsToUsdcData, - usdcToCctpData : usdcToCctpData, - cctpToBaseDomainData : cctpToBaseDomainData, - susdsDepositData : standardUsdsData - }); - - mintRecipients = new MintRecipient[](1); - - mintRecipients[0] = MintRecipient({ - domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) - }); - } - -} - -contract MainnetControllerDeployAndInitFailureTests is MainnetControllerDeployInitTestBase { - - LibraryWrapper wrapper; - - ControllerInstance public controllerInst; - - address public mismatchAddress = makeAddr("mismatchAddress"); - - MainnetControllerInit.AddressParams addresses; - MainnetControllerInit.InitRateLimitData rateLimitData; - MintRecipient[] mintRecipients; - - function setUp() public override { - super.setUp(); - - controllerInst = MainnetControllerDeploy.deployFull( - SPARK_PROXY, - vault, - PSM, - DAI_USDS, - CCTP_MESSENGER - ); - - MintRecipient[] memory mintRecipients_ = new MintRecipient[](1); - - ( addresses, rateLimitData, mintRecipients_ ) = _getDefaultParams(); - - // NOTE: This would need to be refactored to a for loop if more than one recipient - mintRecipients.push(mintRecipients_[0]); - - // Overwrite storage for all previous deployments in setUp and assert deployment - - almProxy = ALMProxy(payable(controllerInst.almProxy)); - mainnetController = MainnetController(controllerInst.controller); - rateLimits = RateLimits(controllerInst.rateLimits); - - // Admin will be calling the library from its own address - vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); - - wrapper = LibraryWrapper(SPARK_PROXY); - } - - /**********************************************************************************************/ - /*** ACL tests ***/ - /**********************************************************************************************/ - - function test_init_incorrectAdminAlmProxy() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_PROXY); - almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); - almProxy.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); - vm.stopPrank(); - - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-almProxy")); - } - - function test_init_incorrectAdminRateLimits() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_PROXY); - rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); - rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); - vm.stopPrank(); - - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-rateLimits")); - } +// // SPDX-License-Identifier: AGPL-3.0-or-later +// pragma solidity >=0.8.0; + +// import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; +// import { MainnetControllerDeploy } from "../../deploy/ControllerDeploy.sol"; + +// import { +// MainnetControllerInit, +// RateLimitData, +// MintRecipient +// } from "../../deploy/ControllerInit.sol"; + +// import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; + +// import "./ForkTestBase.t.sol"; + +// // Necessary to get error message assertions to work +// contract LibraryWrapper { + +// function subDaoInitController( +// MainnetControllerInit.AddressParams memory params, +// ControllerInstance memory controllerInst, +// MainnetControllerInit.InitRateLimitData memory rateLimitData, +// MintRecipient[] memory mintRecipients +// ) +// external +// { +// MainnetControllerInit.subDaoInitController( +// params, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// } + +// function subDaoInitFull( +// MainnetControllerInit.AddressParams memory params, +// ControllerInstance memory controllerInst, +// MainnetControllerInit.InitRateLimitData memory rateLimitData, +// MintRecipient[] memory mintRecipients +// ) +// external +// { +// MainnetControllerInit.subDaoInitFull( +// params, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// } + +// } + +// contract MainnetControllerDeployInitTestBase is ForkTestBase { + +// function _getDefaultParams() +// internal returns ( +// MainnetControllerInit.AddressParams memory addresses, +// MainnetControllerInit.InitRateLimitData memory rateLimitData, +// MintRecipient[] memory mintRecipients +// ) +// { +// addresses = MainnetControllerInit.AddressParams({ +// admin : Ethereum.SPARK_PROXY, +// freezer : freezer, +// relayer : relayer, +// oldController : address(0), +// psm : Ethereum.PSM, +// vault : vault, +// buffer : buffer, +// cctpMessenger : Ethereum.CCTP_TOKEN_MESSENGER, +// dai : Ethereum.DAI, +// daiUsds : Ethereum.DAI_USDS, +// usdc : Ethereum.USDC, +// usds : Ethereum.USDS, +// susds : Ethereum.SUSDS +// }); + +// RateLimitData memory standardUsdsData = RateLimitData({ +// maxAmount : 1_000_000e18, +// slope : uint256(1_000_000e18) / 4 hours +// }); + +// RateLimitData memory usdsToUsdcData = RateLimitData({ +// maxAmount : 2_000_000e6, +// slope : uint256(2_000_000e6) / 4 hours +// }); + +// RateLimitData memory usdcToCctpData = RateLimitData({ +// maxAmount : 3_000_000e6, +// slope : uint256(3_000_000e6) / 4 hours +// }); + +// RateLimitData memory cctpToBaseDomainData = RateLimitData({ +// maxAmount : 4_000_000e6, +// slope : uint256(4_000_000e6) / 4 hours +// }); + +// rateLimitData = MainnetControllerInit.InitRateLimitData({ +// usdsMintData : standardUsdsData, +// usdsToUsdcData : usdsToUsdcData, +// usdcToCctpData : usdcToCctpData, +// cctpToBaseDomainData : cctpToBaseDomainData, +// susdsDepositData : standardUsdsData +// }); + +// mintRecipients = new MintRecipient[](1); + +// mintRecipients[0] = MintRecipient({ +// domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, +// mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) +// }); +// } + +// } + +// contract MainnetControllerDeployAndInitFailureTests is MainnetControllerDeployInitTestBase { + +// LibraryWrapper wrapper; + +// ControllerInstance public controllerInst; + +// address public mismatchAddress = makeAddr("mismatchAddress"); + +// MainnetControllerInit.AddressParams addresses; +// MainnetControllerInit.InitRateLimitData rateLimitData; +// MintRecipient[] mintRecipients; + +// function setUp() public override { +// super.setUp(); + +// controllerInst = MainnetControllerDeploy.deployFull( +// SPARK_PROXY, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER +// ); + +// MintRecipient[] memory mintRecipients_ = new MintRecipient[](1); + +// ( addresses, rateLimitData, mintRecipients_ ) = _getDefaultParams(); + +// // NOTE: This would need to be refactored to a for loop if more than one recipient +// mintRecipients.push(mintRecipients_[0]); + +// // Overwrite storage for all previous deployments in setUp and assert deployment + +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// mainnetController = MainnetController(controllerInst.controller); +// rateLimits = RateLimits(controllerInst.rateLimits); + +// // Admin will be calling the library from its own address +// vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); + +// wrapper = LibraryWrapper(SPARK_PROXY); +// } + +// /**********************************************************************************************/ +// /*** ACL tests ***/ +// /**********************************************************************************************/ + +// function test_init_incorrectAdminAlmProxy() external { +// // Isolate different contracts instead of setting param so can get three different failures +// vm.startPrank(SPARK_PROXY); +// almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); +// almProxy.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); +// vm.stopPrank(); + +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-almProxy")); +// } + +// function test_init_incorrectAdminRateLimits() external { +// // Isolate different contracts instead of setting param so can get three different failures +// vm.startPrank(SPARK_PROXY); +// rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); +// rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); +// vm.stopPrank(); + +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-rateLimits")); +// } - function test_init_incorrectAdminController() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_PROXY); - mainnetController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); - mainnetController.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); - vm.stopPrank(); +// function test_init_incorrectAdminController() external { +// // Isolate different contracts instead of setting param so can get three different failures +// vm.startPrank(SPARK_PROXY); +// mainnetController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); +// mainnetController.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); +// vm.stopPrank(); - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-controller")); - } +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-controller")); +// } - /**********************************************************************************************/ - /*** Constructor tests ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /*** Constructor tests ***/ +// /**********************************************************************************************/ - function test_init_incorrectAlmProxy() external { - // Deploy new address that will not EVM revert on OZ ACL check - controllerInst.almProxy = address(new ALMProxy(SPARK_PROXY)); +// function test_init_incorrectAlmProxy() external { +// // Deploy new address that will not EVM revert on OZ ACL check +// controllerInst.almProxy = address(new ALMProxy(SPARK_PROXY)); - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-almProxy")); - } +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-almProxy")); +// } - function test_init_incorrectRateLimits() external { - // Deploy new address that will not EVM revert on OZ ACL check - controllerInst.rateLimits = address(new RateLimits(SPARK_PROXY)); +// function test_init_incorrectRateLimits() external { +// // Deploy new address that will not EVM revert on OZ ACL check +// controllerInst.rateLimits = address(new RateLimits(SPARK_PROXY)); - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-rateLimits")); - } +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-rateLimits")); +// } - function test_init_incorrectVault() external { - addresses.vault = mismatchAddress; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-vault")); - } +// function test_init_incorrectVault() external { +// addresses.vault = mismatchAddress; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-vault")); +// } - function test_init_incorrectBuffer() external { - addresses.buffer = mismatchAddress; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-buffer")); - } +// function test_init_incorrectBuffer() external { +// addresses.buffer = mismatchAddress; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-buffer")); +// } - function test_init_incorrectPsm() external { - addresses.psm = mismatchAddress; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-psm")); - } - - function test_init_incorrectDaiUsds() external { - addresses.daiUsds = mismatchAddress; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-daiUsds")); - } - - function test_init_incorrectCctp() external { - addresses.cctpMessenger = mismatchAddress; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-cctpMessenger")); - } - - function test_init_incorrectDai() external { - addresses.dai = mismatchAddress; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-dai")); - } - - function test_init_incorrectUsdc() external { - addresses.usdc = mismatchAddress; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-usdc")); - } - - function test_init_incorrectUsds() external { - addresses.usds = mismatchAddress; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-usds")); - } - - function test_init_controllerInactive() external { - // Cheating to set this outside of init scripts so that the controller can be frozen - vm.startPrank(SPARK_PROXY); - mainnetController.grantRole(FREEZER, freezer); - - vm.startPrank(freezer); - mainnetController.freeze(); - vm.stopPrank(); - - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/controller-not-active")); - } - - function test_init_oldControllerIsNewController() external { - addresses.oldController = controllerInst.controller; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-is-new-controller")); - } - - // TODO: Skipping conversion factor test, can add later if needed - - /**********************************************************************************************/ - /*** Unlimited `maxAmount` rate limit boundary tests ***/ - /**********************************************************************************************/ - - function test_init_incorrectUsdsMintData_unlimitedBoundary() external { - rateLimitData.usdsMintData.maxAmount = type(uint256).max; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdsMintData")); - - rateLimitData.usdsMintData.slope = 0; - _checkBothInitsSucceed(); - } - - function test_init_incorrectUsdcToUsdsData_unlimitedBoundary() external { - rateLimitData.usdsToUsdcData.maxAmount = type(uint256).max; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdsToUsdcData")); - - rateLimitData.usdsToUsdcData.slope = 0; - _checkBothInitsSucceed(); - } +// function test_init_incorrectPsm() external { +// addresses.psm = mismatchAddress; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-psm")); +// } + +// function test_init_incorrectDaiUsds() external { +// addresses.daiUsds = mismatchAddress; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-daiUsds")); +// } + +// function test_init_incorrectCctp() external { +// addresses.cctpMessenger = mismatchAddress; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-cctpMessenger")); +// } + +// function test_init_incorrectDai() external { +// addresses.dai = mismatchAddress; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-dai")); +// } + +// function test_init_incorrectUsdc() external { +// addresses.usdc = mismatchAddress; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-usdc")); +// } + +// function test_init_incorrectUsds() external { +// addresses.usds = mismatchAddress; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-usds")); +// } + +// function test_init_controllerInactive() external { +// // Cheating to set this outside of init scripts so that the controller can be frozen +// vm.startPrank(SPARK_PROXY); +// mainnetController.grantRole(FREEZER, freezer); + +// vm.startPrank(freezer); +// mainnetController.freeze(); +// vm.stopPrank(); + +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/controller-not-active")); +// } + +// function test_init_oldControllerIsNewController() external { +// addresses.oldController = controllerInst.controller; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-is-new-controller")); +// } + +// // TODO: Skipping conversion factor test, can add later if needed + +// /**********************************************************************************************/ +// /*** Unlimited `maxAmount` rate limit boundary tests ***/ +// /**********************************************************************************************/ + +// function test_init_incorrectUsdsMintData_unlimitedBoundary() external { +// rateLimitData.usdsMintData.maxAmount = type(uint256).max; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdsMintData")); + +// rateLimitData.usdsMintData.slope = 0; +// _checkBothInitsSucceed(); +// } + +// function test_init_incorrectUsdcToUsdsData_unlimitedBoundary() external { +// rateLimitData.usdsToUsdcData.maxAmount = type(uint256).max; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdsToUsdcData")); + +// rateLimitData.usdsToUsdcData.slope = 0; +// _checkBothInitsSucceed(); +// } - function test_init_incorrectUsdcToCctpData_unlimitedBoundary() external { - rateLimitData.usdcToCctpData.maxAmount = type(uint256).max; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdcToCctpData")); +// function test_init_incorrectUsdcToCctpData_unlimitedBoundary() external { +// rateLimitData.usdcToCctpData.maxAmount = type(uint256).max; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdcToCctpData")); - rateLimitData.usdcToCctpData.slope = 0; - _checkBothInitsSucceed(); - } +// rateLimitData.usdcToCctpData.slope = 0; +// _checkBothInitsSucceed(); +// } - function test_init_incorrectCctpToBaseDomain_unlimitedBoundary() external { - rateLimitData.cctpToBaseDomainData.maxAmount = type(uint256).max; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-cctpToBaseDomainData")); +// function test_init_incorrectCctpToBaseDomain_unlimitedBoundary() external { +// rateLimitData.cctpToBaseDomainData.maxAmount = type(uint256).max; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-cctpToBaseDomainData")); - rateLimitData.cctpToBaseDomainData.slope = 0; - _checkBothInitsSucceed(); - } +// rateLimitData.cctpToBaseDomainData.slope = 0; +// _checkBothInitsSucceed(); +// } - /**********************************************************************************************/ - /*** `maxAmount` rate limit precision boundary tests ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /*** `maxAmount` rate limit precision boundary tests ***/ +// /**********************************************************************************************/ - function test_init_incorrectUsdsMintData_maxAmountPrecisionBoundary() external { - rateLimitData.usdsMintData.maxAmount = 1e12 * 1e18 + 1; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdsMintData")); +// function test_init_incorrectUsdsMintData_maxAmountPrecisionBoundary() external { +// rateLimitData.usdsMintData.maxAmount = 1e12 * 1e18 + 1; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdsMintData")); - rateLimitData.usdsMintData.maxAmount = 1e12 * 1e18; - _checkBothInitsSucceed(); - } +// rateLimitData.usdsMintData.maxAmount = 1e12 * 1e18; +// _checkBothInitsSucceed(); +// } - function test_init_incorrectUsdcToUsdsData_maxAmountPrecisionBoundary() external { - rateLimitData.usdsToUsdcData.maxAmount = 1e12 * 1e6 + 1; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdsToUsdcData")); +// function test_init_incorrectUsdcToUsdsData_maxAmountPrecisionBoundary() external { +// rateLimitData.usdsToUsdcData.maxAmount = 1e12 * 1e6 + 1; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdsToUsdcData")); - rateLimitData.usdsToUsdcData.maxAmount = 1e12 * 1e6; - _checkBothInitsSucceed(); - } +// rateLimitData.usdsToUsdcData.maxAmount = 1e12 * 1e6; +// _checkBothInitsSucceed(); +// } - function test_init_incorrectUsdcToCctpData_maxAmountPrecisionBoundary() external { - rateLimitData.usdcToCctpData.maxAmount = 1e12 * 1e6 + 1; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdcToCctpData")); +// function test_init_incorrectUsdcToCctpData_maxAmountPrecisionBoundary() external { +// rateLimitData.usdcToCctpData.maxAmount = 1e12 * 1e6 + 1; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdcToCctpData")); - rateLimitData.usdcToCctpData.maxAmount = 1e12 * 1e6; - _checkBothInitsSucceed(); - } +// rateLimitData.usdcToCctpData.maxAmount = 1e12 * 1e6; +// _checkBothInitsSucceed(); +// } - function test_init_incorrectCctpToBaseDomain_maxAmountPrecisionBoundary() external { - rateLimitData.cctpToBaseDomainData.maxAmount = 1e12 * 1e6 + 1; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-cctpToBaseDomainData")); +// function test_init_incorrectCctpToBaseDomain_maxAmountPrecisionBoundary() external { +// rateLimitData.cctpToBaseDomainData.maxAmount = 1e12 * 1e6 + 1; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-cctpToBaseDomainData")); - rateLimitData.cctpToBaseDomainData.maxAmount = 1e12 * 1e6; - _checkBothInitsSucceed(); - } +// rateLimitData.cctpToBaseDomainData.maxAmount = 1e12 * 1e6; +// _checkBothInitsSucceed(); +// } - /**********************************************************************************************/ - /*** `slope` rate limit precision boundary tests ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /*** `slope` rate limit precision boundary tests ***/ +// /**********************************************************************************************/ - function test_init_incorrectUsdsMintData_slopePrecisionBoundary() external { - rateLimitData.usdsMintData.slope = uint256(1e12 * 1e18) / 1 hours + 1; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdsMintData")); +// function test_init_incorrectUsdsMintData_slopePrecisionBoundary() external { +// rateLimitData.usdsMintData.slope = uint256(1e12 * 1e18) / 1 hours + 1; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdsMintData")); - rateLimitData.usdsMintData.slope = uint256(1e12 * 1e18) / 1 hours; - _checkBothInitsSucceed(); - } +// rateLimitData.usdsMintData.slope = uint256(1e12 * 1e18) / 1 hours; +// _checkBothInitsSucceed(); +// } - function test_init_incorrectUsdcToUsdsData_slopePrecisionBoundary() external { - rateLimitData.usdsToUsdcData.slope = uint256(1e12 * 1e6) / 1 hours + 1; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdsToUsdcData")); - - rateLimitData.usdsToUsdcData.slope = uint256(1e12 * 1e6) / 1 hours; - _checkBothInitsSucceed(); - } - - function test_init_incorrectUsdcToCctpData_slopePrecisionBoundary() external { - rateLimitData.usdcToCctpData.slope = uint256(1e12 * 1e6) / 1 hours + 1; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdcToCctpData")); - - rateLimitData.usdcToCctpData.slope = uint256(1e12 * 1e6) / 1 hours; - _checkBothInitsSucceed(); - } - - function test_init_incorrectCctpToBaseDomain_slopePrecisionBoundary() external { - rateLimitData.cctpToBaseDomainData.slope = uint256(1e12 * 1e6) / 1 hours + 1; - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-cctpToBaseDomainData")); - - rateLimitData.cctpToBaseDomainData.slope = uint256(1e12 * 1e6) / 1 hours; - _checkBothInitsSucceed(); - } - - /**********************************************************************************************/ - /*** Old controller role check tests ***/ - /**********************************************************************************************/ - - function test_init_oldControllerDoesNotHaveRoleInAlmProxy() external { - _deployNewControllerAfterExistingControllerInit(); - - // Revoke the old controller address in ALM proxy - - vm.startPrank(SPARK_PROXY); - almProxy.revokeRole(almProxy.CONTROLLER(), addresses.oldController); - vm.stopPrank(); - - // Try to init with the old controller address that is doesn't have the CONTROLLER role - - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-almProxy-controller")); - } - - function test_init_oldControllerDoesNotHaveRoleInRateLimits() external { - _deployNewControllerAfterExistingControllerInit(); - - // Revoke the old controller address - - vm.startPrank(SPARK_PROXY); - rateLimits.revokeRole(rateLimits.CONTROLLER(), addresses.oldController); - vm.stopPrank(); - - // Try to init with the old controller address that is doesn't have the CONTROLLER role - - _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-rateLimits-controller")); - } - - /**********************************************************************************************/ - /*** Helper functions ***/ - /**********************************************************************************************/ - - function _deployNewControllerAfterExistingControllerInit() internal { - // Successfully init first controller - - vm.startPrank(SPARK_PROXY); - MainnetControllerInit.subDaoInitFull( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - // Deploy a new controller (controllerInst is used in init with new controller address) - - controllerInst.controller = MainnetControllerDeploy.deployController( - SPARK_PROXY, - address(almProxy), - address(rateLimits), - vault, - PSM, - DAI_USDS, - CCTP_MESSENGER - ); - - addresses.oldController = address(mainnetController); - } - - // Added this function to ensure that all the failure modes from `subDaoInitController` - // are also covered by `subDaoInitFull` calls - function _checkBothInitsFail(bytes memory expectedError) internal { - vm.expectRevert(expectedError); - wrapper.subDaoInitController( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - - vm.expectRevert(expectedError); - wrapper.subDaoInitFull( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - } - - function _checkBothInitsSucceed() internal { - wrapper.subDaoInitController( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - - wrapper.subDaoInitFull( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - } -} - -contract MainnetControllerDeployAndInitSuccessTests is MainnetControllerDeployInitTestBase { - - function test_deployAllAndInitFull() external { - // Perform new deployments against existing fork environment - - ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( - SPARK_PROXY, - vault, - PSM, - DAI_USDS, - CCTP_MESSENGER - ); - - // Overwrite storage for all previous deployments in setUp and assert deployment - - almProxy = ALMProxy(payable(controllerInst.almProxy)); - mainnetController = MainnetController(controllerInst.controller); - rateLimits = RateLimits(controllerInst.rateLimits); - - assertEq(almProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); - assertEq(mainnetController.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); - assertEq(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); - - assertEq(address(mainnetController.proxy()), controllerInst.almProxy); - assertEq(address(mainnetController.rateLimits()), controllerInst.rateLimits); - assertEq(address(mainnetController.vault()), vault); - assertEq(address(mainnetController.buffer()), buffer); - assertEq(address(mainnetController.psm()), PSM); - assertEq(address(mainnetController.daiUsds()), DAI_USDS); - assertEq(address(mainnetController.cctp()), CCTP_MESSENGER); - assertEq(address(mainnetController.dai()), address(dai)); - assertEq(address(mainnetController.usdc()), address(usdc)); - assertEq(address(mainnetController.usds()), address(usds)); - - assertEq(mainnetController.psmTo18ConversionFactor(), 1e12); - assertEq(mainnetController.active(), true); - - // Perform SubDAO initialization (from SPARK_PROXY during spell) - // Setting rate limits to different values from setUp to make assertions more robust - - ( - MainnetControllerInit.AddressParams memory addresses, - MainnetControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) = _getDefaultParams(); - - vm.startPrank(SPARK_PROXY); - MainnetControllerInit.subDaoInitFull( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - // Assert SubDAO initialization - - assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); - assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); - - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); - - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); - - bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( - mainnetController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE - ); - - _assertRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimitData.usdsMintData); - _assertRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimitData.usdsToUsdcData); - _assertRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimitData.usdcToCctpData); - _assertRateLimitData(domainKeyBase, rateLimitData.cctpToBaseDomainData); - - assertEq( - mainnetController.mintRecipients(mintRecipients[0].domain), - mintRecipients[0].mintRecipient - ); - - assertEq( - mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), - bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) - ); - - assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 1); - - assertEq(usds.allowance(buffer, controllerInst.almProxy), type(uint256).max); - - // Perform Maker initialization (from PAUSE_PROXY during spell) - - vm.startPrank(PAUSE_PROXY); - MainnetControllerInit.pauseProxyInit(PSM, controllerInst.almProxy); - vm.stopPrank(); - - // Assert Maker initialization - - assertEq(IPSMLike(PSM).bud(controllerInst.almProxy), 1); - } - - function test_deployAllAndInitController() external { - // Perform new deployments against existing fork environment - - ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( - SPARK_PROXY, - vault, - PSM, - DAI_USDS, - CCTP_MESSENGER - ); - - // Overwrite storage for all previous deployments in setUp and assert deployment - - almProxy = ALMProxy(payable(controllerInst.almProxy)); - mainnetController = MainnetController(controllerInst.controller); - rateLimits = RateLimits(controllerInst.rateLimits); - - ( - MainnetControllerInit.AddressParams memory addresses, - MainnetControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) = _getDefaultParams(); - - // Perform ONLY controller initialization, setting rate limits and updating ACL - // Setting rate limits to different values from setUp to make assertions more robust - - vm.startPrank(SPARK_PROXY); - MainnetControllerInit.subDaoInitController( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); - assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); - - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); - - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); - - bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( - mainnetController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE - ); - - _assertRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimitData.usdsMintData); - _assertRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimitData.usdsToUsdcData); - _assertRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimitData.usdcToCctpData); - _assertRateLimitData(domainKeyBase, rateLimitData.cctpToBaseDomainData); - - assertEq( - mainnetController.mintRecipients(mintRecipients[0].domain), - mintRecipients[0].mintRecipient - ); - - assertEq( - mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), - bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) - ); - } - - function test_init_transferAclToNewController() public { - // Deploy and init a controller - - ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( - SPARK_PROXY, - vault, - PSM, - DAI_USDS, - CCTP_MESSENGER - ); - - ( - MainnetControllerInit.AddressParams memory addresses, - MainnetControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) = _getDefaultParams(); - - vm.startPrank(SPARK_PROXY); - MainnetControllerInit.subDaoInitController( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - // Deploy a new controller (example of how an upgrade would work) - - address newController = MainnetControllerDeploy.deployController( - SPARK_PROXY, - controllerInst.almProxy, - controllerInst.rateLimits, - vault, - PSM, - DAI_USDS, - CCTP_MESSENGER - ); - - // Overwrite storage for all previous deployments in setUp and assert deployment - - almProxy = ALMProxy(payable(controllerInst.almProxy)); - mainnetController = MainnetController(controllerInst.controller); - rateLimits = RateLimits(controllerInst.rateLimits); - - address oldController = address(controllerInst.controller); - - controllerInst.controller = newController; // Overwrite struct for param - - // All other info is the same, just need to transfer ACL - addresses.oldController = oldController; - - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); - - vm.startPrank(SPARK_PROXY); - MainnetControllerInit.subDaoInitController( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); - } - - function _assertRateLimitData(bytes32 domainKey, RateLimitData memory expectedData) internal view { - IRateLimits.RateLimitData memory data = rateLimits.getRateLimitData(domainKey); - - assertEq(data.maxAmount, expectedData.maxAmount); - assertEq(data.slope, expectedData.slope); - assertEq(data.lastAmount, expectedData.maxAmount); - assertEq(data.lastUpdated, block.timestamp); - - assertEq(rateLimits.getCurrentRateLimit(domainKey), expectedData.maxAmount); - } - -} +// function test_init_incorrectUsdcToUsdsData_slopePrecisionBoundary() external { +// rateLimitData.usdsToUsdcData.slope = uint256(1e12 * 1e6) / 1 hours + 1; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdsToUsdcData")); + +// rateLimitData.usdsToUsdcData.slope = uint256(1e12 * 1e6) / 1 hours; +// _checkBothInitsSucceed(); +// } + +// function test_init_incorrectUsdcToCctpData_slopePrecisionBoundary() external { +// rateLimitData.usdcToCctpData.slope = uint256(1e12 * 1e6) / 1 hours + 1; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdcToCctpData")); + +// rateLimitData.usdcToCctpData.slope = uint256(1e12 * 1e6) / 1 hours; +// _checkBothInitsSucceed(); +// } + +// function test_init_incorrectCctpToBaseDomain_slopePrecisionBoundary() external { +// rateLimitData.cctpToBaseDomainData.slope = uint256(1e12 * 1e6) / 1 hours + 1; +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-cctpToBaseDomainData")); + +// rateLimitData.cctpToBaseDomainData.slope = uint256(1e12 * 1e6) / 1 hours; +// _checkBothInitsSucceed(); +// } + +// /**********************************************************************************************/ +// /*** Old controller role check tests ***/ +// /**********************************************************************************************/ + +// function test_init_oldControllerDoesNotHaveRoleInAlmProxy() external { +// _deployNewControllerAfterExistingControllerInit(); + +// // Revoke the old controller address in ALM proxy + +// vm.startPrank(SPARK_PROXY); +// almProxy.revokeRole(almProxy.CONTROLLER(), addresses.oldController); +// vm.stopPrank(); + +// // Try to init with the old controller address that is doesn't have the CONTROLLER role + +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-almProxy-controller")); +// } + +// function test_init_oldControllerDoesNotHaveRoleInRateLimits() external { +// _deployNewControllerAfterExistingControllerInit(); + +// // Revoke the old controller address + +// vm.startPrank(SPARK_PROXY); +// rateLimits.revokeRole(rateLimits.CONTROLLER(), addresses.oldController); +// vm.stopPrank(); + +// // Try to init with the old controller address that is doesn't have the CONTROLLER role + +// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-rateLimits-controller")); +// } + +// /**********************************************************************************************/ +// /*** Helper functions ***/ +// /**********************************************************************************************/ + +// function _deployNewControllerAfterExistingControllerInit() internal { +// // Successfully init first controller + +// vm.startPrank(SPARK_PROXY); +// MainnetControllerInit.subDaoInitFull( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// vm.stopPrank(); + +// // Deploy a new controller (controllerInst is used in init with new controller address) + +// controllerInst.controller = MainnetControllerDeploy.deployController( +// SPARK_PROXY, +// address(almProxy), +// address(rateLimits), +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER +// ); + +// addresses.oldController = address(mainnetController); +// } + +// // Added this function to ensure that all the failure modes from `subDaoInitController` +// // are also covered by `subDaoInitFull` calls +// function _checkBothInitsFail(bytes memory expectedError) internal { +// vm.expectRevert(expectedError); +// wrapper.subDaoInitController( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); + +// vm.expectRevert(expectedError); +// wrapper.subDaoInitFull( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// } + +// function _checkBothInitsSucceed() internal { +// wrapper.subDaoInitController( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); + +// wrapper.subDaoInitFull( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// } +// } + +// contract MainnetControllerDeployAndInitSuccessTests is MainnetControllerDeployInitTestBase { + +// function test_deployAllAndInitFull() external { +// // Perform new deployments against existing fork environment + +// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( +// SPARK_PROXY, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER +// ); + +// // Overwrite storage for all previous deployments in setUp and assert deployment + +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// mainnetController = MainnetController(controllerInst.controller); +// rateLimits = RateLimits(controllerInst.rateLimits); + +// assertEq(almProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); +// assertEq(mainnetController.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); +// assertEq(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); + +// assertEq(address(mainnetController.proxy()), controllerInst.almProxy); +// assertEq(address(mainnetController.rateLimits()), controllerInst.rateLimits); +// assertEq(address(mainnetController.vault()), vault); +// assertEq(address(mainnetController.buffer()), buffer); +// assertEq(address(mainnetController.psm()), PSM); +// assertEq(address(mainnetController.daiUsds()), DAI_USDS); +// assertEq(address(mainnetController.cctp()), CCTP_MESSENGER); +// assertEq(address(mainnetController.dai()), address(dai)); +// assertEq(address(mainnetController.usdc()), address(usdc)); +// assertEq(address(mainnetController.usds()), address(usds)); + +// assertEq(mainnetController.psmTo18ConversionFactor(), 1e12); +// assertEq(mainnetController.active(), true); + +// // Perform SubDAO initialization (from SPARK_PROXY during spell) +// // Setting rate limits to different values from setUp to make assertions more robust + +// ( +// MainnetControllerInit.AddressParams memory addresses, +// MainnetControllerInit.InitRateLimitData memory rateLimitData, +// MintRecipient[] memory mintRecipients +// ) = _getDefaultParams(); + +// vm.startPrank(SPARK_PROXY); +// MainnetControllerInit.subDaoInitFull( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// vm.stopPrank(); + +// // Assert SubDAO initialization + +// assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); +// assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); + +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); + +// bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( +// mainnetController.LIMIT_USDC_TO_DOMAIN(), +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE +// ); + +// _assertRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimitData.usdsMintData); +// _assertRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimitData.usdsToUsdcData); +// _assertRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimitData.usdcToCctpData); +// _assertRateLimitData(domainKeyBase, rateLimitData.cctpToBaseDomainData); + +// assertEq( +// mainnetController.mintRecipients(mintRecipients[0].domain), +// mintRecipients[0].mintRecipient +// ); + +// assertEq( +// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), +// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) +// ); + +// assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 1); + +// assertEq(usds.allowance(buffer, controllerInst.almProxy), type(uint256).max); + +// // Perform Maker initialization (from PAUSE_PROXY during spell) + +// vm.startPrank(PAUSE_PROXY); +// MainnetControllerInit.pauseProxyInit(PSM, controllerInst.almProxy); +// vm.stopPrank(); + +// // Assert Maker initialization + +// assertEq(IPSMLike(PSM).bud(controllerInst.almProxy), 1); +// } + +// function test_deployAllAndInitController() external { +// // Perform new deployments against existing fork environment + +// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( +// SPARK_PROXY, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER +// ); + +// // Overwrite storage for all previous deployments in setUp and assert deployment + +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// mainnetController = MainnetController(controllerInst.controller); +// rateLimits = RateLimits(controllerInst.rateLimits); + +// ( +// MainnetControllerInit.AddressParams memory addresses, +// MainnetControllerInit.InitRateLimitData memory rateLimitData, +// MintRecipient[] memory mintRecipients +// ) = _getDefaultParams(); + +// // Perform ONLY controller initialization, setting rate limits and updating ACL +// // Setting rate limits to different values from setUp to make assertions more robust + +// vm.startPrank(SPARK_PROXY); +// MainnetControllerInit.subDaoInitController( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// vm.stopPrank(); + +// assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); +// assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); + +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); + +// bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( +// mainnetController.LIMIT_USDC_TO_DOMAIN(), +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE +// ); + +// _assertRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimitData.usdsMintData); +// _assertRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimitData.usdsToUsdcData); +// _assertRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimitData.usdcToCctpData); +// _assertRateLimitData(domainKeyBase, rateLimitData.cctpToBaseDomainData); + +// assertEq( +// mainnetController.mintRecipients(mintRecipients[0].domain), +// mintRecipients[0].mintRecipient +// ); + +// assertEq( +// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), +// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) +// ); +// } + +// function test_init_transferAclToNewController() public { +// // Deploy and init a controller + +// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( +// SPARK_PROXY, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER +// ); + +// ( +// MainnetControllerInit.AddressParams memory addresses, +// MainnetControllerInit.InitRateLimitData memory rateLimitData, +// MintRecipient[] memory mintRecipients +// ) = _getDefaultParams(); + +// vm.startPrank(SPARK_PROXY); +// MainnetControllerInit.subDaoInitController( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// vm.stopPrank(); + +// // Deploy a new controller (example of how an upgrade would work) + +// address newController = MainnetControllerDeploy.deployController( +// SPARK_PROXY, +// controllerInst.almProxy, +// controllerInst.rateLimits, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER +// ); + +// // Overwrite storage for all previous deployments in setUp and assert deployment + +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// mainnetController = MainnetController(controllerInst.controller); +// rateLimits = RateLimits(controllerInst.rateLimits); + +// address oldController = address(controllerInst.controller); + +// controllerInst.controller = newController; // Overwrite struct for param + +// // All other info is the same, just need to transfer ACL +// addresses.oldController = oldController; + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); + +// vm.startPrank(SPARK_PROXY); +// MainnetControllerInit.subDaoInitController( +// addresses, +// controllerInst, +// rateLimitData, +// mintRecipients +// ); +// vm.stopPrank(); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); +// } + +// function _assertRateLimitData(bytes32 domainKey, RateLimitData memory expectedData) internal view { +// IRateLimits.RateLimitData memory data = rateLimits.getRateLimitData(domainKey); + +// assertEq(data.maxAmount, expectedData.maxAmount); +// assertEq(data.slope, expectedData.slope); +// assertEq(data.lastAmount, expectedData.maxAmount); +// assertEq(data.lastUpdated, block.timestamp); + +// assertEq(rateLimits.getCurrentRateLimit(domainKey), expectedData.maxAmount); +// } + +// } From 2b3f67194e6a747117b7dd5350f895d68494fba0 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 19 Dec 2024 11:45:11 -0500 Subject: [PATCH 03/33] test: finish init tests --- deploy/MainnetControllerInit.sol | 104 +++-- test/mainnet-fork/InitAndUpgrade.t.sol | 594 +++++++++++++++++++++++++ 2 files changed, 652 insertions(+), 46 deletions(-) create mode 100644 test/mainnet-fork/InitAndUpgrade.t.sol diff --git a/deploy/MainnetControllerInit.sol b/deploy/MainnetControllerInit.sol index 216981a..dc26847 100644 --- a/deploy/MainnetControllerInit.sol +++ b/deploy/MainnetControllerInit.sol @@ -23,6 +23,10 @@ interface IVaultLike { library MainnetControllerInit { + /**********************************************************************************************/ + /*** Structs and constants ***/ + /**********************************************************************************************/ + struct CheckAddressParams { address admin; address proxy; @@ -46,13 +50,64 @@ library MainnetControllerInit { bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; - function initController( + /**********************************************************************************************/ + /*** Internal library functions ***/ + /**********************************************************************************************/ + + function initAlmSystem( + address vault, + address usds, ControllerInstance memory controllerInst, ConfigAddressParams memory configAddresses, CheckAddressParams memory checkAddresses, MintRecipient[] memory mintRecipients ) - private // Not all, add underscores + internal + { + // Step 1: Do sanity checks outside of the controller + + require(IALMProxy(controllerInst.almProxy).hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "MainnetControllerInit/incorrect-admin-almProxy"); + require(IRateLimits(controllerInst.rateLimits).hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "MainnetControllerInit/incorrect-admin-rateLimits"); + + // Step 2: Initialize the controller + + _initController(controllerInst, configAddresses, checkAddresses, mintRecipients); + + // Step 3: Configure almProxy within the allocation system + + require(vault == checkAddresses.vault, "MainnetControllerInit/incorrect-vault"); + + IVaultLike(vault).rely(controllerInst.almProxy); + IBufferLike(IVaultLike(vault).buffer()).approve(usds, controllerInst.almProxy, type(uint256).max); + } + + function upgradeController( + ControllerInstance memory controllerInst, + ConfigAddressParams memory configAddresses, + CheckAddressParams memory checkAddresses, + MintRecipient[] memory mintRecipients + ) + internal + { + _initController(controllerInst, configAddresses, checkAddresses, mintRecipients); + _revokeOldControllerRoles(controllerInst, configAddresses.oldController); + } + + function pauseProxyInitAlmSystem(address psm, address almProxy) internal { + IPSMLike(psm).kiss(almProxy); // To allow using no fee functionality + } + + /**********************************************************************************************/ + /*** Private helper functions ***/ + /**********************************************************************************************/ + + function _initController( + ControllerInstance memory controllerInst, + ConfigAddressParams memory configAddresses, + CheckAddressParams memory checkAddresses, + MintRecipient[] memory mintRecipients + ) + private { // Step 1: Perform controller sanity checks @@ -91,7 +146,7 @@ library MainnetControllerInit { } } - function revokeOldControllerRoles(ControllerInstance memory controllerInst, address oldController) private { + function _revokeOldControllerRoles(ControllerInstance memory controllerInst, address oldController) private { IALMProxy almProxy = IALMProxy(controllerInst.almProxy); IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); @@ -104,47 +159,4 @@ library MainnetControllerInit { rateLimits.revokeRole(rateLimits.CONTROLLER(), oldController); } - function upgradeController( - ControllerInstance memory controllerInst, - ConfigAddressParams memory configAddresses, - CheckAddressParams memory checkAddresses, - MintRecipient[] memory mintRecipients - ) - private - { - initController(controllerInst, configAddresses, checkAddresses, mintRecipients); - revokeOldControllerRoles(controllerInst, configAddresses.oldController); - } - - function initAlmSystem( - address vault, - address usds, - ControllerInstance memory controllerInst, - ConfigAddressParams memory configAddresses, - CheckAddressParams memory checkAddresses, - MintRecipient[] memory mintRecipients - ) - private - { - // Step 1: Do sanity checks outside of the controller - - require(IALMProxy(controllerInst.almProxy).hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "MainnetControllerInit/incorrect-admin-almProxy"); - require(IRateLimits(controllerInst.rateLimits).hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "MainnetControllerInit/incorrect-admin-rateLimits"); - - // Step 2: Initialize the controller - - initController(controllerInst, configAddresses, checkAddresses, mintRecipients); - - // Step 3: Configure almProxy within the allocation system - - require(vault == checkAddresses.vault, "MainnetControllerInit/incorrect-vault"); - - IVaultLike(vault).rely(controllerInst.almProxy); - IBufferLike(IVaultLike(vault).buffer()).approve(usds, controllerInst.almProxy, type(uint256).max); - } - - function pauseProxyInit(address psm, address almProxy) private { - IPSMLike(psm).kiss(almProxy); // To allow using no fee functionality - } - } \ No newline at end of file diff --git a/test/mainnet-fork/InitAndUpgrade.t.sol b/test/mainnet-fork/InitAndUpgrade.t.sol new file mode 100644 index 0000000..400f710 --- /dev/null +++ b/test/mainnet-fork/InitAndUpgrade.t.sol @@ -0,0 +1,594 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity >=0.8.0; + +import "test/mainnet-fork/ForkTestBase.t.sol"; + +import { IRateLimits } from "src/interfaces/IRateLimits.sol"; + +import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; +import { MainnetControllerDeploy } from "../../deploy/ControllerDeploy.sol"; + +import { MainnetControllerInit as Init } from "../../deploy/MainnetControllerInit.sol"; + +// Necessary to get error message assertions to work +contract LibraryWrapper { + + function initAlmSystem( + address vault, + address usds, + ControllerInstance memory controllerInst, + Init.ConfigAddressParams memory configAddresses, + Init.CheckAddressParams memory checkAddresses, + Init.MintRecipient[] memory mintRecipients + ) + external + { + Init.initAlmSystem(vault, usds, controllerInst, configAddresses, checkAddresses, mintRecipients); + } + + function upgradeController( + ControllerInstance memory controllerInst, + Init.ConfigAddressParams memory configAddresses, + Init.CheckAddressParams memory checkAddresses, + Init.MintRecipient[] memory mintRecipients + ) + external + { + Init.upgradeController(controllerInst, configAddresses, checkAddresses, mintRecipients); + } + +} + +contract MainnetControllerInitAndUpgradeTestBase is ForkTestBase { + + function _getDefaultParams() + internal returns ( + Init.ConfigAddressParams memory configAddresses, + Init.CheckAddressParams memory checkAddresses, + Init.MintRecipient[] memory mintRecipients + ) + { + configAddresses = Init.ConfigAddressParams({ + freezer : freezer, + relayer : relayer, + oldController : address(0) + }); + + checkAddresses = Init.CheckAddressParams({ + admin : Ethereum.SPARK_PROXY, + proxy : Ethereum.ALM_PROXY, + rateLimits : Ethereum.ALM_RATE_LIMITS, + vault : Ethereum.ALLOCATOR_VAULT, + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER + }); + + mintRecipients = new Init.MintRecipient[](1); + + mintRecipients[0] = Init.MintRecipient({ + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) + }); + } + +} + +contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTestBase { + + LibraryWrapper wrapper; + + ControllerInstance public controllerInst; + + address public mismatchAddress = makeAddr("mismatchAddress"); + + Init.ConfigAddressParams configAddresses; + Init.CheckAddressParams checkAddresses; + Init.MintRecipient[] mintRecipients; + + function setUp() public override { + super.setUp(); + + mainnetController = MainnetController(MainnetControllerDeploy.deployController({ + admin : Ethereum.SPARK_PROXY, + almProxy : Ethereum.ALM_PROXY, + rateLimits : Ethereum.ALM_RATE_LIMITS, + vault : Ethereum.ALLOCATOR_VAULT, + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER + })); + + almProxy = ALMProxy(payable(Ethereum.ALM_PROXY)); + rateLimits = RateLimits(Ethereum.ALM_RATE_LIMITS); + + Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); + + ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); + + // NOTE: This would need to be refactored to a for loop if more than one recipient + mintRecipients.push(mintRecipients_[0]); + + controllerInst = ControllerInstance({ + almProxy : Ethereum.ALM_PROXY, + controller : address(mainnetController), + rateLimits : Ethereum.ALM_RATE_LIMITS + }); + + // Admin will be calling the library from its own address + vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); + + wrapper = LibraryWrapper(SPARK_PROXY); + } + + function _getBlock() internal pure override returns (uint256) { + return 21430000; // Dec 18, 2024 + } + + /**********************************************************************************************/ + /*** ACL tests ***/ + /**********************************************************************************************/ + + function test_init_incorrectAdminAlmProxy() external { + // Isolate different contracts instead of setting param so can get three different failures + vm.startPrank(SPARK_PROXY); + almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + almProxy.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); + vm.stopPrank(); + + vm.expectRevert("MainnetControllerInit/incorrect-admin-almProxy"); + wrapper.initAlmSystem( + vault, + address(usds), + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_init_incorrectAdminRateLimits() external { + // Isolate different contracts instead of setting param so can get three different failures + vm.startPrank(SPARK_PROXY); + rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); + vm.stopPrank(); + + vm.expectRevert("MainnetControllerInit/incorrect-admin-rateLimits"); + wrapper.initAlmSystem( + vault, + address(usds), + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_init_incorrectAdminController() external { + // Isolate different contracts instead of setting param so can get three different failures + vm.startPrank(SPARK_PROXY); + mainnetController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + mainnetController.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); + vm.stopPrank(); + + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-controller")); + } + + /**********************************************************************************************/ + /*** Constructor tests ***/ + /**********************************************************************************************/ + + function test_init_incorrectAlmProxy() external { + // Deploy new address that will not EVM revert on OZ ACL check + controllerInst.almProxy = address(new ALMProxy(SPARK_PROXY)); + + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-almProxy")); + } + + function test_init_incorrectRateLimits() external { + // Deploy new address that will not EVM revert on OZ ACL check + controllerInst.rateLimits = address(new RateLimits(SPARK_PROXY)); + + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-rateLimits")); + } + + function test_init_incorrectVault() external { + checkAddresses.vault = mismatchAddress; + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-vault")); + } + + function test_init_incorrectPsm() external { + checkAddresses.psm = mismatchAddress; + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-psm")); + } + + function test_init_incorrectDaiUsds() external { + checkAddresses.daiUsds = mismatchAddress; + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-daiUsds")); + } + + function test_init_incorrectCctp() external { + checkAddresses.cctp = mismatchAddress; + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-cctp")); + } + + function test_init_controllerInactive() external { + // Cheating to set this outside of init scripts so that the controller can be frozen + vm.startPrank(SPARK_PROXY); + mainnetController.grantRole(FREEZER, freezer); + + vm.startPrank(freezer); + mainnetController.freeze(); + vm.stopPrank(); + + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/controller-not-active")); + } + + function test_init_oldControllerIsNewController() external { + configAddresses.oldController = controllerInst.controller; + _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/old-controller-is-new-controller")); + } + + function test_init_vaultMismatch() external { + vault = mismatchAddress; + + vm.expectRevert("MainnetControllerInit/incorrect-vault"); + wrapper.initAlmSystem( + vault, + address(usds), + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function _checkInitAndUpgradeFail(bytes memory expectedError) internal { + vm.expectRevert(expectedError); + wrapper.initAlmSystem( + vault, + address(usds), + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + vm.expectRevert(expectedError); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + +} + +// contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgradeTestBase { + +// // // TODO: Skipping conversion factor test, can add later if needed + +// // /**********************************************************************************************/ +// // /*** Old controller role check tests ***/ +// // /**********************************************************************************************/ + +// // function test_init_oldControllerDoesNotHaveRoleInAlmProxy() external { +// // _deployNewControllerAfterExistingControllerInit(); + +// // // Revoke the old controller address in ALM proxy + +// // vm.startPrank(SPARK_PROXY); +// // almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); +// // vm.stopPrank(); + +// // // Try to init with the old controller address that is doesn't have the CONTROLLER role + +// // _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-almProxy-controller")); +// // } + +// // function test_init_oldControllerDoesNotHaveRoleInRateLimits() external { +// // _deployNewControllerAfterExistingControllerInit(); + +// // // Revoke the old controller address + +// // vm.startPrank(SPARK_PROXY); +// // rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); +// // vm.stopPrank(); + +// // // Try to init with the old controller address that is doesn't have the CONTROLLER role + +// // _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-rateLimits-controller")); +// // } + +// // /**********************************************************************************************/ +// // /*** Helper functions ***/ +// // /**********************************************************************************************/ + +// // function _deployNewControllerAfterExistingControllerInit() internal { +// // // Successfully init first controller + +// // vm.startPrank(SPARK_PROXY); +// // Init.subDaoInitController( +// // configAddresses, +// // checkAddresses, +// // controllerInst, +// // mintRecipients +// // ); +// // vm.stopPrank(); + +// // // Deploy a new controller (controllerInst is used in init with new controller address) + +// // controllerInst.controller = MainnetControllerDeploy.deployController({ +// // admin : Ethereum.SPARK_PROXY, +// // almProxy : Ethereum.ALM_PROXY, +// // rateLimits : Ethereum.ALM_RATE_LIMITS, +// // vault : Ethereum.ALLOCATOR_VAULT, +// // psm : Ethereum.PSM, +// // daiUsds : Ethereum.DAI_USDS, +// // cctp : Ethereum.CCTP_TOKEN_MESSENGER, +// // susds : Ethereum.SUSDS +// // }); + +// // configAddresses.oldController = address(mainnetController); +// // } + +// // Added this function to ensure that all the failure modes from `subDaoInitController` +// // are also covered by `subDaoInitFull` calls +// function _checkInitAndUpgradeFail(bytes memory expectedError) internal { +// vm.expectRevert(expectedError); +// wrapper.initAlmSystem( +// vault, +// address(usds), +// controllerInst, +// configAddresses, +// checkAddresses, +// mintRecipients +// ); + +// vm.expectRevert(expectedError); +// wrapper.upgradeController( +// controllerInst, +// configAddresses, +// checkAddresses, +// mintRecipients +// ); +// } + +// // function _checkInitAndUpgradeSucceed() internal { +// // wrapper.subDaoInitController( +// // configAddresses, +// // checkAddresses, +// // controllerInst, +// // mintRecipients +// // ); + +// // wrapper.subDaoInitFull( +// // configAddresses, +// // checkAddresses, +// // controllerInst, +// // mintRecipients +// // ); +// // } +// } + +// contract MainnetControllerDeployAndInitSuccessTests is MainnetControllerDeployInitTestBase { + +// function test_deployAllAndInitFull() external { +// // Perform new deployments against existing fork environment + +// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( +// SPARK_PROXY, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER, +// address(susds) +// ); + +// // Overwrite storage for all previous deployments in setUp and assert deployment + +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// mainnetController = MainnetController(controllerInst.controller); +// rateLimits = RateLimits(controllerInst.rateLimits); + +// assertEq(almProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); +// assertEq(mainnetController.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); +// assertEq(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); + +// assertEq(address(mainnetController.proxy()), controllerInst.almProxy); +// assertEq(address(mainnetController.rateLimits()), controllerInst.rateLimits); +// assertEq(address(mainnetController.vault()), vault); +// assertEq(address(mainnetController.buffer()), buffer); +// assertEq(address(mainnetController.psm()), PSM); +// assertEq(address(mainnetController.daiUsds()), DAI_USDS); +// assertEq(address(mainnetController.cctp()), CCTP_MESSENGER); +// assertEq(address(mainnetController.susds()), address(susds)); +// assertEq(address(mainnetController.dai()), address(dai)); +// assertEq(address(mainnetController.usdc()), address(usdc)); +// assertEq(address(mainnetController.usds()), address(usds)); + +// assertEq(mainnetController.psmTo18ConversionFactor(), 1e12); +// assertEq(mainnetController.active(), true); + +// // Perform SubDAO initialization (from SPARK_PROXY during spell) +// // Setting rate limits to different values from setUp to make assertions more robust + +// ( +// Init.ConfigAddressParams memory configAddresses, +// Init.CheckAddressParams memory checkAddresses, +// MintRecipient[] memory mintRecipients +// ) = _getDefaultParams(); + +// vm.startPrank(SPARK_PROXY); +// Init.subDaoInitFull( +// configAddresses, +// checkAddresses, +// controllerInst, +// mintRecipients +// ); +// vm.stopPrank(); + +// // Assert SubDAO initialization + +// assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); +// assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); + +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); + +// assertEq( +// mainnetController.mintRecipients(mintRecipients[0].domain), +// mintRecipients[0].mintRecipient +// ); + +// assertEq( +// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), +// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) +// ); + +// assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 1); + +// assertEq(usds.allowance(buffer, controllerInst.almProxy), type(uint256).max); + +// // Perform Maker initialization (from PAUSE_PROXY during spell) + +// vm.startPrank(PAUSE_PROXY); +// Init.pauseProxyInit(PSM, controllerInst.almProxy); +// vm.stopPrank(); + +// // Assert Maker initialization + +// assertEq(IPSMLike(PSM).bud(controllerInst.almProxy), 1); +// } + +// function test_deployAllAndInitController() external { +// // Perform new deployments against existing fork environment + +// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( +// SPARK_PROXY, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER, +// address(susds) +// ); + +// // Overwrite storage for all previous deployments in setUp and assert deployment + +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// mainnetController = MainnetController(controllerInst.controller); +// rateLimits = RateLimits(controllerInst.rateLimits); + +// ( +// Init.ConfigAddressParams memory configAddresses, +// Init.CheckAddressParams memory checkAddresses, +// MintRecipient[] memory mintRecipients +// ) = _getDefaultParams(); + +// // Perform ONLY controller initialization, setting rate limits and updating ACL +// // Setting rate limits to different values from setUp to make assertions more robust + +// vm.startPrank(SPARK_PROXY); +// Init.subDaoInitController( +// configAddresses, +// checkAddresses, +// controllerInst, +// mintRecipients +// ); +// vm.stopPrank(); + +// assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); +// assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); + +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); + +// assertEq( +// mainnetController.mintRecipients(mintRecipients[0].domain), +// mintRecipients[0].mintRecipient +// ); + +// assertEq( +// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), +// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) +// ); +// } + +// function test_init_transferAclToNewController_Test() public { +// // Deploy and init a controller + +// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( +// SPARK_PROXY, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER, +// address(susds) +// ); + +// ( +// Init.ConfigAddressParams memory configAddresses, +// Init.CheckAddressParams memory checkAddresses, +// MintRecipient[] memory mintRecipients +// ) = _getDefaultParams(); + +// vm.startPrank(SPARK_PROXY); +// Init.subDaoInitController( +// configAddresses, +// checkAddresses, +// controllerInst, +// mintRecipients +// ); +// vm.stopPrank(); + +// // Deploy a new controller (example of how an upgrade would work) + +// address newController = MainnetControllerDeploy.deployController( +// SPARK_PROXY, +// controllerInst.almProxy, +// controllerInst.rateLimits, +// vault, +// PSM, +// DAI_USDS, +// CCTP_MESSENGER, +// address(susds) +// ); + +// // Overwrite storage for all previous deployments in setUp and assert deployment + +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// mainnetController = MainnetController(controllerInst.controller); +// rateLimits = RateLimits(controllerInst.rateLimits); + +// address oldController = address(controllerInst.controller); + +// controllerInst.controller = newController; // Overwrite struct for param + +// // All other info is the same, just need to transfer ACL +// configAddresses.oldController = oldController; + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); + +// vm.startPrank(SPARK_PROXY); +// Init.subDaoInitController( +// configAddresses, +// checkAddresses, +// controllerInst, +// mintRecipients +// ); +// vm.stopPrank(); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); +// } + +// } \ No newline at end of file From f613c86a44f13f736e898fb544e751e9845e0980 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 19 Dec 2024 15:44:49 -0500 Subject: [PATCH 04/33] test: get mainnet deploy, init, and upgrade tests working --- deploy/MainnetControllerInit.sol | 25 ++--- test/mainnet-fork/Deploy.t.sol | 2 +- test/mainnet-fork/InitAndUpgrade.t.sol | 140 ++++++++++++++++--------- 3 files changed, 100 insertions(+), 67 deletions(-) diff --git a/deploy/MainnetControllerInit.sol b/deploy/MainnetControllerInit.sol index dc26847..5ae2e79 100644 --- a/deploy/MainnetControllerInit.sol +++ b/deploy/MainnetControllerInit.sol @@ -90,7 +90,17 @@ library MainnetControllerInit { internal { _initController(controllerInst, configAddresses, checkAddresses, mintRecipients); - _revokeOldControllerRoles(controllerInst, configAddresses.oldController); + + IALMProxy almProxy = IALMProxy(controllerInst.almProxy); + IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); + + require(configAddresses.oldController != address(0), "MainnetControllerInit/old-controller-zero-address"); + + require(almProxy.hasRole(almProxy.CONTROLLER(), configAddresses.oldController), "MainnetControllerInit/old-controller-not-almProxy-controller"); + require(rateLimits.hasRole(rateLimits.CONTROLLER(), configAddresses.oldController), "MainnetControllerInit/old-controller-not-rateLimits-controller"); + + almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); + rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); } function pauseProxyInitAlmSystem(address psm, address almProxy) internal { @@ -146,17 +156,4 @@ library MainnetControllerInit { } } - function _revokeOldControllerRoles(ControllerInstance memory controllerInst, address oldController) private { - IALMProxy almProxy = IALMProxy(controllerInst.almProxy); - IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); - - require(oldController != address(0), "MainnetControllerInit/old-controller-zero-address"); - - require(almProxy.hasRole(almProxy.CONTROLLER(), oldController), "MainnetControllerInit/old-controller-not-almProxy-controller"); - require(rateLimits.hasRole(rateLimits.CONTROLLER(), oldController), "MainnetControllerInit/old-controller-not-rateLimits-controller"); - - almProxy.revokeRole(almProxy.CONTROLLER(), oldController); - rateLimits.revokeRole(rateLimits.CONTROLLER(), oldController); - } - } \ No newline at end of file diff --git a/test/mainnet-fork/Deploy.t.sol b/test/mainnet-fork/Deploy.t.sol index dadb0f5..bf4ffde 100644 --- a/test/mainnet-fork/Deploy.t.sol +++ b/test/mainnet-fork/Deploy.t.sol @@ -26,7 +26,7 @@ contract MainnetControllerDeploySuccessTests is ForkTestBase { assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); - _assertControllerInitState(newController, address(almProxy), address(rateLimits), vault, buffer); + _assertControllerInitState(newController, address(newAlmProxy), address(newRateLimits), vault, buffer); } function test_deployController() external { diff --git a/test/mainnet-fork/InitAndUpgrade.t.sol b/test/mainnet-fork/InitAndUpgrade.t.sol index 400f710..ec5220f 100644 --- a/test/mainnet-fork/InitAndUpgrade.t.sol +++ b/test/mainnet-fork/InitAndUpgrade.t.sol @@ -89,6 +89,9 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes function setUp() public override { super.setUp(); + // Deploy new controller against live mainnet system + // NOTE: initAlmSystem will redundantly call rely and approve on already inited + // almProxy and rateLimits, this setup was chosen to easily test upgrade and init failures mainnetController = MainnetController(MainnetControllerDeploy.deployController({ admin : Ethereum.SPARK_PROXY, almProxy : Ethereum.ALM_PROXY, @@ -266,73 +269,106 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes } -// contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgradeTestBase { +contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgradeTestBase { -// // // TODO: Skipping conversion factor test, can add later if needed + LibraryWrapper wrapper; -// // /**********************************************************************************************/ -// // /*** Old controller role check tests ***/ -// // /**********************************************************************************************/ + ControllerInstance public controllerInst; -// // function test_init_oldControllerDoesNotHaveRoleInAlmProxy() external { -// // _deployNewControllerAfterExistingControllerInit(); + address public mismatchAddress = makeAddr("mismatchAddress"); -// // // Revoke the old controller address in ALM proxy + Init.ConfigAddressParams configAddresses; + Init.CheckAddressParams checkAddresses; + Init.MintRecipient[] mintRecipients; -// // vm.startPrank(SPARK_PROXY); -// // almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); -// // vm.stopPrank(); + function setUp() public override { + super.setUp(); -// // // Try to init with the old controller address that is doesn't have the CONTROLLER role + // Deploy new controller against live mainnet system + controllerInst.controller = MainnetControllerDeploy.deployController({ + admin : Ethereum.SPARK_PROXY, + almProxy : Ethereum.ALM_PROXY, + rateLimits : Ethereum.ALM_RATE_LIMITS, + vault : Ethereum.ALLOCATOR_VAULT, + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER + }); -// // _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-almProxy-controller")); -// // } + // Overwrite storage for all previous deployments in setUp and assert deployment + almProxy = ALMProxy(payable(Ethereum.ALM_PROXY)); + rateLimits = RateLimits(Ethereum.ALM_RATE_LIMITS); -// // function test_init_oldControllerDoesNotHaveRoleInRateLimits() external { -// // _deployNewControllerAfterExistingControllerInit(); + controllerInst.almProxy = address(almProxy); + controllerInst.rateLimits = address(rateLimits); -// // // Revoke the old controller address + Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); -// // vm.startPrank(SPARK_PROXY); -// // rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); -// // vm.stopPrank(); + ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); -// // // Try to init with the old controller address that is doesn't have the CONTROLLER role + mintRecipients.push(mintRecipients_[0]); -// // _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-rateLimits-controller")); -// // } + configAddresses.oldController = Ethereum.ALM_CONTROLLER; -// // /**********************************************************************************************/ -// // /*** Helper functions ***/ -// // /**********************************************************************************************/ + // Admin will be calling the library from its own address + vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); -// // function _deployNewControllerAfterExistingControllerInit() internal { -// // // Successfully init first controller + wrapper = LibraryWrapper(SPARK_PROXY); + } -// // vm.startPrank(SPARK_PROXY); -// // Init.subDaoInitController( -// // configAddresses, -// // checkAddresses, -// // controllerInst, -// // mintRecipients -// // ); -// // vm.stopPrank(); - -// // // Deploy a new controller (controllerInst is used in init with new controller address) - -// // controllerInst.controller = MainnetControllerDeploy.deployController({ -// // admin : Ethereum.SPARK_PROXY, -// // almProxy : Ethereum.ALM_PROXY, -// // rateLimits : Ethereum.ALM_RATE_LIMITS, -// // vault : Ethereum.ALLOCATOR_VAULT, -// // psm : Ethereum.PSM, -// // daiUsds : Ethereum.DAI_USDS, -// // cctp : Ethereum.CCTP_TOKEN_MESSENGER, -// // susds : Ethereum.SUSDS -// // }); - -// // configAddresses.oldController = address(mainnetController); -// // } + function _getBlock() internal pure override returns (uint256) { + return 21430000; // Dec 18, 2024 + } + + /**********************************************************************************************/ + /*** Old controller role check tests ***/ + /**********************************************************************************************/ + + function test_upgrade_oldControllerZeroAddress() external { + configAddresses.oldController = address(0); + + vm.expectRevert("MainnetControllerInit/old-controller-zero-address"); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_upgrade_oldControllerDoesNotHaveRoleInAlmProxy() external { + // Revoke the old controller address in ALM proxy + vm.startPrank(SPARK_PROXY); + almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); + vm.stopPrank(); + + // Try to upgrade with the old controller address that is doesn't have the CONTROLLER role + vm.expectRevert("MainnetControllerInit/old-controller-not-almProxy-controller"); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_upgrade_oldControllerDoesNotHaveRoleInRateLimits() external { + // Revoke the old controller address in rate limits + vm.startPrank(SPARK_PROXY); + rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); + vm.stopPrank(); + + // Try to upgrade with the old controller address that is doesn't have the CONTROLLER role + vm.expectRevert("MainnetControllerInit/old-controller-not-rateLimits-controller"); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + +} // // Added this function to ensure that all the failure modes from `subDaoInitController` // // are also covered by `subDaoInitFull` calls From 69b06a3834fdcd391e72179a8cba6a26eb78e7fa Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 10:55:29 -0500 Subject: [PATCH 05/33] feat: mainnet scripts fully tested --- lib/spark-address-registry | 2 +- test/base-fork/ForkTestBase.t.sol | 7 +- test/mainnet-fork/ForkTestBase.t.sol | 4 +- test/mainnet-fork/InitAndUpgrade.t.sol | 473 +++++++++++-------------- 4 files changed, 218 insertions(+), 268 deletions(-) diff --git a/lib/spark-address-registry b/lib/spark-address-registry index bf584d8..399e26d 160000 --- a/lib/spark-address-registry +++ b/lib/spark-address-registry @@ -1 +1 @@ -Subproject commit bf584d8b5d0afdd6cdc581fbffe543d3e00e2c3c +Subproject commit 399e26da866f3182fd40e67ad6cdc42fc7b1723f diff --git a/test/base-fork/ForkTestBase.t.sol b/test/base-fork/ForkTestBase.t.sol index 4ec6caf..3b6d095 100644 --- a/test/base-fork/ForkTestBase.t.sol +++ b/test/base-fork/ForkTestBase.t.sol @@ -41,9 +41,10 @@ contract ForkTestBase is Test { bytes32 FREEZER; bytes32 RELAYER; - address freezer = makeAddr("freezer"); - address pocket = makeAddr("pocket"); - address relayer = makeAddr("relayer"); + address freezer = Base.ALM_FREEZER; + address relayer = Base.ALM_RELAYER; + + address pocket = makeAddr("pocket"); /**********************************************************************************************/ /*** Base addresses ***/ diff --git a/test/mainnet-fork/ForkTestBase.t.sol b/test/mainnet-fork/ForkTestBase.t.sol index 6caf971..ef4b15a 100644 --- a/test/mainnet-fork/ForkTestBase.t.sol +++ b/test/mainnet-fork/ForkTestBase.t.sol @@ -81,8 +81,8 @@ contract ForkTestBase is DssTest { 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 = makeAddr("freezer"); - address relayer = makeAddr("relayer"); + address freezer = Ethereum.ALM_FREEZER; + address relayer = Ethereum.ALM_RELAYER; bytes32 CONTROLLER; bytes32 FREEZER; diff --git a/test/mainnet-fork/InitAndUpgrade.t.sol b/test/mainnet-fork/InitAndUpgrade.t.sol index ec5220f..7a6792c 100644 --- a/test/mainnet-fork/InitAndUpgrade.t.sol +++ b/test/mainnet-fork/InitAndUpgrade.t.sol @@ -37,6 +37,10 @@ contract LibraryWrapper { Init.upgradeController(controllerInst, configAddresses, checkAddresses, mintRecipients); } + function pauseProxyInitAlmSystem(address psm, address almProxy) external { + Init.pauseProxyInitAlmSystem(psm, almProxy); + } + } contract MainnetControllerInitAndUpgradeTestBase is ForkTestBase { @@ -320,10 +324,6 @@ contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgrade return 21430000; // Dec 18, 2024 } - /**********************************************************************************************/ - /*** Old controller role check tests ***/ - /**********************************************************************************************/ - function test_upgrade_oldControllerZeroAddress() external { configAddresses.oldController = address(0); @@ -370,261 +370,210 @@ contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgrade } -// // Added this function to ensure that all the failure modes from `subDaoInitController` -// // are also covered by `subDaoInitFull` calls -// function _checkInitAndUpgradeFail(bytes memory expectedError) internal { -// vm.expectRevert(expectedError); -// wrapper.initAlmSystem( -// vault, -// address(usds), -// controllerInst, -// configAddresses, -// checkAddresses, -// mintRecipients -// ); - -// vm.expectRevert(expectedError); -// wrapper.upgradeController( -// controllerInst, -// configAddresses, -// checkAddresses, -// mintRecipients -// ); -// } - -// // function _checkInitAndUpgradeSucceed() internal { -// // wrapper.subDaoInitController( -// // configAddresses, -// // checkAddresses, -// // controllerInst, -// // mintRecipients -// // ); - -// // wrapper.subDaoInitFull( -// // configAddresses, -// // checkAddresses, -// // controllerInst, -// // mintRecipients -// // ); -// // } -// } - -// contract MainnetControllerDeployAndInitSuccessTests is MainnetControllerDeployInitTestBase { - -// function test_deployAllAndInitFull() external { -// // Perform new deployments against existing fork environment - -// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( -// SPARK_PROXY, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER, -// address(susds) -// ); - -// // Overwrite storage for all previous deployments in setUp and assert deployment - -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// mainnetController = MainnetController(controllerInst.controller); -// rateLimits = RateLimits(controllerInst.rateLimits); - -// assertEq(almProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); -// assertEq(mainnetController.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); -// assertEq(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); - -// assertEq(address(mainnetController.proxy()), controllerInst.almProxy); -// assertEq(address(mainnetController.rateLimits()), controllerInst.rateLimits); -// assertEq(address(mainnetController.vault()), vault); -// assertEq(address(mainnetController.buffer()), buffer); -// assertEq(address(mainnetController.psm()), PSM); -// assertEq(address(mainnetController.daiUsds()), DAI_USDS); -// assertEq(address(mainnetController.cctp()), CCTP_MESSENGER); -// assertEq(address(mainnetController.susds()), address(susds)); -// assertEq(address(mainnetController.dai()), address(dai)); -// assertEq(address(mainnetController.usdc()), address(usdc)); -// assertEq(address(mainnetController.usds()), address(usds)); - -// assertEq(mainnetController.psmTo18ConversionFactor(), 1e12); -// assertEq(mainnetController.active(), true); - -// // Perform SubDAO initialization (from SPARK_PROXY during spell) -// // Setting rate limits to different values from setUp to make assertions more robust - -// ( -// Init.ConfigAddressParams memory configAddresses, -// Init.CheckAddressParams memory checkAddresses, -// MintRecipient[] memory mintRecipients -// ) = _getDefaultParams(); - -// vm.startPrank(SPARK_PROXY); -// Init.subDaoInitFull( -// configAddresses, -// checkAddresses, -// controllerInst, -// mintRecipients -// ); -// vm.stopPrank(); - -// // Assert SubDAO initialization - -// assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); -// assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); - -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); - -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); - -// assertEq( -// mainnetController.mintRecipients(mintRecipients[0].domain), -// mintRecipients[0].mintRecipient -// ); - -// assertEq( -// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), -// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) -// ); - -// assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 1); - -// assertEq(usds.allowance(buffer, controllerInst.almProxy), type(uint256).max); - -// // Perform Maker initialization (from PAUSE_PROXY during spell) - -// vm.startPrank(PAUSE_PROXY); -// Init.pauseProxyInit(PSM, controllerInst.almProxy); -// vm.stopPrank(); - -// // Assert Maker initialization - -// assertEq(IPSMLike(PSM).bud(controllerInst.almProxy), 1); -// } - -// function test_deployAllAndInitController() external { -// // Perform new deployments against existing fork environment - -// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( -// SPARK_PROXY, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER, -// address(susds) -// ); - -// // Overwrite storage for all previous deployments in setUp and assert deployment - -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// mainnetController = MainnetController(controllerInst.controller); -// rateLimits = RateLimits(controllerInst.rateLimits); - -// ( -// Init.ConfigAddressParams memory configAddresses, -// Init.CheckAddressParams memory checkAddresses, -// MintRecipient[] memory mintRecipients -// ) = _getDefaultParams(); - -// // Perform ONLY controller initialization, setting rate limits and updating ACL -// // Setting rate limits to different values from setUp to make assertions more robust - -// vm.startPrank(SPARK_PROXY); -// Init.subDaoInitController( -// configAddresses, -// checkAddresses, -// controllerInst, -// mintRecipients -// ); -// vm.stopPrank(); - -// assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); -// assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); - -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); - -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); - -// assertEq( -// mainnetController.mintRecipients(mintRecipients[0].domain), -// mintRecipients[0].mintRecipient -// ); - -// assertEq( -// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), -// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) -// ); -// } - -// function test_init_transferAclToNewController_Test() public { -// // Deploy and init a controller - -// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( -// SPARK_PROXY, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER, -// address(susds) -// ); - -// ( -// Init.ConfigAddressParams memory configAddresses, -// Init.CheckAddressParams memory checkAddresses, -// MintRecipient[] memory mintRecipients -// ) = _getDefaultParams(); - -// vm.startPrank(SPARK_PROXY); -// Init.subDaoInitController( -// configAddresses, -// checkAddresses, -// controllerInst, -// mintRecipients -// ); -// vm.stopPrank(); - -// // Deploy a new controller (example of how an upgrade would work) - -// address newController = MainnetControllerDeploy.deployController( -// SPARK_PROXY, -// controllerInst.almProxy, -// controllerInst.rateLimits, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER, -// address(susds) -// ); - -// // Overwrite storage for all previous deployments in setUp and assert deployment - -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// mainnetController = MainnetController(controllerInst.controller); -// rateLimits = RateLimits(controllerInst.rateLimits); - -// address oldController = address(controllerInst.controller); - -// controllerInst.controller = newController; // Overwrite struct for param - -// // All other info is the same, just need to transfer ACL -// configAddresses.oldController = oldController; - -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); - -// vm.startPrank(SPARK_PROXY); -// Init.subDaoInitController( -// configAddresses, -// checkAddresses, -// controllerInst, -// mintRecipients -// ); -// vm.stopPrank(); - -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); -// } - -// } \ No newline at end of file +contract MainnetControllerInitAlmSystemSuccessTests is MainnetControllerInitAndUpgradeTestBase { + + LibraryWrapper wrapper; + + ControllerInstance public controllerInst; + + address public mismatchAddress = makeAddr("mismatchAddress"); + + Init.ConfigAddressParams configAddresses; + Init.CheckAddressParams checkAddresses; + Init.MintRecipient[] mintRecipients; + + function setUp() public override { + super.setUp(); + + controllerInst = MainnetControllerDeploy.deployFull( + Ethereum.SPARK_PROXY, + Ethereum.ALLOCATOR_VAULT, + Ethereum.PSM, + Ethereum.DAI_USDS, + Ethereum.CCTP_TOKEN_MESSENGER + ); + + // Overwrite storage for all previous deployments in setUp and assert brand new deployment + mainnetController = MainnetController(controllerInst.controller); + almProxy = ALMProxy(payable(controllerInst.almProxy)); + rateLimits = RateLimits(controllerInst.rateLimits); + vault = Ethereum.ALLOCATOR_VAULT; // Use mainnet vault + buffer = Ethereum.ALLOCATOR_BUFFER; // Use mainnet buffer + + Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); + + ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); + + mintRecipients.push(mintRecipients_[0]); + + // Admin will be calling the library from its own address + vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); + + wrapper = LibraryWrapper(SPARK_PROXY); + } + + function _getBlock() internal pure override returns (uint256) { + return 21430000; // Dec 18, 2024 + } + + function test_initAlmSystem() public { + assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), false); + assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), false); + + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), false); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), false); + + assertEq(mainnetController.mintRecipients(mintRecipients[0].domain), bytes32(0)); + assertEq(mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), bytes32(0)); + + assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 0); + assertEq(usds.allowance(buffer, controllerInst.almProxy), 0); + + vm.startPrank(SPARK_PROXY); + wrapper.initAlmSystem( + Ethereum.ALLOCATOR_VAULT, + Ethereum.USDS, + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); + assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); + + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); + + assertEq( + mainnetController.mintRecipients(mintRecipients[0].domain), + mintRecipients[0].mintRecipient + ); + + assertEq( + mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), + bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) + ); + + assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 1); + assertEq(usds.allowance(buffer, controllerInst.almProxy), type(uint256).max); + } + + function test_pauseProxyInitAlmSystem() public { + // Update to call the library from the pause proxy + vm.etch(PAUSE_PROXY, address(new LibraryWrapper()).code); + wrapper = LibraryWrapper(PAUSE_PROXY); + + assertEq(IPSMLike(Ethereum.PSM).bud(controllerInst.almProxy), 0); + + vm.startPrank(PAUSE_PROXY); + wrapper.pauseProxyInitAlmSystem(Ethereum.PSM, controllerInst.almProxy); + vm.stopPrank(); + + assertEq(IPSMLike(Ethereum.PSM).bud(controllerInst.almProxy), 1); + } + +} + +contract MainnetControllerUpgradeControllerSuccessTests is MainnetControllerInitAndUpgradeTestBase { + + LibraryWrapper wrapper; + + ControllerInstance public controllerInst; + + address public mismatchAddress = makeAddr("mismatchAddress"); + + Init.ConfigAddressParams configAddresses; + Init.CheckAddressParams checkAddresses; + Init.MintRecipient[] mintRecipients; + + MainnetController newController; + + function setUp() public override { + super.setUp(); + + // Upgrade against mainnet contracts + controllerInst = ControllerInstance({ + almProxy : Ethereum.ALM_PROXY, + controller : Ethereum.ALM_CONTROLLER, + rateLimits : Ethereum.ALM_RATE_LIMITS + }); + + // Overwrite storage for all previous deployments in setUp and assert brand new deployment + mainnetController = MainnetController(controllerInst.controller); + almProxy = ALMProxy(payable(controllerInst.almProxy)); + rateLimits = RateLimits(controllerInst.rateLimits); + vault = Ethereum.ALLOCATOR_VAULT; // Use mainnet vault + buffer = Ethereum.ALLOCATOR_BUFFER; // Use mainnet buffer + + Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); + + ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); + + mintRecipients.push(mintRecipients_[0]); + + newController = MainnetController(MainnetControllerDeploy.deployController({ + admin : Ethereum.SPARK_PROXY, + almProxy : Ethereum.ALM_PROXY, + rateLimits : Ethereum.ALM_RATE_LIMITS, + vault : Ethereum.ALLOCATOR_VAULT, + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER + })); + + controllerInst.controller = address(newController); // Upgrade to new controller + configAddresses.oldController = Ethereum.ALM_CONTROLLER; // Revoke from old controller + + // Admin will be calling the library from its own address + vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); + + wrapper = LibraryWrapper(SPARK_PROXY); + } + + function _getBlock() internal pure override returns (uint256) { + return 21430000; // Dec 18, 2024 + } + + function test_upgradeController() public { + assertEq(newController.hasRole(newController.FREEZER(), freezer), false); + assertEq(newController.hasRole(newController.RELAYER(), relayer), false); + + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); + + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(newController)), false); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(newController)), false); + + assertEq(newController.mintRecipients(mintRecipients[0].domain), bytes32(0)); + assertEq(newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), bytes32(0)); + + vm.startPrank(SPARK_PROXY); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + assertEq(newController.hasRole(newController.FREEZER(), freezer), true); + assertEq(newController.hasRole(newController.RELAYER(), relayer), true); + + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), false); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), false); + + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(newController)), true); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(newController)), true); + + assertEq( + newController.mintRecipients(mintRecipients[0].domain), + mintRecipients[0].mintRecipient + ); + + assertEq( + newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), + bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) + ); + } + +} \ No newline at end of file From c43db387acaa406f6a178a5905c9f1b9fbb6a194 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 11:07:24 -0500 Subject: [PATCH 06/33] feat: update foreign controller init lib --- deploy/ForeignControllerInit.sol | 217 +++++++++++++------------------ lib/spark-address-registry | 2 +- 2 files changed, 89 insertions(+), 130 deletions(-) diff --git a/deploy/ForeignControllerInit.sol b/deploy/ForeignControllerInit.sol index 11c7460..cabd86f 100644 --- a/deploy/ForeignControllerInit.sol +++ b/deploy/ForeignControllerInit.sol @@ -1,180 +1,139 @@ // SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity >=0.8.0; -import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; - import { ForeignController } from "../src/ForeignController.sol"; -import { MainnetController } from "../src/MainnetController.sol"; -import { RateLimitHelpers } from "../src/RateLimitHelpers.sol"; import { IALMProxy } from "../src/interfaces/IALMProxy.sol"; import { IRateLimits } from "../src/interfaces/IRateLimits.sol"; import { ControllerInstance } from "./ControllerInstance.sol"; -interface IBufferLike { - function approve(address, address, uint256) external; -} - -interface IPSMLike { - function kiss(address) external; -} - -interface IPSM3Like { - function totalAssets() external view returns (uint256); - function totalShares() external view returns (uint256); - function usdc() external view returns (address); - function usds() external view returns (address); - function susds() external view returns (address); -} - -interface IVaultLike { - function rely(address) external; -} - -struct RateLimitData { - uint256 maxAmount; - uint256 slope; -} +library ForeignControllerInit { -struct MintRecipient { - uint32 domain; - bytes32 mintRecipient; -} + /**********************************************************************************************/ + /*** Structs and constants ***/ + /**********************************************************************************************/ -library ForeignControllerInit { + struct CheckAddressParams { + address psm; + address usdc; + address cctp; + } - struct AddressParams { - address admin; + struct ConfigAddressParams { address freezer; address relayer; address oldController; - address psm; - address cctpMessenger; - address usdc; - address usds; - address susds; + } + + struct MintRecipient { + uint32 domain; + bytes32 mintRecipient; } bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; - struct InitRateLimitData { - RateLimitData usdcDepositData; - RateLimitData usdcWithdrawData; - RateLimitData usdsDepositData; - RateLimitData usdsWithdrawData; - RateLimitData susdsDepositData; - RateLimitData susdsWithdrawData; - RateLimitData usdcToCctpData; - RateLimitData cctpToEthereumDomainData; + /**********************************************************************************************/ + /*** Internal library functions ***/ + /**********************************************************************************************/ + + function initAlmSystem( + ControllerInstance memory controllerInst, + ConfigAddressParams memory configAddresses, + CheckAddressParams memory checkAddresses, + MintRecipient[] memory mintRecipients + ) + internal + { + // Step 1: Do sanity checks outside of the controller + + require(IALMProxy(controllerInst.almProxy).hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "ForeignControllerInit/incorrect-admin-almProxy"); + require(IRateLimits(controllerInst.rateLimits).hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "ForeignControllerInit/incorrect-admin-rateLimits"); + + // Step 2: Initialize the controller + + _initController(controllerInst, configAddresses, checkAddresses, mintRecipients); } - function init( - AddressParams memory addresses, - ControllerInstance memory controllerInst, - InitRateLimitData memory data, - MintRecipient[] memory mintRecipients + function upgradeController( + ControllerInstance memory controllerInst, + ConfigAddressParams memory configAddresses, + CheckAddressParams memory checkAddresses, + MintRecipient[] memory mintRecipients ) internal { + _initController(controllerInst, configAddresses, checkAddresses, mintRecipients); + IALMProxy almProxy = IALMProxy(controllerInst.almProxy); IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); - ForeignController controller = ForeignController(controllerInst.controller); + require(configAddresses.oldController != address(0), "ForeignControllerInit/old-controller-zero-address"); - require(almProxy.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-almProxy"); - require(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-rateLimits"); - require(controller.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-controller"); + require(almProxy.hasRole(almProxy.CONTROLLER(), configAddresses.oldController), "ForeignControllerInit/old-controller-not-almProxy-controller"); + require(rateLimits.hasRole(rateLimits.CONTROLLER(), configAddresses.oldController), "ForeignControllerInit/old-controller-not-rateLimits-controller"); - require(address(controller.proxy()) == controllerInst.almProxy, "ForeignControllerInit/incorrect-almProxy"); - require(address(controller.rateLimits()) == controllerInst.rateLimits, "ForeignControllerInit/incorrect-rateLimits"); - require(address(controller.psm()) == addresses.psm, "ForeignControllerInit/incorrect-psm"); - require(address(controller.usdc()) == addresses.usdc, "ForeignControllerInit/incorrect-usdc"); - require(address(controller.cctp()) == addresses.cctpMessenger, "ForeignControllerInit/incorrect-cctp"); + almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); + rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); + } - require(controller.active(), "ForeignControllerInit/controller-not-active"); + /**********************************************************************************************/ + /*** Private helper functions ***/ + /**********************************************************************************************/ - require(addresses.oldController != address(controller), "ForeignControllerInit/old-controller-is-new-controller"); + function _initController( + ControllerInstance memory controllerInst, + ConfigAddressParams memory configAddresses, + CheckAddressParams memory checkAddresses, + MintRecipient[] memory mintRecipients + ) + private + { + // Step 1: Perform controller sanity checks - IPSM3Like psm = IPSM3Like(addresses.psm); + ForeignController newController = ForeignController(controllerInst.controller); - require(psm.totalAssets() >= 1e18, "ForeignControllerInit/psm-totalAssets-not-seeded"); - require(psm.totalShares() >= 1e18, "ForeignControllerInit/psm-totalShares-not-seeded"); + require(newController.hasRole(DEFAULT_ADMIN_ROLE, checkAddresses.admin), "ForeignControllerInit/incorrect-admin-controller"); - require(psm.usdc() == addresses.usdc, "ForeignControllerInit/psm-incorrect-usdc"); - require(psm.usds() == addresses.usds, "ForeignControllerInit/psm-incorrect-usds"); - require(psm.susds() == addresses.susds, "ForeignControllerInit/psm-incorrect-susds"); + require(address(newController.proxy()) == controllerInst.almProxy, "ForeignControllerInit/incorrect-almProxy"); + require(address(newController.rateLimits()) == controllerInst.rateLimits, "ForeignControllerInit/incorrect-rateLimits"); - // Step 1: Configure ACL permissions for controller and almProxy + require(address(controller.psm()) == checkAddresses.psm, "ForeignControllerInit/incorrect-psm"); + require(address(controller.usdc()) == checkAddresses.usdc, "ForeignControllerInit/incorrect-usdc"); + require(address(controller.cctp()) == checkAddresses.cctp, "ForeignControllerInit/incorrect-cctp"); - controller.grantRole(controller.FREEZER(), addresses.freezer); - controller.grantRole(controller.RELAYER(), addresses.relayer); + require(newController.psmTo18ConversionFactor() == 1e12, "ForeignControllerInit/incorrect-psmTo18ConversionFactor"); + require(newController.active(), "ForeignControllerInit/controller-not-active"); - almProxy.grantRole(almProxy.CONTROLLER(), address(controller)); - rateLimits.grantRole(rateLimits.CONTROLLER(), address(controller)); + require(configAddresses.oldController != address(newController), "ForeignControllerInit/old-controller-is-new-controller"); - if (addresses.oldController != address(0)) { - require(almProxy.hasRole(almProxy.CONTROLLER(), addresses.oldController) == true, "ForeignControllerInit/old-controller-not-almProxy-controller"); - require(rateLimits.hasRole(rateLimits.CONTROLLER(), addresses.oldController) == true, "ForeignControllerInit/old-controller-not-rateLimits-controller"); + // Step 2: Perform PSM sanity checks - almProxy.revokeRole(almProxy.CONTROLLER(), addresses.oldController); - rateLimits.revokeRole(rateLimits.CONTROLLER(), addresses.oldController); - } + IPSM3Like psm = IPSM3Like(addresses.psm); - // Step 2: Configure all rate limits for controller + require(psm.totalAssets() >= 1e18, "ForeignControllerInit/psm-totalAssets-not-seeded"); + require(psm.totalShares() >= 1e18, "ForeignControllerInit/psm-totalShares-not-seeded"); - bytes32 depositKey = controller.LIMIT_PSM_DEPOSIT(); - bytes32 withdrawKey = controller.LIMIT_PSM_WITHDRAW(); + require(psm.usdc() == addresses.usdc, "ForeignControllerInit/psm-incorrect-usdc"); + require(psm.usds() == addresses.usds, "ForeignControllerInit/psm-incorrect-usds"); + require(psm.susds() == addresses.susds, "ForeignControllerInit/psm-incorrect-susds"); - bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( - controller.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM - ); + // Step 3: Configure ACL permissions controller, almProxy, and rateLimits - setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.usdc), rateLimits, data.usdcDepositData, "usdcDepositData", 6); - setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.usdc), rateLimits, data.usdcWithdrawData, "usdcWithdrawData", 6); - setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.usds), rateLimits, data.usdsDepositData, "usdsDepositData", 18); - setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.usds), rateLimits, data.usdsWithdrawData, "usdsWithdrawData", 18); - setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.susds), rateLimits, data.susdsDepositData, "susdsDepositData", 18); - setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.susds), rateLimits, data.susdsWithdrawData, "susdsWithdrawData", 18); + IALMProxy almProxy = IALMProxy(controllerInst.almProxy); + IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); - setRateLimitData(controller.LIMIT_USDC_TO_CCTP(), rateLimits, data.usdcToCctpData, "usdcToCctpData", 6); - setRateLimitData(domainKeyEthereum, rateLimits, data.cctpToEthereumDomainData, "cctpToEthereumDomainData", 6); + newController.grantRole(newController.FREEZER(), configAddresses.freezer); + newController.grantRole(newController.RELAYER(), configAddresses.relayer); - // Step 3: Configure the mint recipients on other domains + almProxy.grantRole(almProxy.CONTROLLER(), address(newController)); + rateLimits.grantRole(rateLimits.CONTROLLER(), address(newController)); - for (uint256 i = 0; i < mintRecipients.length; i++) { - controller.setMintRecipient(mintRecipients[i].domain, mintRecipients[i].mintRecipient); - } - } + // Step 4: Configure the mint recipients on other domains - function setRateLimitData( - bytes32 key, - IRateLimits rateLimits, - RateLimitData memory data, - string memory name, - uint256 decimals - ) - internal - { - // Handle setting an unlimited rate limit - if (data.maxAmount == type(uint256).max) { - require( - data.slope == 0, - string(abi.encodePacked("ForeignControllerInit/invalid-rate-limit-", name)) - ); - } - else { - require( - data.maxAmount <= 1e12 * (10 ** decimals), - string(abi.encodePacked("ForeignControllerInit/invalid-max-amount-precision-", name)) - ); - require( - data.slope <= 1e12 * (10 ** decimals) / 1 hours, - string(abi.encodePacked("ForeignControllerInit/invalid-slope-precision-", name)) - ); + for (uint256 i = 0; i < mintRecipients.length; i++) { + newController.setMintRecipient(mintRecipients[i].domain, mintRecipients[i].mintRecipient); } - rateLimits.setRateLimitData(key, data.maxAmount, data.slope); } -} +} \ No newline at end of file diff --git a/lib/spark-address-registry b/lib/spark-address-registry index 399e26d..0894d15 160000 --- a/lib/spark-address-registry +++ b/lib/spark-address-registry @@ -1 +1 @@ -Subproject commit 399e26da866f3182fd40e67ad6cdc42fc7b1723f +Subproject commit 0894d151cab9cc50dcf49c4c32e6469b16b391a1 From 73929d8a0d646bbed210ea374f5fc93b92fc8e38 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 11:12:02 -0500 Subject: [PATCH 07/33] test: add deploy tests --- test/base-fork/Deploy.t.sol | 58 +++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 test/base-fork/Deploy.t.sol diff --git a/test/base-fork/Deploy.t.sol b/test/base-fork/Deploy.t.sol new file mode 100644 index 0000000..b0346b3 --- /dev/null +++ b/test/base-fork/Deploy.t.sol @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity >=0.8.0; + +import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; +import { ForeignControllerDeploy } from "../../deploy/ControllerDeploy.sol"; + +import "./ForkTestBase.t.sol"; + +contract ForeignControllerDeploySuccessTests is ForkTestBase { + + function test_deployFull() external { + // Perform new deployments against existing fork environment + + ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull({ + admin : Base.SPARK_EXECUTOR, + psm : Base.PSM3, + usdc : Base.USDC, + cctp : Base.CCTP_TOKEN_MESSENGER + }); + + ALMProxy newAlmProxy = ALMProxy(payable(controllerInst.almProxy)); + ForeignController newController = ForeignController(controllerInst.controller); + RateLimits newRateLimits = RateLimits(controllerInst.rateLimits); + + assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR), true); + assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR), true); + + _assertControllerInitState(newController, address(newAlmProxy), address(newRateLimits)); + } + + function test_deployController() external { + // Perform new deployments against existing fork environment + + ForeignController newController = ForeignController(ForeignControllerDeploy.deployController({ + admin : Base.SPARK_EXECUTOR, + almProxy : address(almProxy), + rateLimits : address(rateLimits), + psm : Base.PSM3, + usdc : Base.USDC, + cctp : Base.CCTP_TOKEN_MESSENGER + })); + + _assertControllerInitState(newController, address(almProxy), address(rateLimits)); + } + + function _assertControllerInitState(ForeignController controller, address almProxy, address rateLimits) internal view { + assertEq(controller.hasRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR), true); + + assertEq(address(controller.proxy()), almProxy); + assertEq(address(controller.rateLimits()), rateLimits); + assertEq(address(controller.psm()), Base.PSM3); + assertEq(address(controller.usdc()), Base.USDC); + assertEq(address(controller.cctp()), Base.CCTP_TOKEN_MESSENGER); + + assertEq(controller.active(), true); + } + +} From 3bb71ee03d24616f612a7ee34147a81ad36b78e9 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 11:27:56 -0500 Subject: [PATCH 08/33] test: get init tests set up --- deploy/ForeignControllerInit.sol | 30 +- test/base-fork/InitAndUpgrade.t.sol | 569 ++++++++++++++++++++++++++++ 2 files changed, 589 insertions(+), 10 deletions(-) create mode 100644 test/base-fork/InitAndUpgrade.t.sol diff --git a/deploy/ForeignControllerInit.sol b/deploy/ForeignControllerInit.sol index cabd86f..ff390b4 100644 --- a/deploy/ForeignControllerInit.sol +++ b/deploy/ForeignControllerInit.sol @@ -8,6 +8,14 @@ import { IRateLimits } from "../src/interfaces/IRateLimits.sol"; import { ControllerInstance } from "./ControllerInstance.sol"; +interface IPSM3Like { + function susds() external view returns (address); + function totalAssets() external view returns (uint256); + function totalShares() external view returns (uint256); + function usdc() external view returns (address); + function usds() external view returns (address); +} + library ForeignControllerInit { /**********************************************************************************************/ @@ -15,9 +23,12 @@ library ForeignControllerInit { /**********************************************************************************************/ struct CheckAddressParams { + address admin; address psm; - address usdc; address cctp; + address usdc; + address susds; + address usds; } struct ConfigAddressParams { @@ -98,25 +109,24 @@ library ForeignControllerInit { require(address(newController.proxy()) == controllerInst.almProxy, "ForeignControllerInit/incorrect-almProxy"); require(address(newController.rateLimits()) == controllerInst.rateLimits, "ForeignControllerInit/incorrect-rateLimits"); - require(address(controller.psm()) == checkAddresses.psm, "ForeignControllerInit/incorrect-psm"); - require(address(controller.usdc()) == checkAddresses.usdc, "ForeignControllerInit/incorrect-usdc"); - require(address(controller.cctp()) == checkAddresses.cctp, "ForeignControllerInit/incorrect-cctp"); + require(address(newController.psm()) == checkAddresses.psm, "ForeignControllerInit/incorrect-psm"); + require(address(newController.usdc()) == checkAddresses.usdc, "ForeignControllerInit/incorrect-usdc"); + require(address(newController.cctp()) == checkAddresses.cctp, "ForeignControllerInit/incorrect-cctp"); - require(newController.psmTo18ConversionFactor() == 1e12, "ForeignControllerInit/incorrect-psmTo18ConversionFactor"); - require(newController.active(), "ForeignControllerInit/controller-not-active"); + require(newController.active(), "ForeignControllerInit/controller-not-active"); require(configAddresses.oldController != address(newController), "ForeignControllerInit/old-controller-is-new-controller"); // Step 2: Perform PSM sanity checks - IPSM3Like psm = IPSM3Like(addresses.psm); + IPSM3Like psm = IPSM3Like(checkAddresses.psm); require(psm.totalAssets() >= 1e18, "ForeignControllerInit/psm-totalAssets-not-seeded"); require(psm.totalShares() >= 1e18, "ForeignControllerInit/psm-totalShares-not-seeded"); - require(psm.usdc() == addresses.usdc, "ForeignControllerInit/psm-incorrect-usdc"); - require(psm.usds() == addresses.usds, "ForeignControllerInit/psm-incorrect-usds"); - require(psm.susds() == addresses.susds, "ForeignControllerInit/psm-incorrect-susds"); + require(psm.usdc() == checkAddresses.usdc, "ForeignControllerInit/psm-incorrect-usdc"); + require(psm.usds() == checkAddresses.usds, "ForeignControllerInit/psm-incorrect-usds"); + require(psm.susds() == checkAddresses.susds, "ForeignControllerInit/psm-incorrect-susds"); // Step 3: Configure ACL permissions controller, almProxy, and rateLimits diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/base-fork/InitAndUpgrade.t.sol new file mode 100644 index 0000000..2686791 --- /dev/null +++ b/test/base-fork/InitAndUpgrade.t.sol @@ -0,0 +1,569 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity >=0.8.0; + +import "../../test/base-fork/ForkTestBase.t.sol"; + +import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; + +import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; +import { ForeignControllerDeploy } from "../../deploy/ControllerDeploy.sol"; + +import { ForeignControllerInit as Init } from "../../deploy/ForeignControllerInit.sol"; + +// Necessary to get error message assertions to work +contract LibraryWrapper { + + function initAlmSystem( + ControllerInstance memory controllerInst, + Init.ConfigAddressParams memory configAddresses, + Init.CheckAddressParams memory checkAddresses, + Init.MintRecipient[] memory mintRecipients + ) + external + { + Init.initAlmSystem(controllerInst, configAddresses, checkAddresses, mintRecipients); + } + + function upgradeController( + ControllerInstance memory controllerInst, + Init.ConfigAddressParams memory configAddresses, + Init.CheckAddressParams memory checkAddresses, + Init.MintRecipient[] memory mintRecipients + ) + external + { + Init.upgradeController(controllerInst, configAddresses, checkAddresses, mintRecipients); + } + +} + +contract ForeignControllerInitAndUpgradeTestBase is ForkTestBase { + + function _getDefaultParams() + internal returns ( + Init.ConfigAddressParams memory configAddresses, + Init.CheckAddressParams memory checkAddresses, + Init.MintRecipient[] memory mintRecipients + ) + { + configAddresses = Init.ConfigAddressParams({ + freezer : freezer, + relayer : relayer, + oldController : address(0) + }); + + checkAddresses = Init.CheckAddressParams({ + admin : Base.SPARK_EXECUTOR, + psm : Base.PSM3, + cctp : Base.CCTP_TOKEN_MESSENGER, + usdc : Base.USDS, + susds : Base.SUSDS, + usds : Base.USDC + }); + + mintRecipients = new Init.MintRecipient[](1); + + mintRecipients[0] = Init.MintRecipient({ + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + mintRecipient : bytes32(uint256(uint160(makeAddr("mainnetAlmProxy")))) + }); + } + +} + +contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTestBase { + + LibraryWrapper wrapper; + + ControllerInstance public controllerInst; + + address public mismatchAddress = makeAddr("mismatchAddress"); + + Init.ConfigAddressParams configAddresses; + Init.CheckAddressParams checkAddresses; + Init.MintRecipient[] mintRecipients; + + function setUp() public override { + super.setUp(); + + // Deploy new controller against live mainnet system + // NOTE: initAlmSystem will redundantly call rely and approve on already inited + // almProxy and rateLimits, this setup was chosen to easily test upgrade and init failures + foreignController = ForeignController(ForeignControllerDeploy.deployController({ + admin : Base.SPARK_EXECUTOR, + almProxy : address(almProxy), + rateLimits : address(rateLimits), + psm : Base.PSM3, + usdc : Base.USDC, + cctp : Base.CCTP_TOKEN_MESSENGER + })); + + almProxy = ALMProxy(payable(Base.ALM_PROXY)); + rateLimits = RateLimits(Base.ALM_RATE_LIMITS); + + Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); + + ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); + + // NOTE: This would need to be refactored to a for loop if more than one recipient + mintRecipients.push(mintRecipients_[0]); + + controllerInst = ControllerInstance({ + almProxy : Base.ALM_PROXY, + controller : address(foreignController), + rateLimits : Base.ALM_RATE_LIMITS + }); + + // Admin will be calling the library from its own address + vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); + + wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); + } + + function _getBlock() internal pure override returns (uint256) { + return 23900000; // Dec 19, 2024 + } + + /**********************************************************************************************/ + /*** ACL tests ***/ + /**********************************************************************************************/ + + function test_init_incorrectAdminAlmProxy() external { + // Isolate different contracts instead of setting param so can get three different failures + vm.startPrank(Base.SPARK_EXECUTOR); + almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + almProxy.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); + vm.stopPrank(); + + vm.expectRevert("ForeignControllerInit/incorrect-admin-almProxy"); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + // function test_init_incorrectAdminRateLimits() external { + // // Isolate different contracts instead of setting param so can get three different failures + // vm.startPrank(Base.SPARK_EXECUTOR); + // rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + // rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); + // vm.stopPrank(); + + // vm.expectRevert("ForeignControllerInit/incorrect-admin-rateLimits"); + // wrapper.initAlmSystem( + // vault, + // address(usds), + // controllerInst, + // configAddresses, + // checkAddresses, + // mintRecipients + // ); + // } + + // function test_init_incorrectAdminController() external { + // // Isolate different contracts instead of setting param so can get three different failures + // vm.startPrank(Base.SPARK_EXECUTOR); + // foreignController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + // foreignController.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); + // vm.stopPrank(); + + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-admin-controller")); + // } + + // /**********************************************************************************************/ + // /*** Constructor tests ***/ + // /**********************************************************************************************/ + + // function test_init_incorrectAlmProxy() external { + // // Deploy new address that will not EVM revert on OZ ACL check + // controllerInst.almProxy = address(new ALMProxy(Base.SPARK_EXECUTOR)); + + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-almProxy")); + // } + + // function test_init_incorrectRateLimits() external { + // // Deploy new address that will not EVM revert on OZ ACL check + // controllerInst.rateLimits = address(new RateLimits(Base.SPARK_EXECUTOR)); + + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-rateLimits")); + // } + + // function test_init_incorrectVault() external { + // checkAddresses.vault = mismatchAddress; + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-vault")); + // } + + // function test_init_incorrectPsm() external { + // checkAddresses.psm = mismatchAddress; + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-psm")); + // } + + // function test_init_incorrectDaiUsds() external { + // checkAddresses.daiUsds = mismatchAddress; + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-daiUsds")); + // } + + // function test_init_incorrectCctp() external { + // checkAddresses.cctp = mismatchAddress; + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-cctp")); + // } + + // function test_init_controllerInactive() external { + // // Cheating to set this outside of init scripts so that the controller can be frozen + // vm.startPrank(Base.SPARK_EXECUTOR); + // foreignController.grantRole(FREEZER, freezer); + + // vm.startPrank(freezer); + // foreignController.freeze(); + // vm.stopPrank(); + + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/controller-not-active")); + // } + + // function test_init_oldControllerIsNewController() external { + // configAddresses.oldController = controllerInst.controller; + // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/old-controller-is-new-controller")); + // } + + // function test_init_vaultMismatch() external { + // vault = mismatchAddress; + + // vm.expectRevert("ForeignControllerInit/incorrect-vault"); + // wrapper.initAlmSystem( + // vault, + // address(usds), + // controllerInst, + // configAddresses, + // checkAddresses, + // mintRecipients + // ); + // } + + // function _checkInitAndUpgradeFail(bytes memory expectedError) internal { + // vm.expectRevert(expectedError); + // wrapper.initAlmSystem( + // vault, + // address(usds), + // controllerInst, + // configAddresses, + // checkAddresses, + // mintRecipients + // ); + + // vm.expectRevert(expectedError); + // wrapper.upgradeController( + // controllerInst, + // configAddresses, + // checkAddresses, + // mintRecipients + // ); + // } + +} + +// contract ForeignControllerUpgradeFailureTests is ForeignControllerInitAndUpgradeTestBase { + +// LibraryWrapper wrapper; + +// ControllerInstance public controllerInst; + +// address public mismatchAddress = makeAddr("mismatchAddress"); + +// Init.ConfigAddressParams configAddresses; +// Init.CheckAddressParams checkAddresses; +// Init.MintRecipient[] mintRecipients; + +// function setUp() public override { +// super.setUp(); + +// // Deploy new controller against live mainnet system +// controllerInst.controller = ForeignControllerDeploy.deployController({ +// admin : Base.Base.SPARK_EXECUTOR, +// almProxy : Base.ALM_PROXY, +// rateLimits : Base.ALM_RATE_LIMITS, +// vault : Base.ALLOCATOR_VAULT, +// psm : Base.PSM, +// daiUsds : Base.DAI_USDS, +// cctp : Base.CCTP_TOKEN_MESSENGER +// }); + +// // Overwrite storage for all previous deployments in setUp and assert deployment +// almProxy = ALMProxy(payable(Base.ALM_PROXY)); +// rateLimits = RateLimits(Base.ALM_RATE_LIMITS); + +// controllerInst.almProxy = address(almProxy); +// controllerInst.rateLimits = address(rateLimits); + +// Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); + +// ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); + +// mintRecipients.push(mintRecipients_[0]); + +// configAddresses.oldController = Base.ALM_CONTROLLER; + +// // Admin will be calling the library from its own address +// vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); + +// wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); +// } + +// function _getBlock() internal pure override returns (uint256) { +// return 21430000; // Dec 18, 2024 +// } + +// function test_upgrade_oldControllerZeroAddress() external { +// configAddresses.oldController = address(0); + +// vm.expectRevert("ForeignControllerInit/old-controller-zero-address"); +// wrapper.upgradeController( +// controllerInst, +// configAddresses, +// checkAddresses, +// mintRecipients +// ); +// } + +// function test_upgrade_oldControllerDoesNotHaveRoleInAlmProxy() external { +// // Revoke the old controller address in ALM proxy +// vm.startPrank(Base.SPARK_EXECUTOR); +// almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); +// vm.stopPrank(); + +// // Try to upgrade with the old controller address that is doesn't have the CONTROLLER role +// vm.expectRevert("ForeignControllerInit/old-controller-not-almProxy-controller"); +// wrapper.upgradeController( +// controllerInst, +// configAddresses, +// checkAddresses, +// mintRecipients +// ); +// } + +// function test_upgrade_oldControllerDoesNotHaveRoleInRateLimits() external { +// // Revoke the old controller address in rate limits +// vm.startPrank(Base.SPARK_EXECUTOR); +// rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); +// vm.stopPrank(); + +// // Try to upgrade with the old controller address that is doesn't have the CONTROLLER role +// vm.expectRevert("ForeignControllerInit/old-controller-not-rateLimits-controller"); +// wrapper.upgradeController( +// controllerInst, +// configAddresses, +// checkAddresses, +// mintRecipients +// ); +// } + +// } + +// contract ForeignControllerInitAlmSystemSuccessTests is ForeignControllerInitAndUpgradeTestBase { + +// LibraryWrapper wrapper; + +// ControllerInstance public controllerInst; + +// address public mismatchAddress = makeAddr("mismatchAddress"); + +// Init.ConfigAddressParams configAddresses; +// Init.CheckAddressParams checkAddresses; +// Init.MintRecipient[] mintRecipients; + +// function setUp() public override { +// super.setUp(); + +// controllerInst = ForeignControllerDeploy.deployFull( +// Base.Base.SPARK_EXECUTOR, +// Base.ALLOCATOR_VAULT, +// Base.PSM, +// Base.DAI_USDS, +// Base.CCTP_TOKEN_MESSENGER +// ); + +// // Overwrite storage for all previous deployments in setUp and assert brand new deployment +// foreignController = ForeignController(controllerInst.controller); +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// rateLimits = RateLimits(controllerInst.rateLimits); +// vault = Base.ALLOCATOR_VAULT; // Use mainnet vault +// buffer = Base.ALLOCATOR_BUFFER; // Use mainnet buffer + +// Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); + +// ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); + +// mintRecipients.push(mintRecipients_[0]); + +// // Admin will be calling the library from its own address +// vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); + +// wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); +// } + +// function _getBlock() internal pure override returns (uint256) { +// return 21430000; // Dec 18, 2024 +// } + +// function test_initAlmSystem() public { +// assertEq(foreignController.hasRole(foreignController.FREEZER(), freezer), false); +// assertEq(foreignController.hasRole(foreignController.RELAYER(), relayer), false); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), false); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), false); + +// assertEq(foreignController.mintRecipients(mintRecipients[0].domain), bytes32(0)); +// assertEq(foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), bytes32(0)); + +// assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 0); +// assertEq(usds.allowance(buffer, controllerInst.almProxy), 0); + +// vm.startPrank(Base.SPARK_EXECUTOR); +// wrapper.initAlmSystem( +// Base.ALLOCATOR_VAULT, +// Base.USDS, +// controllerInst, +// configAddresses, +// checkAddresses, +// mintRecipients +// ); + +// assertEq(foreignController.hasRole(foreignController.FREEZER(), freezer), true); +// assertEq(foreignController.hasRole(foreignController.RELAYER(), relayer), true); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), true); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), true); + +// assertEq( +// foreignController.mintRecipients(mintRecipients[0].domain), +// mintRecipients[0].mintRecipient +// ); + +// assertEq( +// foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), +// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) +// ); + +// assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 1); +// assertEq(usds.allowance(buffer, controllerInst.almProxy), type(uint256).max); +// } + +// function test_pauseProxyInitAlmSystem() public { +// // Update to call the library from the pause proxy +// vm.etch(PAUSE_PROXY, address(new LibraryWrapper()).code); +// wrapper = LibraryWrapper(PAUSE_PROXY); + +// assertEq(IPSMLike(Base.PSM).bud(controllerInst.almProxy), 0); + +// vm.startPrank(PAUSE_PROXY); +// wrapper.pauseProxyInitAlmSystem(Base.PSM, controllerInst.almProxy); +// vm.stopPrank(); + +// assertEq(IPSMLike(Base.PSM).bud(controllerInst.almProxy), 1); +// } + +// } + +// contract ForeignControllerUpgradeControllerSuccessTests is ForeignControllerInitAndUpgradeTestBase { + +// LibraryWrapper wrapper; + +// ControllerInstance public controllerInst; + +// address public mismatchAddress = makeAddr("mismatchAddress"); + +// Init.ConfigAddressParams configAddresses; +// Init.CheckAddressParams checkAddresses; +// Init.MintRecipient[] mintRecipients; + +// ForeignController newController; + +// function setUp() public override { +// super.setUp(); + +// // Upgrade against mainnet contracts +// controllerInst = ControllerInstance({ +// almProxy : Base.ALM_PROXY, +// controller : Base.ALM_CONTROLLER, +// rateLimits : Base.ALM_RATE_LIMITS +// }); + +// // Overwrite storage for all previous deployments in setUp and assert brand new deployment +// foreignController = ForeignController(controllerInst.controller); +// almProxy = ALMProxy(payable(controllerInst.almProxy)); +// rateLimits = RateLimits(controllerInst.rateLimits); +// vault = Base.ALLOCATOR_VAULT; // Use mainnet vault +// buffer = Base.ALLOCATOR_BUFFER; // Use mainnet buffer + +// Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); + +// ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); + +// mintRecipients.push(mintRecipients_[0]); + +// newController = ForeignController(ForeignControllerDeploy.deployController({ +// admin : Base.Base.SPARK_EXECUTOR, +// almProxy : Base.ALM_PROXY, +// rateLimits : Base.ALM_RATE_LIMITS, +// vault : Base.ALLOCATOR_VAULT, +// psm : Base.PSM, +// daiUsds : Base.DAI_USDS, +// cctp : Base.CCTP_TOKEN_MESSENGER +// })); + +// controllerInst.controller = address(newController); // Upgrade to new controller +// configAddresses.oldController = Base.ALM_CONTROLLER; // Revoke from old controller + +// // Admin will be calling the library from its own address +// vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); + +// wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); +// } + +// function _getBlock() internal pure override returns (uint256) { +// return 21430000; // Dec 18, 2024 +// } + +// function test_upgradeController() public { +// assertEq(newController.hasRole(newController.FREEZER(), freezer), false); +// assertEq(newController.hasRole(newController.RELAYER(), relayer), false); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), true); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), true); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(newController)), false); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(newController)), false); + +// assertEq(newController.mintRecipients(mintRecipients[0].domain), bytes32(0)); +// assertEq(newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), bytes32(0)); + +// vm.startPrank(Base.SPARK_EXECUTOR); +// wrapper.upgradeController( +// controllerInst, +// configAddresses, +// checkAddresses, +// mintRecipients +// ); + +// assertEq(newController.hasRole(newController.FREEZER(), freezer), true); +// assertEq(newController.hasRole(newController.RELAYER(), relayer), true); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), false); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), false); + +// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(newController)), true); +// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(newController)), true); + +// assertEq( +// newController.mintRecipients(mintRecipients[0].domain), +// mintRecipients[0].mintRecipient +// ); + +// assertEq( +// newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), +// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) +// ); +// } + +// } \ No newline at end of file From 40ac8e12930eb3ba0aa3f4e828d91d14d6fb405f Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 13:14:36 -0500 Subject: [PATCH 09/33] test: update foreign init tests --- test/base-fork/InitAndUpgrade.t.sol | 405 ++++++++++++++++++---------- 1 file changed, 269 insertions(+), 136 deletions(-) diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/base-fork/InitAndUpgrade.t.sol index 2686791..18702c3 100644 --- a/test/base-fork/InitAndUpgrade.t.sol +++ b/test/base-fork/InitAndUpgrade.t.sol @@ -54,11 +54,11 @@ contract ForeignControllerInitAndUpgradeTestBase is ForkTestBase { checkAddresses = Init.CheckAddressParams({ admin : Base.SPARK_EXECUTOR, - psm : Base.PSM3, + psm : address(psmBase), cctp : Base.CCTP_TOKEN_MESSENGER, - usdc : Base.USDS, - susds : Base.SUSDS, - usds : Base.USDC + usdc : address(usdcBase), + susds : address(susdsBase), + usds : address(usdsBase) }); mintRecipients = new Init.MintRecipient[](1); @@ -93,14 +93,11 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes admin : Base.SPARK_EXECUTOR, almProxy : address(almProxy), rateLimits : address(rateLimits), - psm : Base.PSM3, - usdc : Base.USDC, + psm : address(psmBase), + usdc : address(usdcBase), cctp : Base.CCTP_TOKEN_MESSENGER })); - almProxy = ALMProxy(payable(Base.ALM_PROXY)); - rateLimits = RateLimits(Base.ALM_RATE_LIMITS); - Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); @@ -109,9 +106,9 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes mintRecipients.push(mintRecipients_[0]); controllerInst = ControllerInstance({ - almProxy : Base.ALM_PROXY, + almProxy : address(almProxy), controller : address(foreignController), - rateLimits : Base.ALM_RATE_LIMITS + rateLimits : address(rateLimits) }); // Admin will be calling the library from its own address @@ -144,122 +141,258 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes ); } - // function test_init_incorrectAdminRateLimits() external { - // // Isolate different contracts instead of setting param so can get three different failures - // vm.startPrank(Base.SPARK_EXECUTOR); - // rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); - // rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); - // vm.stopPrank(); - - // vm.expectRevert("ForeignControllerInit/incorrect-admin-rateLimits"); - // wrapper.initAlmSystem( - // vault, - // address(usds), - // controllerInst, - // configAddresses, - // checkAddresses, - // mintRecipients - // ); - // } - - // function test_init_incorrectAdminController() external { - // // Isolate different contracts instead of setting param so can get three different failures - // vm.startPrank(Base.SPARK_EXECUTOR); - // foreignController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); - // foreignController.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); - // vm.stopPrank(); - - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-admin-controller")); - // } - - // /**********************************************************************************************/ - // /*** Constructor tests ***/ - // /**********************************************************************************************/ - - // function test_init_incorrectAlmProxy() external { - // // Deploy new address that will not EVM revert on OZ ACL check - // controllerInst.almProxy = address(new ALMProxy(Base.SPARK_EXECUTOR)); - - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-almProxy")); - // } - - // function test_init_incorrectRateLimits() external { - // // Deploy new address that will not EVM revert on OZ ACL check - // controllerInst.rateLimits = address(new RateLimits(Base.SPARK_EXECUTOR)); - - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-rateLimits")); - // } - - // function test_init_incorrectVault() external { - // checkAddresses.vault = mismatchAddress; - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-vault")); - // } - - // function test_init_incorrectPsm() external { - // checkAddresses.psm = mismatchAddress; - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-psm")); - // } - - // function test_init_incorrectDaiUsds() external { - // checkAddresses.daiUsds = mismatchAddress; - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-daiUsds")); - // } - - // function test_init_incorrectCctp() external { - // checkAddresses.cctp = mismatchAddress; - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-cctp")); - // } - - // function test_init_controllerInactive() external { - // // Cheating to set this outside of init scripts so that the controller can be frozen - // vm.startPrank(Base.SPARK_EXECUTOR); - // foreignController.grantRole(FREEZER, freezer); - - // vm.startPrank(freezer); - // foreignController.freeze(); - // vm.stopPrank(); - - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/controller-not-active")); - // } - - // function test_init_oldControllerIsNewController() external { - // configAddresses.oldController = controllerInst.controller; - // _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/old-controller-is-new-controller")); - // } - - // function test_init_vaultMismatch() external { - // vault = mismatchAddress; - - // vm.expectRevert("ForeignControllerInit/incorrect-vault"); - // wrapper.initAlmSystem( - // vault, - // address(usds), - // controllerInst, - // configAddresses, - // checkAddresses, - // mintRecipients - // ); - // } - - // function _checkInitAndUpgradeFail(bytes memory expectedError) internal { - // vm.expectRevert(expectedError); - // wrapper.initAlmSystem( - // vault, - // address(usds), - // controllerInst, - // configAddresses, - // checkAddresses, - // mintRecipients - // ); - - // vm.expectRevert(expectedError); - // wrapper.upgradeController( - // controllerInst, - // configAddresses, - // checkAddresses, - // mintRecipients - // ); - // } + function test_init_incorrectAdminRateLimits() external { + // Isolate different contracts instead of setting param so can get three different failures + vm.startPrank(Base.SPARK_EXECUTOR); + rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); + vm.stopPrank(); + + vm.expectRevert("ForeignControllerInit/incorrect-admin-rateLimits"); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_init_incorrectAdminController() external { + // Isolate different contracts instead of setting param so can get three different failures + vm.startPrank(Base.SPARK_EXECUTOR); + foreignController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + foreignController.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); + vm.stopPrank(); + + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-admin-controller")); + } + + /**********************************************************************************************/ + /*** Constructor tests ***/ + /**********************************************************************************************/ + + function test_init_incorrectAlmProxy() external { + // Deploy new address that will not EVM revert on OZ ACL check + controllerInst.almProxy = address(new ALMProxy(Base.SPARK_EXECUTOR)); + + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-almProxy")); + } + + function test_init_incorrectRateLimits() external { + // Deploy new address that will not EVM revert on OZ ACL check + controllerInst.rateLimits = address(new RateLimits(Base.SPARK_EXECUTOR)); + + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-rateLimits")); + } + + function test_init_incorrectPsm() external { + checkAddresses.psm = mismatchAddress; + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-psm")); + } + + function test_init_incorrectUsdc() external { + checkAddresses.usdc = mismatchAddress; + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-usdc")); + } + + function test_init_incorrectCctp() external { + checkAddresses.cctp = mismatchAddress; + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-cctp")); + } + + function test_init_controllerInactive() external { + // Cheating to set this outside of init scripts so that the controller can be frozen + vm.startPrank(Base.SPARK_EXECUTOR); + foreignController.grantRole(FREEZER, freezer); + + vm.startPrank(freezer); + foreignController.freeze(); + vm.stopPrank(); + + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/controller-not-active")); + } + + function test_init_oldControllerIsNewController() external { + configAddresses.oldController = controllerInst.controller; + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/old-controller-is-new-controller")); + } + + /**********************************************************************************************/ + /*** PSM tests ***/ + /**********************************************************************************************/ + + function test_init_totalAssetsNotSeededBoundary() external { + // Remove one wei from PSM to make seeded condition not met + vm.prank(address(0)); + psmBase.withdraw(address(usdsBase), address(this), 1); // Withdraw one wei from PSM + + assertEq(psmBase.totalAssets(), 1e18 - 1); + + vm.expectRevert("ForeignControllerInit/psm-totalAssets-not-seeded"); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + // Approve from address(this) cause it received the one wei + // Redo the seeding + usdsBase.approve(address(psmBase), 1); + psmBase.deposit(address(usdsBase), address(0), 1); + + assertEq(psmBase.totalAssets(), 1e18); + + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_init_totalSharesNotSeededBoundary() external { + // Remove one wei from PSM to make seeded condition not met + vm.prank(address(0)); + psmBase.withdraw(address(usdsBase), address(this), 1); // Withdraw one wei from PSM + + usdsBase.transfer(address(psmBase), 1); // Transfer one wei to PSM to update totalAssets + + assertEq(psmBase.totalAssets(), 1e18); + assertEq(psmBase.totalShares(), 1e18 - 1); + + vm.expectRevert("ForeignControllerInit/psm-totalShares-not-seeded"); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + // Do deposit to update shares, need to do 2 wei to get back to 1e18 because of rounding + deal(address(usdsBase), address(this), 2); + usdsBase.approve(address(psmBase), 2); + psmBase.deposit(address(usdsBase), address(0), 2); + + assertEq(psmBase.totalAssets(), 1e18 + 2); + assertEq(psmBase.totalShares(), 1e18); + + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_init_incorrectPsmUsdc() external { + ERC20Mock wrongUsdc = new ERC20Mock(); + + deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment + + // Deploy a new PSM with the wrong USDC + psmBase = IPSM3(PSM3Deploy.deploy( + SPARK_EXECUTOR, address(wrongUsdc), address(usdsBase), address(susdsBase), SSR_ORACLE + )); + + // Deploy a new controller pointing to misconfigured PSM + controllerInst = ForeignControllerDeploy.deployFull( + SPARK_EXECUTOR, + address(psmBase), + USDC_BASE, + CCTP_MESSENGER_BASE + ); + + checkAddresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM + + vm.expectRevert("ForeignControllerInit/psm-incorrect-usdc"); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_init_incorrectPsmUsds() external { + ERC20Mock wrongUsds = new ERC20Mock(); + + deal(address(wrongUsds), address(this), 1e18); // For seeding PSM during deployment + + // Deploy a new PSM with the wrong USDC + psmBase = IPSM3(PSM3Deploy.deploy( + SPARK_EXECUTOR, USDC_BASE, address(wrongUsds), address(susdsBase), SSR_ORACLE + )); + + // Deploy a new controller pointing to misconfigured PSM + controllerInst = ForeignControllerDeploy.deployFull( + SPARK_EXECUTOR, + address(psmBase), + USDC_BASE, + CCTP_MESSENGER_BASE + ); + + checkAddresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM + + vm.expectRevert("ForeignControllerInit/psm-incorrect-usds"); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_init_incorrectPsmSUsds() external { + ERC20Mock wrongSUsds = new ERC20Mock(); + + deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment + + // Deploy a new PSM with the wrong USDC + psmBase = IPSM3(PSM3Deploy.deploy( + SPARK_EXECUTOR, USDC_BASE, address(usdsBase), address(wrongSUsds), SSR_ORACLE + )); + + // Deploy a new controller pointing to misconfigured PSM + controllerInst = ForeignControllerDeploy.deployFull( + SPARK_EXECUTOR, + address(psmBase), + USDC_BASE, + CCTP_MESSENGER_BASE + ); + + checkAddresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM + + vm.expectRevert("ForeignControllerInit/psm-incorrect-susds"); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + /**********************************************************************************************/ + /*** Helper functions ***/ + /**********************************************************************************************/ + + function _checkInitAndUpgradeFail(bytes memory expectedError) internal { + vm.expectRevert(expectedError); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + vm.expectRevert(expectedError); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } } @@ -281,8 +414,8 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes // // Deploy new controller against live mainnet system // controllerInst.controller = ForeignControllerDeploy.deployController({ // admin : Base.Base.SPARK_EXECUTOR, -// almProxy : Base.ALM_PROXY, -// rateLimits : Base.ALM_RATE_LIMITS, +// almProxy : almProxy, +// rateLimits : rateLimits, // vault : Base.ALLOCATOR_VAULT, // psm : Base.PSM, // daiUsds : Base.DAI_USDS, @@ -290,8 +423,8 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes // }); // // Overwrite storage for all previous deployments in setUp and assert deployment -// almProxy = ALMProxy(payable(Base.ALM_PROXY)); -// rateLimits = RateLimits(Base.ALM_RATE_LIMITS); +// almProxy = ALMProxy(payable(almProxy)); +// rateLimits = RateLimits(rateLimits); // controllerInst.almProxy = address(almProxy); // controllerInst.rateLimits = address(rateLimits); @@ -422,7 +555,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes // vm.startPrank(Base.SPARK_EXECUTOR); // wrapper.initAlmSystem( // Base.ALLOCATOR_VAULT, -// Base.USDS, +// usdsBase, // controllerInst, // configAddresses, // checkAddresses, @@ -484,9 +617,9 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes // // Upgrade against mainnet contracts // controllerInst = ControllerInstance({ -// almProxy : Base.ALM_PROXY, +// almProxy : almProxy, // controller : Base.ALM_CONTROLLER, -// rateLimits : Base.ALM_RATE_LIMITS +// rateLimits : rateLimits // }); // // Overwrite storage for all previous deployments in setUp and assert brand new deployment @@ -504,8 +637,8 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes // newController = ForeignController(ForeignControllerDeploy.deployController({ // admin : Base.Base.SPARK_EXECUTOR, -// almProxy : Base.ALM_PROXY, -// rateLimits : Base.ALM_RATE_LIMITS, +// almProxy : almProxy, +// rateLimits : rateLimits, // vault : Base.ALLOCATOR_VAULT, // psm : Base.PSM, // daiUsds : Base.DAI_USDS, From c58bb0b42b92c87844966b283320dd164866c869 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 13:15:08 -0500 Subject: [PATCH 10/33] test: update foreign init tests --- test/base-fork/InitAndUpgrade.t.sol | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/base-fork/InitAndUpgrade.t.sol index 18702c3..cfaaf6f 100644 --- a/test/base-fork/InitAndUpgrade.t.sol +++ b/test/base-fork/InitAndUpgrade.t.sol @@ -228,13 +228,15 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes assertEq(psmBase.totalAssets(), 1e18 - 1); - vm.expectRevert("ForeignControllerInit/psm-totalAssets-not-seeded"); - wrapper.initAlmSystem( - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); + // vm.expectRevert("ForeignControllerInit/psm-totalAssets-not-seeded"); + // wrapper.initAlmSystem( + // controllerInst, + // configAddresses, + // checkAddresses, + // mintRecipients + // ); + + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-totalAssets-not-seeded")); // Approve from address(this) cause it received the one wei // Redo the seeding From b044570a927fef4b77dd001149268aadefabe65d Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 13:22:35 -0500 Subject: [PATCH 11/33] test: refactor to use test state not mainnet --- test/base-fork/InitAndUpgrade.t.sol | 79 +++++++++++------------------ 1 file changed, 31 insertions(+), 48 deletions(-) diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/base-fork/InitAndUpgrade.t.sol index cfaaf6f..50fb291 100644 --- a/test/base-fork/InitAndUpgrade.t.sol +++ b/test/base-fork/InitAndUpgrade.t.sol @@ -78,6 +78,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes ControllerInstance public controllerInst; address public mismatchAddress = makeAddr("mismatchAddress"); + address public oldController; Init.ConfigAddressParams configAddresses; Init.CheckAddressParams checkAddresses; @@ -86,6 +87,8 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes function setUp() public override { super.setUp(); + oldController = address(foreignController); // Cache for later testing + // Deploy new controller against live mainnet system // NOTE: initAlmSystem will redundantly call rely and approve on already inited // almProxy and rateLimits, this setup was chosen to easily test upgrade and init failures @@ -228,14 +231,6 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes assertEq(psmBase.totalAssets(), 1e18 - 1); - // vm.expectRevert("ForeignControllerInit/psm-totalAssets-not-seeded"); - // wrapper.initAlmSystem( - // controllerInst, - // configAddresses, - // checkAddresses, - // mintRecipients - // ); - _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-totalAssets-not-seeded")); // Approve from address(this) cause it received the one wei @@ -245,12 +240,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes assertEq(psmBase.totalAssets(), 1e18); - wrapper.initAlmSystem( - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); + _checkInitAndUpgradeSucceed(); } function test_init_totalSharesNotSeededBoundary() external { @@ -263,13 +253,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes assertEq(psmBase.totalAssets(), 1e18); assertEq(psmBase.totalShares(), 1e18 - 1); - vm.expectRevert("ForeignControllerInit/psm-totalShares-not-seeded"); - wrapper.initAlmSystem( - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-totalShares-not-seeded")); // Do deposit to update shares, need to do 2 wei to get back to 1e18 because of rounding deal(address(usdsBase), address(this), 2); @@ -279,12 +263,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes assertEq(psmBase.totalAssets(), 1e18 + 2); assertEq(psmBase.totalShares(), 1e18); - wrapper.initAlmSystem( - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); + _checkInitAndUpgradeSucceed(); } function test_init_incorrectPsmUsdc() external { @@ -307,13 +286,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes checkAddresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM - vm.expectRevert("ForeignControllerInit/psm-incorrect-usdc"); - wrapper.initAlmSystem( - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-incorrect-usdc")); } function test_init_incorrectPsmUsds() external { @@ -336,13 +309,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes checkAddresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM - vm.expectRevert("ForeignControllerInit/psm-incorrect-usds"); - wrapper.initAlmSystem( - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-incorrect-usds")); } function test_init_incorrectPsmSUsds() external { @@ -365,13 +332,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes checkAddresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM - vm.expectRevert("ForeignControllerInit/psm-incorrect-susds"); - wrapper.initAlmSystem( - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); + _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-incorrect-susds")); } /**********************************************************************************************/ @@ -396,6 +357,28 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes ); } + function _checkInitAndUpgradeSucceed() internal { + uint256 id = vm.snapshot(); + + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + vm.revertTo(id); + + configAddresses.oldController = oldController; + + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + } // contract ForeignControllerUpgradeFailureTests is ForeignControllerInitAndUpgradeTestBase { From c9ed53e74dfa9a4610ba8b997cfeafd3c0bb0482 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 13:30:19 -0500 Subject: [PATCH 12/33] test: refactor to include upgrade tests --- test/base-fork/InitAndUpgrade.t.sol | 185 +++++++++++----------------- 1 file changed, 72 insertions(+), 113 deletions(-) diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/base-fork/InitAndUpgrade.t.sol index 50fb291..b9248f5 100644 --- a/test/base-fork/InitAndUpgrade.t.sol +++ b/test/base-fork/InitAndUpgrade.t.sol @@ -71,7 +71,11 @@ contract ForeignControllerInitAndUpgradeTestBase is ForkTestBase { } -contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTestBase { +contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndUpgradeTestBase { + + // NOTE: `initAlmSystem` and `upgradeController` are tested in the same contract because + // they both use _initController and have similar specific setups, so it + // less complex/repetitive to test them together. LibraryWrapper wrapper; @@ -128,7 +132,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes /*** ACL tests ***/ /**********************************************************************************************/ - function test_init_incorrectAdminAlmProxy() external { + function test_initAlmSystem_upgradeController_incorrectAdminAlmProxy() external { // Isolate different contracts instead of setting param so can get three different failures vm.startPrank(Base.SPARK_EXECUTOR); almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); @@ -144,7 +148,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes ); } - function test_init_incorrectAdminRateLimits() external { + function test_initAlmSystem_upgradeController_incorrectAdminRateLimits() external { // Isolate different contracts instead of setting param so can get three different failures vm.startPrank(Base.SPARK_EXECUTOR); rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); @@ -160,7 +164,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes ); } - function test_init_incorrectAdminController() external { + function test_initAlmSystem_upgradeController_incorrectAdminController() external { // Isolate different contracts instead of setting param so can get three different failures vm.startPrank(Base.SPARK_EXECUTOR); foreignController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); @@ -174,36 +178,36 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes /*** Constructor tests ***/ /**********************************************************************************************/ - function test_init_incorrectAlmProxy() external { + function test_initAlmSystem_upgradeController_incorrectAlmProxy() external { // Deploy new address that will not EVM revert on OZ ACL check controllerInst.almProxy = address(new ALMProxy(Base.SPARK_EXECUTOR)); _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-almProxy")); } - function test_init_incorrectRateLimits() external { + function test_initAlmSystem_upgradeController_incorrectRateLimits() external { // Deploy new address that will not EVM revert on OZ ACL check controllerInst.rateLimits = address(new RateLimits(Base.SPARK_EXECUTOR)); _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-rateLimits")); } - function test_init_incorrectPsm() external { + function test_initAlmSystem_upgradeController_incorrectPsm() external { checkAddresses.psm = mismatchAddress; _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-psm")); } - function test_init_incorrectUsdc() external { + function test_initAlmSystem_upgradeController_incorrectUsdc() external { checkAddresses.usdc = mismatchAddress; _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-usdc")); } - function test_init_incorrectCctp() external { + function test_initAlmSystem_upgradeController_incorrectCctp() external { checkAddresses.cctp = mismatchAddress; _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-cctp")); } - function test_init_controllerInactive() external { + function test_initAlmSystem_upgradeController_controllerInactive() external { // Cheating to set this outside of init scripts so that the controller can be frozen vm.startPrank(Base.SPARK_EXECUTOR); foreignController.grantRole(FREEZER, freezer); @@ -215,7 +219,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/controller-not-active")); } - function test_init_oldControllerIsNewController() external { + function test_initAlmSystem_upgradeController_oldControllerIsNewController() external { configAddresses.oldController = controllerInst.controller; _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/old-controller-is-new-controller")); } @@ -224,7 +228,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes /*** PSM tests ***/ /**********************************************************************************************/ - function test_init_totalAssetsNotSeededBoundary() external { + function test_initAlmSystem_upgradeController_totalAssetsNotSeededBoundary() external { // Remove one wei from PSM to make seeded condition not met vm.prank(address(0)); psmBase.withdraw(address(usdsBase), address(this), 1); // Withdraw one wei from PSM @@ -243,7 +247,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes _checkInitAndUpgradeSucceed(); } - function test_init_totalSharesNotSeededBoundary() external { + function test_initAlmSystem_upgradeController_totalSharesNotSeededBoundary() external { // Remove one wei from PSM to make seeded condition not met vm.prank(address(0)); psmBase.withdraw(address(usdsBase), address(this), 1); // Withdraw one wei from PSM @@ -266,7 +270,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes _checkInitAndUpgradeSucceed(); } - function test_init_incorrectPsmUsdc() external { + function test_initAlmSystem_upgradeController_incorrectPsmUsdc() external { ERC20Mock wrongUsdc = new ERC20Mock(); deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment @@ -289,7 +293,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-incorrect-usdc")); } - function test_init_incorrectPsmUsds() external { + function test_initAlmSystem_upgradeController_incorrectPsmUsds() external { ERC20Mock wrongUsds = new ERC20Mock(); deal(address(wrongUsds), address(this), 1e18); // For seeding PSM during deployment @@ -312,7 +316,7 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-incorrect-usds")); } - function test_init_incorrectPsmSUsds() external { + function test_initAlmSystem_upgradeController_incorrectPsmSUsds() external { ERC20Mock wrongSUsds = new ERC20Mock(); deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment @@ -335,6 +339,58 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/psm-incorrect-susds")); } + /**********************************************************************************************/ + /*** Upgrade tests ***/ + /**********************************************************************************************/ + + function test_upgradeController_oldControllerZeroAddress() external { + configAddresses.oldController = address(0); + + vm.expectRevert("ForeignControllerInit/old-controller-zero-address"); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_upgradeController_oldControllerDoesNotHaveRoleInAlmProxy() external { + configAddresses.oldController = oldController; + + // Revoke the old controller address in ALM proxy + vm.startPrank(Base.SPARK_EXECUTOR); + almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); + vm.stopPrank(); + + // Try to upgrade with the old controller address that is doesn't have the CONTROLLER role + vm.expectRevert("ForeignControllerInit/old-controller-not-almProxy-controller"); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + + function test_upgradeController_oldControllerDoesNotHaveRoleInRateLimits() external { + configAddresses.oldController = oldController; + + // Revoke the old controller address in rate limits + vm.startPrank(Base.SPARK_EXECUTOR); + rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); + vm.stopPrank(); + + // Try to upgrade with the old controller address that is doesn't have the CONTROLLER role + vm.expectRevert("ForeignControllerInit/old-controller-not-rateLimits-controller"); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + /**********************************************************************************************/ /*** Helper functions ***/ /**********************************************************************************************/ @@ -381,103 +437,6 @@ contract ForeignControllerInitFailureTests is ForeignControllerInitAndUpgradeTes } -// contract ForeignControllerUpgradeFailureTests is ForeignControllerInitAndUpgradeTestBase { - -// LibraryWrapper wrapper; - -// ControllerInstance public controllerInst; - -// address public mismatchAddress = makeAddr("mismatchAddress"); - -// Init.ConfigAddressParams configAddresses; -// Init.CheckAddressParams checkAddresses; -// Init.MintRecipient[] mintRecipients; - -// function setUp() public override { -// super.setUp(); - -// // Deploy new controller against live mainnet system -// controllerInst.controller = ForeignControllerDeploy.deployController({ -// admin : Base.Base.SPARK_EXECUTOR, -// almProxy : almProxy, -// rateLimits : rateLimits, -// vault : Base.ALLOCATOR_VAULT, -// psm : Base.PSM, -// daiUsds : Base.DAI_USDS, -// cctp : Base.CCTP_TOKEN_MESSENGER -// }); - -// // Overwrite storage for all previous deployments in setUp and assert deployment -// almProxy = ALMProxy(payable(almProxy)); -// rateLimits = RateLimits(rateLimits); - -// controllerInst.almProxy = address(almProxy); -// controllerInst.rateLimits = address(rateLimits); - -// Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); - -// ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); - -// mintRecipients.push(mintRecipients_[0]); - -// configAddresses.oldController = Base.ALM_CONTROLLER; - -// // Admin will be calling the library from its own address -// vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); - -// wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); -// } - -// function _getBlock() internal pure override returns (uint256) { -// return 21430000; // Dec 18, 2024 -// } - -// function test_upgrade_oldControllerZeroAddress() external { -// configAddresses.oldController = address(0); - -// vm.expectRevert("ForeignControllerInit/old-controller-zero-address"); -// wrapper.upgradeController( -// controllerInst, -// configAddresses, -// checkAddresses, -// mintRecipients -// ); -// } - -// function test_upgrade_oldControllerDoesNotHaveRoleInAlmProxy() external { -// // Revoke the old controller address in ALM proxy -// vm.startPrank(Base.SPARK_EXECUTOR); -// almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); -// vm.stopPrank(); - -// // Try to upgrade with the old controller address that is doesn't have the CONTROLLER role -// vm.expectRevert("ForeignControllerInit/old-controller-not-almProxy-controller"); -// wrapper.upgradeController( -// controllerInst, -// configAddresses, -// checkAddresses, -// mintRecipients -// ); -// } - -// function test_upgrade_oldControllerDoesNotHaveRoleInRateLimits() external { -// // Revoke the old controller address in rate limits -// vm.startPrank(Base.SPARK_EXECUTOR); -// rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); -// vm.stopPrank(); - -// // Try to upgrade with the old controller address that is doesn't have the CONTROLLER role -// vm.expectRevert("ForeignControllerInit/old-controller-not-rateLimits-controller"); -// wrapper.upgradeController( -// controllerInst, -// configAddresses, -// checkAddresses, -// mintRecipients -// ); -// } - -// } - // contract ForeignControllerInitAlmSystemSuccessTests is ForeignControllerInitAndUpgradeTestBase { // LibraryWrapper wrapper; From e569330fd8e9f9b277666a79a07065ae551e5a7a Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 13:40:06 -0500 Subject: [PATCH 13/33] test: add success tests --- test/base-fork/InitAndUpgrade.t.sol | 285 ++++++++++++---------------- 1 file changed, 123 insertions(+), 162 deletions(-) diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/base-fork/InitAndUpgrade.t.sol index b9248f5..bbca5eb 100644 --- a/test/base-fork/InitAndUpgrade.t.sol +++ b/test/base-fork/InitAndUpgrade.t.sol @@ -64,8 +64,8 @@ contract ForeignControllerInitAndUpgradeTestBase is ForkTestBase { mintRecipients = new Init.MintRecipient[](1); mintRecipients[0] = Init.MintRecipient({ - domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - mintRecipient : bytes32(uint256(uint160(makeAddr("mainnetAlmProxy")))) + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, + mintRecipient : bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) }); } @@ -437,210 +437,171 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU } -// contract ForeignControllerInitAlmSystemSuccessTests is ForeignControllerInitAndUpgradeTestBase { +contract ForeignControllerInitAlmSystemSuccessTests is ForeignControllerInitAndUpgradeTestBase { -// LibraryWrapper wrapper; - -// ControllerInstance public controllerInst; - -// address public mismatchAddress = makeAddr("mismatchAddress"); - -// Init.ConfigAddressParams configAddresses; -// Init.CheckAddressParams checkAddresses; -// Init.MintRecipient[] mintRecipients; - -// function setUp() public override { -// super.setUp(); - -// controllerInst = ForeignControllerDeploy.deployFull( -// Base.Base.SPARK_EXECUTOR, -// Base.ALLOCATOR_VAULT, -// Base.PSM, -// Base.DAI_USDS, -// Base.CCTP_TOKEN_MESSENGER -// ); - -// // Overwrite storage for all previous deployments in setUp and assert brand new deployment -// foreignController = ForeignController(controllerInst.controller); -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// rateLimits = RateLimits(controllerInst.rateLimits); -// vault = Base.ALLOCATOR_VAULT; // Use mainnet vault -// buffer = Base.ALLOCATOR_BUFFER; // Use mainnet buffer - -// Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); - -// ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); - -// mintRecipients.push(mintRecipients_[0]); + LibraryWrapper wrapper; -// // Admin will be calling the library from its own address -// vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); + ControllerInstance public controllerInst; -// wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); -// } + Init.ConfigAddressParams configAddresses; + Init.CheckAddressParams checkAddresses; + Init.MintRecipient[] mintRecipients; -// function _getBlock() internal pure override returns (uint256) { -// return 21430000; // Dec 18, 2024 -// } + function setUp() public override { + super.setUp(); -// function test_initAlmSystem() public { -// assertEq(foreignController.hasRole(foreignController.FREEZER(), freezer), false); -// assertEq(foreignController.hasRole(foreignController.RELAYER(), relayer), false); + controllerInst = ForeignControllerDeploy.deployFull( + Base.SPARK_EXECUTOR, + address(psmBase), + address(usdcBase), + Base.CCTP_TOKEN_MESSENGER + ); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), false); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), false); + // Overwrite storage for all previous deployments in setUp and assert brand new deployment + foreignController = ForeignController(controllerInst.controller); + almProxy = ALMProxy(payable(controllerInst.almProxy)); + rateLimits = RateLimits(controllerInst.rateLimits); -// assertEq(foreignController.mintRecipients(mintRecipients[0].domain), bytes32(0)); -// assertEq(foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), bytes32(0)); + Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); -// assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 0); -// assertEq(usds.allowance(buffer, controllerInst.almProxy), 0); + ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); -// vm.startPrank(Base.SPARK_EXECUTOR); -// wrapper.initAlmSystem( -// Base.ALLOCATOR_VAULT, -// usdsBase, -// controllerInst, -// configAddresses, -// checkAddresses, -// mintRecipients -// ); + mintRecipients.push(mintRecipients_[0]); -// assertEq(foreignController.hasRole(foreignController.FREEZER(), freezer), true); -// assertEq(foreignController.hasRole(foreignController.RELAYER(), relayer), true); + // Admin will be calling the library from its own address + vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), true); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), true); + wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); + } -// assertEq( -// foreignController.mintRecipients(mintRecipients[0].domain), -// mintRecipients[0].mintRecipient -// ); + function _getBlock() internal pure override returns (uint256) { + return 21430000; // Dec 18, 2024 + } -// assertEq( -// foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), -// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) -// ); + function test_initAlmSystem() public { + assertEq(foreignController.hasRole(foreignController.FREEZER(), freezer), false); + assertEq(foreignController.hasRole(foreignController.RELAYER(), relayer), false); -// assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 1); -// assertEq(usds.allowance(buffer, controllerInst.almProxy), type(uint256).max); -// } + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), false); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), false); -// function test_pauseProxyInitAlmSystem() public { -// // Update to call the library from the pause proxy -// vm.etch(PAUSE_PROXY, address(new LibraryWrapper()).code); -// wrapper = LibraryWrapper(PAUSE_PROXY); + assertEq(foreignController.mintRecipients(mintRecipients[0].domain), bytes32(0)); + assertEq(foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), bytes32(0)); -// assertEq(IPSMLike(Base.PSM).bud(controllerInst.almProxy), 0); + vm.startPrank(Base.SPARK_EXECUTOR); + wrapper.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); -// vm.startPrank(PAUSE_PROXY); -// wrapper.pauseProxyInitAlmSystem(Base.PSM, controllerInst.almProxy); -// vm.stopPrank(); + assertEq(foreignController.hasRole(foreignController.FREEZER(), freezer), true); + assertEq(foreignController.hasRole(foreignController.RELAYER(), relayer), true); -// assertEq(IPSMLike(Base.PSM).bud(controllerInst.almProxy), 1); -// } + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), true); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), true); -// } + assertEq( + foreignController.mintRecipients(mintRecipients[0].domain), + mintRecipients[0].mintRecipient + ); -// contract ForeignControllerUpgradeControllerSuccessTests is ForeignControllerInitAndUpgradeTestBase { + assertEq( + foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), + bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) + ); + } -// LibraryWrapper wrapper; +} -// ControllerInstance public controllerInst; +contract ForeignControllerUpgradeControllerSuccessTests is ForeignControllerInitAndUpgradeTestBase { -// address public mismatchAddress = makeAddr("mismatchAddress"); + LibraryWrapper wrapper; -// Init.ConfigAddressParams configAddresses; -// Init.CheckAddressParams checkAddresses; -// Init.MintRecipient[] mintRecipients; + ControllerInstance public controllerInst; -// ForeignController newController; + Init.ConfigAddressParams configAddresses; + Init.CheckAddressParams checkAddresses; + Init.MintRecipient[] mintRecipients; -// function setUp() public override { -// super.setUp(); + ForeignController newController; -// // Upgrade against mainnet contracts -// controllerInst = ControllerInstance({ -// almProxy : almProxy, -// controller : Base.ALM_CONTROLLER, -// rateLimits : rateLimits -// }); + function setUp() public override { + super.setUp(); -// // Overwrite storage for all previous deployments in setUp and assert brand new deployment -// foreignController = ForeignController(controllerInst.controller); -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// rateLimits = RateLimits(controllerInst.rateLimits); -// vault = Base.ALLOCATOR_VAULT; // Use mainnet vault -// buffer = Base.ALLOCATOR_BUFFER; // Use mainnet buffer + Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); -// Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); + ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); -// ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); + mintRecipients.push(mintRecipients_[0]); -// mintRecipients.push(mintRecipients_[0]); + newController = ForeignController(ForeignControllerDeploy.deployController({ + admin : Base.SPARK_EXECUTOR, + almProxy : address(almProxy), + rateLimits : address(rateLimits), + psm : address(psmBase), + usdc : address(usdcBase), + cctp : Base.CCTP_TOKEN_MESSENGER + })); -// newController = ForeignController(ForeignControllerDeploy.deployController({ -// admin : Base.Base.SPARK_EXECUTOR, -// almProxy : almProxy, -// rateLimits : rateLimits, -// vault : Base.ALLOCATOR_VAULT, -// psm : Base.PSM, -// daiUsds : Base.DAI_USDS, -// cctp : Base.CCTP_TOKEN_MESSENGER -// })); + controllerInst = ControllerInstance({ + almProxy : address(almProxy), + controller : address(newController), + rateLimits : address(rateLimits) + }); -// controllerInst.controller = address(newController); // Upgrade to new controller -// configAddresses.oldController = Base.ALM_CONTROLLER; // Revoke from old controller + configAddresses.oldController = address(foreignController); // Revoke from old controller -// // Admin will be calling the library from its own address -// vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); + // Admin will be calling the library from its own address + vm.etch(Base.SPARK_EXECUTOR, address(new LibraryWrapper()).code); -// wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); -// } + wrapper = LibraryWrapper(Base.SPARK_EXECUTOR); + } -// function _getBlock() internal pure override returns (uint256) { -// return 21430000; // Dec 18, 2024 -// } + function _getBlock() internal pure override returns (uint256) { + return 21430000; // Dec 18, 2024 + } -// function test_upgradeController() public { -// assertEq(newController.hasRole(newController.FREEZER(), freezer), false); -// assertEq(newController.hasRole(newController.RELAYER(), relayer), false); + function test_upgradeController() public { + assertEq(newController.hasRole(newController.FREEZER(), freezer), false); + assertEq(newController.hasRole(newController.RELAYER(), relayer), false); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), true); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), true); + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), true); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), true); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(newController)), false); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(newController)), false); + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(newController)), false); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(newController)), false); -// assertEq(newController.mintRecipients(mintRecipients[0].domain), bytes32(0)); -// assertEq(newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), bytes32(0)); + assertEq(newController.mintRecipients(mintRecipients[0].domain), bytes32(0)); + assertEq(newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), bytes32(0)); -// vm.startPrank(Base.SPARK_EXECUTOR); -// wrapper.upgradeController( -// controllerInst, -// configAddresses, -// checkAddresses, -// mintRecipients -// ); + vm.startPrank(Base.SPARK_EXECUTOR); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); -// assertEq(newController.hasRole(newController.FREEZER(), freezer), true); -// assertEq(newController.hasRole(newController.RELAYER(), relayer), true); + assertEq(newController.hasRole(newController.FREEZER(), freezer), true); + assertEq(newController.hasRole(newController.RELAYER(), relayer), true); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), false); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), false); + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), false); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), false); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(newController)), true); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(newController)), true); + assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(newController)), true); + assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(newController)), true); -// assertEq( -// newController.mintRecipients(mintRecipients[0].domain), -// mintRecipients[0].mintRecipient -// ); + assertEq( + newController.mintRecipients(mintRecipients[0].domain), + mintRecipients[0].mintRecipient + ); -// assertEq( -// newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), -// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) -// ); -// } + assertEq( + newController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), + bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) + ); + } -// } \ No newline at end of file +} \ No newline at end of file From b60a3d76c44f3def1762f282535d0f15e52549e8 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 13:56:41 -0500 Subject: [PATCH 14/33] test: refactor to use test deployed system --- test/base-fork/InitAndUpgrade.t.sol | 3 +- test/mainnet-fork/InitAndUpgrade.t.sol | 205 ++++++++++--------------- 2 files changed, 82 insertions(+), 126 deletions(-) diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/base-fork/InitAndUpgrade.t.sol index bbca5eb..03309ab 100644 --- a/test/base-fork/InitAndUpgrade.t.sol +++ b/test/base-fork/InitAndUpgrade.t.sol @@ -82,6 +82,7 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU ControllerInstance public controllerInst; address public mismatchAddress = makeAddr("mismatchAddress"); + address public oldController; Init.ConfigAddressParams configAddresses; @@ -340,7 +341,7 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU } /**********************************************************************************************/ - /*** Upgrade tests ***/ + /*** Upgrade tests ***/ /**********************************************************************************************/ function test_upgradeController_oldControllerZeroAddress() external { diff --git a/test/mainnet-fork/InitAndUpgrade.t.sol b/test/mainnet-fork/InitAndUpgrade.t.sol index 7a6792c..95d7211 100644 --- a/test/mainnet-fork/InitAndUpgrade.t.sol +++ b/test/mainnet-fork/InitAndUpgrade.t.sol @@ -60,9 +60,9 @@ contract MainnetControllerInitAndUpgradeTestBase is ForkTestBase { checkAddresses = Init.CheckAddressParams({ admin : Ethereum.SPARK_PROXY, - proxy : Ethereum.ALM_PROXY, - rateLimits : Ethereum.ALM_RATE_LIMITS, - vault : Ethereum.ALLOCATOR_VAULT, + proxy : address(almProxy), + rateLimits : address(rateLimits), + vault : address(vault), psm : Ethereum.PSM, daiUsds : Ethereum.DAI_USDS, cctp : Ethereum.CCTP_TOKEN_MESSENGER @@ -78,7 +78,11 @@ contract MainnetControllerInitAndUpgradeTestBase is ForkTestBase { } -contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTestBase { +contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndUpgradeTestBase { + + // NOTE: `initAlmSystem` and `upgradeController` are tested in the same contract because + // they both use _initController and have similar specific setups, so it + // less complex/repetitive to test them together. LibraryWrapper wrapper; @@ -86,6 +90,8 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes address public mismatchAddress = makeAddr("mismatchAddress"); + address public oldController; + Init.ConfigAddressParams configAddresses; Init.CheckAddressParams checkAddresses; Init.MintRecipient[] mintRecipients; @@ -93,22 +99,23 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes function setUp() public override { super.setUp(); - // Deploy new controller against live mainnet system + oldController = address(mainnetController); // Cache for later testing + // NOTE: initAlmSystem will redundantly call rely and approve on already inited - // almProxy and rateLimits, this setup was chosen to easily test upgrade and init failures + // almProxy and rateLimits, this setup was chosen to easily test upgrade and init failures. + // It also should be noted that the almProxy and rateLimits that are being used in initAlmSystem + // 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, - almProxy : Ethereum.ALM_PROXY, - rateLimits : Ethereum.ALM_RATE_LIMITS, - vault : Ethereum.ALLOCATOR_VAULT, + almProxy : address(almProxy), + rateLimits : address(rateLimits), + vault : address(vault), psm : Ethereum.PSM, daiUsds : Ethereum.DAI_USDS, cctp : Ethereum.CCTP_TOKEN_MESSENGER })); - almProxy = ALMProxy(payable(Ethereum.ALM_PROXY)); - rateLimits = RateLimits(Ethereum.ALM_RATE_LIMITS); - Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); @@ -117,9 +124,9 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes mintRecipients.push(mintRecipients_[0]); controllerInst = ControllerInstance({ - almProxy : Ethereum.ALM_PROXY, + almProxy : address(almProxy), controller : address(mainnetController), - rateLimits : Ethereum.ALM_RATE_LIMITS + rateLimits : address(rateLimits) }); // Admin will be calling the library from its own address @@ -136,7 +143,7 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes /*** ACL tests ***/ /**********************************************************************************************/ - function test_init_incorrectAdminAlmProxy() external { + function test_initAlmSystem_incorrectAdminAlmProxy() external { // Isolate different contracts instead of setting param so can get three different failures vm.startPrank(SPARK_PROXY); almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); @@ -154,7 +161,7 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes ); } - function test_init_incorrectAdminRateLimits() external { + function test_initAlmSystem_incorrectAdminRateLimits() external { // Isolate different contracts instead of setting param so can get three different failures vm.startPrank(SPARK_PROXY); rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); @@ -172,7 +179,7 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes ); } - function test_init_incorrectAdminController() external { + function test_initAlmSystem_upgradeController_incorrectAdminController() external { // Isolate different contracts instead of setting param so can get three different failures vm.startPrank(SPARK_PROXY); mainnetController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); @@ -186,41 +193,41 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes /*** Constructor tests ***/ /**********************************************************************************************/ - function test_init_incorrectAlmProxy() external { + 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)); _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-almProxy")); } - function test_init_incorrectRateLimits() external { + 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)); _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-rateLimits")); } - function test_init_incorrectVault() external { + function test_initAlmSystem_upgradeController_incorrectVault() external { checkAddresses.vault = mismatchAddress; _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-vault")); } - function test_init_incorrectPsm() external { + function test_initAlmSystem_upgradeController_incorrectPsm() external { checkAddresses.psm = mismatchAddress; _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-psm")); } - function test_init_incorrectDaiUsds() external { + function test_initAlmSystem_upgradeController_incorrectDaiUsds() external { checkAddresses.daiUsds = mismatchAddress; _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-daiUsds")); } - function test_init_incorrectCctp() external { + function test_initAlmSystem_upgradeController_incorrectCctp() external { checkAddresses.cctp = mismatchAddress; _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-cctp")); } - function test_init_controllerInactive() external { + function test_initAlmSystem_upgradeController_controllerInactive() external { // Cheating to set this outside of init scripts so that the controller can be frozen vm.startPrank(SPARK_PROXY); mainnetController.grantRole(FREEZER, freezer); @@ -232,12 +239,12 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/controller-not-active")); } - function test_init_oldControllerIsNewController() external { + function test_initAlmSystem_upgradeController_oldControllerIsNewController() external { configAddresses.oldController = controllerInst.controller; _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/old-controller-is-new-controller")); } - function test_init_vaultMismatch() external { + function test_initAlmSystem_upgradeController_vaultMismatch() external { vault = mismatchAddress; vm.expectRevert("MainnetControllerInit/incorrect-vault"); @@ -251,80 +258,11 @@ contract MainnetControllerInitFailureTests is MainnetControllerInitAndUpgradeTes ); } - function _checkInitAndUpgradeFail(bytes memory expectedError) internal { - vm.expectRevert(expectedError); - wrapper.initAlmSystem( - vault, - address(usds), - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); - - vm.expectRevert(expectedError); - wrapper.upgradeController( - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); - } - -} - -contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgradeTestBase { - - LibraryWrapper wrapper; - - ControllerInstance public controllerInst; - - address public mismatchAddress = makeAddr("mismatchAddress"); - - Init.ConfigAddressParams configAddresses; - Init.CheckAddressParams checkAddresses; - Init.MintRecipient[] mintRecipients; - - function setUp() public override { - super.setUp(); - - // Deploy new controller against live mainnet system - controllerInst.controller = MainnetControllerDeploy.deployController({ - admin : Ethereum.SPARK_PROXY, - almProxy : Ethereum.ALM_PROXY, - rateLimits : Ethereum.ALM_RATE_LIMITS, - vault : Ethereum.ALLOCATOR_VAULT, - psm : Ethereum.PSM, - daiUsds : Ethereum.DAI_USDS, - cctp : Ethereum.CCTP_TOKEN_MESSENGER - }); - - // Overwrite storage for all previous deployments in setUp and assert deployment - almProxy = ALMProxy(payable(Ethereum.ALM_PROXY)); - rateLimits = RateLimits(Ethereum.ALM_RATE_LIMITS); - - controllerInst.almProxy = address(almProxy); - controllerInst.rateLimits = address(rateLimits); - - Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); - - ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); - - mintRecipients.push(mintRecipients_[0]); - - configAddresses.oldController = Ethereum.ALM_CONTROLLER; - - // Admin will be calling the library from its own address - vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); - - wrapper = LibraryWrapper(SPARK_PROXY); - } - - function _getBlock() internal pure override returns (uint256) { - return 21430000; // Dec 18, 2024 - } + /**********************************************************************************************/ + /*** Upgrade tests ***/ + /**********************************************************************************************/ - function test_upgrade_oldControllerZeroAddress() external { + function test_upgradeController_oldControllerZeroAddress() external { configAddresses.oldController = address(0); vm.expectRevert("MainnetControllerInit/old-controller-zero-address"); @@ -336,7 +274,9 @@ contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgrade ); } - function test_upgrade_oldControllerDoesNotHaveRoleInAlmProxy() external { + function test_upgradeController_oldControllerDoesNotHaveRoleInAlmProxy() external { + configAddresses.oldController = oldController; + // Revoke the old controller address in ALM proxy vm.startPrank(SPARK_PROXY); almProxy.revokeRole(almProxy.CONTROLLER(), configAddresses.oldController); @@ -352,7 +292,9 @@ contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgrade ); } - function test_upgrade_oldControllerDoesNotHaveRoleInRateLimits() external { + function test_upgradeController_oldControllerDoesNotHaveRoleInRateLimits() external { + configAddresses.oldController = oldController; + // Revoke the old controller address in rate limits vm.startPrank(SPARK_PROXY); rateLimits.revokeRole(rateLimits.CONTROLLER(), configAddresses.oldController); @@ -368,6 +310,30 @@ contract MainnetControllerUpgradeFailureTests is MainnetControllerInitAndUpgrade ); } + /**********************************************************************************************/ + /*** Helper functions ***/ + /**********************************************************************************************/ + + function _checkInitAndUpgradeFail(bytes memory expectedError) internal { + vm.expectRevert(expectedError); + wrapper.initAlmSystem( + vault, + address(usds), + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + vm.expectRevert(expectedError); + wrapper.upgradeController( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + } + } contract MainnetControllerInitAlmSystemSuccessTests is MainnetControllerInitAndUpgradeTestBase { @@ -387,7 +353,7 @@ contract MainnetControllerInitAlmSystemSuccessTests is MainnetControllerInitAndU controllerInst = MainnetControllerDeploy.deployFull( Ethereum.SPARK_PROXY, - Ethereum.ALLOCATOR_VAULT, + address(vault), Ethereum.PSM, Ethereum.DAI_USDS, Ethereum.CCTP_TOKEN_MESSENGER @@ -397,8 +363,6 @@ contract MainnetControllerInitAlmSystemSuccessTests is MainnetControllerInitAndU mainnetController = MainnetController(controllerInst.controller); almProxy = ALMProxy(payable(controllerInst.almProxy)); rateLimits = RateLimits(controllerInst.rateLimits); - vault = Ethereum.ALLOCATOR_VAULT; // Use mainnet vault - buffer = Ethereum.ALLOCATOR_BUFFER; // Use mainnet buffer Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); @@ -431,8 +395,8 @@ contract MainnetControllerInitAlmSystemSuccessTests is MainnetControllerInitAndU vm.startPrank(SPARK_PROXY); wrapper.initAlmSystem( - Ethereum.ALLOCATOR_VAULT, - Ethereum.USDS, + address(vault), + address(usds), controllerInst, configAddresses, checkAddresses, @@ -492,20 +456,6 @@ contract MainnetControllerUpgradeControllerSuccessTests is MainnetControllerInit function setUp() public override { super.setUp(); - // Upgrade against mainnet contracts - controllerInst = ControllerInstance({ - almProxy : Ethereum.ALM_PROXY, - controller : Ethereum.ALM_CONTROLLER, - rateLimits : Ethereum.ALM_RATE_LIMITS - }); - - // Overwrite storage for all previous deployments in setUp and assert brand new deployment - mainnetController = MainnetController(controllerInst.controller); - almProxy = ALMProxy(payable(controllerInst.almProxy)); - rateLimits = RateLimits(controllerInst.rateLimits); - vault = Ethereum.ALLOCATOR_VAULT; // Use mainnet vault - buffer = Ethereum.ALLOCATOR_BUFFER; // Use mainnet buffer - Init.MintRecipient[] memory mintRecipients_ = new Init.MintRecipient[](1); ( configAddresses, checkAddresses, mintRecipients_ ) = _getDefaultParams(); @@ -514,16 +464,21 @@ contract MainnetControllerUpgradeControllerSuccessTests is MainnetControllerInit newController = MainnetController(MainnetControllerDeploy.deployController({ admin : Ethereum.SPARK_PROXY, - almProxy : Ethereum.ALM_PROXY, - rateLimits : Ethereum.ALM_RATE_LIMITS, - vault : Ethereum.ALLOCATOR_VAULT, + almProxy : address(almProxy), + rateLimits : address(rateLimits), + vault : address(vault), psm : Ethereum.PSM, daiUsds : Ethereum.DAI_USDS, cctp : Ethereum.CCTP_TOKEN_MESSENGER })); - controllerInst.controller = address(newController); // Upgrade to new controller - configAddresses.oldController = Ethereum.ALM_CONTROLLER; // Revoke from old controller + controllerInst = ControllerInstance({ + almProxy : address(almProxy), + controller : address(newController), + rateLimits : address(rateLimits) + }); + + 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); From a18dce85784f4b592140879d8db3ce21063637a4 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 14:22:09 -0500 Subject: [PATCH 15/33] test: main tests passing with new libs --- deploy/ControllerInit.sol | 344 ------ script/staging/FullStagingDeploy.s.sol | 840 +++++++-------- script/staging/test/StagingDeployment.t.sol | 900 ++++++++-------- src/RateLimitHelpers.sol | 10 +- test/base-fork/DeployAndInit.t.sol | 900 ---------------- test/base-fork/ForkTestBase.t.sol | 86 +- test/mainnet-fork/CCTPCalls.t.sol | 1036 +++++++++---------- test/mainnet-fork/DeployAndInit.t.sol | 722 ------------- test/mainnet-fork/ForkTestBase.t.sol | 112 +- 9 files changed, 1506 insertions(+), 3444 deletions(-) delete mode 100644 deploy/ControllerInit.sol delete mode 100644 test/base-fork/DeployAndInit.t.sol delete mode 100644 test/mainnet-fork/DeployAndInit.t.sol diff --git a/deploy/ControllerInit.sol b/deploy/ControllerInit.sol deleted file mode 100644 index 3409975..0000000 --- a/deploy/ControllerInit.sol +++ /dev/null @@ -1,344 +0,0 @@ -// SPDX-License-Identifier: AGPL-3.0-or-later -pragma solidity >=0.8.0; - -import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; - -import { ForeignController } from "../src/ForeignController.sol"; -import { MainnetController } from "../src/MainnetController.sol"; -import { RateLimitHelpers } from "../src/RateLimitHelpers.sol"; - -import { IALMProxy } from "../src/interfaces/IALMProxy.sol"; -import { IRateLimits } from "../src/interfaces/IRateLimits.sol"; - -import { ControllerInstance } from "./ControllerInstance.sol"; - -interface IBufferLike { - function approve(address, address, uint256) external; -} - -interface IPSMLike { - function kiss(address) external; -} - -interface IPSM3Like { - function totalAssets() external view returns (uint256); - function totalShares() external view returns (uint256); - function usdc() external view returns (address); - function usds() external view returns (address); - function susds() external view returns (address); -} - -interface IVaultLike { - function rely(address) external; -} - -struct RateLimitData { - uint256 maxAmount; - uint256 slope; -} - -struct MintRecipient { - uint32 domain; - bytes32 mintRecipient; -} - -library MainnetControllerInit { - - struct AddressParams { - address admin; - address freezer; - address relayer; - address oldController; - address psm; - address vault; - address buffer; - address cctpMessenger; - address dai; - address daiUsds; - address usdc; - address usds; - address susds; - } - - struct InitRateLimitData { - RateLimitData usdsMintData; - RateLimitData usdsToUsdcData; - RateLimitData usdcToCctpData; - RateLimitData cctpToBaseDomainData; - RateLimitData susdsDepositData; - } - - bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; - - function subDaoInitController( - AddressParams memory addresses, - ControllerInstance memory controllerInst, - InitRateLimitData memory data, - MintRecipient[] memory mintRecipients - ) - internal - { - IALMProxy almProxy = IALMProxy(controllerInst.almProxy); - IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); - - MainnetController controller = MainnetController(controllerInst.controller); - - // Step 1: Perform sanity checks - - require(almProxy.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "MainnetControllerInit/incorrect-admin-almProxy"); - require(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "MainnetControllerInit/incorrect-admin-rateLimits"); - require(controller.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "MainnetControllerInit/incorrect-admin-controller"); - - require(address(controller.proxy()) == controllerInst.almProxy, "MainnetControllerInit/incorrect-almProxy"); - require(address(controller.rateLimits()) == controllerInst.rateLimits, "MainnetControllerInit/incorrect-rateLimits"); - require(address(controller.vault()) == addresses.vault, "MainnetControllerInit/incorrect-vault"); - require(address(controller.buffer()) == addresses.buffer, "MainnetControllerInit/incorrect-buffer"); - require(address(controller.psm()) == addresses.psm, "MainnetControllerInit/incorrect-psm"); - require(address(controller.daiUsds()) == addresses.daiUsds, "MainnetControllerInit/incorrect-daiUsds"); - require(address(controller.cctp()) == addresses.cctpMessenger, "MainnetControllerInit/incorrect-cctpMessenger"); - require(address(controller.dai()) == addresses.dai, "MainnetControllerInit/incorrect-dai"); - require(address(controller.usdc()) == addresses.usdc, "MainnetControllerInit/incorrect-usdc"); - require(address(controller.usds()) == addresses.usds, "MainnetControllerInit/incorrect-usds"); - - require(controller.psmTo18ConversionFactor() == 1e12, "MainnetControllerInit/incorrect-psmTo18ConversionFactor"); - - require(controller.active(), "MainnetControllerInit/controller-not-active"); - - require(addresses.oldController != address(controller), "MainnetControllerInit/old-controller-is-new-controller"); - - // Step 2: Configure ACL permissions for controller and almProxy - - controller.grantRole(controller.FREEZER(), addresses.freezer); - controller.grantRole(controller.RELAYER(), addresses.relayer); - - almProxy.grantRole(almProxy.CONTROLLER(), address(controller)); - rateLimits.grantRole(rateLimits.CONTROLLER(), address(controller)); - - if (addresses.oldController != address(0)) { - require(almProxy.hasRole(almProxy.CONTROLLER(), addresses.oldController), "MainnetControllerInit/old-controller-not-almProxy-controller"); - require(rateLimits.hasRole(rateLimits.CONTROLLER(), addresses.oldController), "MainnetControllerInit/old-controller-not-rateLimits-controller"); - - almProxy.revokeRole(almProxy.CONTROLLER(), addresses.oldController); - rateLimits.revokeRole(rateLimits.CONTROLLER(), addresses.oldController); - } - - // Step 3: Configure all rate limits for controller, using Base as only domain - - bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( - controller.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE - ); - - bytes32 susdsKey = RateLimitHelpers.makeAssetKey( - controller.LIMIT_4626_DEPOSIT(), - addresses.susds - ); - - setRateLimitData(controller.LIMIT_USDS_MINT(), rateLimits, data.usdsMintData, "usdsMintData", 18); - setRateLimitData(controller.LIMIT_USDS_TO_USDC(), rateLimits, data.usdsToUsdcData, "usdsToUsdcData", 6); - setRateLimitData(controller.LIMIT_USDC_TO_CCTP(), rateLimits, data.usdcToCctpData, "usdcToCctpData", 6); - setRateLimitData(domainKeyBase, rateLimits, data.cctpToBaseDomainData, "cctpToBaseDomainData", 6); - setRateLimitData(susdsKey, rateLimits, data.susdsDepositData, "susdsDepositData", 18); - - // Step 4: Configure the mint recipients on other domains - - for (uint256 i = 0; i < mintRecipients.length; i++) { - controller.setMintRecipient(mintRecipients[i].domain, mintRecipients[i].mintRecipient); - } - } - - function subDaoInitFull( - AddressParams memory addresses, - ControllerInstance memory controllerInst, - InitRateLimitData memory data, - MintRecipient[] memory mintRecipients - ) - internal - { - // Step 1: Perform controller sanity checks, configure ACL permissions for controller - // and almProxy and rate limits. - - subDaoInitController( - addresses, - controllerInst, - data, - mintRecipients - ); - - // Step 2: Configure almProxy within the allocation system - - IVaultLike(addresses.vault).rely(controllerInst.almProxy); - IBufferLike(addresses.buffer).approve(addresses.usds, controllerInst.almProxy, type(uint256).max); - } - - function pauseProxyInit(address psm, address almProxy) internal { - IPSMLike(psm).kiss(almProxy); // To allow using no fee functionality - } - - function setRateLimitData( - bytes32 key, - IRateLimits rateLimits, - RateLimitData memory data, - string memory name, - uint256 decimals - ) - internal - { - // Handle setting an unlimited rate limit - if (data.maxAmount == type(uint256).max) { - require( - data.slope == 0, - string(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-", name)) - ); - } - else { - require( - data.maxAmount <= 1e12 * (10 ** decimals), - string(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-", name)) - ); - require( - data.slope <= 1e12 * (10 ** decimals) / 1 hours, - string(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-", name)) - ); - } - rateLimits.setRateLimitData(key, data.maxAmount, data.slope); - } - -} - -library ForeignControllerInit { - - struct AddressParams { - address admin; - address freezer; - address relayer; - address oldController; - address psm; - address cctpMessenger; - address usdc; - address usds; - address susds; - } - - bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; - - struct InitRateLimitData { - RateLimitData usdcDepositData; - RateLimitData usdcWithdrawData; - RateLimitData usdsDepositData; - RateLimitData usdsWithdrawData; - RateLimitData susdsDepositData; - RateLimitData susdsWithdrawData; - RateLimitData usdcToCctpData; - RateLimitData cctpToEthereumDomainData; - } - - function init( - AddressParams memory addresses, - ControllerInstance memory controllerInst, - InitRateLimitData memory data, - MintRecipient[] memory mintRecipients - ) - internal - { - IALMProxy almProxy = IALMProxy(controllerInst.almProxy); - IRateLimits rateLimits = IRateLimits(controllerInst.rateLimits); - - ForeignController controller = ForeignController(controllerInst.controller); - - require(almProxy.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-almProxy"); - require(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-rateLimits"); - require(controller.hasRole(DEFAULT_ADMIN_ROLE, addresses.admin), "ForeignControllerInit/incorrect-admin-controller"); - - require(address(controller.proxy()) == controllerInst.almProxy, "ForeignControllerInit/incorrect-almProxy"); - require(address(controller.rateLimits()) == controllerInst.rateLimits, "ForeignControllerInit/incorrect-rateLimits"); - require(address(controller.psm()) == addresses.psm, "ForeignControllerInit/incorrect-psm"); - require(address(controller.usdc()) == addresses.usdc, "ForeignControllerInit/incorrect-usdc"); - require(address(controller.cctp()) == addresses.cctpMessenger, "ForeignControllerInit/incorrect-cctp"); - - require(controller.active(), "ForeignControllerInit/controller-not-active"); - - require(addresses.oldController != address(controller), "ForeignControllerInit/old-controller-is-new-controller"); - - IPSM3Like psm = IPSM3Like(addresses.psm); - - require(psm.totalAssets() >= 1e18, "ForeignControllerInit/psm-totalAssets-not-seeded"); - require(psm.totalShares() >= 1e18, "ForeignControllerInit/psm-totalShares-not-seeded"); - - require(psm.usdc() == addresses.usdc, "ForeignControllerInit/psm-incorrect-usdc"); - require(psm.usds() == addresses.usds, "ForeignControllerInit/psm-incorrect-usds"); - require(psm.susds() == addresses.susds, "ForeignControllerInit/psm-incorrect-susds"); - - // Step 1: Configure ACL permissions for controller and almProxy - - controller.grantRole(controller.FREEZER(), addresses.freezer); - controller.grantRole(controller.RELAYER(), addresses.relayer); - - almProxy.grantRole(almProxy.CONTROLLER(), address(controller)); - rateLimits.grantRole(rateLimits.CONTROLLER(), address(controller)); - - if (addresses.oldController != address(0)) { - require(almProxy.hasRole(almProxy.CONTROLLER(), addresses.oldController) == true, "ForeignControllerInit/old-controller-not-almProxy-controller"); - require(rateLimits.hasRole(rateLimits.CONTROLLER(), addresses.oldController) == true, "ForeignControllerInit/old-controller-not-rateLimits-controller"); - - almProxy.revokeRole(almProxy.CONTROLLER(), addresses.oldController); - rateLimits.revokeRole(rateLimits.CONTROLLER(), addresses.oldController); - } - - // Step 2: Configure all rate limits for controller - - bytes32 depositKey = controller.LIMIT_PSM_DEPOSIT(); - bytes32 withdrawKey = controller.LIMIT_PSM_WITHDRAW(); - - bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( - controller.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM - ); - - setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.usdc), rateLimits, data.usdcDepositData, "usdcDepositData", 6); - setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.usdc), rateLimits, data.usdcWithdrawData, "usdcWithdrawData", 6); - setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.usds), rateLimits, data.usdsDepositData, "usdsDepositData", 18); - setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.usds), rateLimits, data.usdsWithdrawData, "usdsWithdrawData", 18); - setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, addresses.susds), rateLimits, data.susdsDepositData, "susdsDepositData", 18); - setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, addresses.susds), rateLimits, data.susdsWithdrawData, "susdsWithdrawData", 18); - - setRateLimitData(controller.LIMIT_USDC_TO_CCTP(), rateLimits, data.usdcToCctpData, "usdcToCctpData", 6); - setRateLimitData(domainKeyEthereum, rateLimits, data.cctpToEthereumDomainData, "cctpToEthereumDomainData", 6); - - // Step 3: Configure the mint recipients on other domains - - for (uint256 i = 0; i < mintRecipients.length; i++) { - controller.setMintRecipient(mintRecipients[i].domain, mintRecipients[i].mintRecipient); - } - } - - function setRateLimitData( - bytes32 key, - IRateLimits rateLimits, - RateLimitData memory data, - string memory name, - uint256 decimals - ) - internal - { - // Handle setting an unlimited rate limit - if (data.maxAmount == type(uint256).max) { - require( - data.slope == 0, - string(abi.encodePacked("ForeignControllerInit/invalid-rate-limit-", name)) - ); - } - else { - require( - data.maxAmount <= 1e12 * (10 ** decimals), - string(abi.encodePacked("ForeignControllerInit/invalid-max-amount-precision-", name)) - ); - require( - data.slope <= 1e12 * (10 ** decimals) / 1 hours, - string(abi.encodePacked("ForeignControllerInit/invalid-slope-precision-", name)) - ); - } - rateLimits.setRateLimitData(key, data.maxAmount, data.slope); - } - -} \ No newline at end of file diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 05b6cd6..487e8c4 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -1,443 +1,443 @@ -// SPDX-License-Identifier: AGPL-3.0-or-later -pragma solidity ^0.8.21; - -import { - AllocatorDeploy, - AllocatorIlkInstance, - AllocatorSharedInstance -} from "dss-allocator/deploy/AllocatorDeploy.sol"; - -import { - BufferLike, - RegistryLike, - RolesLike, - VaultLike -} from "dss-allocator/deploy/AllocatorInit.sol"; - -import { AllocatorBuffer } from "dss-allocator/src/AllocatorBuffer.sol"; -import { AllocatorVault } from "dss-allocator/src/AllocatorVault.sol"; - -import { ScriptTools } from "dss-test/ScriptTools.sol"; - -import { IERC20 } from "forge-std/interfaces/IERC20.sol"; -import { Script } from "forge-std/Script.sol"; -import { stdJson } from "forge-std/StdJson.sol"; - -import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; - -import { - ControllerInstance, - ForeignController, - ForeignControllerDeploy, - MainnetController, - MainnetControllerDeploy -} from "../../deploy/ControllerDeploy.sol"; - -import { - ForeignControllerInit, - MainnetControllerInit, - MintRecipient, - RateLimitData -} from "../../deploy/ControllerInit.sol"; - -import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; -import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; - -import { MockJug } from "./mocks/MockJug.sol"; -import { MockUsdsJoin } from "./mocks/MockUsdsJoin.sol"; -import { MockVat } from "./mocks/MockVat.sol"; -import { PSMWrapper } from "./mocks/PSMWrapper.sol"; - -struct Domain { - string name; - string nameDeps; - string config; - uint256 forkId; - address admin; -} +// // SPDX-License-Identifier: AGPL-3.0-or-later +// pragma solidity ^0.8.21; + +// import { +// AllocatorDeploy, +// AllocatorIlkInstance, +// AllocatorSharedInstance +// } from "dss-allocator/deploy/AllocatorDeploy.sol"; + +// import { +// BufferLike, +// RegistryLike, +// RolesLike, +// VaultLike +// } from "dss-allocator/deploy/AllocatorInit.sol"; + +// import { AllocatorBuffer } from "dss-allocator/src/AllocatorBuffer.sol"; +// import { AllocatorVault } from "dss-allocator/src/AllocatorVault.sol"; + +// import { ScriptTools } from "dss-test/ScriptTools.sol"; + +// import { IERC20 } from "forge-std/interfaces/IERC20.sol"; +// import { Script } from "forge-std/Script.sol"; +// import { stdJson } from "forge-std/StdJson.sol"; + +// import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; + +// import { +// ControllerInstance, +// ForeignController, +// ForeignControllerDeploy, +// MainnetController, +// MainnetControllerDeploy +// } from "../../deploy/ControllerDeploy.sol"; + +// import { +// ForeignControllerInit, +// MainnetControllerInit, +// MintRecipient, +// RateLimitData +// } from "../../deploy/ControllerInit.sol"; + +// import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; +// import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; + +// import { MockJug } from "./mocks/MockJug.sol"; +// import { MockUsdsJoin } from "./mocks/MockUsdsJoin.sol"; +// import { MockVat } from "./mocks/MockVat.sol"; +// import { PSMWrapper } from "./mocks/PSMWrapper.sol"; + +// struct Domain { +// string name; +// string nameDeps; +// string config; +// uint256 forkId; +// address admin; +// } -contract FullStagingDeploy is Script { +// contract FullStagingDeploy is Script { - using stdJson for string; - using ScriptTools for string; +// using stdJson for string; +// using ScriptTools for string; - /**********************************************************************************************/ - /*** Mainnet existing/mock deployments ***/ - /**********************************************************************************************/ - - address dai; - address daiUsds; - address livePsm; - address psm; - address susds; - address usds; - address usdc; +// /**********************************************************************************************/ +// /*** Mainnet existing/mock deployments ***/ +// /**********************************************************************************************/ + +// address dai; +// address daiUsds; +// address livePsm; +// address psm; +// address susds; +// address usds; +// address usdc; - // Mocked MCD contracts - address jug; - address usdsJoin; - address vat; - - /**********************************************************************************************/ - /*** Mainnet allocation system deployments ***/ - /**********************************************************************************************/ - - address oracle; - address roles; - address registry; - - address buffer; - address vault; - - /**********************************************************************************************/ - /*** ALM system deployments ***/ - /**********************************************************************************************/ +// // Mocked MCD contracts +// address jug; +// address usdsJoin; +// address vat; + +// /**********************************************************************************************/ +// /*** Mainnet allocation system deployments ***/ +// /**********************************************************************************************/ + +// address oracle; +// address roles; +// address registry; + +// address buffer; +// address vault; + +// /**********************************************************************************************/ +// /*** ALM system deployments ***/ +// /**********************************************************************************************/ - address baseAlmProxy; - address baseController; - - address mainnetAlmProxy; - address mainnetController; - - /**********************************************************************************************/ - /*** Deployment-specific variables ***/ - /**********************************************************************************************/ +// address baseAlmProxy; +// address baseController; + +// address mainnetAlmProxy; +// address mainnetController; + +// /**********************************************************************************************/ +// /*** Deployment-specific variables ***/ +// /**********************************************************************************************/ - address deployer; - bytes32 ilk; +// address deployer; +// bytes32 ilk; - uint256 USDC_UNIT_SIZE; - uint256 USDS_UNIT_SIZE; +// uint256 USDC_UNIT_SIZE; +// uint256 USDS_UNIT_SIZE; - Domain mainnet; - Domain base; +// Domain mainnet; +// Domain base; - /**********************************************************************************************/ - /*** Helper functions ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /*** Helper functions ***/ +// /**********************************************************************************************/ - function _setUpDependencies() internal { - vm.selectFork(mainnet.forkId); - vm.startBroadcast(); +// function _setUpDependencies() internal { +// vm.selectFork(mainnet.forkId); +// vm.startBroadcast(); - // Step 1: Use existing contracts for tokens, DaiUsds and PSM +// // Step 1: Use existing contracts for tokens, DaiUsds and PSM - dai = mainnet.config.readAddress(".dai"); - usds = mainnet.config.readAddress(".usds"); - susds = mainnet.config.readAddress(".susds"); - usdc = mainnet.config.readAddress(".usdc"); - daiUsds = mainnet.config.readAddress(".daiUsds"); - livePsm = mainnet.config.readAddress(".psm"); +// dai = mainnet.config.readAddress(".dai"); +// usds = mainnet.config.readAddress(".usds"); +// susds = mainnet.config.readAddress(".susds"); +// usdc = mainnet.config.readAddress(".usdc"); +// daiUsds = mainnet.config.readAddress(".daiUsds"); +// livePsm = mainnet.config.readAddress(".psm"); - // This contract is necessary to get past the `kiss` requirement from the pause proxy. - // It wraps the `noFee` calls with regular PSM swap calls. - psm = address(new PSMWrapper(usdc, dai, livePsm)); +// // This contract is necessary to get past the `kiss` requirement from the pause proxy. +// // It wraps the `noFee` calls with regular PSM swap calls. +// psm = address(new PSMWrapper(usdc, dai, livePsm)); - // NOTE: This is a HACK to make sure that `fill` doesn't get called until the call reverts. - // Because this PSM contract is a wrapper over the real PSM, the controller queries - // the DAI balance of the PSM to check if it should fill or not. Filling with DAI - // fills the live PSM NOT the wrapper, so the while loop will continue until the - // function reverts. Dealing DAI into the wrapper will prevent fill from being called. - IERC20(dai).transfer(psm, USDS_UNIT_SIZE); +// // NOTE: This is a HACK to make sure that `fill` doesn't get called until the call reverts. +// // Because this PSM contract is a wrapper over the real PSM, the controller queries +// // the DAI balance of the PSM to check if it should fill or not. Filling with DAI +// // fills the live PSM NOT the wrapper, so the while loop will continue until the +// // function reverts. Dealing DAI into the wrapper will prevent fill from being called. +// IERC20(dai).transfer(psm, USDS_UNIT_SIZE); - // Step 2: Deploy mocked MCD contracts +// // Step 2: Deploy mocked MCD contracts - vat = address(new MockVat(mainnet.admin)); - usdsJoin = address(new MockUsdsJoin(mainnet.admin, vat, usds)); - jug = address(new MockJug()); +// vat = address(new MockVat(mainnet.admin)); +// usdsJoin = address(new MockUsdsJoin(mainnet.admin, vat, usds)); +// jug = address(new MockJug()); - // Step 3: Transfer USDS into the join contract +// // Step 3: Transfer USDS into the join contract - require(IERC20(usds).balanceOf(deployer) >= USDS_UNIT_SIZE, "USDS balance too low"); +// require(IERC20(usds).balanceOf(deployer) >= USDS_UNIT_SIZE, "USDS balance too low"); - IERC20(usds).transfer(usdsJoin, USDS_UNIT_SIZE); +// IERC20(usds).transfer(usdsJoin, USDS_UNIT_SIZE); - vm.stopBroadcast(); +// vm.stopBroadcast(); - // Step 4: Export all deployed addresses +// // Step 4: Export all deployed addresses - ScriptTools.exportContract(mainnet.nameDeps, "dai", dai); - ScriptTools.exportContract(mainnet.nameDeps, "daiUsds", daiUsds); - ScriptTools.exportContract(mainnet.nameDeps, "jug", jug); - ScriptTools.exportContract(mainnet.nameDeps, "psm", psm); - ScriptTools.exportContract(mainnet.nameDeps, "susds", susds); - ScriptTools.exportContract(mainnet.nameDeps, "usdc", usdc); - ScriptTools.exportContract(mainnet.nameDeps, "usds", usds); - ScriptTools.exportContract(mainnet.nameDeps, "usdsJoin", usdsJoin); - ScriptTools.exportContract(mainnet.nameDeps, "vat", vat); - } - - function _setUpAllocationSystem() internal { - vm.selectFork(mainnet.forkId); - vm.startBroadcast(); - - // Step 1: Deploy allocation system - - AllocatorSharedInstance memory allocatorSharedInstance - = AllocatorDeploy.deployShared(deployer, mainnet.admin); - - AllocatorIlkInstance memory allocatorIlkInstance = AllocatorDeploy.deployIlk( - deployer, - mainnet.admin, - allocatorSharedInstance.roles, - ilk, - usdsJoin - ); - - oracle = allocatorSharedInstance.oracle; - registry = allocatorSharedInstance.registry; - roles = allocatorSharedInstance.roles; - - buffer = allocatorIlkInstance.buffer; - vault = allocatorIlkInstance.vault; - - // Step 2: Perform partial initialization (not using library because of mocked MCD) - - RegistryLike(registry).file(ilk, "buffer", buffer); - VaultLike(vault).file("jug", jug); - BufferLike(buffer).approve(usds, vault, type(uint256).max); - RolesLike(roles).setIlkAdmin(ilk, mainnet.admin); - - // Step 3: Move ownership of both the vault and buffer to the admin - - ScriptTools.switchOwner(vault, allocatorIlkInstance.owner, mainnet.admin); - ScriptTools.switchOwner(buffer, allocatorIlkInstance.owner, mainnet.admin); - - vm.stopBroadcast(); - - // Step 4: Export all deployed addresses - - ScriptTools.exportContract(mainnet.nameDeps, "allocatorOracle", oracle); - ScriptTools.exportContract(mainnet.nameDeps, "allocatorRegistry", registry); - ScriptTools.exportContract(mainnet.nameDeps, "allocatorRoles", roles); - - ScriptTools.exportContract(mainnet.nameDeps, "allocatorBuffer", buffer); - ScriptTools.exportContract(mainnet.nameDeps, "allocatorVault", vault); - } - - function _setUpALMController() internal { - vm.selectFork(mainnet.forkId); - vm.startBroadcast(); - - // Step 1: Deploy ALM controller - - ControllerInstance memory instance = MainnetControllerDeploy.deployFull({ - admin : mainnet.admin, - vault : vault, - psm : psm, - daiUsds : daiUsds, - cctp : mainnet.config.readAddress(".cctpTokenMessenger") - }); - - mainnetAlmProxy = instance.almProxy; - mainnetController = instance.controller; - - // Step 2: Initialize ALM controller, setting rate limits, mint recipients, and setting ACL - - // Still constrained by the USDC_UNIT_SIZE - RateLimitData memory rateLimitData18 = RateLimitData({ - maxAmount : USDC_UNIT_SIZE * 1e12 * 5, - slope : USDC_UNIT_SIZE * 1e12 / 4 hours - }); - RateLimitData memory rateLimitData6 = RateLimitData({ - maxAmount : USDC_UNIT_SIZE * 5, - slope : USDC_UNIT_SIZE / 4 hours - }); - RateLimitData memory unlimitedRateLimit = RateLimitData({ - maxAmount : type(uint256).max, - slope : 0 - }); - - // Configure this after Base ALM Proxy is deployed - MintRecipient[] memory mintRecipients = new MintRecipient[](0); - - MainnetControllerInit.subDaoInitFull({ - addresses: MainnetControllerInit.AddressParams({ - admin : mainnet.admin, - freezer : mainnet.config.readAddress(".freezer"), - relayer : mainnet.config.readAddress(".relayer"), - oldController : address(0), - psm : psm, - vault : vault, - buffer : buffer, - cctpMessenger : mainnet.config.readAddress(".cctpTokenMessenger"), - dai : dai, - daiUsds : daiUsds, - usdc : usdc, - usds : usds, - susds : susds - }), - controllerInst: instance, - data: MainnetControllerInit.InitRateLimitData({ - usdsMintData : rateLimitData18, - usdsToUsdcData : rateLimitData6, - usdcToCctpData : unlimitedRateLimit, - cctpToBaseDomainData : rateLimitData6, - susdsDepositData : rateLimitData18 - }), - mintRecipients: mintRecipients - }); - - // Extra rate limit configuration - bytes32 mintKey = MainnetController(instance.controller).LIMIT_USDE_MINT(); - bytes32 burnKey = MainnetController(instance.controller).LIMIT_USDE_BURN(); +// ScriptTools.exportContract(mainnet.nameDeps, "dai", dai); +// ScriptTools.exportContract(mainnet.nameDeps, "daiUsds", daiUsds); +// ScriptTools.exportContract(mainnet.nameDeps, "jug", jug); +// ScriptTools.exportContract(mainnet.nameDeps, "psm", psm); +// ScriptTools.exportContract(mainnet.nameDeps, "susds", susds); +// ScriptTools.exportContract(mainnet.nameDeps, "usdc", usdc); +// ScriptTools.exportContract(mainnet.nameDeps, "usds", usds); +// ScriptTools.exportContract(mainnet.nameDeps, "usdsJoin", usdsJoin); +// ScriptTools.exportContract(mainnet.nameDeps, "vat", vat); +// } + +// function _setUpAllocationSystem() internal { +// vm.selectFork(mainnet.forkId); +// vm.startBroadcast(); + +// // Step 1: Deploy allocation system + +// AllocatorSharedInstance memory allocatorSharedInstance +// = AllocatorDeploy.deployShared(deployer, mainnet.admin); + +// AllocatorIlkInstance memory allocatorIlkInstance = AllocatorDeploy.deployIlk( +// deployer, +// mainnet.admin, +// allocatorSharedInstance.roles, +// ilk, +// usdsJoin +// ); + +// oracle = allocatorSharedInstance.oracle; +// registry = allocatorSharedInstance.registry; +// roles = allocatorSharedInstance.roles; + +// buffer = allocatorIlkInstance.buffer; +// vault = allocatorIlkInstance.vault; + +// // Step 2: Perform partial initialization (not using library because of mocked MCD) + +// RegistryLike(registry).file(ilk, "buffer", buffer); +// VaultLike(vault).file("jug", jug); +// BufferLike(buffer).approve(usds, vault, type(uint256).max); +// RolesLike(roles).setIlkAdmin(ilk, mainnet.admin); + +// // Step 3: Move ownership of both the vault and buffer to the admin + +// ScriptTools.switchOwner(vault, allocatorIlkInstance.owner, mainnet.admin); +// ScriptTools.switchOwner(buffer, allocatorIlkInstance.owner, mainnet.admin); + +// vm.stopBroadcast(); + +// // Step 4: Export all deployed addresses + +// ScriptTools.exportContract(mainnet.nameDeps, "allocatorOracle", oracle); +// ScriptTools.exportContract(mainnet.nameDeps, "allocatorRegistry", registry); +// ScriptTools.exportContract(mainnet.nameDeps, "allocatorRoles", roles); + +// ScriptTools.exportContract(mainnet.nameDeps, "allocatorBuffer", buffer); +// ScriptTools.exportContract(mainnet.nameDeps, "allocatorVault", vault); +// } + +// function _setUpALMController() internal { +// vm.selectFork(mainnet.forkId); +// vm.startBroadcast(); + +// // Step 1: Deploy ALM controller + +// ControllerInstance memory instance = MainnetControllerDeploy.deployFull({ +// admin : mainnet.admin, +// vault : vault, +// psm : psm, +// daiUsds : daiUsds, +// cctp : mainnet.config.readAddress(".cctpTokenMessenger") +// }); + +// mainnetAlmProxy = instance.almProxy; +// mainnetController = instance.controller; + +// // Step 2: Initialize ALM controller, setting rate limits, mint recipients, and setting ACL + +// // Still constrained by the USDC_UNIT_SIZE +// RateLimitData memory rateLimitData18 = RateLimitData({ +// maxAmount : USDC_UNIT_SIZE * 1e12 * 5, +// slope : USDC_UNIT_SIZE * 1e12 / 4 hours +// }); +// RateLimitData memory rateLimitData6 = RateLimitData({ +// maxAmount : USDC_UNIT_SIZE * 5, +// slope : USDC_UNIT_SIZE / 4 hours +// }); +// RateLimitData memory unlimitedRateLimit = RateLimitData({ +// maxAmount : type(uint256).max, +// slope : 0 +// }); + +// // Configure this after Base ALM Proxy is deployed +// MintRecipient[] memory mintRecipients = new MintRecipient[](0); + +// MainnetControllerInit.subDaoInitFull({ +// addresses: MainnetControllerInit.AddressParams({ +// admin : mainnet.admin, +// freezer : mainnet.config.readAddress(".freezer"), +// relayer : mainnet.config.readAddress(".relayer"), +// oldController : address(0), +// psm : psm, +// vault : vault, +// buffer : buffer, +// cctpMessenger : mainnet.config.readAddress(".cctpTokenMessenger"), +// dai : dai, +// daiUsds : daiUsds, +// usdc : usdc, +// usds : usds, +// susds : susds +// }), +// controllerInst: instance, +// data: MainnetControllerInit.InitRateLimitData({ +// usdsMintData : rateLimitData18, +// usdsToUsdcData : rateLimitData6, +// usdcToCctpData : unlimitedRateLimit, +// cctpToBaseDomainData : rateLimitData6, +// susdsDepositData : rateLimitData18 +// }), +// mintRecipients: mintRecipients +// }); + +// // Extra rate limit configuration +// bytes32 mintKey = MainnetController(instance.controller).LIMIT_USDE_MINT(); +// bytes32 burnKey = MainnetController(instance.controller).LIMIT_USDE_BURN(); - bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey( - MainnetController(instance.controller).LIMIT_4626_DEPOSIT(), - address(MainnetController(instance.controller).susde()) - ); - - bytes32 susdsWithdrawKey = RateLimitHelpers.makeAssetKey( - MainnetController(instance.controller).LIMIT_4626_WITHDRAW(), - address(MainnetController(instance.controller).susde()) - ); - - // Extra rate limit configuration - MainnetControllerInit.setRateLimitData(mintKey, IRateLimits(instance.rateLimits), rateLimitData6, "usdeMintData", 6); - MainnetControllerInit.setRateLimitData(burnKey, IRateLimits(instance.rateLimits), rateLimitData18, "usdeBurnData", 18); - MainnetControllerInit.setRateLimitData(susdsDepositKey, IRateLimits(instance.rateLimits), rateLimitData18, "susdsDepositData", 18); - MainnetControllerInit.setRateLimitData(susdsWithdrawKey, IRateLimits(instance.rateLimits), rateLimitData18, "susdsWithdrawData", 18); - - // Step 3: Transfer ownership of mock usdsJoin to the vault (able to mint usds) - - MockUsdsJoin(usdsJoin).transferOwnership(vault); - - vm.stopBroadcast(); - - // Step 4: Export all deployed addresses - - ScriptTools.exportContract(mainnet.nameDeps, "freezer", mainnet.config.readAddress(".freezer")); - ScriptTools.exportContract(mainnet.nameDeps, "relayer", mainnet.config.readAddress(".relayer")); - - ScriptTools.exportContract(mainnet.name, "almProxy", instance.almProxy); - ScriptTools.exportContract(mainnet.name, "controller", instance.controller); - ScriptTools.exportContract(mainnet.name, "rateLimits", instance.rateLimits); - } - - function _setUpBaseALMController() public { - vm.selectFork(base.forkId); - vm.startBroadcast(); - - // Step 1: Deploy ALM controller - - ControllerInstance memory instance = ForeignControllerDeploy.deployFull({ - admin : base.admin, - psm : base.config.readAddress(".psm"), - usdc : base.config.readAddress(".usdc"), - cctp : base.config.readAddress(".cctpTokenMessenger") - }); - - baseAlmProxy = instance.almProxy; - baseController = instance.controller; - - // Step 2: Initialize ALM controller, setting rate limits, mint recipients, and setting ACL - - // Still constrained by the USDC_UNIT_SIZE - RateLimitData memory rateLimitData18 = RateLimitData({ - maxAmount : USDC_UNIT_SIZE * 1e12 * 5, - slope : USDC_UNIT_SIZE * 1e12 / 4 hours - }); - RateLimitData memory rateLimitData6 = RateLimitData({ - maxAmount : USDC_UNIT_SIZE * 5, - slope : USDC_UNIT_SIZE / 4 hours - }); - RateLimitData memory unlimitedRateLimit = RateLimitData({ - maxAmount : type(uint256).max, - slope : 0 - }); - - MintRecipient[] memory mintRecipients = new MintRecipient[](1); - mintRecipients[0] = MintRecipient({ - domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - mintRecipient : bytes32(uint256(uint160(mainnetAlmProxy))) - }); - - ForeignControllerInit.init({ - addresses: ForeignControllerInit.AddressParams({ - admin : base.admin, - freezer : base.config.readAddress(".freezer"), - relayer : base.config.readAddress(".relayer"), - oldController : address(0), - psm : base.config.readAddress(".psm"), - cctpMessenger : base.config.readAddress(".cctpTokenMessenger"), - usdc : base.config.readAddress(".usdc"), - usds : base.config.readAddress(".usds"), - susds : base.config.readAddress(".susds") - }), - controllerInst: instance, - data: ForeignControllerInit.InitRateLimitData({ - usdcDepositData : rateLimitData6, - usdcWithdrawData : rateLimitData6, - usdsDepositData : rateLimitData18, - usdsWithdrawData : rateLimitData18, - susdsDepositData : rateLimitData18, - susdsWithdrawData : rateLimitData18, - usdcToCctpData : unlimitedRateLimit, - cctpToEthereumDomainData : rateLimitData6 - }), - mintRecipients: mintRecipients - }); - - vm.stopBroadcast(); - - // Step 3: Export all deployed addresses - - ScriptTools.exportContract(base.nameDeps, "freezer", base.config.readAddress(".freezer")); - ScriptTools.exportContract(base.nameDeps, "relayer", base.config.readAddress(".relayer")); - - ScriptTools.exportContract(base.name, "almProxy", instance.almProxy); - ScriptTools.exportContract(base.name, "controller", instance.controller); - ScriptTools.exportContract(base.name, "rateLimits", instance.rateLimits); - } - - function _setBaseMintRecipient() internal { - vm.selectFork(mainnet.forkId); - vm.startBroadcast(); - - MainnetController(mainnetController).setMintRecipient( - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - bytes32(uint256(uint160(baseAlmProxy))) - ); - - vm.stopBroadcast(); - } - - function run() public { - vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); - vm.setEnv("FOUNDRY_EXPORTS_OVERWRITE_LATEST", "true"); - - deployer = msg.sender; - - mainnet = Domain({ - name : "mainnet-staging", - nameDeps : "mainnet-staging-deps", - config : ScriptTools.loadConfig("mainnet-staging"), - forkId : vm.createFork(getChain("mainnet").rpcUrl), - admin : deployer - }); - base = Domain({ - name : "base-staging", - nameDeps : "base-staging-deps", - config : ScriptTools.loadConfig("base-staging"), - forkId : vm.createFork(getChain("base").rpcUrl), - admin : deployer - }); - - // Ballpark sizing of rate limits, tokens in PSMs, etc - // Ballpark sizing of USDS to put in the join contracts, PSMs, etc - USDC_UNIT_SIZE = mainnet.config.readUint(".usdcUnitSize") * 1e6; - USDS_UNIT_SIZE = mainnet.config.readUint(".usdsUnitSize") * 1e18; - - // Run deployment scripts after setting storage variables - - _setUpDependencies(); - _setUpAllocationSystem(); - _setUpALMController(); - _setUpBaseALMController(); - _setBaseMintRecipient(); - - ScriptTools.exportContract(mainnet.nameDeps, "admin", deployer); - ScriptTools.exportContract(base.nameDeps, "admin", deployer); - } - -} +// bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey( +// MainnetController(instance.controller).LIMIT_4626_DEPOSIT(), +// address(MainnetController(instance.controller).susde()) +// ); + +// bytes32 susdsWithdrawKey = RateLimitHelpers.makeAssetKey( +// MainnetController(instance.controller).LIMIT_4626_WITHDRAW(), +// address(MainnetController(instance.controller).susde()) +// ); + +// // Extra rate limit configuration +// MainnetControllerInit.setRateLimitData(mintKey, IRateLimits(instance.rateLimits), rateLimitData6, "usdeMintData", 6); +// MainnetControllerInit.setRateLimitData(burnKey, IRateLimits(instance.rateLimits), rateLimitData18, "usdeBurnData", 18); +// MainnetControllerInit.setRateLimitData(susdsDepositKey, IRateLimits(instance.rateLimits), rateLimitData18, "susdsDepositData", 18); +// MainnetControllerInit.setRateLimitData(susdsWithdrawKey, IRateLimits(instance.rateLimits), rateLimitData18, "susdsWithdrawData", 18); + +// // Step 3: Transfer ownership of mock usdsJoin to the vault (able to mint usds) + +// MockUsdsJoin(usdsJoin).transferOwnership(vault); + +// vm.stopBroadcast(); + +// // Step 4: Export all deployed addresses + +// ScriptTools.exportContract(mainnet.nameDeps, "freezer", mainnet.config.readAddress(".freezer")); +// ScriptTools.exportContract(mainnet.nameDeps, "relayer", mainnet.config.readAddress(".relayer")); + +// ScriptTools.exportContract(mainnet.name, "almProxy", instance.almProxy); +// ScriptTools.exportContract(mainnet.name, "controller", instance.controller); +// ScriptTools.exportContract(mainnet.name, "rateLimits", instance.rateLimits); +// } + +// function _setUpBaseALMController() public { +// vm.selectFork(base.forkId); +// vm.startBroadcast(); + +// // Step 1: Deploy ALM controller + +// ControllerInstance memory instance = ForeignControllerDeploy.deployFull({ +// admin : base.admin, +// psm : base.config.readAddress(".psm"), +// usdc : base.config.readAddress(".usdc"), +// cctp : base.config.readAddress(".cctpTokenMessenger") +// }); + +// baseAlmProxy = instance.almProxy; +// baseController = instance.controller; + +// // Step 2: Initialize ALM controller, setting rate limits, mint recipients, and setting ACL + +// // Still constrained by the USDC_UNIT_SIZE +// RateLimitData memory rateLimitData18 = RateLimitData({ +// maxAmount : USDC_UNIT_SIZE * 1e12 * 5, +// slope : USDC_UNIT_SIZE * 1e12 / 4 hours +// }); +// RateLimitData memory rateLimitData6 = RateLimitData({ +// maxAmount : USDC_UNIT_SIZE * 5, +// slope : USDC_UNIT_SIZE / 4 hours +// }); +// RateLimitData memory unlimitedRateLimit = RateLimitData({ +// maxAmount : type(uint256).max, +// slope : 0 +// }); + +// MintRecipient[] memory mintRecipients = new MintRecipient[](1); +// mintRecipients[0] = MintRecipient({ +// domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, +// mintRecipient : bytes32(uint256(uint160(mainnetAlmProxy))) +// }); + +// ForeignControllerInit.init({ +// addresses: ForeignControllerInit.AddressParams({ +// admin : base.admin, +// freezer : base.config.readAddress(".freezer"), +// relayer : base.config.readAddress(".relayer"), +// oldController : address(0), +// psm : base.config.readAddress(".psm"), +// cctpMessenger : base.config.readAddress(".cctpTokenMessenger"), +// usdc : base.config.readAddress(".usdc"), +// usds : base.config.readAddress(".usds"), +// susds : base.config.readAddress(".susds") +// }), +// controllerInst: instance, +// data: ForeignControllerInit.InitRateLimitData({ +// usdcDepositData : rateLimitData6, +// usdcWithdrawData : rateLimitData6, +// usdsDepositData : rateLimitData18, +// usdsWithdrawData : rateLimitData18, +// susdsDepositData : rateLimitData18, +// susdsWithdrawData : rateLimitData18, +// usdcToCctpData : unlimitedRateLimit, +// cctpToEthereumDomainData : rateLimitData6 +// }), +// mintRecipients: mintRecipients +// }); + +// vm.stopBroadcast(); + +// // Step 3: Export all deployed addresses + +// ScriptTools.exportContract(base.nameDeps, "freezer", base.config.readAddress(".freezer")); +// ScriptTools.exportContract(base.nameDeps, "relayer", base.config.readAddress(".relayer")); + +// ScriptTools.exportContract(base.name, "almProxy", instance.almProxy); +// ScriptTools.exportContract(base.name, "controller", instance.controller); +// ScriptTools.exportContract(base.name, "rateLimits", instance.rateLimits); +// } + +// function _setBaseMintRecipient() internal { +// vm.selectFork(mainnet.forkId); +// vm.startBroadcast(); + +// MainnetController(mainnetController).setMintRecipient( +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, +// bytes32(uint256(uint160(baseAlmProxy))) +// ); + +// vm.stopBroadcast(); +// } + +// function run() public { +// vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); +// vm.setEnv("FOUNDRY_EXPORTS_OVERWRITE_LATEST", "true"); + +// deployer = msg.sender; + +// mainnet = Domain({ +// name : "mainnet-staging", +// nameDeps : "mainnet-staging-deps", +// config : ScriptTools.loadConfig("mainnet-staging"), +// forkId : vm.createFork(getChain("mainnet").rpcUrl), +// admin : deployer +// }); +// base = Domain({ +// name : "base-staging", +// nameDeps : "base-staging-deps", +// config : ScriptTools.loadConfig("base-staging"), +// forkId : vm.createFork(getChain("base").rpcUrl), +// admin : deployer +// }); + +// // Ballpark sizing of rate limits, tokens in PSMs, etc +// // Ballpark sizing of USDS to put in the join contracts, PSMs, etc +// USDC_UNIT_SIZE = mainnet.config.readUint(".usdcUnitSize") * 1e6; +// USDS_UNIT_SIZE = mainnet.config.readUint(".usdsUnitSize") * 1e18; + +// // Run deployment scripts after setting storage variables + +// _setUpDependencies(); +// _setUpAllocationSystem(); +// _setUpALMController(); +// _setUpBaseALMController(); +// _setBaseMintRecipient(); + +// ScriptTools.exportContract(mainnet.nameDeps, "admin", deployer); +// ScriptTools.exportContract(base.nameDeps, "admin", deployer); +// } + +// } diff --git a/script/staging/test/StagingDeployment.t.sol b/script/staging/test/StagingDeployment.t.sol index a13fd70..ef7a3be 100644 --- a/script/staging/test/StagingDeployment.t.sol +++ b/script/staging/test/StagingDeployment.t.sol @@ -1,605 +1,605 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; +// // SPDX-License-Identifier: MIT +// pragma solidity ^0.8.0; -import { ScriptTools } from "dss-test/ScriptTools.sol"; +// import { ScriptTools } from "dss-test/ScriptTools.sol"; -import "forge-std/Test.sol"; +// import "forge-std/Test.sol"; -import { IERC20 } from "forge-std/interfaces/IERC20.sol"; -import { IERC4626 } from "forge-std/interfaces/IERC4626.sol"; +// import { IERC20 } from "forge-std/interfaces/IERC20.sol"; +// import { IERC4626 } from "forge-std/interfaces/IERC4626.sol"; -import { IMetaMorpho, Id } from "metamorpho/interfaces/IMetaMorpho.sol"; +// import { IMetaMorpho, Id } from "metamorpho/interfaces/IMetaMorpho.sol"; -import { MarketParamsLib } from "morpho-blue/src/libraries/MarketParamsLib.sol"; -import { IMorpho, MarketParams } from "morpho-blue/src/interfaces/IMorpho.sol"; +// import { MarketParamsLib } from "morpho-blue/src/libraries/MarketParamsLib.sol"; +// import { IMorpho, MarketParams } from "morpho-blue/src/interfaces/IMorpho.sol"; -import { Usds } from "usds/src/Usds.sol"; +// import { Usds } from "usds/src/Usds.sol"; -import { SUsds } from "sdai/src/SUsds.sol"; +// import { SUsds } from "sdai/src/SUsds.sol"; -import { Base } from "spark-address-registry/src/Base.sol"; -import { Ethereum } from "spark-address-registry/src/Ethereum.sol"; +// import { Base } from "spark-address-registry/src/Base.sol"; +// import { Ethereum } from "spark-address-registry/src/Ethereum.sol"; -import { PSM3 } from "spark-psm/src/PSM3.sol"; +// import { PSM3 } from "spark-psm/src/PSM3.sol"; -import { Bridge } from "xchain-helpers/src/testing/Bridge.sol"; -import { Domain, DomainHelpers } from "xchain-helpers/src/testing/Domain.sol"; -import { CCTPBridgeTesting } from "xchain-helpers/src/testing/bridges/CCTPBridgeTesting.sol"; -import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; +// import { Bridge } from "xchain-helpers/src/testing/Bridge.sol"; +// import { Domain, DomainHelpers } from "xchain-helpers/src/testing/Domain.sol"; +// import { CCTPBridgeTesting } from "xchain-helpers/src/testing/bridges/CCTPBridgeTesting.sol"; +// import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; -import { MainnetControllerDeploy } from "../../../deploy/ControllerDeploy.sol"; -import { MainnetControllerInit } from "../../../deploy/ControllerInit.sol"; +// import { MainnetControllerDeploy } from "../../../deploy/ControllerDeploy.sol"; +// import { MainnetControllerInit } from "../../../deploy/ControllerInit.sol"; -import { IRateLimits } from "../../../src/interfaces/IRateLimits.sol"; +// import { IRateLimits } from "../../../src/interfaces/IRateLimits.sol"; -import { ALMProxy } from "../../../src/ALMProxy.sol"; -import { ForeignController } from "../../../src/ForeignController.sol"; -import { MainnetController } from "../../../src/MainnetController.sol"; -import { RateLimits } from "../../../src/RateLimits.sol"; -import { RateLimitHelpers } from "../../../src/RateLimitHelpers.sol"; +// import { ALMProxy } from "../../../src/ALMProxy.sol"; +// import { ForeignController } from "../../../src/ForeignController.sol"; +// import { MainnetController } from "../../../src/MainnetController.sol"; +// import { RateLimits } from "../../../src/RateLimits.sol"; +// import { RateLimitHelpers } from "../../../src/RateLimitHelpers.sol"; -interface IVatLike { - function can(address, address) external view returns (uint256); -} +// interface IVatLike { +// function can(address, address) external view returns (uint256); +// } -contract StagingDeploymentTestBase is Test { +// contract StagingDeploymentTestBase is Test { - using stdJson for *; - using DomainHelpers for *; - using CCTPBridgeTesting for *; - using ScriptTools for *; +// using stdJson for *; +// using DomainHelpers for *; +// using CCTPBridgeTesting for *; +// using ScriptTools for *; - // AAVE aTokens for testing - address constant AUSDS = 0x32a6268f9Ba3642Dda7892aDd74f1D34469A4259; - address constant AUSDC = 0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c; +// // AAVE aTokens for testing +// address constant AUSDS = 0x32a6268f9Ba3642Dda7892aDd74f1D34469A4259; +// address constant AUSDC = 0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c; - bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; +// bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; - uint256 constant RELEASE_DATE = 20241210; +// uint256 constant RELEASE_DATE = 20241210; - // Common variables - address admin; +// // Common variables +// address admin; - // Configuration data - string inputBase; - string inputMainnet; - string outputBase; - string outputBaseDeps; - string outputMainnet; - string outputMainnetDeps; +// // Configuration data +// string inputBase; +// string inputMainnet; +// string outputBase; +// string outputBaseDeps; +// string outputMainnet; +// string outputMainnetDeps; - // Bridging - Domain mainnet; - Domain base; - Bridge cctpBridge; +// // Bridging +// Domain mainnet; +// Domain base; +// Bridge cctpBridge; - // Mainnet contracts +// // Mainnet contracts - Usds usds; - SUsds susds; - IERC20 usdc; - IERC20 dai; +// Usds usds; +// SUsds susds; +// IERC20 usdc; +// IERC20 dai; - address vault; - address relayerSafe; - address usdsJoin; +// address vault; +// address relayerSafe; +// address usdsJoin; - ALMProxy almProxy; - MainnetController mainnetController; - RateLimits rateLimits; +// ALMProxy almProxy; +// MainnetController mainnetController; +// RateLimits rateLimits; - // Base contracts +// // Base contracts - address relayerSafeBase; +// address relayerSafeBase; - PSM3 psmBase; +// PSM3 psmBase; - IERC20 usdsBase; - IERC20 susdsBase; - IERC20 usdcBase; +// IERC20 usdsBase; +// IERC20 susdsBase; +// IERC20 usdcBase; - ALMProxy baseAlmProxy; - ForeignController baseController; - RateLimits baseRateLimits; +// ALMProxy baseAlmProxy; +// ForeignController baseController; +// RateLimits baseRateLimits; - /**********************************************************************************************/ - /**** Setup ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /**** Setup ***/ +// /**********************************************************************************************/ - function setUp() public virtual { - vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); +// function setUp() public virtual { +// vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); - // Domains and bridge - mainnet = getChain("mainnet").createSelectFork(); - base = getChain("base").createFork(); - cctpBridge = CCTPBridgeTesting.createCircleBridge(mainnet, base); +// // Domains and bridge +// mainnet = getChain("mainnet").createSelectFork(); +// base = getChain("base").createFork(); +// cctpBridge = CCTPBridgeTesting.createCircleBridge(mainnet, base); - // JSON data - inputBase = ScriptTools.readInput("base-staging"); - inputMainnet = ScriptTools.readInput("mainnet-staging"); +// // JSON data +// inputBase = ScriptTools.readInput("base-staging"); +// inputMainnet = ScriptTools.readInput("mainnet-staging"); - outputBase = ScriptTools.readOutput("base-staging-release", RELEASE_DATE); - outputBaseDeps = ScriptTools.readOutput("base-staging-deps-release", RELEASE_DATE); - outputMainnet = ScriptTools.readOutput("mainnet-staging-release", RELEASE_DATE); - outputMainnetDeps = ScriptTools.readOutput("mainnet-staging-deps-release", RELEASE_DATE); +// outputBase = ScriptTools.readOutput("base-staging-release", RELEASE_DATE); +// outputBaseDeps = ScriptTools.readOutput("base-staging-deps-release", RELEASE_DATE); +// outputMainnet = ScriptTools.readOutput("mainnet-staging-release", RELEASE_DATE); +// outputMainnetDeps = ScriptTools.readOutput("mainnet-staging-deps-release", RELEASE_DATE); - // Roles - admin = outputMainnetDeps.readAddress(".admin"); - relayerSafe = outputMainnetDeps.readAddress(".relayer"); +// // Roles +// admin = outputMainnetDeps.readAddress(".admin"); +// relayerSafe = outputMainnetDeps.readAddress(".relayer"); - // Tokens - usds = Usds(outputMainnetDeps.readAddress(".usds")); - susds = SUsds(outputMainnetDeps.readAddress(".susds")); - usdc = IERC20(outputMainnetDeps.readAddress(".usdc")); - dai = IERC20(outputMainnetDeps.readAddress(".dai")); - - // Dependencies - vault = outputMainnetDeps.readAddress(".allocatorVault"); - usdsJoin = outputMainnetDeps.readAddress(".usdsJoin"); +// // Tokens +// usds = Usds(outputMainnetDeps.readAddress(".usds")); +// susds = SUsds(outputMainnetDeps.readAddress(".susds")); +// usdc = IERC20(outputMainnetDeps.readAddress(".usdc")); +// dai = IERC20(outputMainnetDeps.readAddress(".dai")); + +// // Dependencies +// vault = outputMainnetDeps.readAddress(".allocatorVault"); +// usdsJoin = outputMainnetDeps.readAddress(".usdsJoin"); - // ALM system - almProxy = ALMProxy(payable(outputMainnet.readAddress(".almProxy"))); - rateLimits = RateLimits(outputMainnet.readAddress(".rateLimits")); - mainnetController = _reconfigureMainnetController(); +// // ALM system +// almProxy = ALMProxy(payable(outputMainnet.readAddress(".almProxy"))); +// rateLimits = RateLimits(outputMainnet.readAddress(".rateLimits")); +// mainnetController = _reconfigureMainnetController(); - // Base roles - relayerSafeBase = outputBaseDeps.readAddress(".relayer"); - - // Base tokens - usdsBase = IERC20(inputBase.readAddress(".usds")); - susdsBase = IERC20(inputBase.readAddress(".susds")); - usdcBase = IERC20(inputBase.readAddress(".usdc")); - - // Base ALM system - baseAlmProxy = ALMProxy(payable(outputBase.readAddress(".almProxy"))); - baseController = ForeignController(outputBase.readAddress(".controller")); - baseRateLimits = RateLimits(outputBase.readAddress(".rateLimits")); +// // Base roles +// relayerSafeBase = outputBaseDeps.readAddress(".relayer"); + +// // Base tokens +// usdsBase = IERC20(inputBase.readAddress(".usds")); +// susdsBase = IERC20(inputBase.readAddress(".susds")); +// usdcBase = IERC20(inputBase.readAddress(".usdc")); + +// // Base ALM system +// baseAlmProxy = ALMProxy(payable(outputBase.readAddress(".almProxy"))); +// baseController = ForeignController(outputBase.readAddress(".controller")); +// baseRateLimits = RateLimits(outputBase.readAddress(".rateLimits")); - // Base PSM - psmBase = PSM3(inputBase.readAddress(".psm")); - - mainnet.selectFork(); - - deal(address(usds), address(usdsJoin), 1000e18); // Ensure there is enough balance - } - - // TODO: Remove this once a deployment has been done on mainnet - function _reconfigureMainnetController() internal returns (MainnetController newController) { - newController = MainnetController(MainnetControllerDeploy.deployController({ - admin : admin, - almProxy : address(almProxy), - rateLimits : address(rateLimits), - vault : address(vault), - psm : inputMainnet.readAddress(".psm"), - daiUsds : inputMainnet.readAddress(".daiUsds"), - cctp : inputMainnet.readAddress(".cctpTokenMessenger") - })); +// // Base PSM +// psmBase = PSM3(inputBase.readAddress(".psm")); + +// mainnet.selectFork(); + +// deal(address(usds), address(usdsJoin), 1000e18); // Ensure there is enough balance +// } + +// // TODO: Remove this once a deployment has been done on mainnet +// function _reconfigureMainnetController() internal returns (MainnetController newController) { +// newController = MainnetController(MainnetControllerDeploy.deployController({ +// admin : admin, +// almProxy : address(almProxy), +// rateLimits : address(rateLimits), +// vault : address(vault), +// psm : inputMainnet.readAddress(".psm"), +// daiUsds : inputMainnet.readAddress(".daiUsds"), +// cctp : inputMainnet.readAddress(".cctpTokenMessenger") +// })); - vm.startPrank(admin); - - newController.grantRole(newController.FREEZER(), inputMainnet.readAddress(".freezer")); - newController.grantRole(newController.RELAYER(), inputMainnet.readAddress(".relayer")); +// vm.startPrank(admin); + +// newController.grantRole(newController.FREEZER(), inputMainnet.readAddress(".freezer")); +// newController.grantRole(newController.RELAYER(), inputMainnet.readAddress(".relayer")); - almProxy.grantRole(almProxy.CONTROLLER(), address(newController)); - rateLimits.grantRole(rateLimits.CONTROLLER(), address(newController)); +// almProxy.grantRole(almProxy.CONTROLLER(), address(newController)); +// rateLimits.grantRole(rateLimits.CONTROLLER(), address(newController)); - almProxy.revokeRole(almProxy.CONTROLLER(), outputMainnet.readAddress(".controller")); - rateLimits.revokeRole(rateLimits.CONTROLLER(), outputMainnet.readAddress(".controller")); - - newController.setMintRecipient( - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - bytes32(uint256(uint160(address(outputBase.readAddress(".almProxy"))))) - ); - - // Set all rate limits - - bytes32[] memory rateLimitKeys = new bytes32[](10); - - rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDS); - rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDC); - rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDS); - rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDE); - rateLimitKeys[4] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDS); - rateLimitKeys[5] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDC); - rateLimitKeys[6] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_WITHDRAW(), Ethereum.SUSDS); - rateLimitKeys[7] = newController.LIMIT_USDE_MINT(); - rateLimitKeys[8] = newController.LIMIT_USDE_BURN(); - rateLimitKeys[9] = newController.LIMIT_SUSDE_COOLDOWN(); +// almProxy.revokeRole(almProxy.CONTROLLER(), outputMainnet.readAddress(".controller")); +// rateLimits.revokeRole(rateLimits.CONTROLLER(), outputMainnet.readAddress(".controller")); + +// newController.setMintRecipient( +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, +// bytes32(uint256(uint160(address(outputBase.readAddress(".almProxy"))))) +// ); + +// // Set all rate limits + +// bytes32[] memory rateLimitKeys = new bytes32[](10); + +// rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDS); +// rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDC); +// rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDS); +// rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDE); +// rateLimitKeys[4] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDS); +// rateLimitKeys[5] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDC); +// rateLimitKeys[6] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_WITHDRAW(), Ethereum.SUSDS); +// rateLimitKeys[7] = newController.LIMIT_USDE_MINT(); +// rateLimitKeys[8] = newController.LIMIT_USDE_BURN(); +// rateLimitKeys[9] = newController.LIMIT_SUSDE_COOLDOWN(); - for (uint256 i; i < rateLimitKeys.length; i++) { - rateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); - } +// for (uint256 i; i < rateLimitKeys.length; i++) { +// rateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); +// } - vm.stopPrank(); - } -} +// vm.stopPrank(); +// } +// } -contract MainnetStagingDeploymentTests is StagingDeploymentTestBase { +// contract MainnetStagingDeploymentTests is StagingDeploymentTestBase { - function test_mintUSDS() public { - uint256 startingBalance = usds.balanceOf(address(almProxy)); +// function test_mintUSDS() public { +// uint256 startingBalance = usds.balanceOf(address(almProxy)); - vm.prank(relayerSafe); - mainnetController.mintUSDS(10e18); +// vm.prank(relayerSafe); +// mainnetController.mintUSDS(10e18); - assertEq(usds.balanceOf(address(almProxy)), startingBalance + 10e18); - } +// assertEq(usds.balanceOf(address(almProxy)), startingBalance + 10e18); +// } - function test_mintAndSwapToUSDC() public { - uint256 startingBalance = usdc.balanceOf(address(almProxy)); +// function test_mintAndSwapToUSDC() public { +// uint256 startingBalance = usdc.balanceOf(address(almProxy)); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// vm.stopPrank(); - assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); - } +// assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); +// } - function test_depositAndWithdrawUsdsFromSUsds() public { - uint256 startingBalance = usds.balanceOf(address(almProxy)); +// function test_depositAndWithdrawUsdsFromSUsds() public { +// uint256 startingBalance = usds.balanceOf(address(almProxy)); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.depositERC4626(Ethereum.SUSDS, 10e18); - skip(1 days); - mainnetController.withdrawERC4626(Ethereum.SUSDS, 10e18); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.depositERC4626(Ethereum.SUSDS, 10e18); +// skip(1 days); +// mainnetController.withdrawERC4626(Ethereum.SUSDS, 10e18); +// vm.stopPrank(); - assertEq(usds.balanceOf(address(almProxy)), startingBalance + 10e18); +// assertEq(usds.balanceOf(address(almProxy)), startingBalance + 10e18); - assertGe(IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy)), 0); // Interest earned - } +// assertGe(IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy)), 0); // Interest earned +// } - function test_depositAndRedeemUsdsFromSUsds() public { - uint256 startingBalance = usds.balanceOf(address(almProxy)); +// function test_depositAndRedeemUsdsFromSUsds() public { +// uint256 startingBalance = usds.balanceOf(address(almProxy)); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.depositERC4626(Ethereum.SUSDS, 10e18); - skip(1 days); - mainnetController.redeemERC4626(Ethereum.SUSDS, IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy))); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.depositERC4626(Ethereum.SUSDS, 10e18); +// skip(1 days); +// mainnetController.redeemERC4626(Ethereum.SUSDS, IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy))); +// vm.stopPrank(); - assertGe(usds.balanceOf(address(almProxy)), startingBalance + 10e18); // Interest earned +// assertGe(usds.balanceOf(address(almProxy)), startingBalance + 10e18); // Interest earned - assertEq(IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy)), 0); - } +// assertEq(IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy)), 0); +// } - function test_depositAndWithdrawUsdsFromAave() public { - uint256 startingBalance = usds.balanceOf(address(almProxy)); +// function test_depositAndWithdrawUsdsFromAave() public { +// uint256 startingBalance = usds.balanceOf(address(almProxy)); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.depositAave(AUSDS, 10e6); - skip(1 days); - mainnetController.withdrawAave(AUSDS, type(uint256).max); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.depositAave(AUSDS, 10e6); +// skip(1 days); +// mainnetController.withdrawAave(AUSDS, type(uint256).max); +// vm.stopPrank(); - assertGe(usds.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned - } +// assertGe(usds.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned +// } - function test_depositAndWithdrawUsdcFromAave() public { - uint256 startingBalance = usdc.balanceOf(address(almProxy)); +// function test_depositAndWithdrawUsdcFromAave() public { +// uint256 startingBalance = usdc.balanceOf(address(almProxy)); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.depositAave(AUSDC, 10e6); - skip(1 days); - mainnetController.withdrawAave(AUSDC, type(uint256).max); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.depositAave(AUSDC, 10e6); +// skip(1 days); +// mainnetController.withdrawAave(AUSDC, type(uint256).max); +// vm.stopPrank(); - assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned - } +// assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned +// } - function test_mintDepositCooldownAssetsBurnUsde() public { - uint256 startingBalance = usdc.balanceOf(address(almProxy)); +// function test_mintDepositCooldownAssetsBurnUsde() public { +// uint256 startingBalance = usdc.balanceOf(address(almProxy)); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.prepareUSDeMint(10e6); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.prepareUSDeMint(10e6); +// vm.stopPrank(); - _simulateUsdeMint(10e6); +// _simulateUsdeMint(10e6); - vm.startPrank(relayerSafe); - mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); - skip(1 days); - mainnetController.cooldownAssetsSUSDe(10e18); - skip(7 days); - mainnetController.unstakeSUSDe(); - mainnetController.prepareUSDeBurn(10e18); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); +// skip(1 days); +// mainnetController.cooldownAssetsSUSDe(10e18); +// skip(7 days); +// mainnetController.unstakeSUSDe(); +// mainnetController.prepareUSDeBurn(10e18); +// vm.stopPrank(); - _simulateUsdeBurn(10e18); +// _simulateUsdeBurn(10e18); - assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); +// assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); - assertGe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); // Interest earned - } +// assertGe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); // Interest earned +// } - function test_mintDepositCooldownSharesBurnUsde() public { - uint256 startingBalance = usdc.balanceOf(address(almProxy)); +// function test_mintDepositCooldownSharesBurnUsde() public { +// uint256 startingBalance = usdc.balanceOf(address(almProxy)); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.prepareUSDeMint(10e6); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.prepareUSDeMint(10e6); +// vm.stopPrank(); - _simulateUsdeMint(10e6); +// _simulateUsdeMint(10e6); - vm.startPrank(relayerSafe); - mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); - skip(1 days); - uint256 usdeAmount = mainnetController.cooldownSharesSUSDe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy))); - skip(7 days); - mainnetController.unstakeSUSDe(); - mainnetController.prepareUSDeBurn(usdeAmount); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); +// skip(1 days); +// uint256 usdeAmount = mainnetController.cooldownSharesSUSDe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy))); +// skip(7 days); +// mainnetController.unstakeSUSDe(); +// mainnetController.prepareUSDeBurn(usdeAmount); +// vm.stopPrank(); - _simulateUsdeBurn(usdeAmount); +// _simulateUsdeBurn(usdeAmount); - assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned +// assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned - assertEq(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); - } +// assertEq(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); +// } - /**********************************************************************************************/ - /**** Helper functions ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /**** Helper functions ***/ +// /**********************************************************************************************/ - // NOTE: In reality these actions are performed by the signer submitting an order with an - // EIP712 signature which is verified by the ethenaMinter contract, - // minting/burning USDe into the ALMProxy. Also, for the purposes of this test, - // minting/burning is done 1:1 with USDC. +// // NOTE: In reality these actions are performed by the signer submitting an order with an +// // EIP712 signature which is verified by the ethenaMinter contract, +// // minting/burning USDe into the ALMProxy. Also, for the purposes of this test, +// // minting/burning is done 1:1 with USDC. - // TODO: Try doing ethena minting with EIP-712 signatures (vm.sign) +// // TODO: Try doing ethena minting with EIP-712 signatures (vm.sign) - function _simulateUsdeMint(uint256 amount) internal { - vm.prank(Ethereum.ETHENA_MINTER); - usdc.transferFrom(address(almProxy), Ethereum.ETHENA_MINTER, amount); - deal( - Ethereum.USDE, - address(almProxy), - IERC20(Ethereum.USDE).balanceOf(address(almProxy)) + amount * 1e12 - ); - } +// function _simulateUsdeMint(uint256 amount) internal { +// vm.prank(Ethereum.ETHENA_MINTER); +// usdc.transferFrom(address(almProxy), Ethereum.ETHENA_MINTER, amount); +// deal( +// Ethereum.USDE, +// address(almProxy), +// IERC20(Ethereum.USDE).balanceOf(address(almProxy)) + amount * 1e12 +// ); +// } - function _simulateUsdeBurn(uint256 amount) internal { - vm.prank(Ethereum.ETHENA_MINTER); - IERC20(Ethereum.USDE).transferFrom(address(almProxy), Ethereum.ETHENA_MINTER, amount); - deal(address(usdc), address(almProxy), usdc.balanceOf(address(almProxy)) + amount / 1e12); - } +// function _simulateUsdeBurn(uint256 amount) internal { +// vm.prank(Ethereum.ETHENA_MINTER); +// IERC20(Ethereum.USDE).transferFrom(address(almProxy), Ethereum.ETHENA_MINTER, amount); +// deal(address(usdc), address(almProxy), usdc.balanceOf(address(almProxy)) + amount / 1e12); +// } -} +// } -contract BaseStagingDeploymentTests is StagingDeploymentTestBase { +// contract BaseStagingDeploymentTests is StagingDeploymentTestBase { - using DomainHelpers for *; - using CCTPBridgeTesting for *; +// using DomainHelpers for *; +// using CCTPBridgeTesting for *; - address constant AUSDC_BASE = 0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB; - address constant MORPHO = 0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb; - address constant MORPHO_VAULT_USDC = 0x305E03Ed9ADaAB22F4A58c24515D79f2B1E2FD5D; +// address constant AUSDC_BASE = 0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB; +// address constant MORPHO = 0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb; +// address constant MORPHO_VAULT_USDC = 0x305E03Ed9ADaAB22F4A58c24515D79f2B1E2FD5D; - function setUp() public override { - super.setUp(); +// function setUp() public override { +// super.setUp(); - base.selectFork(); +// base.selectFork(); - bytes32[] memory rateLimitKeys = new bytes32[](4); +// bytes32[] memory rateLimitKeys = new bytes32[](4); - rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_DEPOSIT(), AUSDC_BASE); - rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_DEPOSIT(), MORPHO_VAULT_USDC); - rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_WITHDRAW(), AUSDC_BASE); - rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_WITHDRAW(), MORPHO_VAULT_USDC); +// rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_DEPOSIT(), AUSDC_BASE); +// rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_DEPOSIT(), MORPHO_VAULT_USDC); +// rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_WITHDRAW(), AUSDC_BASE); +// rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_WITHDRAW(), MORPHO_VAULT_USDC); - vm.startPrank(admin); +// vm.startPrank(admin); - for (uint256 i; i < rateLimitKeys.length; i++) { - baseRateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); - } +// for (uint256 i; i < rateLimitKeys.length; i++) { +// baseRateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); +// } - vm.stopPrank(); - } +// vm.stopPrank(); +// } - function test_transferCCTP() public { - base.selectFork(); +// function test_transferCCTP() public { +// base.selectFork(); - uint256 startingBalance = usdcBase.balanceOf(address(baseAlmProxy)); +// uint256 startingBalance = usdcBase.balanceOf(address(baseAlmProxy)); - mainnet.selectFork(); +// mainnet.selectFork(); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.stopPrank(); - cctpBridge.relayMessagesToDestination(true); +// cctpBridge.relayMessagesToDestination(true); - assertEq(usdcBase.balanceOf(address(baseAlmProxy)), startingBalance + 10e6); - } +// assertEq(usdcBase.balanceOf(address(baseAlmProxy)), startingBalance + 10e6); +// } - function test_transferToPSM() public { - base.selectFork(); +// function test_transferToPSM() public { +// base.selectFork(); - uint256 startingBalance = usdcBase.balanceOf(address(psmBase)); +// uint256 startingBalance = usdcBase.balanceOf(address(psmBase)); - mainnet.selectFork(); +// mainnet.selectFork(); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.stopPrank(); - cctpBridge.relayMessagesToDestination(true); +// cctpBridge.relayMessagesToDestination(true); - uint256 startingShares = psmBase.shares(address(baseAlmProxy)); +// uint256 startingShares = psmBase.shares(address(baseAlmProxy)); - vm.startPrank(relayerSafeBase); - baseController.depositPSM(address(usdcBase), 10e6); - vm.stopPrank(); +// vm.startPrank(relayerSafeBase); +// baseController.depositPSM(address(usdcBase), 10e6); +// vm.stopPrank(); - assertEq(usdcBase.balanceOf(address(psmBase)), startingBalance + 10e6); +// assertEq(usdcBase.balanceOf(address(psmBase)), startingBalance + 10e6); - assertEq(psmBase.shares(address(baseAlmProxy)), startingShares + psmBase.convertToShares(10e18)); - } +// assertEq(psmBase.shares(address(baseAlmProxy)), startingShares + psmBase.convertToShares(10e18)); +// } - function test_addAndRemoveFundsFromBasePSM() public { - mainnet.selectFork(); +// function test_addAndRemoveFundsFromBasePSM() public { +// mainnet.selectFork(); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.stopPrank(); - cctpBridge.relayMessagesToDestination(true); +// cctpBridge.relayMessagesToDestination(true); - vm.startPrank(relayerSafeBase); - baseController.depositPSM(address(usdcBase), 10e6); - skip(1 days); - baseController.withdrawPSM(address(usdcBase), 10e6); - baseController.transferUSDCToCCTP(10e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding - vm.stopPrank(); +// vm.startPrank(relayerSafeBase); +// baseController.depositPSM(address(usdcBase), 10e6); +// skip(1 days); +// baseController.withdrawPSM(address(usdcBase), 10e6); +// baseController.transferUSDCToCCTP(10e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding +// vm.stopPrank(); - cctpBridge.relayMessagesToSource(true); +// cctpBridge.relayMessagesToSource(true); - vm.startPrank(relayerSafe); - mainnetController.swapUSDCToUSDS(10e6 - 1); - mainnetController.burnUSDS((10e6 - 1) * 1e12); - vm.stopPrank(); - } +// vm.startPrank(relayerSafe); +// mainnetController.swapUSDCToUSDS(10e6 - 1); +// mainnetController.burnUSDS((10e6 - 1) * 1e12); +// vm.stopPrank(); +// } - function test_addAndRemoveFundsFromBaseAAVE() public { - mainnet.selectFork(); +// function test_addAndRemoveFundsFromBaseAAVE() public { +// mainnet.selectFork(); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.stopPrank(); - cctpBridge.relayMessagesToDestination(true); +// cctpBridge.relayMessagesToDestination(true); - vm.startPrank(relayerSafeBase); - baseController.depositAave(AUSDC_BASE, 10e6); - skip(1 days); - baseController.withdrawAave(AUSDC_BASE, 10e6); +// vm.startPrank(relayerSafeBase); +// baseController.depositAave(AUSDC_BASE, 10e6); +// skip(1 days); +// baseController.withdrawAave(AUSDC_BASE, 10e6); - assertEq(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); +// assertEq(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); - assertGe(IERC20(AUSDC_BASE).balanceOf(address(baseAlmProxy)), 0); // Interest earned +// assertGe(IERC20(AUSDC_BASE).balanceOf(address(baseAlmProxy)), 0); // Interest earned - baseController.transferUSDCToCCTP(10e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding - vm.stopPrank(); +// baseController.transferUSDCToCCTP(10e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding +// vm.stopPrank(); - cctpBridge.relayMessagesToSource(true); +// cctpBridge.relayMessagesToSource(true); - vm.startPrank(relayerSafe); - mainnetController.swapUSDCToUSDS(10e6 - 1); - mainnetController.burnUSDS((10e6 - 1) * 1e12); - vm.stopPrank(); - } +// vm.startPrank(relayerSafe); +// mainnetController.swapUSDCToUSDS(10e6 - 1); +// mainnetController.burnUSDS((10e6 - 1) * 1e12); +// vm.stopPrank(); +// } - function test_depositWithdrawFundsFromBaseMorphoUsdc() public { - _setUpMorphoMarket(); +// function test_depositWithdrawFundsFromBaseMorphoUsdc() public { +// _setUpMorphoMarket(); - mainnet.selectFork(); +// mainnet.selectFork(); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.stopPrank(); - cctpBridge.relayMessagesToDestination(true); +// cctpBridge.relayMessagesToDestination(true); - vm.startPrank(relayerSafeBase); - baseController.depositERC4626(MORPHO_VAULT_USDC, 10e6); - skip(1 days); - baseController.withdrawERC4626(MORPHO_VAULT_USDC, 10e6); +// vm.startPrank(relayerSafeBase); +// baseController.depositERC4626(MORPHO_VAULT_USDC, 10e6); +// skip(1 days); +// baseController.withdrawERC4626(MORPHO_VAULT_USDC, 10e6); - assertEq(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); +// assertEq(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); - assertGe(IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy)), 0); // Interest earned +// assertGe(IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy)), 0); // Interest earned - baseController.transferUSDCToCCTP(1e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding - vm.stopPrank(); +// baseController.transferUSDCToCCTP(1e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding +// vm.stopPrank(); - cctpBridge.relayMessagesToSource(true); +// cctpBridge.relayMessagesToSource(true); - vm.startPrank(relayerSafe); - mainnetController.swapUSDCToUSDS(1e6 - 1); - mainnetController.burnUSDS((1e6 - 1) * 1e12); - vm.stopPrank(); - } +// vm.startPrank(relayerSafe); +// mainnetController.swapUSDCToUSDS(1e6 - 1); +// mainnetController.burnUSDS((1e6 - 1) * 1e12); +// vm.stopPrank(); +// } - function test_depositRedeemFundsFromBaseMorphoUsdc() public { - _setUpMorphoMarket(); +// function test_depositRedeemFundsFromBaseMorphoUsdc() public { +// _setUpMorphoMarket(); - mainnet.selectFork(); +// mainnet.selectFork(); - vm.startPrank(relayerSafe); - mainnetController.mintUSDS(10e18); - mainnetController.swapUSDSToUSDC(10e6); - mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - vm.stopPrank(); +// vm.startPrank(relayerSafe); +// mainnetController.mintUSDS(10e18); +// mainnetController.swapUSDSToUSDC(10e6); +// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.stopPrank(); - cctpBridge.relayMessagesToDestination(true); +// cctpBridge.relayMessagesToDestination(true); - vm.startPrank(relayerSafeBase); - baseController.depositERC4626(MORPHO_VAULT_USDC, 10e6); - skip(1 days); - baseController.redeemERC4626(MORPHO_VAULT_USDC, IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy))); +// vm.startPrank(relayerSafeBase); +// baseController.depositERC4626(MORPHO_VAULT_USDC, 10e6); +// skip(1 days); +// baseController.redeemERC4626(MORPHO_VAULT_USDC, IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy))); - assertGe(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); // Interest earned +// assertGe(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); // Interest earned - assertEq(IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy)), 0); +// assertEq(IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy)), 0); - baseController.transferUSDCToCCTP(1e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding - vm.stopPrank(); +// baseController.transferUSDCToCCTP(1e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding +// vm.stopPrank(); - cctpBridge.relayMessagesToSource(true); +// cctpBridge.relayMessagesToSource(true); - vm.startPrank(relayerSafe); - mainnetController.swapUSDCToUSDS(1e6 - 1); - mainnetController.burnUSDS((1e6 - 1) * 1e12); - vm.stopPrank(); - } +// vm.startPrank(relayerSafe); +// mainnetController.swapUSDCToUSDS(1e6 - 1); +// mainnetController.burnUSDS((1e6 - 1) * 1e12); +// vm.stopPrank(); +// } - // TODO: Replace this once market is live - function _setUpMorphoMarket() public { - vm.startPrank(Base.SPARK_EXECUTOR); +// // TODO: Replace this once market is live +// function _setUpMorphoMarket() public { +// vm.startPrank(Base.SPARK_EXECUTOR); - // Add in the idle markets so deposits can be made - MarketParams memory usdcParams = MarketParams({ - loanToken : Base.USDC, - collateralToken : address(0), - oracle : address(0), - irm : address(0), - lltv : 0 - }); +// // Add in the idle markets so deposits can be made +// MarketParams memory usdcParams = MarketParams({ +// loanToken : Base.USDC, +// collateralToken : address(0), +// oracle : address(0), +// irm : address(0), +// lltv : 0 +// }); - IMetaMorpho(MORPHO_VAULT_USDC).submitCap( - usdcParams, - type(uint184).max - ); +// IMetaMorpho(MORPHO_VAULT_USDC).submitCap( +// usdcParams, +// type(uint184).max +// ); - skip(1 days); +// skip(1 days); - IMetaMorpho(MORPHO_VAULT_USDC).acceptCap(usdcParams); +// IMetaMorpho(MORPHO_VAULT_USDC).acceptCap(usdcParams); - Id[] memory supplyQueueUSDC = new Id[](1); - supplyQueueUSDC[0] = MarketParamsLib.id(usdcParams); - IMetaMorpho(MORPHO_VAULT_USDC).setSupplyQueue(supplyQueueUSDC); +// Id[] memory supplyQueueUSDC = new Id[](1); +// supplyQueueUSDC[0] = MarketParamsLib.id(usdcParams); +// IMetaMorpho(MORPHO_VAULT_USDC).setSupplyQueue(supplyQueueUSDC); - vm.stopPrank(); - } +// vm.stopPrank(); +// } -} +// } diff --git a/src/RateLimitHelpers.sol b/src/RateLimitHelpers.sol index e4f4817..db55d83 100644 --- a/src/RateLimitHelpers.sol +++ b/src/RateLimitHelpers.sol @@ -3,12 +3,12 @@ pragma solidity ^0.8.21; import { IRateLimits } from "../src/interfaces/IRateLimits.sol"; -library RateLimitHelpers { +struct RateLimitData { + uint256 maxAmount; + uint256 slope; +} - struct RateLimitData { - uint256 maxAmount; - uint256 slope; - } +library RateLimitHelpers { function makeAssetKey(bytes32 key, address asset) internal pure returns (bytes32) { return keccak256(abi.encode(key, asset)); diff --git a/test/base-fork/DeployAndInit.t.sol b/test/base-fork/DeployAndInit.t.sol deleted file mode 100644 index 776c768..0000000 --- a/test/base-fork/DeployAndInit.t.sol +++ /dev/null @@ -1,900 +0,0 @@ -// SPDX-License-Identifier: AGPL-3.0-or-later -pragma solidity >=0.8.0; - -import { ERC20Mock } from "openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol"; - -import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; - -import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; -import { ForeignControllerDeploy } from "../../deploy/ControllerDeploy.sol"; - -import { ForeignControllerInit, RateLimitData, MintRecipient } from "../../deploy/ControllerInit.sol"; - -import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; - -import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; - -import "./ForkTestBase.t.sol"; - -// Necessary to get error message assertions to work -contract LibraryWrapper { - - function init( - ForeignControllerInit.AddressParams memory params, - ControllerInstance memory controllerInst, - ForeignControllerInit.InitRateLimitData memory data, - MintRecipient[] memory mintRecipients - ) - external - { - ForeignControllerInit.init(params, controllerInst, data, mintRecipients); - } - -} - -contract ForeignControllerDeployAndInitTestBase is ForkTestBase { - - // Default params used for all testing, can be overridden where needed. - function _getDefaultParams() - internal returns ( - ForeignControllerInit.AddressParams memory addresses, - ForeignControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) - { - addresses = ForeignControllerInit.AddressParams({ - admin : SPARK_EXECUTOR, - freezer : freezer, - relayer : relayer, - oldController : address(0), // Empty - psm : address(psmBase), - cctpMessenger : CCTP_MESSENGER_BASE, - usdc : USDC_BASE, - usds : address(usdsBase), - susds : address(susdsBase) - }); - - RateLimitData memory usdcDepositData = RateLimitData({ - maxAmount : 1_000_000e6, - slope : uint256(1_000_000e6) / 4 hours - }); - - RateLimitData memory usdcWithdrawData = RateLimitData({ - maxAmount : 2_000_000e6, - slope : uint256(2_000_000e6) / 4 hours - }); - - RateLimitData memory usdsDepositData = RateLimitData({ - maxAmount : 3_000_000e6, - slope : uint256(3_000_000e6) / 4 hours - }); - - RateLimitData memory usdsWithdrawData = RateLimitData({ - maxAmount : 4_000_000e6, - slope : uint256(4_000_000e6) / 4 hours - }); - - RateLimitData memory susdsDepositData = RateLimitData({ - maxAmount : 5_000_000e6, - slope : uint256(5_000_000e6) / 4 hours - }); - - RateLimitData memory susdsWithdrawData = RateLimitData({ - maxAmount : 6_000_000e6, - slope : uint256(6_000_000e6) / 4 hours - }); - - RateLimitData memory usdcToCctpData = RateLimitData({ - maxAmount : 7_000_000e6, - slope : uint256(7_000_000e6) / 4 hours - }); - - RateLimitData memory cctpToEthereumDomainData = RateLimitData({ - maxAmount : 8_000_000e6, - slope : uint256(8_000_000e6) / 4 hours - }); - - rateLimitData = ForeignControllerInit.InitRateLimitData({ - usdcDepositData : usdcDepositData, - usdcWithdrawData : usdcWithdrawData, - usdsDepositData : usdsDepositData, - usdsWithdrawData : usdsWithdrawData, - susdsDepositData : susdsDepositData, - susdsWithdrawData : susdsWithdrawData, - usdcToCctpData : usdcToCctpData, - cctpToEthereumDomainData : cctpToEthereumDomainData - }); - - mintRecipients = new MintRecipient[](1); - - mintRecipients[0] = MintRecipient({ - domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - mintRecipient : bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) - }); - } - -} - -contract ForeignControllerDeployAndInitFailureTests is ForeignControllerDeployAndInitTestBase { - - LibraryWrapper wrapper; - - ControllerInstance public controllerInst; - - address public mismatchAddress = makeAddr("mismatchAddress"); - - // Default parameters for success that are overridden for failure tests - - ForeignControllerInit.AddressParams addresses; - ForeignControllerInit.InitRateLimitData rateLimitData; - MintRecipient[] mintRecipients; - - function setUp() public override { - super.setUp(); - - controllerInst = ForeignControllerDeploy.deployFull( - SPARK_EXECUTOR, - address(psmBase), - USDC_BASE, - CCTP_MESSENGER_BASE - ); - - MintRecipient[] memory mintRecipients_ = new MintRecipient[](1); - - ( addresses, rateLimitData, mintRecipients_ ) = _getDefaultParams(); - - // NOTE: This would need to be refactored to a for loop if more than one recipient - mintRecipients.push(mintRecipients_[0]); - - // Overwrite storage for all previous deployments in setUp and assert deployment - - almProxy = ALMProxy(payable(controllerInst.almProxy)); - foreignController = ForeignController(controllerInst.controller); - rateLimits = RateLimits(controllerInst.rateLimits); - - // Admin will be calling the library from its own address - vm.etch(SPARK_EXECUTOR, address(new LibraryWrapper()).code); - - wrapper = LibraryWrapper(SPARK_EXECUTOR); - } - - /**********************************************************************************************/ - /*** ACL failure modes ***/ - /**********************************************************************************************/ - - function test_init_incorrectAdminAlmProxy() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_EXECUTOR); - almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); - almProxy.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_EXECUTOR); - vm.stopPrank(); - - vm.expectRevert("ForeignControllerInit/incorrect-admin-almProxy"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectAdminRateLimits() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_EXECUTOR); - rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); - rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_EXECUTOR); - vm.stopPrank(); - - vm.expectRevert("ForeignControllerInit/incorrect-admin-rateLimits"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectAdminController() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_EXECUTOR); - foreignController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); - foreignController.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_EXECUTOR); - vm.stopPrank(); - - vm.expectRevert("ForeignControllerInit/incorrect-admin-controller"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - /**********************************************************************************************/ - /*** Controller constructor failure modes ***/ - /**********************************************************************************************/ - - function test_init_incorrectAlmProxy() external { - // Deploy new address that will not EVM revert on OZ ACL check - controllerInst.almProxy = address(new ALMProxy(SPARK_EXECUTOR)); - - vm.expectRevert("ForeignControllerInit/incorrect-almProxy"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectRateLimits() external { - // Deploy new address that will not EVM revert on OZ ACL check - controllerInst.rateLimits = address(new RateLimits(SPARK_EXECUTOR)); - - vm.expectRevert("ForeignControllerInit/incorrect-rateLimits"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectPsm() external { - addresses.psm = mismatchAddress; - - vm.expectRevert("ForeignControllerInit/incorrect-psm"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdc() external { - addresses.usdc = mismatchAddress; - - vm.expectRevert("ForeignControllerInit/incorrect-usdc"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectCctp() external { - addresses.cctpMessenger = mismatchAddress; - - vm.expectRevert("ForeignControllerInit/incorrect-cctp"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_controllerInactive() external { - // Cheating to set this outside of init scripts so that the controller can be frozen - vm.prank(SPARK_EXECUTOR); - foreignController.grantRole(FREEZER, freezer); - - vm.startPrank(freezer); - foreignController.freeze(); - vm.stopPrank(); - - vm.expectRevert("ForeignControllerInit/controller-not-active"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - /**********************************************************************************************/ - /*** Sanity check failure modes ***/ - /**********************************************************************************************/ - - function test_init_oldControllerIsNewController() external { - addresses.oldController = controllerInst.controller; - - vm.expectRevert("ForeignControllerInit/old-controller-is-new-controller"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_totalAssetsNotSeededBoundary() external { - // Remove one wei from PSM to make seeded condition not met - vm.prank(address(0)); - psmBase.withdraw(address(usdsBase), address(this), 1); // Withdraw one wei from PSM - - assertEq(psmBase.totalAssets(), 1e18 - 1); - - vm.expectRevert("ForeignControllerInit/psm-totalAssets-not-seeded"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - // Approve from address(this) cause it received the one wei - // Redo the seeding - usdsBase.approve(address(psmBase), 1); - psmBase.deposit(address(usdsBase), address(0), 1); - - assertEq(psmBase.totalAssets(), 1e18); - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_totalSharesNotSeededBoundary() external { - // Remove one wei from PSM to make seeded condition not met - vm.prank(address(0)); - psmBase.withdraw(address(usdsBase), address(this), 1); // Withdraw one wei from PSM - - usdsBase.transfer(address(psmBase), 1); // Transfer one wei to PSM to update totalAssets - - assertEq(psmBase.totalAssets(), 1e18); - assertEq(psmBase.totalShares(), 1e18 - 1); - - vm.expectRevert("ForeignControllerInit/psm-totalShares-not-seeded"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - // Do deposit to update shares, need to do 2 wei to get back to 1e18 because of rounding - deal(address(usdsBase), address(this), 2); - usdsBase.approve(address(psmBase), 2); - psmBase.deposit(address(usdsBase), address(0), 2); - - assertEq(psmBase.totalAssets(), 1e18 + 2); - assertEq(psmBase.totalShares(), 1e18); - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectPsmUsdc() external { - ERC20Mock wrongUsdc = new ERC20Mock(); - - deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment - - // Deploy a new PSM with the wrong USDC - psmBase = IPSM3(PSM3Deploy.deploy( - SPARK_EXECUTOR, address(wrongUsdc), address(usdsBase), address(susdsBase), SSR_ORACLE - )); - - // Deploy a new controller pointing to misconfigured PSM - controllerInst = ForeignControllerDeploy.deployFull( - SPARK_EXECUTOR, - address(psmBase), - USDC_BASE, - CCTP_MESSENGER_BASE - ); - - addresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM - - vm.expectRevert("ForeignControllerInit/psm-incorrect-usdc"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectPsmUsds() external { - ERC20Mock wrongUsds = new ERC20Mock(); - - deal(address(wrongUsds), address(this), 1e18); // For seeding PSM during deployment - - // Deploy a new PSM with the wrong USDC - psmBase = IPSM3(PSM3Deploy.deploy( - SPARK_EXECUTOR, USDC_BASE, address(wrongUsds), address(susdsBase), SSR_ORACLE - )); - - // Deploy a new controller pointing to misconfigured PSM - controllerInst = ForeignControllerDeploy.deployFull( - SPARK_EXECUTOR, - address(psmBase), - USDC_BASE, - CCTP_MESSENGER_BASE - ); - - addresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM - - vm.expectRevert("ForeignControllerInit/psm-incorrect-usds"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectPsmSUsds() external { - ERC20Mock wrongSUsds = new ERC20Mock(); - - deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment - - // Deploy a new PSM with the wrong USDC - psmBase = IPSM3(PSM3Deploy.deploy( - SPARK_EXECUTOR, USDC_BASE, address(usdsBase), address(wrongSUsds), SSR_ORACLE - )); - - // Deploy a new controller pointing to misconfigured PSM - controllerInst = ForeignControllerDeploy.deployFull( - SPARK_EXECUTOR, - address(psmBase), - USDC_BASE, - CCTP_MESSENGER_BASE - ); - - addresses.psm = address(psmBase); // Overwrite to point to misconfigured PSM - - vm.expectRevert("ForeignControllerInit/psm-incorrect-susds"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - /**********************************************************************************************/ - /*** Rate limit unlimited boundary failure modes ***/ - /**********************************************************************************************/ - - function test_init_incorrectUsdcDepositData_unlimitedBoundary() external { - rateLimitData.usdcDepositData.maxAmount = type(uint256).max; - - vm.expectRevert("ForeignControllerInit/invalid-rate-limit-usdcDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcDepositData.slope = 0; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdcWithdrawData_unlimitedBoundary() external { - rateLimitData.usdcWithdrawData.maxAmount = type(uint256).max; - - vm.expectRevert("ForeignControllerInit/invalid-rate-limit-usdcWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcWithdrawData.slope = 0; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdsDepositData_unlimitedBoundary() external { - rateLimitData.usdsDepositData.maxAmount = type(uint256).max; - - vm.expectRevert("ForeignControllerInit/invalid-rate-limit-usdsDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdsDepositData.slope = 0; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdsWithdrawData_unlimitedBoundary() external { - rateLimitData.usdsWithdrawData.maxAmount = type(uint256).max; - - vm.expectRevert("ForeignControllerInit/invalid-rate-limit-usdsWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdsWithdrawData.slope = 0; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectSUsdsDepositData_unlimitedBoundary() external { - rateLimitData.susdsDepositData.maxAmount = type(uint256).max; - - vm.expectRevert("ForeignControllerInit/invalid-rate-limit-susdsDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.susdsDepositData.slope = 0; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectSUsdsWithdrawData_unlimitedBoundary() external { - rateLimitData.susdsWithdrawData.maxAmount = type(uint256).max; - - vm.expectRevert("ForeignControllerInit/invalid-rate-limit-susdsWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.susdsWithdrawData.slope = 0; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdcToCctpData_unlimitedBoundary() external { - rateLimitData.usdcToCctpData.maxAmount = type(uint256).max; - - vm.expectRevert("ForeignControllerInit/invalid-rate-limit-usdcToCctpData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcToCctpData.slope = 0; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectCctpToEthereumDomainData_unlimitedBoundary() external { - rateLimitData.cctpToEthereumDomainData.maxAmount = type(uint256).max; - - vm.expectRevert("ForeignControllerInit/invalid-rate-limit-cctpToEthereumDomainData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.cctpToEthereumDomainData.slope = 0; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - /**********************************************************************************************/ - /*** Rate limit max amount precision boundary failure modes ***/ - /**********************************************************************************************/ - - function test_init_incorrectUsdcDepositData_maxAmountPrecisionBoundary() external { - rateLimitData.usdcDepositData.maxAmount = 1e18 + 1; // 1 USDS, but 1 trillion USDC - - vm.expectRevert("ForeignControllerInit/invalid-max-amount-precision-usdcDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcDepositData.maxAmount = 1e18; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdcWithdrawData_maxAmountPrecisionBoundary() external { - rateLimitData.usdcWithdrawData.maxAmount = 1e18 + 1; // 1 USDS, but 1 trillion USDC - - vm.expectRevert("ForeignControllerInit/invalid-max-amount-precision-usdcWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcWithdrawData.maxAmount = 1e18; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdsDepositData_maxAmountPrecisionBoundary() external { - rateLimitData.usdsDepositData.maxAmount = 1e30 + 1; - - vm.expectRevert("ForeignControllerInit/invalid-max-amount-precision-usdsDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdsDepositData.maxAmount = 1e30; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdsWithdrawData_maxAmountPrecisionBoundary() external { - rateLimitData.usdsWithdrawData.maxAmount = 1e30 + 1; - - vm.expectRevert("ForeignControllerInit/invalid-max-amount-precision-usdsWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdsWithdrawData.maxAmount = 1e30; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectSUsdsDepositData_maxAmountPrecisionBoundary() external { - rateLimitData.susdsDepositData.maxAmount = 1e30 + 1; - - vm.expectRevert("ForeignControllerInit/invalid-max-amount-precision-susdsDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.susdsDepositData.maxAmount = 1e30; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectSUsdsWithdrawData_maxAmountPrecisionBoundary() external { - rateLimitData.susdsWithdrawData.maxAmount = 1e30 + 1; - - vm.expectRevert("ForeignControllerInit/invalid-max-amount-precision-susdsWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.susdsWithdrawData.maxAmount = 1e30; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdcToCctpData_maxAmountPrecisionBoundary() external { - rateLimitData.usdcToCctpData.maxAmount = 1e18 + 1; // 1 USDS, but 1 trillion USDC - - vm.expectRevert("ForeignControllerInit/invalid-max-amount-precision-usdcToCctpData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcToCctpData.maxAmount = 1e18; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectCctpToEthereumDomainData_maxAmountPrecisionBoundary() external { - rateLimitData.cctpToEthereumDomainData.maxAmount = 1e18 + 1; // 1 USDS, but 1 trillion USDC - - vm.expectRevert("ForeignControllerInit/invalid-max-amount-precision-cctpToEthereumDomainData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.cctpToEthereumDomainData.maxAmount = 1e18; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - /**********************************************************************************************/ - /*** Rate limit slope precision boundary failure modes ***/ - /**********************************************************************************************/ - - function test_init_incorrectUsdcDepositData_slopePrecisionBoundary() external { - rateLimitData.usdcDepositData.slope = uint256(1e18) / 1 hours + 1; // 1 USDS, but 1 trillion USDC - - vm.expectRevert("ForeignControllerInit/invalid-slope-precision-usdcDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcDepositData.slope = uint256(1e18) / 1 hours; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdcWithdrawData_slopePrecisionBoundary() external { - rateLimitData.usdcWithdrawData.slope = uint256(1e18) / 1 hours + 1; // 1 USDS, but 1 trillion USDC - - vm.expectRevert("ForeignControllerInit/invalid-slope-precision-usdcWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcWithdrawData.slope = uint256(1e18) / 1 hours; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdsDepositData_slopePrecisionBoundary() external { - rateLimitData.usdsDepositData.slope = uint256(1e30) / 1 hours + 1; - - vm.expectRevert("ForeignControllerInit/invalid-slope-precision-usdsDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdsDepositData.slope = uint256(1e30) / 1 hours; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdsWithdrawData_slopePrecisionBoundary() external { - rateLimitData.usdsWithdrawData.slope = uint256(1e30) / 1 hours + 1; - - vm.expectRevert("ForeignControllerInit/invalid-slope-precision-usdsWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdsWithdrawData.slope = uint256(1e30) / 1 hours; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectSUsdsDepositData_slopePrecisionBoundary() external { - rateLimitData.susdsDepositData.slope = uint256(1e30) / 1 hours + 1; - - vm.expectRevert("ForeignControllerInit/invalid-slope-precision-susdsDepositData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.susdsDepositData.slope = uint256(1e30) / 1 hours; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectSUsdsWithdrawData_slopePrecisionBoundary() external { - rateLimitData.susdsWithdrawData.slope = uint256(1e30) / 1 hours + 1; - - vm.expectRevert("ForeignControllerInit/invalid-slope-precision-susdsWithdrawData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.susdsWithdrawData.slope = uint256(1e30) / 1 hours; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectUsdcToCctpData_slopePrecisionBoundary() external { - rateLimitData.usdcToCctpData.slope = uint256(1e18) / 1 hours + 1; // 1 USDS, but 1 trillion USDC - - vm.expectRevert("ForeignControllerInit/invalid-slope-precision-usdcToCctpData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.usdcToCctpData.slope = uint256(1e18) / 1 hours; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_incorrectCctpToEthereumDomainData_slopePrecisionBoundary() external { - rateLimitData.cctpToEthereumDomainData.slope = uint256(1e18) / 1 hours + 1; // 1 USDS, but 1 trillion USDC - - vm.expectRevert("ForeignControllerInit/invalid-slope-precision-cctpToEthereumDomainData"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - - rateLimitData.cctpToEthereumDomainData.slope = uint256(1e18) / 1 hours; - - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - /**********************************************************************************************/ - /*** Old controller role check tests ***/ - /**********************************************************************************************/ - - function test_init_oldControllerDoesNotHaveRoleInAlmProxy() external { - _deployNewControllerAfterExistingControllerInit(); - - // Revoke the old controller address in ALM proxy - - vm.startPrank(SPARK_EXECUTOR); - almProxy.revokeRole(almProxy.CONTROLLER(), addresses.oldController); - vm.stopPrank(); - - // Try to init with the old controller address that is doesn't have the CONTROLLER role - - vm.expectRevert("ForeignControllerInit/old-controller-not-almProxy-controller"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - function test_init_oldControllerDoesNotHaveRoleInRateLimits() external { - _deployNewControllerAfterExistingControllerInit(); - - // Revoke the old controller address - - vm.startPrank(SPARK_EXECUTOR); - rateLimits.revokeRole(rateLimits.CONTROLLER(), addresses.oldController); - vm.stopPrank(); - - // Try to init with the old controller address that is doesn't have the CONTROLLER role - - vm.expectRevert("ForeignControllerInit/old-controller-not-rateLimits-controller"); - wrapper.init(addresses, controllerInst, rateLimitData, mintRecipients); - } - - /**********************************************************************************************/ - /*** Helper functions ***/ - /**********************************************************************************************/ - - function _deployNewControllerAfterExistingControllerInit() internal { - // Successfully init first controller - - vm.startPrank(SPARK_EXECUTOR); - ForeignControllerInit.init( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - // Deploy a new controller (controllerInst is used in init with new controller address) - - controllerInst.controller = ForeignControllerDeploy.deployController( - SPARK_EXECUTOR, - controllerInst.almProxy, - controllerInst.rateLimits, - address(psmBase), - USDC_BASE, - CCTP_MESSENGER_BASE - ); - - addresses.oldController = address(foreignController); - } - -} - -contract ForeignControllerDeployAndInitSuccessTests is ForeignControllerDeployAndInitTestBase { - - function test_deployAllAndInit() external { - // Perform new deployments against existing fork environment - - ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull( - SPARK_EXECUTOR, - address(psmBase), - USDC_BASE, - CCTP_MESSENGER_BASE - ); - - // Overwrite storage for all previous deployments in setUp and assert deployment - - almProxy = ALMProxy(payable(controllerInst.almProxy)); - foreignController = ForeignController(controllerInst.controller); - rateLimits = RateLimits(controllerInst.rateLimits); - - assertEq(almProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_EXECUTOR), true); - assertEq(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_EXECUTOR), true); - assertEq(foreignController.hasRole(DEFAULT_ADMIN_ROLE, SPARK_EXECUTOR), true); - - assertEq(address(foreignController.proxy()), controllerInst.almProxy); - assertEq(address(foreignController.rateLimits()), controllerInst.rateLimits); - assertEq(address(foreignController.psm()), address(psmBase)); - assertEq(address(foreignController.usdc()), USDC_BASE); - assertEq(address(foreignController.cctp()), CCTP_MESSENGER_BASE); - - assertEq(foreignController.active(), true); - - // Perform SubDAO initialization (from governance relay during spell) - // Setting rate limits to different values from setUp to make assertions more robust - - ( - ForeignControllerInit.AddressParams memory addresses, - ForeignControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) = _getDefaultParams(); - - vm.startPrank(SPARK_EXECUTOR); - ForeignControllerInit.init( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - // Assert SubDAO initialization - - assertEq(foreignController.hasRole(foreignController.FREEZER(), freezer), true); - assertEq(foreignController.hasRole(foreignController.RELAYER(), relayer), true); - - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(foreignController)), true); - - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(foreignController)), true); - - bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( - foreignController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM - ); - - _assertDepositRateLimitData(usdcBase, rateLimitData.usdcDepositData); - _assertDepositRateLimitData(usdsBase, rateLimitData.usdsDepositData); - _assertDepositRateLimitData(susdsBase, rateLimitData.susdsDepositData); - - _assertWithdrawRateLimitData(usdcBase, rateLimitData.usdcWithdrawData); - _assertWithdrawRateLimitData(usdsBase, rateLimitData.usdsWithdrawData); - _assertWithdrawRateLimitData(susdsBase, rateLimitData.susdsWithdrawData); - - _assertRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimitData.usdcToCctpData); - - _assertRateLimitData(domainKeyEthereum, rateLimitData.cctpToEthereumDomainData); - - assertEq( - foreignController.mintRecipients(mintRecipients[0].domain), - mintRecipients[0].mintRecipient - ); - - assertEq( - foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), - bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) - ); - } - - function test_init_transferAclToNewController() public { - ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull( - SPARK_EXECUTOR, - address(psmBase), - USDC_BASE, - CCTP_MESSENGER_BASE - ); - - ( - ForeignControllerInit.AddressParams memory addresses, - ForeignControllerInit.InitRateLimitData memory rateLimitData, - MintRecipient[] memory mintRecipients - ) = _getDefaultParams(); - - vm.startPrank(SPARK_EXECUTOR); - ForeignControllerInit.init( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - // Example of how an upgrade would work - address newController = ForeignControllerDeploy.deployController( - SPARK_EXECUTOR, - controllerInst.almProxy, - controllerInst.rateLimits, - address(psmBase), - USDC_BASE, - CCTP_MESSENGER_BASE - ); - - // Overwrite storage of previous deployments in setUp - - almProxy = ALMProxy(payable(controllerInst.almProxy)); - rateLimits = RateLimits(controllerInst.rateLimits); - - address oldController = address(controllerInst.controller); - - controllerInst.controller = newController; // Overwrite struct for param - - // All other info is the same, just need to transfer ACL - addresses.oldController = oldController; - - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); - - vm.startPrank(SPARK_EXECUTOR); - ForeignControllerInit.init( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); - vm.stopPrank(); - - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); - assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); - assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); - } - - function _assertDepositRateLimitData(IERC20 asset, RateLimitData memory expectedData) internal view { - bytes32 assetKey = RateLimitHelpers.makeAssetKey( - foreignController.LIMIT_PSM_DEPOSIT(), - address(asset) - ); - - _assertRateLimitData(assetKey, expectedData); - } - - function _assertWithdrawRateLimitData(IERC20 asset, RateLimitData memory expectedData) internal view { - bytes32 assetKey = RateLimitHelpers.makeAssetKey( - foreignController.LIMIT_PSM_WITHDRAW(), - address(asset) - ); - - _assertRateLimitData(assetKey, expectedData); - } - - function _assertRateLimitData(bytes32 domainKey, RateLimitData memory expectedData) internal view { - IRateLimits.RateLimitData memory data = rateLimits.getRateLimitData(domainKey); - - assertEq(data.maxAmount, expectedData.maxAmount); - assertEq(data.slope, expectedData.slope); - assertEq(data.lastAmount, expectedData.maxAmount); // `lastAmount` should be `maxAmount` - assertEq(data.lastUpdated, block.timestamp); - - assertEq(rateLimits.getCurrentRateLimit(domainKey), expectedData.maxAmount); - } - -} diff --git a/test/base-fork/ForkTestBase.t.sol b/test/base-fork/ForkTestBase.t.sol index 3b6d095..ca10170 100644 --- a/test/base-fork/ForkTestBase.t.sol +++ b/test/base-fork/ForkTestBase.t.sol @@ -17,16 +17,14 @@ import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; import { ForeignControllerDeploy } from "../../deploy/ControllerDeploy.sol"; import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; -import { - ForeignControllerInit, - MintRecipient, - RateLimitData -} from "../../deploy/ControllerInit.sol"; +import { ForeignControllerInit as Init } from "../../deploy/ForeignControllerInit.sol"; import { ALMProxy } from "../../src/ALMProxy.sol"; import { ForeignController } from "../../src/ForeignController.sol"; import { RateLimits } from "../../src/RateLimits.sol"; +import { RateLimitHelpers, RateLimitData } from "../../src/RateLimitHelpers.sol"; + contract ForkTestBase is Test { // TODO: Refactor to use live addresses @@ -117,54 +115,70 @@ contract ForkTestBase is Test { FREEZER = foreignController.FREEZER(); RELAYER = foreignController.RELAYER(); - ForeignControllerInit.AddressParams memory addresses = ForeignControllerInit.AddressParams({ - admin : SPARK_EXECUTOR, + Init.ConfigAddressParams memory configAddresses = Init.ConfigAddressParams({ freezer : freezer, relayer : relayer, - oldController : address(0), // Empty - psm : address(psmBase), - cctpMessenger : CCTP_MESSENGER_BASE, - usdc : USDC_BASE, - usds : address(usdsBase), - susds : address(susdsBase) + oldController : address(0) + }); + + Init.CheckAddressParams memory checkAddresses = Init.CheckAddressParams({ + admin : Base.SPARK_EXECUTOR, + psm : address(psmBase), + cctp : Base.CCTP_TOKEN_MESSENGER, + usdc : address(usdcBase), + susds : address(susdsBase), + usds : address(usdsBase) + }); + + Init.MintRecipient[] memory mintRecipients = new Init.MintRecipient[](1); + + mintRecipients[0] = Init.MintRecipient({ + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, + mintRecipient : bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) }); - RateLimitData memory standardUsdcRateLimitData = RateLimitData({ + vm.startPrank(SPARK_EXECUTOR); + + Init.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + RateLimitData memory standardUsdcData = RateLimitData({ maxAmount : 5_000_000e6, slope : uint256(1_000_000e6) / 4 hours }); - RateLimitData memory standardUsdsRateLimitData = RateLimitData({ + RateLimitData memory standardUsdsData = RateLimitData({ maxAmount : 5_000_000e18, slope : uint256(1_000_000e18) / 4 hours }); - RateLimitData memory unlimitedRateLimitData = RateLimitData({ + RateLimitData memory unlimitedData = RateLimitData({ maxAmount : type(uint256).max, slope : 0 }); - ForeignControllerInit.InitRateLimitData memory rateLimitData - = ForeignControllerInit.InitRateLimitData({ - usdcDepositData : standardUsdcRateLimitData, - usdcWithdrawData : standardUsdcRateLimitData, - usdsDepositData : standardUsdsRateLimitData, - usdsWithdrawData : unlimitedRateLimitData, - susdsDepositData : standardUsdsRateLimitData, - susdsWithdrawData : unlimitedRateLimitData, - usdcToCctpData : standardUsdcRateLimitData, - cctpToEthereumDomainData : standardUsdcRateLimitData - }); - - MintRecipient[] memory mintRecipients = new MintRecipient[](1); - - mintRecipients[0] = MintRecipient({ - domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - mintRecipient : bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) - }); + bytes32 depositKey = foreignController.LIMIT_PSM_DEPOSIT(); + bytes32 withdrawKey = foreignController.LIMIT_PSM_WITHDRAW(); + + bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM + ); + + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(usdcBase)), rateLimits, standardUsdcData, "usdcDepositData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(usdcBase)), rateLimits, standardUsdcData, "usdcWithdrawData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(usdsBase)), rateLimits, standardUsdsData, "usdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(usdsBase)), rateLimits, unlimitedData, "usdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(susdsBase)), rateLimits, standardUsdsData, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(susdsBase)), rateLimits, unlimitedData, "susdsWithdrawData", 18); + + RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits, standardUsdcData, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, standardUsdcData, "cctpToEthereumDomainData", 6); - vm.startPrank(SPARK_EXECUTOR); - ForeignControllerInit.init(addresses, controllerInst, rateLimitData, mintRecipients); vm.stopPrank(); } diff --git a/test/mainnet-fork/CCTPCalls.t.sol b/test/mainnet-fork/CCTPCalls.t.sol index 41b9401..557f781 100644 --- a/test/mainnet-fork/CCTPCalls.t.sol +++ b/test/mainnet-fork/CCTPCalls.t.sol @@ -1,682 +1,682 @@ -// SPDX-License-Identifier: AGPL-3.0-or-later -pragma solidity >=0.8.0; +// // SPDX-License-Identifier: AGPL-3.0-or-later +// pragma solidity >=0.8.0; -import { IERC20 } from "forge-std/interfaces/IERC20.sol"; +// import { IERC20 } from "forge-std/interfaces/IERC20.sol"; -import { ERC20Mock } from "openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol"; +// import { ERC20Mock } from "openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol"; -import { Base } from "spark-address-registry/src/Base.sol"; +// import { Base } from "spark-address-registry/src/Base.sol"; -import { PSM3Deploy } from "spark-psm/deploy/PSM3Deploy.sol"; -import { IPSM3 } from "spark-psm/src/PSM3.sol"; -import { MockRateProvider } from "spark-psm/test/mocks/MockRateProvider.sol"; +// import { PSM3Deploy } from "spark-psm/deploy/PSM3Deploy.sol"; +// import { IPSM3 } from "spark-psm/src/PSM3.sol"; +// import { MockRateProvider } from "spark-psm/test/mocks/MockRateProvider.sol"; -import { CCTPBridgeTesting } from "xchain-helpers/src/testing/bridges/CCTPBridgeTesting.sol"; -import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; +// import { CCTPBridgeTesting } from "xchain-helpers/src/testing/bridges/CCTPBridgeTesting.sol"; +// import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; -import { ForeignControllerDeploy } from "../../deploy/ControllerDeploy.sol"; -import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; +// import { ForeignControllerDeploy } from "../../deploy/ControllerDeploy.sol"; +// import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; -import { ForeignControllerInit, - MintRecipient, - RateLimitData -} from "../../deploy/ControllerInit.sol"; +// import { ForeignControllerInit, +// MintRecipient, +// RateLimitData +// } from "../../deploy/ControllerInit.sol"; -import { ALMProxy } from "../../src/ALMProxy.sol"; -import { ForeignController } from "../../src/ForeignController.sol"; -import { RateLimits } from "../../src/RateLimits.sol"; -import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; +// import { ALMProxy } from "../../src/ALMProxy.sol"; +// import { ForeignController } from "../../src/ForeignController.sol"; +// import { RateLimits } from "../../src/RateLimits.sol"; +// import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; -import "./ForkTestBase.t.sol"; +// import "./ForkTestBase.t.sol"; -contract MainnetControllerTransferUSDCToCCTPFailureTests is ForkTestBase { +// contract MainnetControllerTransferUSDCToCCTPFailureTests is ForkTestBase { - function test_transferUSDCToCCTP_notRelayer() external { - vm.expectRevert(abi.encodeWithSignature( - "AccessControlUnauthorizedAccount(address,bytes32)", - address(this), - RELAYER - )); - mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - } +// function test_transferUSDCToCCTP_notRelayer() external { +// vm.expectRevert(abi.encodeWithSignature( +// "AccessControlUnauthorizedAccount(address,bytes32)", +// address(this), +// RELAYER +// )); +// mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// } - function test_transferUSDCToCCTP_frozen() external { - vm.prank(freezer); - mainnetController.freeze(); +// function test_transferUSDCToCCTP_frozen() external { +// vm.prank(freezer); +// mainnetController.freeze(); - vm.prank(relayer); - vm.expectRevert("MainnetController/not-active"); - mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - } +// vm.prank(relayer); +// vm.expectRevert("MainnetController/not-active"); +// mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// } - function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { - vm.startPrank(SPARK_PROXY); +// function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { +// vm.startPrank(SPARK_PROXY); - // Set this so second modifier will be passed in success case - rateLimits.setUnlimitedRateLimitData( - RateLimitHelpers.makeDomainKey( - mainnetController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE - ) - ); +// // Set this so second modifier will be passed in success case +// rateLimits.setUnlimitedRateLimitData( +// RateLimitHelpers.makeDomainKey( +// mainnetController.LIMIT_USDC_TO_DOMAIN(), +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE +// ) +// ); - // Rate limit will be constant 10m (higher than setup) - rateLimits.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), 10_000_000e6, 0); +// // Rate limit will be constant 10m (higher than setup) +// rateLimits.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), 10_000_000e6, 0); - // Set this for success case - mainnetController.setMintRecipient( - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - bytes32(uint256(uint160(makeAddr("mintRecipient")))) - ); +// // Set this for success case +// mainnetController.setMintRecipient( +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, +// bytes32(uint256(uint160(makeAddr("mintRecipient")))) +// ); - vm.stopPrank(); +// vm.stopPrank(); - deal(address(usdc), address(almProxy), 10_000_000e6 + 1); +// deal(address(usdc), address(almProxy), 10_000_000e6 + 1); - vm.startPrank(relayer); - vm.expectRevert("RateLimits/rate-limit-exceeded"); - mainnetController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.startPrank(relayer); +// vm.expectRevert("RateLimits/rate-limit-exceeded"); +// mainnetController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - } +// mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// } - function test_transferUSDCToCCTP_domainRateLimitedBoundary() external { - vm.startPrank(SPARK_PROXY); +// function test_transferUSDCToCCTP_domainRateLimitedBoundary() external { +// vm.startPrank(SPARK_PROXY); - // Set this so first modifier will be passed in success case - rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP()); +// // Set this so first modifier will be passed in success case +// rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP()); - // Rate limit will be constant 10m (higher than setup) - rateLimits.setRateLimitData( - RateLimitHelpers.makeDomainKey( - mainnetController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE - ), - 10_000_000e6, - 0 - ); +// // Rate limit will be constant 10m (higher than setup) +// rateLimits.setRateLimitData( +// RateLimitHelpers.makeDomainKey( +// mainnetController.LIMIT_USDC_TO_DOMAIN(), +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE +// ), +// 10_000_000e6, +// 0 +// ); - // Set this for success case - mainnetController.setMintRecipient( - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - bytes32(uint256(uint160(makeAddr("mintRecipient")))) - ); +// // Set this for success case +// mainnetController.setMintRecipient( +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, +// bytes32(uint256(uint160(makeAddr("mintRecipient")))) +// ); - vm.stopPrank(); +// vm.stopPrank(); - deal(address(usdc), address(almProxy), 10_000_000e6 + 1); +// deal(address(usdc), address(almProxy), 10_000_000e6 + 1); - vm.startPrank(relayer); - vm.expectRevert("RateLimits/rate-limit-exceeded"); - mainnetController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.startPrank(relayer); +// vm.expectRevert("RateLimits/rate-limit-exceeded"); +// mainnetController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - } +// mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// } - function test_transferUSDCToCCTP_invalidMintRecipient() external { - // Configure to pass modifiers - vm.startPrank(SPARK_PROXY); +// function test_transferUSDCToCCTP_invalidMintRecipient() external { +// // Configure to pass modifiers +// vm.startPrank(SPARK_PROXY); - rateLimits.setUnlimitedRateLimitData( - RateLimitHelpers.makeDomainKey( - mainnetController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE - ) - ); +// rateLimits.setUnlimitedRateLimitData( +// RateLimitHelpers.makeDomainKey( +// mainnetController.LIMIT_USDC_TO_DOMAIN(), +// CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE +// ) +// ); - rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP()); +// rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP()); - vm.stopPrank(); +// vm.stopPrank(); - vm.prank(relayer); - vm.expectRevert("MainnetController/domain-not-configured"); - mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); - } +// vm.prank(relayer); +// vm.expectRevert("MainnetController/domain-not-configured"); +// mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); +// } -} +// } -// TODO: Figure out finalized structure for this repo/testing structure wise -contract BaseChainUSDCToCCTPTestBase is ForkTestBase { +// // TODO: Figure out finalized structure for this repo/testing structure wise +// contract BaseChainUSDCToCCTPTestBase is ForkTestBase { - using DomainHelpers for *; - using CCTPBridgeTesting for Bridge; +// using DomainHelpers for *; +// using CCTPBridgeTesting for Bridge; - /**********************************************************************************************/ - /*** Constants/state variables ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /*** Constants/state variables ***/ +// /**********************************************************************************************/ - address pocket = makeAddr("pocket"); +// address pocket = makeAddr("pocket"); - /**********************************************************************************************/ - /*** Base addresses ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /*** Base addresses ***/ +// /**********************************************************************************************/ - address constant CCTP_MESSENGER_BASE = Base.CCTP_TOKEN_MESSENGER; - address constant SPARK_EXECUTOR = Base.SPARK_EXECUTOR; - address constant SSR_ORACLE = Base.SSR_AUTH_ORACLE; - address constant USDC_BASE = Base.USDC; +// address constant CCTP_MESSENGER_BASE = Base.CCTP_TOKEN_MESSENGER; +// address constant SPARK_EXECUTOR = Base.SPARK_EXECUTOR; +// address constant SSR_ORACLE = Base.SSR_AUTH_ORACLE; +// address constant USDC_BASE = Base.USDC; - /**********************************************************************************************/ - /*** ALM system deployments ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /*** ALM system deployments ***/ +// /**********************************************************************************************/ - ALMProxy foreignAlmProxy; - RateLimits foreignRateLimits; - ForeignController foreignController; +// ALMProxy foreignAlmProxy; +// RateLimits foreignRateLimits; +// ForeignController foreignController; - /**********************************************************************************************/ - /*** Casted addresses for testing ***/ - /**********************************************************************************************/ +// /**********************************************************************************************/ +// /*** Casted addresses for testing ***/ +// /**********************************************************************************************/ - IERC20 usdsBase; - IERC20 susdsBase; - IERC20 usdcBase; +// IERC20 usdsBase; +// IERC20 susdsBase; +// IERC20 usdcBase; - MockRateProvider rateProvider; +// MockRateProvider rateProvider; - IPSM3 psmBase; +// IPSM3 psmBase; - uint256 USDC_BASE_SUPPLY; +// uint256 USDC_BASE_SUPPLY; - function setUp() public override virtual { - super.setUp(); +// function setUp() public override virtual { +// super.setUp(); - /*** Step 1: Set up environment and deploy mocks ***/ +// /*** Step 1: Set up environment and deploy mocks ***/ - destination = getChain("base").createSelectFork(20782500); // October 7, 2024 +// destination = getChain("base").createSelectFork(20782500); // October 7, 2024 - usdsBase = IERC20(address(new ERC20Mock())); - susdsBase = IERC20(address(new ERC20Mock())); - usdcBase = IERC20(USDC_BASE); +// usdsBase = IERC20(address(new ERC20Mock())); +// susdsBase = IERC20(address(new ERC20Mock())); +// usdcBase = IERC20(USDC_BASE); - /*** Step 2: Deploy and configure PSM with a pocket ***/ +// /*** Step 2: Deploy and configure PSM with a pocket ***/ - deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment +// deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment - psmBase = IPSM3(PSM3Deploy.deploy( - SPARK_EXECUTOR, USDC_BASE, address(usdsBase), address(susdsBase), SSR_ORACLE - )); +// psmBase = IPSM3(PSM3Deploy.deploy( +// SPARK_EXECUTOR, USDC_BASE, address(usdsBase), address(susdsBase), SSR_ORACLE +// )); - vm.prank(SPARK_EXECUTOR); - psmBase.setPocket(pocket); +// vm.prank(SPARK_EXECUTOR); +// psmBase.setPocket(pocket); - vm.prank(pocket); - usdcBase.approve(address(psmBase), type(uint256).max); +// vm.prank(pocket); +// usdcBase.approve(address(psmBase), type(uint256).max); - /*** Step 3: Deploy and configure ALM system ***/ +// /*** Step 3: Deploy and configure ALM system ***/ - ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull({ - admin : SPARK_EXECUTOR, - psm : address(psmBase), - usdc : USDC_BASE, - cctp : CCTP_MESSENGER_BASE - }); +// ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull({ +// admin : SPARK_EXECUTOR, +// psm : address(psmBase), +// usdc : USDC_BASE, +// cctp : CCTP_MESSENGER_BASE +// }); - foreignAlmProxy = ALMProxy(payable(controllerInst.almProxy)); - foreignRateLimits = RateLimits(controllerInst.rateLimits); - foreignController = ForeignController(controllerInst.controller); +// foreignAlmProxy = ALMProxy(payable(controllerInst.almProxy)); +// foreignRateLimits = RateLimits(controllerInst.rateLimits); +// foreignController = ForeignController(controllerInst.controller); - ForeignControllerInit.AddressParams memory addresses = ForeignControllerInit.AddressParams({ - admin : SPARK_EXECUTOR, - freezer : freezer, - relayer : relayer, - oldController : address(0), // Empty - psm : address(psmBase), - cctpMessenger : CCTP_MESSENGER_BASE, - usdc : USDC_BASE, - usds : address(usdsBase), - susds : address(susdsBase) - }); +// ForeignControllerInit.AddressParams memory addresses = ForeignControllerInit.AddressParams({ +// admin : SPARK_EXECUTOR, +// freezer : freezer, +// relayer : relayer, +// oldController : address(0), // Empty +// psm : address(psmBase), +// cctpMessenger : CCTP_MESSENGER_BASE, +// usdc : USDC_BASE, +// usds : address(usdsBase), +// susds : address(susdsBase) +// }); - RateLimitData memory standardUsdcRateLimitData = RateLimitData({ - maxAmount : 5_000_000e6, - slope : uint256(1_000_000e6) / 4 hours - }); +// RateLimitData memory standardUsdcRateLimitData = RateLimitData({ +// maxAmount : 5_000_000e6, +// slope : uint256(1_000_000e6) / 4 hours +// }); - RateLimitData memory standardUsdsRateLimitData = RateLimitData({ - maxAmount : 5_000_000e18, - slope : uint256(1_000_000e18) / 4 hours - }); +// RateLimitData memory standardUsdsRateLimitData = RateLimitData({ +// maxAmount : 5_000_000e18, +// slope : uint256(1_000_000e18) / 4 hours +// }); - RateLimitData memory unlimitedRateLimitData = RateLimitData({ - maxAmount : type(uint256).max, - slope : 0 - }); +// RateLimitData memory unlimitedRateLimitData = RateLimitData({ +// maxAmount : type(uint256).max, +// slope : 0 +// }); - ForeignControllerInit.InitRateLimitData memory rateLimitData - = ForeignControllerInit.InitRateLimitData({ - usdcDepositData : standardUsdcRateLimitData, - usdcWithdrawData : standardUsdcRateLimitData, - usdsDepositData : standardUsdsRateLimitData, - usdsWithdrawData : unlimitedRateLimitData, - susdsDepositData : standardUsdsRateLimitData, - susdsWithdrawData : unlimitedRateLimitData, - usdcToCctpData : standardUsdcRateLimitData, - cctpToEthereumDomainData : standardUsdcRateLimitData - }); +// ForeignControllerInit.InitRateLimitData memory rateLimitData +// = ForeignControllerInit.InitRateLimitData({ +// usdcDepositData : standardUsdcRateLimitData, +// usdcWithdrawData : standardUsdcRateLimitData, +// usdsDepositData : standardUsdsRateLimitData, +// usdsWithdrawData : unlimitedRateLimitData, +// susdsDepositData : standardUsdsRateLimitData, +// susdsWithdrawData : unlimitedRateLimitData, +// usdcToCctpData : standardUsdcRateLimitData, +// cctpToEthereumDomainData : standardUsdcRateLimitData +// }); - MintRecipient[] memory mintRecipients = new MintRecipient[](1); - - mintRecipients[0] = MintRecipient({ - domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - mintRecipient : bytes32(uint256(uint160(address(almProxy)))) - }); - - vm.startPrank(SPARK_EXECUTOR); - ForeignControllerInit.init(addresses, controllerInst, rateLimitData, mintRecipients); - vm.stopPrank(); +// MintRecipient[] memory mintRecipients = new MintRecipient[](1); + +// mintRecipients[0] = MintRecipient({ +// domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, +// mintRecipient : bytes32(uint256(uint160(address(almProxy)))) +// }); + +// vm.startPrank(SPARK_EXECUTOR); +// ForeignControllerInit.init(addresses, controllerInst, rateLimitData, mintRecipients); +// vm.stopPrank(); - USDC_BASE_SUPPLY = usdcBase.totalSupply(); +// USDC_BASE_SUPPLY = usdcBase.totalSupply(); - source.selectFork(); +// source.selectFork(); - bridge = CCTPBridgeTesting.createCircleBridge(source, destination); +// bridge = CCTPBridgeTesting.createCircleBridge(source, destination); - vm.prank(SPARK_PROXY); - mainnetController.setMintRecipient( - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - bytes32(uint256(uint160(address(foreignAlmProxy)))) - ); - } - -} - -contract ForeignControllerTransferUSDCToCCTPFailureTests is BaseChainUSDCToCCTPTestBase { - - using DomainHelpers for *; - - function setUp( ) public override { - super.setUp(); - destination.selectFork(); - } - - function test_transferUSDCToCCTP_notRelayer() external { - vm.expectRevert(abi.encodeWithSignature( - "AccessControlUnauthorizedAccount(address,bytes32)", - address(this), - RELAYER - )); - foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - } - - function test_transferUSDCToCCTP_frozen() external { - vm.prank(freezer); - foreignController.freeze(); - - vm.prank(relayer); - vm.expectRevert("ForeignController/not-active"); - foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - } - - function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { - vm.startPrank(SPARK_EXECUTOR); - - // Set this so second modifier will be passed in success case - foreignRateLimits.setUnlimitedRateLimitData( - RateLimitHelpers.makeDomainKey( - foreignController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM - ) - ); - - // Rate limit will be constant 10m (higher than setup) - foreignRateLimits.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), 10_000_000e6, 0); - - // Set this for success case - foreignController.setMintRecipient( - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - bytes32(uint256(uint160(makeAddr("mintRecipient")))) - ); - - vm.stopPrank(); - - deal(address(usdcBase), address(foreignAlmProxy), 10_000_000e6 + 1); - - vm.startPrank(relayer); - vm.expectRevert("RateLimits/rate-limit-exceeded"); - foreignController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - - foreignController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - } +// vm.prank(SPARK_PROXY); +// mainnetController.setMintRecipient( +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, +// bytes32(uint256(uint160(address(foreignAlmProxy)))) +// ); +// } + +// } + +// contract ForeignControllerTransferUSDCToCCTPFailureTests is BaseChainUSDCToCCTPTestBase { + +// using DomainHelpers for *; + +// function setUp( ) public override { +// super.setUp(); +// destination.selectFork(); +// } + +// function test_transferUSDCToCCTP_notRelayer() external { +// vm.expectRevert(abi.encodeWithSignature( +// "AccessControlUnauthorizedAccount(address,bytes32)", +// address(this), +// RELAYER +// )); +// foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// } + +// function test_transferUSDCToCCTP_frozen() external { +// vm.prank(freezer); +// foreignController.freeze(); + +// vm.prank(relayer); +// vm.expectRevert("ForeignController/not-active"); +// foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// } + +// function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { +// vm.startPrank(SPARK_EXECUTOR); + +// // Set this so second modifier will be passed in success case +// foreignRateLimits.setUnlimitedRateLimitData( +// RateLimitHelpers.makeDomainKey( +// foreignController.LIMIT_USDC_TO_DOMAIN(), +// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM +// ) +// ); + +// // Rate limit will be constant 10m (higher than setup) +// foreignRateLimits.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), 10_000_000e6, 0); + +// // Set this for success case +// foreignController.setMintRecipient( +// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, +// bytes32(uint256(uint160(makeAddr("mintRecipient")))) +// ); + +// vm.stopPrank(); + +// deal(address(usdcBase), address(foreignAlmProxy), 10_000_000e6 + 1); + +// vm.startPrank(relayer); +// vm.expectRevert("RateLimits/rate-limit-exceeded"); +// foreignController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + +// foreignController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// } - function test_transferUSDCToCCTP_domainRateLimitedBoundary() external { - vm.startPrank(SPARK_EXECUTOR); +// function test_transferUSDCToCCTP_domainRateLimitedBoundary() external { +// vm.startPrank(SPARK_EXECUTOR); - // Set this so first modifier will be passed in success case - foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); +// // Set this so first modifier will be passed in success case +// foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); - // Rate limit will be constant 10m (higher than setup) - foreignRateLimits.setRateLimitData( - RateLimitHelpers.makeDomainKey( - foreignController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM - ), - 10_000_000e6, - 0 - ); +// // Rate limit will be constant 10m (higher than setup) +// foreignRateLimits.setRateLimitData( +// RateLimitHelpers.makeDomainKey( +// foreignController.LIMIT_USDC_TO_DOMAIN(), +// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM +// ), +// 10_000_000e6, +// 0 +// ); - // Set this for success case - foreignController.setMintRecipient( - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - bytes32(uint256(uint160(makeAddr("mintRecipient")))) - ); +// // Set this for success case +// foreignController.setMintRecipient( +// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, +// bytes32(uint256(uint160(makeAddr("mintRecipient")))) +// ); - vm.stopPrank(); +// vm.stopPrank(); - deal(address(usdcBase), address(foreignAlmProxy), 10_000_000e6 + 1); +// deal(address(usdcBase), address(foreignAlmProxy), 10_000_000e6 + 1); - vm.startPrank(relayer); - vm.expectRevert("RateLimits/rate-limit-exceeded"); - foreignController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// vm.startPrank(relayer); +// vm.expectRevert("RateLimits/rate-limit-exceeded"); +// foreignController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - foreignController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - } +// foreignController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// } - function test_transferUSDCToCCTP_invalidMintRecipient() external { - // Configure to pass modifiers - vm.startPrank(SPARK_EXECUTOR); +// function test_transferUSDCToCCTP_invalidMintRecipient() external { +// // Configure to pass modifiers +// vm.startPrank(SPARK_EXECUTOR); - foreignRateLimits.setUnlimitedRateLimitData( - RateLimitHelpers.makeDomainKey( - foreignController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE - ) - ); +// foreignRateLimits.setUnlimitedRateLimitData( +// RateLimitHelpers.makeDomainKey( +// foreignController.LIMIT_USDC_TO_DOMAIN(), +// CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE +// ) +// ); - foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); +// foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); - vm.stopPrank(); +// vm.stopPrank(); - vm.prank(relayer); - vm.expectRevert("ForeignController/domain-not-configured"); - foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); - } +// vm.prank(relayer); +// vm.expectRevert("ForeignController/domain-not-configured"); +// foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); +// } -} +// } -contract USDCToCCTPIntegrationTests is BaseChainUSDCToCCTPTestBase { +// contract USDCToCCTPIntegrationTests is BaseChainUSDCToCCTPTestBase { - using DomainHelpers for *; - using CCTPBridgeTesting for Bridge; +// using DomainHelpers for *; +// using CCTPBridgeTesting for Bridge; - event CCTPTransferInitiated( - uint64 indexed nonce, - uint32 indexed destinationDomain, - bytes32 indexed mintRecipient, - uint256 usdcAmount - ); +// event CCTPTransferInitiated( +// uint64 indexed nonce, +// uint32 indexed destinationDomain, +// bytes32 indexed mintRecipient, +// uint256 usdcAmount +// ); - event DepositForBurn( - uint64 indexed nonce, - address indexed burnToken, - uint256 amount, - address indexed depositor, - bytes32 mintRecipient, - uint32 destinationDomain, - bytes32 destinationTokenMessenger, - bytes32 destinationCaller - ); +// event DepositForBurn( +// uint64 indexed nonce, +// address indexed burnToken, +// uint256 amount, +// address indexed depositor, +// bytes32 mintRecipient, +// uint32 destinationDomain, +// bytes32 destinationTokenMessenger, +// bytes32 destinationCaller +// ); - function test_transferUSDCToCCTP_sourceToDestination() external { - deal(address(usdc), address(almProxy), 1e6); +// function test_transferUSDCToCCTP_sourceToDestination() external { +// deal(address(usdc), address(almProxy), 1e6); - assertEq(usdc.balanceOf(address(almProxy)), 1e6); - assertEq(usdc.balanceOf(address(mainnetController)), 0); - assertEq(usdc.totalSupply(), USDC_SUPPLY); +// assertEq(usdc.balanceOf(address(almProxy)), 1e6); +// assertEq(usdc.balanceOf(address(mainnetController)), 0); +// assertEq(usdc.totalSupply(), USDC_SUPPLY); - assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); +// assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); - _expectEthereumCCTPEmit(114_803, 1e6); +// _expectEthereumCCTPEmit(114_803, 1e6); - vm.prank(relayer); - mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.prank(relayer); +// mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - assertEq(usdc.balanceOf(address(almProxy)), 0); - assertEq(usdc.balanceOf(address(mainnetController)), 0); - assertEq(usdc.totalSupply(), USDC_SUPPLY - 1e6); +// assertEq(usdc.balanceOf(address(almProxy)), 0); +// assertEq(usdc.balanceOf(address(mainnetController)), 0); +// assertEq(usdc.totalSupply(), USDC_SUPPLY - 1e6); - assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); +// assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); - destination.selectFork(); +// destination.selectFork(); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); - assertEq(usdcBase.balanceOf(address(foreignController)), 0); - assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); +// assertEq(usdcBase.balanceOf(address(foreignController)), 0); +// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); - bridge.relayMessagesToDestination(true); +// bridge.relayMessagesToDestination(true); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 1e6); - assertEq(usdcBase.balanceOf(address(foreignController)), 0); - assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY + 1e6); - } +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 1e6); +// assertEq(usdcBase.balanceOf(address(foreignController)), 0); +// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY + 1e6); +// } - function test_transferUSDCToCCTP_sourceToDestination_bigTransfer() external { - deal(address(usdc), address(almProxy), 2_900_000e6); +// function test_transferUSDCToCCTP_sourceToDestination_bigTransfer() external { +// deal(address(usdc), address(almProxy), 2_900_000e6); - assertEq(usdc.balanceOf(address(almProxy)), 2_900_000e6); - assertEq(usdc.balanceOf(address(mainnetController)), 0); - assertEq(usdc.totalSupply(), USDC_SUPPLY); +// assertEq(usdc.balanceOf(address(almProxy)), 2_900_000e6); +// assertEq(usdc.balanceOf(address(mainnetController)), 0); +// assertEq(usdc.totalSupply(), USDC_SUPPLY); - assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); +// assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); - // Will split into 3 separate transactions at max 1m each - _expectEthereumCCTPEmit(114_803, 1_000_000e6); - _expectEthereumCCTPEmit(114_804, 1_000_000e6); - _expectEthereumCCTPEmit(114_805, 900_000e6); +// // Will split into 3 separate transactions at max 1m each +// _expectEthereumCCTPEmit(114_803, 1_000_000e6); +// _expectEthereumCCTPEmit(114_804, 1_000_000e6); +// _expectEthereumCCTPEmit(114_805, 900_000e6); - vm.prank(relayer); - mainnetController.transferUSDCToCCTP(2_900_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.prank(relayer); +// mainnetController.transferUSDCToCCTP(2_900_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - assertEq(usdc.balanceOf(address(almProxy)), 0); - assertEq(usdc.balanceOf(address(mainnetController)), 0); - assertEq(usdc.totalSupply(), USDC_SUPPLY - 2_900_000e6); +// assertEq(usdc.balanceOf(address(almProxy)), 0); +// assertEq(usdc.balanceOf(address(mainnetController)), 0); +// assertEq(usdc.totalSupply(), USDC_SUPPLY - 2_900_000e6); - assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); +// assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); - destination.selectFork(); +// destination.selectFork(); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); - assertEq(usdcBase.balanceOf(address(foreignController)), 0); - assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); +// assertEq(usdcBase.balanceOf(address(foreignController)), 0); +// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); - bridge.relayMessagesToDestination(true); +// bridge.relayMessagesToDestination(true); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 2_900_000e6); - assertEq(usdcBase.balanceOf(address(foreignController)), 0); - assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY + 2_900_000e6); - } +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 2_900_000e6); +// assertEq(usdcBase.balanceOf(address(foreignController)), 0); +// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY + 2_900_000e6); +// } - function test_transferUSDCToCCTP_sourceToDestination_rateLimited() external { - bytes32 key = mainnetController.LIMIT_USDC_TO_CCTP(); - deal(address(usdc), address(almProxy), 9_000_000e6); +// function test_transferUSDCToCCTP_sourceToDestination_rateLimited() external { +// bytes32 key = mainnetController.LIMIT_USDC_TO_CCTP(); +// deal(address(usdc), address(almProxy), 9_000_000e6); - vm.startPrank(relayer); +// vm.startPrank(relayer); - assertEq(usdc.balanceOf(address(almProxy)), 9_000_000e6); - assertEq(rateLimits.getCurrentRateLimit(key), 5_000_000e6); +// assertEq(usdc.balanceOf(address(almProxy)), 9_000_000e6); +// assertEq(rateLimits.getCurrentRateLimit(key), 5_000_000e6); - mainnetController.transferUSDCToCCTP(2_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// mainnetController.transferUSDCToCCTP(2_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - assertEq(usdc.balanceOf(address(almProxy)), 7_000_000e6); - assertEq(rateLimits.getCurrentRateLimit(key), 3_000_000e6); +// assertEq(usdc.balanceOf(address(almProxy)), 7_000_000e6); +// assertEq(rateLimits.getCurrentRateLimit(key), 3_000_000e6); - vm.expectRevert("RateLimits/rate-limit-exceeded"); - mainnetController.transferUSDCToCCTP(3_000_001e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// vm.expectRevert("RateLimits/rate-limit-exceeded"); +// mainnetController.transferUSDCToCCTP(3_000_001e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - mainnetController.transferUSDCToCCTP(3_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// mainnetController.transferUSDCToCCTP(3_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - assertEq(usdc.balanceOf(address(almProxy)), 4_000_000e6); - assertEq(rateLimits.getCurrentRateLimit(key), 0); +// assertEq(usdc.balanceOf(address(almProxy)), 4_000_000e6); +// assertEq(rateLimits.getCurrentRateLimit(key), 0); - skip(4 hours); +// skip(4 hours); - assertEq(usdc.balanceOf(address(almProxy)), 4_000_000e6); - assertEq(rateLimits.getCurrentRateLimit(key), 999_999.9936e6); +// assertEq(usdc.balanceOf(address(almProxy)), 4_000_000e6); +// assertEq(rateLimits.getCurrentRateLimit(key), 999_999.9936e6); - mainnetController.transferUSDCToCCTP(999_999.9936e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); +// mainnetController.transferUSDCToCCTP(999_999.9936e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); - assertEq(usdc.balanceOf(address(almProxy)), 3_000_000.0064e6); - assertEq(rateLimits.getCurrentRateLimit(key), 0); +// assertEq(usdc.balanceOf(address(almProxy)), 3_000_000.0064e6); +// assertEq(rateLimits.getCurrentRateLimit(key), 0); - vm.stopPrank(); - } +// vm.stopPrank(); +// } - function test_transferUSDCToCCTP_destinationToSource() external { - destination.selectFork(); +// function test_transferUSDCToCCTP_destinationToSource() external { +// destination.selectFork(); - deal(address(usdcBase), address(foreignAlmProxy), 1e6); +// deal(address(usdcBase), address(foreignAlmProxy), 1e6); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 1e6); - assertEq(usdcBase.balanceOf(address(foreignController)), 0); - assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 1e6); +// assertEq(usdcBase.balanceOf(address(foreignController)), 0); +// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); - assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); +// assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); - _expectBaseCCTPEmit(296_114, 1e6); +// _expectBaseCCTPEmit(296_114, 1e6); - vm.prank(relayer); - foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// vm.prank(relayer); +// foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); - assertEq(usdcBase.balanceOf(address(foreignController)), 0); - assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY - 1e6); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); +// assertEq(usdcBase.balanceOf(address(foreignController)), 0); +// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY - 1e6); - assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); +// assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); - source.selectFork(); +// source.selectFork(); - assertEq(usdc.balanceOf(address(almProxy)), 0); - assertEq(usdc.balanceOf(address(mainnetController)), 0); - assertEq(usdc.totalSupply(), USDC_SUPPLY); +// assertEq(usdc.balanceOf(address(almProxy)), 0); +// assertEq(usdc.balanceOf(address(mainnetController)), 0); +// assertEq(usdc.totalSupply(), USDC_SUPPLY); - bridge.relayMessagesToSource(true); +// bridge.relayMessagesToSource(true); - assertEq(usdc.balanceOf(address(almProxy)), 1e6); - assertEq(usdc.balanceOf(address(mainnetController)), 0); - assertEq(usdc.totalSupply(), USDC_SUPPLY + 1e6); - } +// assertEq(usdc.balanceOf(address(almProxy)), 1e6); +// assertEq(usdc.balanceOf(address(mainnetController)), 0); +// assertEq(usdc.totalSupply(), USDC_SUPPLY + 1e6); +// } - function test_transferUSDCToCCTP_destinationToSource_bigTransfer() external { - destination.selectFork(); +// function test_transferUSDCToCCTP_destinationToSource_bigTransfer() external { +// destination.selectFork(); - deal(address(usdcBase), address(foreignAlmProxy), 2_600_000e6); +// deal(address(usdcBase), address(foreignAlmProxy), 2_600_000e6); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 2_600_000e6); - assertEq(usdcBase.balanceOf(address(foreignController)), 0); - assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 2_600_000e6); +// assertEq(usdcBase.balanceOf(address(foreignController)), 0); +// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); - assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); +// assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); - // Will split into three separate transactions at max 1m each - _expectBaseCCTPEmit(296_114, 1_000_000e6); - _expectBaseCCTPEmit(296_115, 1_000_000e6); - _expectBaseCCTPEmit(296_116, 600_000e6); +// // Will split into three separate transactions at max 1m each +// _expectBaseCCTPEmit(296_114, 1_000_000e6); +// _expectBaseCCTPEmit(296_115, 1_000_000e6); +// _expectBaseCCTPEmit(296_116, 600_000e6); - vm.prank(relayer); - foreignController.transferUSDCToCCTP(2_600_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// vm.prank(relayer); +// foreignController.transferUSDCToCCTP(2_600_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); - assertEq(usdcBase.balanceOf(address(foreignController)), 0); - assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY - 2_600_000e6); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); +// assertEq(usdcBase.balanceOf(address(foreignController)), 0); +// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY - 2_600_000e6); - assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); +// assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); - source.selectFork(); +// source.selectFork(); - assertEq(usdc.balanceOf(address(almProxy)), 0); - assertEq(usdc.balanceOf(address(mainnetController)), 0); - assertEq(usdc.totalSupply(), USDC_SUPPLY); +// assertEq(usdc.balanceOf(address(almProxy)), 0); +// assertEq(usdc.balanceOf(address(mainnetController)), 0); +// assertEq(usdc.totalSupply(), USDC_SUPPLY); - bridge.relayMessagesToSource(true); +// bridge.relayMessagesToSource(true); - assertEq(usdc.balanceOf(address(almProxy)), 2_600_000e6); - assertEq(usdc.balanceOf(address(mainnetController)), 0); - assertEq(usdc.totalSupply(), USDC_SUPPLY + 2_600_000e6); - } +// assertEq(usdc.balanceOf(address(almProxy)), 2_600_000e6); +// assertEq(usdc.balanceOf(address(mainnetController)), 0); +// assertEq(usdc.totalSupply(), USDC_SUPPLY + 2_600_000e6); +// } - function test_transferUSDCToCCTP_destinationToSource_rateLimited() external { - destination.selectFork(); +// function test_transferUSDCToCCTP_destinationToSource_rateLimited() external { +// destination.selectFork(); - bytes32 key = foreignController.LIMIT_USDC_TO_CCTP(); - deal(address(usdcBase), address(foreignAlmProxy), 9_000_000e6); +// bytes32 key = foreignController.LIMIT_USDC_TO_CCTP(); +// deal(address(usdcBase), address(foreignAlmProxy), 9_000_000e6); - vm.startPrank(relayer); +// vm.startPrank(relayer); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 9_000_000e6); - assertEq(foreignRateLimits.getCurrentRateLimit(key), 5_000_000e6); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 9_000_000e6); +// assertEq(foreignRateLimits.getCurrentRateLimit(key), 5_000_000e6); - foreignController.transferUSDCToCCTP(2_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// foreignController.transferUSDCToCCTP(2_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 7_000_000e6); - assertEq(foreignRateLimits.getCurrentRateLimit(key), 3_000_000e6); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 7_000_000e6); +// assertEq(foreignRateLimits.getCurrentRateLimit(key), 3_000_000e6); - vm.expectRevert("RateLimits/rate-limit-exceeded"); - foreignController.transferUSDCToCCTP(3_000_001e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// vm.expectRevert("RateLimits/rate-limit-exceeded"); +// foreignController.transferUSDCToCCTP(3_000_001e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - foreignController.transferUSDCToCCTP(3_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// foreignController.transferUSDCToCCTP(3_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 4_000_000e6); - assertEq(foreignRateLimits.getCurrentRateLimit(key), 0); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 4_000_000e6); +// assertEq(foreignRateLimits.getCurrentRateLimit(key), 0); - skip(4 hours); +// skip(4 hours); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 4_000_000e6); - assertEq(foreignRateLimits.getCurrentRateLimit(key), 999_999.9936e6); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 4_000_000e6); +// assertEq(foreignRateLimits.getCurrentRateLimit(key), 999_999.9936e6); - foreignController.transferUSDCToCCTP(999_999.9936e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); +// foreignController.transferUSDCToCCTP(999_999.9936e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 3_000_000.0064e6); - assertEq(foreignRateLimits.getCurrentRateLimit(key), 0); +// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 3_000_000.0064e6); +// assertEq(foreignRateLimits.getCurrentRateLimit(key), 0); - vm.stopPrank(); - } +// vm.stopPrank(); +// } - function _expectEthereumCCTPEmit(uint64 nonce, uint256 amount) internal { - // NOTE: Focusing on burnToken, amount, depositor, mintRecipient, and destinationDomain - // for assertions - vm.expectEmit(CCTP_MESSENGER); - emit DepositForBurn( - nonce, - address(usdc), - amount, - address(almProxy), - mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - bytes32(0x0000000000000000000000001682ae6375c4e4a97e4b583bc394c861a46d8962), - bytes32(0x0000000000000000000000000000000000000000000000000000000000000000) - ); +// function _expectEthereumCCTPEmit(uint64 nonce, uint256 amount) internal { +// // NOTE: Focusing on burnToken, amount, depositor, mintRecipient, and destinationDomain +// // for assertions +// vm.expectEmit(CCTP_MESSENGER); +// emit DepositForBurn( +// nonce, +// address(usdc), +// amount, +// address(almProxy), +// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, +// bytes32(0x0000000000000000000000001682ae6375c4e4a97e4b583bc394c861a46d8962), +// bytes32(0x0000000000000000000000000000000000000000000000000000000000000000) +// ); - vm.expectEmit(address(mainnetController)); - emit CCTPTransferInitiated( - nonce, - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), - amount - ); - } +// vm.expectEmit(address(mainnetController)); +// emit CCTPTransferInitiated( +// nonce, +// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, +// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), +// amount +// ); +// } - function _expectBaseCCTPEmit(uint64 nonce, uint256 amount) internal { - // NOTE: Focusing on burnToken, amount, depositor, mintRecipient, and destinationDomain - // for assertions - vm.expectEmit(CCTP_MESSENGER_BASE); - emit DepositForBurn( - nonce, - address(usdcBase), - amount, - address(foreignAlmProxy), - foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - bytes32(0x000000000000000000000000bd3fa81b58ba92a82136038b25adec7066af3155), - bytes32(0x0000000000000000000000000000000000000000000000000000000000000000) - ); - - vm.expectEmit(address(foreignController)); - emit CCTPTransferInitiated( - nonce, - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), - amount - ); - } - -} +// function _expectBaseCCTPEmit(uint64 nonce, uint256 amount) internal { +// // NOTE: Focusing on burnToken, amount, depositor, mintRecipient, and destinationDomain +// // for assertions +// vm.expectEmit(CCTP_MESSENGER_BASE); +// emit DepositForBurn( +// nonce, +// address(usdcBase), +// amount, +// address(foreignAlmProxy), +// foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), +// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, +// bytes32(0x000000000000000000000000bd3fa81b58ba92a82136038b25adec7066af3155), +// bytes32(0x0000000000000000000000000000000000000000000000000000000000000000) +// ); + +// vm.expectEmit(address(foreignController)); +// emit CCTPTransferInitiated( +// nonce, +// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, +// foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), +// amount +// ); +// } + +// } diff --git a/test/mainnet-fork/DeployAndInit.t.sol b/test/mainnet-fork/DeployAndInit.t.sol deleted file mode 100644 index dedf181..0000000 --- a/test/mainnet-fork/DeployAndInit.t.sol +++ /dev/null @@ -1,722 +0,0 @@ -// // SPDX-License-Identifier: AGPL-3.0-or-later -// pragma solidity >=0.8.0; - -// import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; -// import { MainnetControllerDeploy } from "../../deploy/ControllerDeploy.sol"; - -// import { -// MainnetControllerInit, -// RateLimitData, -// MintRecipient -// } from "../../deploy/ControllerInit.sol"; - -// import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; - -// import "./ForkTestBase.t.sol"; - -// // Necessary to get error message assertions to work -// contract LibraryWrapper { - -// function subDaoInitController( -// MainnetControllerInit.AddressParams memory params, -// ControllerInstance memory controllerInst, -// MainnetControllerInit.InitRateLimitData memory rateLimitData, -// MintRecipient[] memory mintRecipients -// ) -// external -// { -// MainnetControllerInit.subDaoInitController( -// params, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// } - -// function subDaoInitFull( -// MainnetControllerInit.AddressParams memory params, -// ControllerInstance memory controllerInst, -// MainnetControllerInit.InitRateLimitData memory rateLimitData, -// MintRecipient[] memory mintRecipients -// ) -// external -// { -// MainnetControllerInit.subDaoInitFull( -// params, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// } - -// } - -// contract MainnetControllerDeployInitTestBase is ForkTestBase { - -// function _getDefaultParams() -// internal returns ( -// MainnetControllerInit.AddressParams memory addresses, -// MainnetControllerInit.InitRateLimitData memory rateLimitData, -// MintRecipient[] memory mintRecipients -// ) -// { -// addresses = MainnetControllerInit.AddressParams({ -// admin : Ethereum.SPARK_PROXY, -// freezer : freezer, -// relayer : relayer, -// oldController : address(0), -// psm : Ethereum.PSM, -// vault : vault, -// buffer : buffer, -// cctpMessenger : Ethereum.CCTP_TOKEN_MESSENGER, -// dai : Ethereum.DAI, -// daiUsds : Ethereum.DAI_USDS, -// usdc : Ethereum.USDC, -// usds : Ethereum.USDS, -// susds : Ethereum.SUSDS -// }); - -// RateLimitData memory standardUsdsData = RateLimitData({ -// maxAmount : 1_000_000e18, -// slope : uint256(1_000_000e18) / 4 hours -// }); - -// RateLimitData memory usdsToUsdcData = RateLimitData({ -// maxAmount : 2_000_000e6, -// slope : uint256(2_000_000e6) / 4 hours -// }); - -// RateLimitData memory usdcToCctpData = RateLimitData({ -// maxAmount : 3_000_000e6, -// slope : uint256(3_000_000e6) / 4 hours -// }); - -// RateLimitData memory cctpToBaseDomainData = RateLimitData({ -// maxAmount : 4_000_000e6, -// slope : uint256(4_000_000e6) / 4 hours -// }); - -// rateLimitData = MainnetControllerInit.InitRateLimitData({ -// usdsMintData : standardUsdsData, -// usdsToUsdcData : usdsToUsdcData, -// usdcToCctpData : usdcToCctpData, -// cctpToBaseDomainData : cctpToBaseDomainData, -// susdsDepositData : standardUsdsData -// }); - -// mintRecipients = new MintRecipient[](1); - -// mintRecipients[0] = MintRecipient({ -// domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, -// mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) -// }); -// } - -// } - -// contract MainnetControllerDeployAndInitFailureTests is MainnetControllerDeployInitTestBase { - -// LibraryWrapper wrapper; - -// ControllerInstance public controllerInst; - -// address public mismatchAddress = makeAddr("mismatchAddress"); - -// MainnetControllerInit.AddressParams addresses; -// MainnetControllerInit.InitRateLimitData rateLimitData; -// MintRecipient[] mintRecipients; - -// function setUp() public override { -// super.setUp(); - -// controllerInst = MainnetControllerDeploy.deployFull( -// SPARK_PROXY, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER -// ); - -// MintRecipient[] memory mintRecipients_ = new MintRecipient[](1); - -// ( addresses, rateLimitData, mintRecipients_ ) = _getDefaultParams(); - -// // NOTE: This would need to be refactored to a for loop if more than one recipient -// mintRecipients.push(mintRecipients_[0]); - -// // Overwrite storage for all previous deployments in setUp and assert deployment - -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// mainnetController = MainnetController(controllerInst.controller); -// rateLimits = RateLimits(controllerInst.rateLimits); - -// // Admin will be calling the library from its own address -// vm.etch(SPARK_PROXY, address(new LibraryWrapper()).code); - -// wrapper = LibraryWrapper(SPARK_PROXY); -// } - -// /**********************************************************************************************/ -// /*** ACL tests ***/ -// /**********************************************************************************************/ - -// function test_init_incorrectAdminAlmProxy() external { -// // Isolate different contracts instead of setting param so can get three different failures -// vm.startPrank(SPARK_PROXY); -// almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); -// almProxy.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); -// vm.stopPrank(); - -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-almProxy")); -// } - -// function test_init_incorrectAdminRateLimits() external { -// // Isolate different contracts instead of setting param so can get three different failures -// vm.startPrank(SPARK_PROXY); -// rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); -// rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); -// vm.stopPrank(); - -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-rateLimits")); -// } - -// function test_init_incorrectAdminController() external { -// // Isolate different contracts instead of setting param so can get three different failures -// vm.startPrank(SPARK_PROXY); -// mainnetController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); -// mainnetController.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); -// vm.stopPrank(); - -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-controller")); -// } - -// /**********************************************************************************************/ -// /*** Constructor tests ***/ -// /**********************************************************************************************/ - -// function test_init_incorrectAlmProxy() external { -// // Deploy new address that will not EVM revert on OZ ACL check -// controllerInst.almProxy = address(new ALMProxy(SPARK_PROXY)); - -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-almProxy")); -// } - -// function test_init_incorrectRateLimits() external { -// // Deploy new address that will not EVM revert on OZ ACL check -// controllerInst.rateLimits = address(new RateLimits(SPARK_PROXY)); - -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-rateLimits")); -// } - -// function test_init_incorrectVault() external { -// addresses.vault = mismatchAddress; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-vault")); -// } - -// function test_init_incorrectBuffer() external { -// addresses.buffer = mismatchAddress; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-buffer")); -// } - -// function test_init_incorrectPsm() external { -// addresses.psm = mismatchAddress; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-psm")); -// } - -// function test_init_incorrectDaiUsds() external { -// addresses.daiUsds = mismatchAddress; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-daiUsds")); -// } - -// function test_init_incorrectCctp() external { -// addresses.cctpMessenger = mismatchAddress; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-cctpMessenger")); -// } - -// function test_init_incorrectDai() external { -// addresses.dai = mismatchAddress; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-dai")); -// } - -// function test_init_incorrectUsdc() external { -// addresses.usdc = mismatchAddress; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-usdc")); -// } - -// function test_init_incorrectUsds() external { -// addresses.usds = mismatchAddress; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/incorrect-usds")); -// } - -// function test_init_controllerInactive() external { -// // Cheating to set this outside of init scripts so that the controller can be frozen -// vm.startPrank(SPARK_PROXY); -// mainnetController.grantRole(FREEZER, freezer); - -// vm.startPrank(freezer); -// mainnetController.freeze(); -// vm.stopPrank(); - -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/controller-not-active")); -// } - -// function test_init_oldControllerIsNewController() external { -// addresses.oldController = controllerInst.controller; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-is-new-controller")); -// } - -// // TODO: Skipping conversion factor test, can add later if needed - -// /**********************************************************************************************/ -// /*** Unlimited `maxAmount` rate limit boundary tests ***/ -// /**********************************************************************************************/ - -// function test_init_incorrectUsdsMintData_unlimitedBoundary() external { -// rateLimitData.usdsMintData.maxAmount = type(uint256).max; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdsMintData")); - -// rateLimitData.usdsMintData.slope = 0; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectUsdcToUsdsData_unlimitedBoundary() external { -// rateLimitData.usdsToUsdcData.maxAmount = type(uint256).max; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdsToUsdcData")); - -// rateLimitData.usdsToUsdcData.slope = 0; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectUsdcToCctpData_unlimitedBoundary() external { -// rateLimitData.usdcToCctpData.maxAmount = type(uint256).max; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-usdcToCctpData")); - -// rateLimitData.usdcToCctpData.slope = 0; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectCctpToBaseDomain_unlimitedBoundary() external { -// rateLimitData.cctpToBaseDomainData.maxAmount = type(uint256).max; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-cctpToBaseDomainData")); - -// rateLimitData.cctpToBaseDomainData.slope = 0; -// _checkBothInitsSucceed(); -// } - -// /**********************************************************************************************/ -// /*** `maxAmount` rate limit precision boundary tests ***/ -// /**********************************************************************************************/ - -// function test_init_incorrectUsdsMintData_maxAmountPrecisionBoundary() external { -// rateLimitData.usdsMintData.maxAmount = 1e12 * 1e18 + 1; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdsMintData")); - -// rateLimitData.usdsMintData.maxAmount = 1e12 * 1e18; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectUsdcToUsdsData_maxAmountPrecisionBoundary() external { -// rateLimitData.usdsToUsdcData.maxAmount = 1e12 * 1e6 + 1; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdsToUsdcData")); - -// rateLimitData.usdsToUsdcData.maxAmount = 1e12 * 1e6; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectUsdcToCctpData_maxAmountPrecisionBoundary() external { -// rateLimitData.usdcToCctpData.maxAmount = 1e12 * 1e6 + 1; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-usdcToCctpData")); - -// rateLimitData.usdcToCctpData.maxAmount = 1e12 * 1e6; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectCctpToBaseDomain_maxAmountPrecisionBoundary() external { -// rateLimitData.cctpToBaseDomainData.maxAmount = 1e12 * 1e6 + 1; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-cctpToBaseDomainData")); - -// rateLimitData.cctpToBaseDomainData.maxAmount = 1e12 * 1e6; -// _checkBothInitsSucceed(); -// } - -// /**********************************************************************************************/ -// /*** `slope` rate limit precision boundary tests ***/ -// /**********************************************************************************************/ - -// function test_init_incorrectUsdsMintData_slopePrecisionBoundary() external { -// rateLimitData.usdsMintData.slope = uint256(1e12 * 1e18) / 1 hours + 1; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdsMintData")); - -// rateLimitData.usdsMintData.slope = uint256(1e12 * 1e18) / 1 hours; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectUsdcToUsdsData_slopePrecisionBoundary() external { -// rateLimitData.usdsToUsdcData.slope = uint256(1e12 * 1e6) / 1 hours + 1; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdsToUsdcData")); - -// rateLimitData.usdsToUsdcData.slope = uint256(1e12 * 1e6) / 1 hours; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectUsdcToCctpData_slopePrecisionBoundary() external { -// rateLimitData.usdcToCctpData.slope = uint256(1e12 * 1e6) / 1 hours + 1; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-usdcToCctpData")); - -// rateLimitData.usdcToCctpData.slope = uint256(1e12 * 1e6) / 1 hours; -// _checkBothInitsSucceed(); -// } - -// function test_init_incorrectCctpToBaseDomain_slopePrecisionBoundary() external { -// rateLimitData.cctpToBaseDomainData.slope = uint256(1e12 * 1e6) / 1 hours + 1; -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-cctpToBaseDomainData")); - -// rateLimitData.cctpToBaseDomainData.slope = uint256(1e12 * 1e6) / 1 hours; -// _checkBothInitsSucceed(); -// } - -// /**********************************************************************************************/ -// /*** Old controller role check tests ***/ -// /**********************************************************************************************/ - -// function test_init_oldControllerDoesNotHaveRoleInAlmProxy() external { -// _deployNewControllerAfterExistingControllerInit(); - -// // Revoke the old controller address in ALM proxy - -// vm.startPrank(SPARK_PROXY); -// almProxy.revokeRole(almProxy.CONTROLLER(), addresses.oldController); -// vm.stopPrank(); - -// // Try to init with the old controller address that is doesn't have the CONTROLLER role - -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-almProxy-controller")); -// } - -// function test_init_oldControllerDoesNotHaveRoleInRateLimits() external { -// _deployNewControllerAfterExistingControllerInit(); - -// // Revoke the old controller address - -// vm.startPrank(SPARK_PROXY); -// rateLimits.revokeRole(rateLimits.CONTROLLER(), addresses.oldController); -// vm.stopPrank(); - -// // Try to init with the old controller address that is doesn't have the CONTROLLER role - -// _checkBothInitsFail(abi.encodePacked("MainnetControllerInit/old-controller-not-rateLimits-controller")); -// } - -// /**********************************************************************************************/ -// /*** Helper functions ***/ -// /**********************************************************************************************/ - -// function _deployNewControllerAfterExistingControllerInit() internal { -// // Successfully init first controller - -// vm.startPrank(SPARK_PROXY); -// MainnetControllerInit.subDaoInitFull( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// vm.stopPrank(); - -// // Deploy a new controller (controllerInst is used in init with new controller address) - -// controllerInst.controller = MainnetControllerDeploy.deployController( -// SPARK_PROXY, -// address(almProxy), -// address(rateLimits), -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER -// ); - -// addresses.oldController = address(mainnetController); -// } - -// // Added this function to ensure that all the failure modes from `subDaoInitController` -// // are also covered by `subDaoInitFull` calls -// function _checkBothInitsFail(bytes memory expectedError) internal { -// vm.expectRevert(expectedError); -// wrapper.subDaoInitController( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); - -// vm.expectRevert(expectedError); -// wrapper.subDaoInitFull( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// } - -// function _checkBothInitsSucceed() internal { -// wrapper.subDaoInitController( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); - -// wrapper.subDaoInitFull( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// } -// } - -// contract MainnetControllerDeployAndInitSuccessTests is MainnetControllerDeployInitTestBase { - -// function test_deployAllAndInitFull() external { -// // Perform new deployments against existing fork environment - -// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( -// SPARK_PROXY, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER -// ); - -// // Overwrite storage for all previous deployments in setUp and assert deployment - -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// mainnetController = MainnetController(controllerInst.controller); -// rateLimits = RateLimits(controllerInst.rateLimits); - -// assertEq(almProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); -// assertEq(mainnetController.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); -// assertEq(rateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); - -// assertEq(address(mainnetController.proxy()), controllerInst.almProxy); -// assertEq(address(mainnetController.rateLimits()), controllerInst.rateLimits); -// assertEq(address(mainnetController.vault()), vault); -// assertEq(address(mainnetController.buffer()), buffer); -// assertEq(address(mainnetController.psm()), PSM); -// assertEq(address(mainnetController.daiUsds()), DAI_USDS); -// assertEq(address(mainnetController.cctp()), CCTP_MESSENGER); -// assertEq(address(mainnetController.dai()), address(dai)); -// assertEq(address(mainnetController.usdc()), address(usdc)); -// assertEq(address(mainnetController.usds()), address(usds)); - -// assertEq(mainnetController.psmTo18ConversionFactor(), 1e12); -// assertEq(mainnetController.active(), true); - -// // Perform SubDAO initialization (from SPARK_PROXY during spell) -// // Setting rate limits to different values from setUp to make assertions more robust - -// ( -// MainnetControllerInit.AddressParams memory addresses, -// MainnetControllerInit.InitRateLimitData memory rateLimitData, -// MintRecipient[] memory mintRecipients -// ) = _getDefaultParams(); - -// vm.startPrank(SPARK_PROXY); -// MainnetControllerInit.subDaoInitFull( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// vm.stopPrank(); - -// // Assert SubDAO initialization - -// assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); -// assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); - -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); - -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); - -// bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( -// mainnetController.LIMIT_USDC_TO_DOMAIN(), -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE -// ); - -// _assertRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimitData.usdsMintData); -// _assertRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimitData.usdsToUsdcData); -// _assertRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimitData.usdcToCctpData); -// _assertRateLimitData(domainKeyBase, rateLimitData.cctpToBaseDomainData); - -// assertEq( -// mainnetController.mintRecipients(mintRecipients[0].domain), -// mintRecipients[0].mintRecipient -// ); - -// assertEq( -// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), -// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) -// ); - -// assertEq(IVaultLike(vault).wards(controllerInst.almProxy), 1); - -// assertEq(usds.allowance(buffer, controllerInst.almProxy), type(uint256).max); - -// // Perform Maker initialization (from PAUSE_PROXY during spell) - -// vm.startPrank(PAUSE_PROXY); -// MainnetControllerInit.pauseProxyInit(PSM, controllerInst.almProxy); -// vm.stopPrank(); - -// // Assert Maker initialization - -// assertEq(IPSMLike(PSM).bud(controllerInst.almProxy), 1); -// } - -// function test_deployAllAndInitController() external { -// // Perform new deployments against existing fork environment - -// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( -// SPARK_PROXY, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER -// ); - -// // Overwrite storage for all previous deployments in setUp and assert deployment - -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// mainnetController = MainnetController(controllerInst.controller); -// rateLimits = RateLimits(controllerInst.rateLimits); - -// ( -// MainnetControllerInit.AddressParams memory addresses, -// MainnetControllerInit.InitRateLimitData memory rateLimitData, -// MintRecipient[] memory mintRecipients -// ) = _getDefaultParams(); - -// // Perform ONLY controller initialization, setting rate limits and updating ACL -// // Setting rate limits to different values from setUp to make assertions more robust - -// vm.startPrank(SPARK_PROXY); -// MainnetControllerInit.subDaoInitController( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// vm.stopPrank(); - -// assertEq(mainnetController.hasRole(mainnetController.FREEZER(), freezer), true); -// assertEq(mainnetController.hasRole(mainnetController.RELAYER(), relayer), true); - -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), address(mainnetController)), true); - -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), address(mainnetController)), true); - -// bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( -// mainnetController.LIMIT_USDC_TO_DOMAIN(), -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE -// ); - -// _assertRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimitData.usdsMintData); -// _assertRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimitData.usdsToUsdcData); -// _assertRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimitData.usdcToCctpData); -// _assertRateLimitData(domainKeyBase, rateLimitData.cctpToBaseDomainData); - -// assertEq( -// mainnetController.mintRecipients(mintRecipients[0].domain), -// mintRecipients[0].mintRecipient -// ); - -// assertEq( -// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), -// bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) -// ); -// } - -// function test_init_transferAclToNewController() public { -// // Deploy and init a controller - -// ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull( -// SPARK_PROXY, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER -// ); - -// ( -// MainnetControllerInit.AddressParams memory addresses, -// MainnetControllerInit.InitRateLimitData memory rateLimitData, -// MintRecipient[] memory mintRecipients -// ) = _getDefaultParams(); - -// vm.startPrank(SPARK_PROXY); -// MainnetControllerInit.subDaoInitController( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// vm.stopPrank(); - -// // Deploy a new controller (example of how an upgrade would work) - -// address newController = MainnetControllerDeploy.deployController( -// SPARK_PROXY, -// controllerInst.almProxy, -// controllerInst.rateLimits, -// vault, -// PSM, -// DAI_USDS, -// CCTP_MESSENGER -// ); - -// // Overwrite storage for all previous deployments in setUp and assert deployment - -// almProxy = ALMProxy(payable(controllerInst.almProxy)); -// mainnetController = MainnetController(controllerInst.controller); -// rateLimits = RateLimits(controllerInst.rateLimits); - -// address oldController = address(controllerInst.controller); - -// controllerInst.controller = newController; // Overwrite struct for param - -// // All other info is the same, just need to transfer ACL -// addresses.oldController = oldController; - -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), true); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), false); - -// vm.startPrank(SPARK_PROXY); -// MainnetControllerInit.subDaoInitController( -// addresses, -// controllerInst, -// rateLimitData, -// mintRecipients -// ); -// vm.stopPrank(); - -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); -// assertEq(almProxy.hasRole(almProxy.CONTROLLER(), oldController), false); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); -// assertEq(rateLimits.hasRole(rateLimits.CONTROLLER(), newController), true); -// } - -// function _assertRateLimitData(bytes32 domainKey, RateLimitData memory expectedData) internal view { -// IRateLimits.RateLimitData memory data = rateLimits.getRateLimitData(domainKey); - -// assertEq(data.maxAmount, expectedData.maxAmount); -// assertEq(data.slope, expectedData.slope); -// assertEq(data.lastAmount, expectedData.maxAmount); -// assertEq(data.lastUpdated, block.timestamp); - -// assertEq(rateLimits.getCurrentRateLimit(domainKey), expectedData.maxAmount); -// } - -// } diff --git a/test/mainnet-fork/ForkTestBase.t.sol b/test/mainnet-fork/ForkTestBase.t.sol index ef4b15a..04cbb69 100644 --- a/test/mainnet-fork/ForkTestBase.t.sol +++ b/test/mainnet-fork/ForkTestBase.t.sol @@ -26,17 +26,14 @@ import { Domain, DomainHelpers } from "xchain-helpers/src/testing/Domain.sol"; import { MainnetControllerDeploy } from "../../deploy/ControllerDeploy.sol"; import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; -import { - MainnetControllerInit, - MintRecipient, - RateLimitData -} from "../../deploy/ControllerInit.sol"; +import { MainnetControllerInit as Init } from "../../deploy/MainnetControllerInit.sol"; import { ALMProxy } from "../../src/ALMProxy.sol"; import { RateLimits } from "../../src/RateLimits.sol"; -import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; import { MainnetController } from "../../src/MainnetController.sol"; +import { RateLimitHelpers, RateLimitData } from "../../src/RateLimitHelpers.sol"; + interface IChainlogLike { function getAddress(bytes32) external view returns (address); } @@ -201,14 +198,14 @@ contract ForkTestBase is DssTest { buffer = ilkInst.buffer; vault = ilkInst.vault; - /*** Step 3: Deploy and configure ALM system ***/ + /*** Step 3: Deploy ALM system ***/ ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull({ - admin : Ethereum.SPARK_PROXY, - vault : ilkInst.vault, - psm : Ethereum.PSM, - daiUsds: Ethereum.DAI_USDS, - cctp : Ethereum.CCTP_TOKEN_MESSENGER + admin : Ethereum.SPARK_PROXY, + vault : ilkInst.vault, + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER }); almProxy = ALMProxy(payable(controllerInst.almProxy)); @@ -219,22 +216,49 @@ contract ForkTestBase is DssTest { FREEZER = mainnetController.FREEZER(); RELAYER = mainnetController.RELAYER(); - MainnetControllerInit.AddressParams memory addresses = MainnetControllerInit.AddressParams({ - admin : Ethereum.SPARK_PROXY, - freezer : freezer, - relayer : relayer, - oldController : address(0), - psm : Ethereum.PSM, - vault : vault, - buffer : buffer, - cctpMessenger : Ethereum.CCTP_TOKEN_MESSENGER, - dai : Ethereum.DAI, - daiUsds : Ethereum.DAI_USDS, - usdc : Ethereum.USDC, - usds : Ethereum.USDS, - susds : Ethereum.SUSDS + Init.ConfigAddressParams memory configAddresses + = Init.ConfigAddressParams({ + freezer : freezer, + relayer : relayer, + oldController : address(0) + }); + + Init.CheckAddressParams memory checkAddresses + = Init.CheckAddressParams({ + admin : Ethereum.SPARK_PROXY, + proxy : address(almProxy), + rateLimits : address(rateLimits), + vault : address(vault), + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER + }); + + Init.MintRecipient[] memory mintRecipients = new Init.MintRecipient[](1); + + mintRecipients[0] = Init.MintRecipient({ + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) }); + // Step 4: Initialize through Sky governance + + vm.prank(Ethereum.PAUSE_PROXY); + Init.pauseProxyInitAlmSystem(Ethereum.PSM, controllerInst.almProxy); + + // Step 5: Initialize through Spark governance + + vm.startPrank(Ethereum.SPARK_PROXY); + + Init.initAlmSystem( + vault, + address(usds), + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + RateLimitData memory standardUsdsData = RateLimitData({ maxAmount : 5_000_000e18, slope : uint256(1_000_000e18) / 4 hours @@ -245,32 +269,22 @@ contract ForkTestBase is DssTest { slope : uint256(1_000_000e6) / 4 hours }); - MainnetControllerInit.InitRateLimitData memory rateLimitData - = MainnetControllerInit.InitRateLimitData({ - usdsMintData : standardUsdsData, - usdsToUsdcData : standardUsdcData, - usdcToCctpData : standardUsdcData, - cctpToBaseDomainData : standardUsdcData, - susdsDepositData : standardUsdsData - }); - - MintRecipient[] memory mintRecipients = new MintRecipient[](1); + bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( + mainnetController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE + ); - mintRecipients[0] = MintRecipient({ - domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) - }); + bytes32 susdsKey = RateLimitHelpers.makeAssetKey( + mainnetController.LIMIT_4626_DEPOSIT(), + address(susds) + ); - vm.prank(Ethereum.PAUSE_PROXY); - MainnetControllerInit.pauseProxyInit(Ethereum.PSM, controllerInst.almProxy); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimits, standardUsdsData, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimits, standardUsdcData, "usdsToUsdcData", 6); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimits, standardUsdcData, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits, standardUsdcData, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(susdsKey, rateLimits, standardUsdsData, "susdsDepositData", 18); - vm.startPrank(Ethereum.SPARK_PROXY); - MainnetControllerInit.subDaoInitFull( - addresses, - controllerInst, - rateLimitData, - mintRecipients - ); vm.stopPrank(); /*** Step 4: Label addresses ***/ From 39aadd411a8c2121cfd1ac0d0023b5890ac2d899 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 20 Dec 2024 14:49:29 -0500 Subject: [PATCH 16/33] test: main tests passing with new libs --- script/staging/FullStagingDeploy.s.sol | 882 +++++++++++++------------ 1 file changed, 462 insertions(+), 420 deletions(-) diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 487e8c4..597045a 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -1,443 +1,485 @@ -// // SPDX-License-Identifier: AGPL-3.0-or-later -// pragma solidity ^0.8.21; - -// import { -// AllocatorDeploy, -// AllocatorIlkInstance, -// AllocatorSharedInstance -// } from "dss-allocator/deploy/AllocatorDeploy.sol"; - -// import { -// BufferLike, -// RegistryLike, -// RolesLike, -// VaultLike -// } from "dss-allocator/deploy/AllocatorInit.sol"; - -// import { AllocatorBuffer } from "dss-allocator/src/AllocatorBuffer.sol"; -// import { AllocatorVault } from "dss-allocator/src/AllocatorVault.sol"; - -// import { ScriptTools } from "dss-test/ScriptTools.sol"; - -// import { IERC20 } from "forge-std/interfaces/IERC20.sol"; -// import { Script } from "forge-std/Script.sol"; -// import { stdJson } from "forge-std/StdJson.sol"; - -// import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; - -// import { -// ControllerInstance, -// ForeignController, -// ForeignControllerDeploy, -// MainnetController, -// MainnetControllerDeploy -// } from "../../deploy/ControllerDeploy.sol"; - -// import { -// ForeignControllerInit, -// MainnetControllerInit, -// MintRecipient, -// RateLimitData -// } from "../../deploy/ControllerInit.sol"; - -// import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; -// import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; - -// import { MockJug } from "./mocks/MockJug.sol"; -// import { MockUsdsJoin } from "./mocks/MockUsdsJoin.sol"; -// import { MockVat } from "./mocks/MockVat.sol"; -// import { PSMWrapper } from "./mocks/PSMWrapper.sol"; - -// struct Domain { -// string name; -// string nameDeps; -// string config; -// uint256 forkId; -// address admin; -// } +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity ^0.8.21; -// contract FullStagingDeploy is Script { +import { + AllocatorDeploy, + AllocatorIlkInstance, + AllocatorSharedInstance +} from "dss-allocator/deploy/AllocatorDeploy.sol"; -// using stdJson for string; -// using ScriptTools for string; +import { + BufferLike, + RegistryLike, + RolesLike, + VaultLike +} from "dss-allocator/deploy/AllocatorInit.sol"; -// /**********************************************************************************************/ -// /*** Mainnet existing/mock deployments ***/ -// /**********************************************************************************************/ - -// address dai; -// address daiUsds; -// address livePsm; -// address psm; -// address susds; -// address usds; -// address usdc; +import { AllocatorBuffer } from "dss-allocator/src/AllocatorBuffer.sol"; +import { AllocatorVault } from "dss-allocator/src/AllocatorVault.sol"; -// // Mocked MCD contracts -// address jug; -// address usdsJoin; -// address vat; - -// /**********************************************************************************************/ -// /*** Mainnet allocation system deployments ***/ -// /**********************************************************************************************/ - -// address oracle; -// address roles; -// address registry; - -// address buffer; -// address vault; - -// /**********************************************************************************************/ -// /*** ALM system deployments ***/ -// /**********************************************************************************************/ +import { ScriptTools } from "dss-test/ScriptTools.sol"; -// address baseAlmProxy; -// address baseController; - -// address mainnetAlmProxy; -// address mainnetController; - -// /**********************************************************************************************/ -// /*** Deployment-specific variables ***/ -// /**********************************************************************************************/ +import { IERC20 } from "forge-std/interfaces/IERC20.sol"; +import { Script } from "forge-std/Script.sol"; +import { stdJson } from "forge-std/StdJson.sol"; -// address deployer; -// bytes32 ilk; +import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; -// uint256 USDC_UNIT_SIZE; -// uint256 USDS_UNIT_SIZE; +import { + ControllerInstance, + ForeignController, + ForeignControllerDeploy, + MainnetController, + MainnetControllerDeploy +} from "../../deploy/ControllerDeploy.sol"; -// Domain mainnet; -// Domain base; +import { ForeignControllerInit } from "../../deploy/ForeignControllerInit.sol"; +import { MainnetControllerInit, MintRecipient } from "../../deploy/MainnetControllerInit.sol"; + +import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; + +import { RateLimitHelpers, RateLimitData } from "../../src/RateLimitHelpers.sol"; -// /**********************************************************************************************/ -// /*** Helper functions ***/ -// /**********************************************************************************************/ +import { MockJug } from "./mocks/MockJug.sol"; +import { MockUsdsJoin } from "./mocks/MockUsdsJoin.sol"; +import { MockVat } from "./mocks/MockVat.sol"; +import { PSMWrapper } from "./mocks/PSMWrapper.sol"; -// function _setUpDependencies() internal { -// vm.selectFork(mainnet.forkId); -// vm.startBroadcast(); +struct Domain { + string name; + string nameDeps; + string config; + uint256 forkId; + address admin; +} -// // Step 1: Use existing contracts for tokens, DaiUsds and PSM +contract FullStagingDeploy is Script { -// dai = mainnet.config.readAddress(".dai"); -// usds = mainnet.config.readAddress(".usds"); -// susds = mainnet.config.readAddress(".susds"); -// usdc = mainnet.config.readAddress(".usdc"); -// daiUsds = mainnet.config.readAddress(".daiUsds"); -// livePsm = mainnet.config.readAddress(".psm"); + using stdJson for string; + using ScriptTools for string; -// // This contract is necessary to get past the `kiss` requirement from the pause proxy. -// // It wraps the `noFee` calls with regular PSM swap calls. -// psm = address(new PSMWrapper(usdc, dai, livePsm)); + /**********************************************************************************************/ + /*** Mainnet existing/mock deployments ***/ + /**********************************************************************************************/ -// // NOTE: This is a HACK to make sure that `fill` doesn't get called until the call reverts. -// // Because this PSM contract is a wrapper over the real PSM, the controller queries -// // the DAI balance of the PSM to check if it should fill or not. Filling with DAI -// // fills the live PSM NOT the wrapper, so the while loop will continue until the -// // function reverts. Dealing DAI into the wrapper will prevent fill from being called. -// IERC20(dai).transfer(psm, USDS_UNIT_SIZE); + address dai; + address daiUsds; + address livePsm; + address psm; + address susds; + address usds; + address usdc; -// // Step 2: Deploy mocked MCD contracts + // Mocked MCD contracts + address jug; + address usdsJoin; + address vat; -// vat = address(new MockVat(mainnet.admin)); -// usdsJoin = address(new MockUsdsJoin(mainnet.admin, vat, usds)); -// jug = address(new MockJug()); + /**********************************************************************************************/ + /*** Mainnet allocation system deployments ***/ + /**********************************************************************************************/ -// // Step 3: Transfer USDS into the join contract + address oracle; + address roles; + address registry; -// require(IERC20(usds).balanceOf(deployer) >= USDS_UNIT_SIZE, "USDS balance too low"); + address buffer; + address vault; -// IERC20(usds).transfer(usdsJoin, USDS_UNIT_SIZE); + /**********************************************************************************************/ + /*** ALM system deployments ***/ + /**********************************************************************************************/ -// vm.stopBroadcast(); + address baseAlmProxy; + address baseController; -// // Step 4: Export all deployed addresses + address mainnetAlmProxy; + address mainnetController; -// ScriptTools.exportContract(mainnet.nameDeps, "dai", dai); -// ScriptTools.exportContract(mainnet.nameDeps, "daiUsds", daiUsds); -// ScriptTools.exportContract(mainnet.nameDeps, "jug", jug); -// ScriptTools.exportContract(mainnet.nameDeps, "psm", psm); -// ScriptTools.exportContract(mainnet.nameDeps, "susds", susds); -// ScriptTools.exportContract(mainnet.nameDeps, "usdc", usdc); -// ScriptTools.exportContract(mainnet.nameDeps, "usds", usds); -// ScriptTools.exportContract(mainnet.nameDeps, "usdsJoin", usdsJoin); -// ScriptTools.exportContract(mainnet.nameDeps, "vat", vat); -// } - -// function _setUpAllocationSystem() internal { -// vm.selectFork(mainnet.forkId); -// vm.startBroadcast(); - -// // Step 1: Deploy allocation system - -// AllocatorSharedInstance memory allocatorSharedInstance -// = AllocatorDeploy.deployShared(deployer, mainnet.admin); - -// AllocatorIlkInstance memory allocatorIlkInstance = AllocatorDeploy.deployIlk( -// deployer, -// mainnet.admin, -// allocatorSharedInstance.roles, -// ilk, -// usdsJoin -// ); - -// oracle = allocatorSharedInstance.oracle; -// registry = allocatorSharedInstance.registry; -// roles = allocatorSharedInstance.roles; - -// buffer = allocatorIlkInstance.buffer; -// vault = allocatorIlkInstance.vault; - -// // Step 2: Perform partial initialization (not using library because of mocked MCD) - -// RegistryLike(registry).file(ilk, "buffer", buffer); -// VaultLike(vault).file("jug", jug); -// BufferLike(buffer).approve(usds, vault, type(uint256).max); -// RolesLike(roles).setIlkAdmin(ilk, mainnet.admin); - -// // Step 3: Move ownership of both the vault and buffer to the admin - -// ScriptTools.switchOwner(vault, allocatorIlkInstance.owner, mainnet.admin); -// ScriptTools.switchOwner(buffer, allocatorIlkInstance.owner, mainnet.admin); - -// vm.stopBroadcast(); - -// // Step 4: Export all deployed addresses - -// ScriptTools.exportContract(mainnet.nameDeps, "allocatorOracle", oracle); -// ScriptTools.exportContract(mainnet.nameDeps, "allocatorRegistry", registry); -// ScriptTools.exportContract(mainnet.nameDeps, "allocatorRoles", roles); - -// ScriptTools.exportContract(mainnet.nameDeps, "allocatorBuffer", buffer); -// ScriptTools.exportContract(mainnet.nameDeps, "allocatorVault", vault); -// } - -// function _setUpALMController() internal { -// vm.selectFork(mainnet.forkId); -// vm.startBroadcast(); - -// // Step 1: Deploy ALM controller - -// ControllerInstance memory instance = MainnetControllerDeploy.deployFull({ -// admin : mainnet.admin, -// vault : vault, -// psm : psm, -// daiUsds : daiUsds, -// cctp : mainnet.config.readAddress(".cctpTokenMessenger") -// }); - -// mainnetAlmProxy = instance.almProxy; -// mainnetController = instance.controller; - -// // Step 2: Initialize ALM controller, setting rate limits, mint recipients, and setting ACL - -// // Still constrained by the USDC_UNIT_SIZE -// RateLimitData memory rateLimitData18 = RateLimitData({ -// maxAmount : USDC_UNIT_SIZE * 1e12 * 5, -// slope : USDC_UNIT_SIZE * 1e12 / 4 hours -// }); -// RateLimitData memory rateLimitData6 = RateLimitData({ -// maxAmount : USDC_UNIT_SIZE * 5, -// slope : USDC_UNIT_SIZE / 4 hours -// }); -// RateLimitData memory unlimitedRateLimit = RateLimitData({ -// maxAmount : type(uint256).max, -// slope : 0 -// }); - -// // Configure this after Base ALM Proxy is deployed -// MintRecipient[] memory mintRecipients = new MintRecipient[](0); - -// MainnetControllerInit.subDaoInitFull({ -// addresses: MainnetControllerInit.AddressParams({ -// admin : mainnet.admin, -// freezer : mainnet.config.readAddress(".freezer"), -// relayer : mainnet.config.readAddress(".relayer"), -// oldController : address(0), -// psm : psm, -// vault : vault, -// buffer : buffer, -// cctpMessenger : mainnet.config.readAddress(".cctpTokenMessenger"), -// dai : dai, -// daiUsds : daiUsds, -// usdc : usdc, -// usds : usds, -// susds : susds -// }), -// controllerInst: instance, -// data: MainnetControllerInit.InitRateLimitData({ -// usdsMintData : rateLimitData18, -// usdsToUsdcData : rateLimitData6, -// usdcToCctpData : unlimitedRateLimit, -// cctpToBaseDomainData : rateLimitData6, -// susdsDepositData : rateLimitData18 -// }), -// mintRecipients: mintRecipients -// }); - -// // Extra rate limit configuration -// bytes32 mintKey = MainnetController(instance.controller).LIMIT_USDE_MINT(); -// bytes32 burnKey = MainnetController(instance.controller).LIMIT_USDE_BURN(); + /**********************************************************************************************/ + /*** Deployment-specific variables ***/ + /**********************************************************************************************/ + + address deployer; + bytes32 ilk; + + uint256 USDC_UNIT_SIZE; + uint256 USDS_UNIT_SIZE; + + Domain mainnet; + Domain base; + + /**********************************************************************************************/ + /*** Helper functions ***/ + /**********************************************************************************************/ + + function _setUpDependencies() internal { + vm.selectFork(mainnet.forkId); + vm.startBroadcast(); + + // Step 1: Use existing contracts for tokens, DaiUsds and PSM + + dai = mainnet.config.readAddress(".dai"); + usds = mainnet.config.readAddress(".usds"); + susds = mainnet.config.readAddress(".susds"); + usdc = mainnet.config.readAddress(".usdc"); + daiUsds = mainnet.config.readAddress(".daiUsds"); + livePsm = mainnet.config.readAddress(".psm"); + + // This contract is necessary to get past the `kiss` requirement from the pause proxy. + // It wraps the `noFee` calls with regular PSM swap calls. + psm = address(new PSMWrapper(usdc, dai, livePsm)); + + // NOTE: This is a HACK to make sure that `fill` doesn't get called until the call reverts. + // Because this PSM contract is a wrapper over the real PSM, the controller queries + // the DAI balance of the PSM to check if it should fill or not. Filling with DAI + // fills the live PSM NOT the wrapper, so the while loop will continue until the + // function reverts. Dealing DAI into the wrapper will prevent fill from being called. + IERC20(dai).transfer(psm, USDS_UNIT_SIZE); + + // Step 2: Deploy mocked MCD contracts + + vat = address(new MockVat(mainnet.admin)); + usdsJoin = address(new MockUsdsJoin(mainnet.admin, vat, usds)); + jug = address(new MockJug()); + + // Step 3: Transfer USDS into the join contract + + require(IERC20(usds).balanceOf(deployer) >= USDS_UNIT_SIZE, "USDS balance too low"); + + IERC20(usds).transfer(usdsJoin, USDS_UNIT_SIZE); + + vm.stopBroadcast(); + + // Step 4: Export all deployed addresses + + ScriptTools.exportContract(mainnet.nameDeps, "dai", dai); + ScriptTools.exportContract(mainnet.nameDeps, "daiUsds", daiUsds); + ScriptTools.exportContract(mainnet.nameDeps, "jug", jug); + ScriptTools.exportContract(mainnet.nameDeps, "psm", psm); + ScriptTools.exportContract(mainnet.nameDeps, "susds", susds); + ScriptTools.exportContract(mainnet.nameDeps, "usdc", usdc); + ScriptTools.exportContract(mainnet.nameDeps, "usds", usds); + ScriptTools.exportContract(mainnet.nameDeps, "usdsJoin", usdsJoin); + ScriptTools.exportContract(mainnet.nameDeps, "vat", vat); + } + + function _setUpAllocationSystem() internal { + vm.selectFork(mainnet.forkId); + vm.startBroadcast(); + + // Step 1: Deploy allocation system + + AllocatorSharedInstance memory allocatorSharedInstance + = AllocatorDeploy.deployShared(deployer, mainnet.admin); + + AllocatorIlkInstance memory allocatorIlkInstance = AllocatorDeploy.deployIlk( + deployer, + mainnet.admin, + allocatorSharedInstance.roles, + ilk, + usdsJoin + ); + + oracle = allocatorSharedInstance.oracle; + registry = allocatorSharedInstance.registry; + roles = allocatorSharedInstance.roles; + + buffer = allocatorIlkInstance.buffer; + vault = allocatorIlkInstance.vault; + + // Step 2: Perform partial initialization (not using library because of mocked MCD) + + RegistryLike(registry).file(ilk, "buffer", buffer); + VaultLike(vault).file("jug", jug); + BufferLike(buffer).approve(usds, vault, type(uint256).max); + RolesLike(roles).setIlkAdmin(ilk, mainnet.admin); + + // Step 3: Move ownership of both the vault and buffer to the admin + + ScriptTools.switchOwner(vault, allocatorIlkInstance.owner, mainnet.admin); + ScriptTools.switchOwner(buffer, allocatorIlkInstance.owner, mainnet.admin); + + vm.stopBroadcast(); + + // Step 4: Export all deployed addresses + + ScriptTools.exportContract(mainnet.nameDeps, "allocatorOracle", oracle); + ScriptTools.exportContract(mainnet.nameDeps, "allocatorRegistry", registry); + ScriptTools.exportContract(mainnet.nameDeps, "allocatorRoles", roles); + + ScriptTools.exportContract(mainnet.nameDeps, "allocatorBuffer", buffer); + ScriptTools.exportContract(mainnet.nameDeps, "allocatorVault", vault); + } + + function _setUpALMController() internal { + vm.selectFork(mainnet.forkId); + vm.startBroadcast(); + + // Step 1: Deploy ALM controller + + ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull({ + admin : mainnet.admin, + vault : vault, + psm : psm, + daiUsds : daiUsds, + cctp : mainnet.config.readAddress(".cctpTokenMessenger") + }); + + mainnetAlmProxy = controllerInst.almProxy; + mainnetController = controllerInst.controller; + + // Step 2: Initialize ALM system + + MainnetControllerInit.ConfigAddressParams memory configAddresses + = MainnetControllerInit.ConfigAddressParams({ + freezer : freezer, + relayer : relayer, + oldController : address(0) + }); + + MainnetControllerInit.CheckAddressParams memory checkAddresses + = MainnetControllerInit.CheckAddressParams({ + admin : Ethereum.SPARK_PROXY, + proxy : address(almProxy), + rateLimits : address(rateLimits), + vault : address(vault), + psm : Ethereum.PSM, + daiUsds : Ethereum.DAI_USDS, + cctp : Ethereum.CCTP_TOKEN_MESSENGER + }); + + MainnetControllerInit.MintRecipient[] memory mintRecipients = new MainnetControllerInit.MintRecipient[](1); + + mintRecipients[0] = MainnetControllerInit.MintRecipient({ + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) + }); + + Init.MintRecipient[] memory mintRecipients = new Init.MintRecipient[](1); + + Init.initAlmSystem( + vault, + address(usds), + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + // Step 3: Set all rate limits for the controller + + // Still constrained by the USDC_UNIT_SIZE + RateLimitData memory rateLimitData18 = RateLimitData({ + maxAmount : USDC_UNIT_SIZE * 1e12 * 5, + slope : USDC_UNIT_SIZE * 1e12 / 4 hours + }); + RateLimitData memory rateLimitData6 = RateLimitData({ + maxAmount : USDC_UNIT_SIZE * 5, + slope : USDC_UNIT_SIZE / 4 hours + }); + RateLimitData memory unlimitedRateLimit = RateLimitData({ + maxAmount : type(uint256).max, + slope : 0 + }); + + bytes32 mintKey = MainnetController(controllerInst.controller).LIMIT_USDE_MINT(); + bytes32 burnKey = MainnetController(controllerInst.controller).LIMIT_USDE_BURN(); -// bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey( -// MainnetController(instance.controller).LIMIT_4626_DEPOSIT(), -// address(MainnetController(instance.controller).susde()) -// ); - -// bytes32 susdsWithdrawKey = RateLimitHelpers.makeAssetKey( -// MainnetController(instance.controller).LIMIT_4626_WITHDRAW(), -// address(MainnetController(instance.controller).susde()) -// ); - -// // Extra rate limit configuration -// MainnetControllerInit.setRateLimitData(mintKey, IRateLimits(instance.rateLimits), rateLimitData6, "usdeMintData", 6); -// MainnetControllerInit.setRateLimitData(burnKey, IRateLimits(instance.rateLimits), rateLimitData18, "usdeBurnData", 18); -// MainnetControllerInit.setRateLimitData(susdsDepositKey, IRateLimits(instance.rateLimits), rateLimitData18, "susdsDepositData", 18); -// MainnetControllerInit.setRateLimitData(susdsWithdrawKey, IRateLimits(instance.rateLimits), rateLimitData18, "susdsWithdrawData", 18); - -// // Step 3: Transfer ownership of mock usdsJoin to the vault (able to mint usds) - -// MockUsdsJoin(usdsJoin).transferOwnership(vault); - -// vm.stopBroadcast(); - -// // Step 4: Export all deployed addresses - -// ScriptTools.exportContract(mainnet.nameDeps, "freezer", mainnet.config.readAddress(".freezer")); -// ScriptTools.exportContract(mainnet.nameDeps, "relayer", mainnet.config.readAddress(".relayer")); - -// ScriptTools.exportContract(mainnet.name, "almProxy", instance.almProxy); -// ScriptTools.exportContract(mainnet.name, "controller", instance.controller); -// ScriptTools.exportContract(mainnet.name, "rateLimits", instance.rateLimits); -// } - -// function _setUpBaseALMController() public { -// vm.selectFork(base.forkId); -// vm.startBroadcast(); - -// // Step 1: Deploy ALM controller - -// ControllerInstance memory instance = ForeignControllerDeploy.deployFull({ -// admin : base.admin, -// psm : base.config.readAddress(".psm"), -// usdc : base.config.readAddress(".usdc"), -// cctp : base.config.readAddress(".cctpTokenMessenger") -// }); - -// baseAlmProxy = instance.almProxy; -// baseController = instance.controller; - -// // Step 2: Initialize ALM controller, setting rate limits, mint recipients, and setting ACL - -// // Still constrained by the USDC_UNIT_SIZE -// RateLimitData memory rateLimitData18 = RateLimitData({ -// maxAmount : USDC_UNIT_SIZE * 1e12 * 5, -// slope : USDC_UNIT_SIZE * 1e12 / 4 hours -// }); -// RateLimitData memory rateLimitData6 = RateLimitData({ -// maxAmount : USDC_UNIT_SIZE * 5, -// slope : USDC_UNIT_SIZE / 4 hours -// }); -// RateLimitData memory unlimitedRateLimit = RateLimitData({ -// maxAmount : type(uint256).max, -// slope : 0 -// }); - -// MintRecipient[] memory mintRecipients = new MintRecipient[](1); -// mintRecipients[0] = MintRecipient({ -// domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, -// mintRecipient : bytes32(uint256(uint160(mainnetAlmProxy))) -// }); - -// ForeignControllerInit.init({ -// addresses: ForeignControllerInit.AddressParams({ -// admin : base.admin, -// freezer : base.config.readAddress(".freezer"), -// relayer : base.config.readAddress(".relayer"), -// oldController : address(0), -// psm : base.config.readAddress(".psm"), -// cctpMessenger : base.config.readAddress(".cctpTokenMessenger"), -// usdc : base.config.readAddress(".usdc"), -// usds : base.config.readAddress(".usds"), -// susds : base.config.readAddress(".susds") -// }), -// controllerInst: instance, -// data: ForeignControllerInit.InitRateLimitData({ -// usdcDepositData : rateLimitData6, -// usdcWithdrawData : rateLimitData6, -// usdsDepositData : rateLimitData18, -// usdsWithdrawData : rateLimitData18, -// susdsDepositData : rateLimitData18, -// susdsWithdrawData : rateLimitData18, -// usdcToCctpData : unlimitedRateLimit, -// cctpToEthereumDomainData : rateLimitData6 -// }), -// mintRecipients: mintRecipients -// }); - -// vm.stopBroadcast(); - -// // Step 3: Export all deployed addresses - -// ScriptTools.exportContract(base.nameDeps, "freezer", base.config.readAddress(".freezer")); -// ScriptTools.exportContract(base.nameDeps, "relayer", base.config.readAddress(".relayer")); - -// ScriptTools.exportContract(base.name, "almProxy", instance.almProxy); -// ScriptTools.exportContract(base.name, "controller", instance.controller); -// ScriptTools.exportContract(base.name, "rateLimits", instance.rateLimits); -// } - -// function _setBaseMintRecipient() internal { -// vm.selectFork(mainnet.forkId); -// vm.startBroadcast(); - -// MainnetController(mainnetController).setMintRecipient( -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, -// bytes32(uint256(uint160(baseAlmProxy))) -// ); - -// vm.stopBroadcast(); -// } - -// function run() public { -// vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); -// vm.setEnv("FOUNDRY_EXPORTS_OVERWRITE_LATEST", "true"); - -// deployer = msg.sender; - -// mainnet = Domain({ -// name : "mainnet-staging", -// nameDeps : "mainnet-staging-deps", -// config : ScriptTools.loadConfig("mainnet-staging"), -// forkId : vm.createFork(getChain("mainnet").rpcUrl), -// admin : deployer -// }); -// base = Domain({ -// name : "base-staging", -// nameDeps : "base-staging-deps", -// config : ScriptTools.loadConfig("base-staging"), -// forkId : vm.createFork(getChain("base").rpcUrl), -// admin : deployer -// }); - -// // Ballpark sizing of rate limits, tokens in PSMs, etc -// // Ballpark sizing of USDS to put in the join contracts, PSMs, etc -// USDC_UNIT_SIZE = mainnet.config.readUint(".usdcUnitSize") * 1e6; -// USDS_UNIT_SIZE = mainnet.config.readUint(".usdsUnitSize") * 1e18; - -// // Run deployment scripts after setting storage variables - -// _setUpDependencies(); -// _setUpAllocationSystem(); -// _setUpALMController(); -// _setUpBaseALMController(); -// _setBaseMintRecipient(); - -// ScriptTools.exportContract(mainnet.nameDeps, "admin", deployer); -// ScriptTools.exportContract(base.nameDeps, "admin", deployer); -// } - -// } + bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey( + MainnetController(controllerInst.controller).LIMIT_4626_DEPOSIT(), + address(MainnetController(controllerInst.controller).susde()) + ); + + bytes32 susdsWithdrawKey = RateLimitHelpers.makeAssetKey( + MainnetController(controllerInst.controller).LIMIT_4626_WITHDRAW(), + address(MainnetController(controllerInst.controller).susde()) + ); + + bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( + mainnetController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE + ); + + bytes32 susdsKey = RateLimitHelpers.makeAssetKey( + mainnetController.LIMIT_4626_DEPOSIT(), + address(susds) + ); + + IRateLimits rateLimits_ = IRateLimits(controllerInst.rateLimits); + + RateLimitHelpers.setRateLimitData(mintKey, rateLimits_, rateLimitData6, "usdeMintData", 6); + RateLimitHelpers.setRateLimitData(burnKey, rateLimits_, rateLimitData18, "usdeBurnData", 18); + RateLimitHelpers.setRateLimitData(susdsDepositKey, rateLimits_, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(susdsWithdrawKey, rateLimits_, rateLimitData18, "susdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimits_, rateLimitData18, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimits_, rateLimitData6 , "usdsToUsdcData", 6); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimits_, rateLimitData6, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits_, rateLimitData6, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(susdsKey, rateLimits_, rateLimitData18, "susdsDepositData", 18); + + // Step 3: Transfer ownership of mock usdsJoin to the vault (able to mint usds) + + MockUsdsJoin(usdsJoin).transferOwnership(vault); + + vm.stopBroadcast(); + + // Step 4: Export all deployed addresses + + ScriptTools.exportContract(mainnet.nameDeps, "freezer", mainnet.config.readAddress(".freezer")); + ScriptTools.exportContract(mainnet.nameDeps, "relayer", mainnet.config.readAddress(".relayer")); + + ScriptTools.exportContract(mainnet.name, "almProxy", instance.almProxy); + ScriptTools.exportContract(mainnet.name, "controller", instance.controller); + ScriptTools.exportContract(mainnet.name, "rateLimits", instance.rateLimits); + } + + function _setUpBaseALMController() public { + vm.selectFork(base.forkId); + vm.startBroadcast(); + + // Step 1: Deploy ALM controller + + ControllerInstance memory instance = ForeignControllerDeploy.deployFull({ + admin : base.admin, + psm : base.config.readAddress(".psm"), + usdc : base.config.readAddress(".usdc"), + cctp : base.config.readAddress(".cctpTokenMessenger") + }); + + baseAlmProxy = instance.almProxy; + baseController = instance.controller; + + // Step 2: Initialize ALM system + + ForeignControllerInit.ConfigAddressParams memory configAddresses = ForeignControllerInit.ConfigAddressParams({ + freezer : base.config.readAddress(".freezer"), + relayer : base.config.readAddress(".relayer"), + oldController : address(0) + }); + + ForeignControllerInit.CheckAddressParams memory checkAddresses = ForeignControllerInit.CheckAddressParams({ + admin : ase.admin, + psm : base.config.readAddress(".psm"), + cctp : base.config.readAddress(".cctpTokenMessenger"), + usdc : base.config.readAddress(".usdc"), + susds : base.config.readAddress(".usdc"), + usds : base.config.readAddress(".susds") + }); + + ForeignControllerInit.MintRecipient[] memory mintRecipients = new ForeignControllerInit.MintRecipient[](1); + + mintRecipients[0] = ForeignControllerInit.MintRecipient({ + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, + mintRecipient : bytes32(uint256(uint160(mainnetAlmProxy))) + }); + + ForeignControllerInit.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); + + // Step 3: Set all rate limits for the controller + + RateLimitData memory rateLimitData18 = RateLimitData({ + maxAmount : USDC_UNIT_SIZE * 1e12 * 5, + slope : USDC_UNIT_SIZE * 1e12 / 4 hours + }); + RateLimitData memory rateLimitData6 = RateLimitData({ + maxAmount : USDC_UNIT_SIZE * 5, + slope : USDC_UNIT_SIZE / 4 hours + }); + RateLimitData memory unlimitedRateLimit = RateLimitData({ + maxAmount : type(uint256).max, + slope : 0 + }); + + bytes32 depositKey = foreignController.LIMIT_PSM_DEPOSIT(); + bytes32 withdrawKey = foreignController.LIMIT_PSM_WITHDRAW(); + + bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM + ); + + address usdc = base.config.readAddress(".usdc"); + address usds = base.config.readAddress(".usds"); + address susds = base.config.readAddress(".susds"); + + IRateLimits rateLimits_ = IRateLimits(controllerInst.rateLimits); + + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usdc), rateLimits_, standardUsdcData, "usdcDepositData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usdc), rateLimits_, standardUsdcData, "usdcWithdrawData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usds), rateLimits_, standardUsdsData, "usdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usds), rateLimits_, unlimitedData, "usdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, susds), rateLimits_, standardUsdsData, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, susds), rateLimits_, unlimitedData, "susdsWithdrawData", 18); + + RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits_, standardUsdcData, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits_, standardUsdcData, "cctpToEthereumDomainData", 6); + + vm.stopBroadcast(); + + // Step 3: Export all deployed addresses + + ScriptTools.exportContract(base.nameDeps, "freezer", base.config.readAddress(".freezer")); + ScriptTools.exportContract(base.nameDeps, "relayer", base.config.readAddress(".relayer")); + + ScriptTools.exportContract(base.name, "almProxy", instance.almProxy); + ScriptTools.exportContract(base.name, "controller", instance.controller); + ScriptTools.exportContract(base.name, "rateLimits", instance.rateLimits); + } + + function _setBaseMintRecipient() internal { + vm.selectFork(mainnet.forkId); + vm.startBroadcast(); + + MainnetController(mainnetController).setMintRecipient( + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + bytes32(uint256(uint160(baseAlmProxy))) + ); + + vm.stopBroadcast(); + } + + function run() public { + vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); + vm.setEnv("FOUNDRY_EXPORTS_OVERWRITE_LATEST", "true"); + + deployer = msg.sender; + + mainnet = Domain({ + name : "mainnet-staging", + nameDeps : "mainnet-staging-deps", + config : ScriptTools.loadConfig("mainnet-staging"), + forkId : vm.createFork(getChain("mainnet").rpcUrl), + admin : deployer + }); + base = Domain({ + name : "base-staging", + nameDeps : "base-staging-deps", + config : ScriptTools.loadConfig("base-staging"), + forkId : vm.createFork(getChain("base").rpcUrl), + admin : deployer + }); + + // Ballpark sizing of rate limits, tokens in PSMs, etc + // Ballpark sizing of USDS to put in the join contracts, PSMs, etc + USDC_UNIT_SIZE = mainnet.config.readUint(".usdcUnitSize") * 1e6; + USDS_UNIT_SIZE = mainnet.config.readUint(".usdsUnitSize") * 1e18; + + // Run deployment scripts after setting storage variables + + _setUpDependencies(); + _setUpAllocationSystem(); + _setUpALMController(); + _setUpBaseALMController(); + _setBaseMintRecipient(); + + ScriptTools.exportContract(mainnet.nameDeps, "admin", deployer); + ScriptTools.exportContract(base.nameDeps, "admin", deployer); + } + +} From a557c1eacc8f5a94a5a34bf1cc767cd6604993da Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 12:46:21 -0500 Subject: [PATCH 17/33] feat: all tests passing --- script/staging/FullStagingDeploy.s.sol | 107 +-- script/staging/test/StagingDeployment.t.sol | 900 ++++++++++---------- 2 files changed, 504 insertions(+), 503 deletions(-) diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 597045a..9131040 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -33,8 +33,8 @@ import { MainnetControllerDeploy } from "../../deploy/ControllerDeploy.sol"; -import { ForeignControllerInit } from "../../deploy/ForeignControllerInit.sol"; -import { MainnetControllerInit, MintRecipient } from "../../deploy/MainnetControllerInit.sol"; +import { ForeignControllerInit } from "../../deploy/ForeignControllerInit.sol"; +import { MainnetControllerInit } from "../../deploy/MainnetControllerInit.sol"; import { IRateLimits } from "../../src/interfaces/IRateLimits.sol"; @@ -233,20 +233,20 @@ contract FullStagingDeploy is Script { MainnetControllerInit.ConfigAddressParams memory configAddresses = MainnetControllerInit.ConfigAddressParams({ - freezer : freezer, - relayer : relayer, + freezer : mainnet.config.readAddress(".freezer"), + relayer : mainnet.config.readAddress(".relayer"), oldController : address(0) }); MainnetControllerInit.CheckAddressParams memory checkAddresses = MainnetControllerInit.CheckAddressParams({ - admin : Ethereum.SPARK_PROXY, - proxy : address(almProxy), - rateLimits : address(rateLimits), - vault : address(vault), - psm : Ethereum.PSM, - daiUsds : Ethereum.DAI_USDS, - cctp : Ethereum.CCTP_TOKEN_MESSENGER + admin : mainnet.admin, + proxy : controllerInst.almProxy, + rateLimits : controllerInst.rateLimits, + vault : mainnet.config.readAddress(".psm"), + psm : mainnet.config.readAddress(".psm"), + daiUsds : mainnet.config.readAddress(".daiUsds"), + cctp : mainnet.config.readAddress(".cctpTokenMessenger") }); MainnetControllerInit.MintRecipient[] memory mintRecipients = new MainnetControllerInit.MintRecipient[](1); @@ -256,9 +256,7 @@ contract FullStagingDeploy is Script { mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) }); - Init.MintRecipient[] memory mintRecipients = new Init.MintRecipient[](1); - - Init.initAlmSystem( + MainnetControllerInit.initAlmSystem( vault, address(usds), controllerInst, @@ -283,40 +281,42 @@ contract FullStagingDeploy is Script { slope : 0 }); - bytes32 mintKey = MainnetController(controllerInst.controller).LIMIT_USDE_MINT(); - bytes32 burnKey = MainnetController(controllerInst.controller).LIMIT_USDE_BURN(); + MainnetController mainnetController_ = MainnetController(mainnetController); + + bytes32 mintKey = mainnetController_.LIMIT_USDE_MINT(); + bytes32 burnKey = mainnetController_.LIMIT_USDE_BURN(); bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey( - MainnetController(controllerInst.controller).LIMIT_4626_DEPOSIT(), - address(MainnetController(controllerInst.controller).susde()) + mainnetController_.LIMIT_4626_DEPOSIT(), + address(mainnetController_.susde()) ); bytes32 susdsWithdrawKey = RateLimitHelpers.makeAssetKey( - MainnetController(controllerInst.controller).LIMIT_4626_WITHDRAW(), - address(MainnetController(controllerInst.controller).susde()) + mainnetController_.LIMIT_4626_WITHDRAW(), + address(mainnetController_.susde()) ); bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( - mainnetController.LIMIT_USDC_TO_DOMAIN(), + mainnetController_.LIMIT_USDC_TO_DOMAIN(), CCTPForwarder.DOMAIN_ID_CIRCLE_BASE ); bytes32 susdsKey = RateLimitHelpers.makeAssetKey( - mainnetController.LIMIT_4626_DEPOSIT(), + mainnetController_.LIMIT_4626_DEPOSIT(), address(susds) ); IRateLimits rateLimits_ = IRateLimits(controllerInst.rateLimits); - RateLimitHelpers.setRateLimitData(mintKey, rateLimits_, rateLimitData6, "usdeMintData", 6); - RateLimitHelpers.setRateLimitData(burnKey, rateLimits_, rateLimitData18, "usdeBurnData", 18); - RateLimitHelpers.setRateLimitData(susdsDepositKey, rateLimits_, rateLimitData18, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(susdsWithdrawKey, rateLimits_, rateLimitData18, "susdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimits_, rateLimitData18, "usdsMintData", 18); - RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimits_, rateLimitData6 , "usdsToUsdcData", 6); - RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimits_, rateLimitData6, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits_, rateLimitData6, "cctpToBaseDomainData", 6); - RateLimitHelpers.setRateLimitData(susdsKey, rateLimits_, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(mintKey, rateLimits_, rateLimitData6, "usdeMintData", 6); + RateLimitHelpers.setRateLimitData(burnKey, rateLimits_, rateLimitData18, "usdeBurnData", 18); + RateLimitHelpers.setRateLimitData(susdsDepositKey, rateLimits_, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(susdsWithdrawKey, rateLimits_, rateLimitData18, "susdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), rateLimits_, rateLimitData18, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), rateLimits_, rateLimitData6, "usdsToUsdcData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), rateLimits_, rateLimitData6, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits_, rateLimitData6, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(susdsKey, rateLimits_, rateLimitData18, "susdsDepositData", 18); // Step 3: Transfer ownership of mock usdsJoin to the vault (able to mint usds) @@ -326,12 +326,12 @@ contract FullStagingDeploy is Script { // Step 4: Export all deployed addresses - ScriptTools.exportContract(mainnet.nameDeps, "freezer", mainnet.config.readAddress(".freezer")); - ScriptTools.exportContract(mainnet.nameDeps, "relayer", mainnet.config.readAddress(".relayer")); + ScriptTools.exportContract(mainnet.nameDeps, "freezer", mainnet.config.readAddress(".freezer")); + ScriptTools.exportContract(mainnet.nameDeps, "relayer", mainnet.config.readAddress(".relayer")); - ScriptTools.exportContract(mainnet.name, "almProxy", instance.almProxy); - ScriptTools.exportContract(mainnet.name, "controller", instance.controller); - ScriptTools.exportContract(mainnet.name, "rateLimits", instance.rateLimits); + ScriptTools.exportContract(mainnet.name, "almProxy", controllerInst.almProxy); + ScriptTools.exportContract(mainnet.name, "controller", controllerInst.controller); + ScriptTools.exportContract(mainnet.name, "rateLimits", controllerInst.rateLimits); } function _setUpBaseALMController() public { @@ -340,15 +340,15 @@ contract FullStagingDeploy is Script { // Step 1: Deploy ALM controller - ControllerInstance memory instance = ForeignControllerDeploy.deployFull({ + ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull({ admin : base.admin, psm : base.config.readAddress(".psm"), usdc : base.config.readAddress(".usdc"), cctp : base.config.readAddress(".cctpTokenMessenger") }); - baseAlmProxy = instance.almProxy; - baseController = instance.controller; + baseAlmProxy = controllerInst.almProxy; + baseController = controllerInst.controller; // Step 2: Initialize ALM system @@ -359,7 +359,7 @@ contract FullStagingDeploy is Script { }); ForeignControllerInit.CheckAddressParams memory checkAddresses = ForeignControllerInit.CheckAddressParams({ - admin : ase.admin, + admin : base.admin, psm : base.config.readAddress(".psm"), cctp : base.config.readAddress(".cctpTokenMessenger"), usdc : base.config.readAddress(".usdc"), @@ -396,6 +396,9 @@ contract FullStagingDeploy is Script { slope : 0 }); + ForeignController foreignController = ForeignController(baseController); + IRateLimits rateLimits_ = IRateLimits(controllerInst.rateLimits); + bytes32 depositKey = foreignController.LIMIT_PSM_DEPOSIT(); bytes32 withdrawKey = foreignController.LIMIT_PSM_WITHDRAW(); @@ -408,17 +411,15 @@ contract FullStagingDeploy is Script { address usds = base.config.readAddress(".usds"); address susds = base.config.readAddress(".susds"); - IRateLimits rateLimits_ = IRateLimits(controllerInst.rateLimits); - - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usdc), rateLimits_, standardUsdcData, "usdcDepositData", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usdc), rateLimits_, standardUsdcData, "usdcWithdrawData", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usds), rateLimits_, standardUsdsData, "usdsDepositData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usds), rateLimits_, unlimitedData, "usdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, susds), rateLimits_, standardUsdsData, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, susds), rateLimits_, unlimitedData, "susdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usdc), rateLimits_, rateLimitData6, "usdcDepositData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usdc), rateLimits_, rateLimitData6, "usdcWithdrawData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usds), rateLimits_, rateLimitData18, "usdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usds), rateLimits_, unlimitedRateLimit, "usdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, susds), rateLimits_, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, susds), rateLimits_, unlimitedRateLimit, "susdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits_, standardUsdcData, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits_, standardUsdcData, "cctpToEthereumDomainData", 6); + RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits_, rateLimitData6, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits_, rateLimitData6, "cctpToEthereumDomainData", 6); vm.stopBroadcast(); @@ -427,9 +428,9 @@ contract FullStagingDeploy is Script { ScriptTools.exportContract(base.nameDeps, "freezer", base.config.readAddress(".freezer")); ScriptTools.exportContract(base.nameDeps, "relayer", base.config.readAddress(".relayer")); - ScriptTools.exportContract(base.name, "almProxy", instance.almProxy); - ScriptTools.exportContract(base.name, "controller", instance.controller); - ScriptTools.exportContract(base.name, "rateLimits", instance.rateLimits); + ScriptTools.exportContract(base.name, "almProxy", controllerInst.almProxy); + ScriptTools.exportContract(base.name, "controller", controllerInst.controller); + ScriptTools.exportContract(base.name, "rateLimits", controllerInst.rateLimits); } function _setBaseMintRecipient() internal { diff --git a/script/staging/test/StagingDeployment.t.sol b/script/staging/test/StagingDeployment.t.sol index ef7a3be..a9a283f 100644 --- a/script/staging/test/StagingDeployment.t.sol +++ b/script/staging/test/StagingDeployment.t.sol @@ -1,605 +1,605 @@ -// // SPDX-License-Identifier: MIT -// pragma solidity ^0.8.0; +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; -// import { ScriptTools } from "dss-test/ScriptTools.sol"; +import { ScriptTools } from "dss-test/ScriptTools.sol"; -// import "forge-std/Test.sol"; +import "forge-std/Test.sol"; -// import { IERC20 } from "forge-std/interfaces/IERC20.sol"; -// import { IERC4626 } from "forge-std/interfaces/IERC4626.sol"; +import { IERC20 } from "forge-std/interfaces/IERC20.sol"; +import { IERC4626 } from "forge-std/interfaces/IERC4626.sol"; -// import { IMetaMorpho, Id } from "metamorpho/interfaces/IMetaMorpho.sol"; +import { IMetaMorpho, Id } from "metamorpho/interfaces/IMetaMorpho.sol"; -// import { MarketParamsLib } from "morpho-blue/src/libraries/MarketParamsLib.sol"; -// import { IMorpho, MarketParams } from "morpho-blue/src/interfaces/IMorpho.sol"; +import { MarketParamsLib } from "morpho-blue/src/libraries/MarketParamsLib.sol"; +import { IMorpho, MarketParams } from "morpho-blue/src/interfaces/IMorpho.sol"; -// import { Usds } from "usds/src/Usds.sol"; +import { Usds } from "usds/src/Usds.sol"; -// import { SUsds } from "sdai/src/SUsds.sol"; +import { SUsds } from "sdai/src/SUsds.sol"; -// import { Base } from "spark-address-registry/src/Base.sol"; -// import { Ethereum } from "spark-address-registry/src/Ethereum.sol"; +import { Base } from "spark-address-registry/src/Base.sol"; +import { Ethereum } from "spark-address-registry/src/Ethereum.sol"; -// import { PSM3 } from "spark-psm/src/PSM3.sol"; +import { PSM3 } from "spark-psm/src/PSM3.sol"; -// import { Bridge } from "xchain-helpers/src/testing/Bridge.sol"; -// import { Domain, DomainHelpers } from "xchain-helpers/src/testing/Domain.sol"; -// import { CCTPBridgeTesting } from "xchain-helpers/src/testing/bridges/CCTPBridgeTesting.sol"; -// import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; +import { Bridge } from "xchain-helpers/src/testing/Bridge.sol"; +import { Domain, DomainHelpers } from "xchain-helpers/src/testing/Domain.sol"; +import { CCTPBridgeTesting } from "xchain-helpers/src/testing/bridges/CCTPBridgeTesting.sol"; +import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; -// import { MainnetControllerDeploy } from "../../../deploy/ControllerDeploy.sol"; -// import { MainnetControllerInit } from "../../../deploy/ControllerInit.sol"; +import { MainnetControllerDeploy } from "../../../deploy/ControllerDeploy.sol"; +import { MainnetControllerInit } from "../../../deploy/MainnetControllerInit.sol"; -// import { IRateLimits } from "../../../src/interfaces/IRateLimits.sol"; +import { IRateLimits } from "../../../src/interfaces/IRateLimits.sol"; -// import { ALMProxy } from "../../../src/ALMProxy.sol"; -// import { ForeignController } from "../../../src/ForeignController.sol"; -// import { MainnetController } from "../../../src/MainnetController.sol"; -// import { RateLimits } from "../../../src/RateLimits.sol"; -// import { RateLimitHelpers } from "../../../src/RateLimitHelpers.sol"; +import { ALMProxy } from "../../../src/ALMProxy.sol"; +import { ForeignController } from "../../../src/ForeignController.sol"; +import { MainnetController } from "../../../src/MainnetController.sol"; +import { RateLimits } from "../../../src/RateLimits.sol"; +import { RateLimitHelpers } from "../../../src/RateLimitHelpers.sol"; -// interface IVatLike { -// function can(address, address) external view returns (uint256); -// } +interface IVatLike { + function can(address, address) external view returns (uint256); +} -// contract StagingDeploymentTestBase is Test { +contract StagingDeploymentTestBase is Test { -// using stdJson for *; -// using DomainHelpers for *; -// using CCTPBridgeTesting for *; -// using ScriptTools for *; + using stdJson for *; + using DomainHelpers for *; + using CCTPBridgeTesting for *; + using ScriptTools for *; -// // AAVE aTokens for testing -// address constant AUSDS = 0x32a6268f9Ba3642Dda7892aDd74f1D34469A4259; -// address constant AUSDC = 0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c; + // AAVE aTokens for testing + address constant AUSDS = 0x32a6268f9Ba3642Dda7892aDd74f1D34469A4259; + address constant AUSDC = 0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c; -// bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; + bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; -// uint256 constant RELEASE_DATE = 20241210; + uint256 constant RELEASE_DATE = 20241210; -// // Common variables -// address admin; + // Common variables + address admin; -// // Configuration data -// string inputBase; -// string inputMainnet; -// string outputBase; -// string outputBaseDeps; -// string outputMainnet; -// string outputMainnetDeps; + // Configuration data + string inputBase; + string inputMainnet; + string outputBase; + string outputBaseDeps; + string outputMainnet; + string outputMainnetDeps; -// // Bridging -// Domain mainnet; -// Domain base; -// Bridge cctpBridge; + // Bridging + Domain mainnet; + Domain base; + Bridge cctpBridge; -// // Mainnet contracts + // Mainnet contracts -// Usds usds; -// SUsds susds; -// IERC20 usdc; -// IERC20 dai; + Usds usds; + SUsds susds; + IERC20 usdc; + IERC20 dai; -// address vault; -// address relayerSafe; -// address usdsJoin; + address vault; + address relayerSafe; + address usdsJoin; -// ALMProxy almProxy; -// MainnetController mainnetController; -// RateLimits rateLimits; + ALMProxy almProxy; + MainnetController mainnetController; + RateLimits rateLimits; -// // Base contracts + // Base contracts -// address relayerSafeBase; + address relayerSafeBase; -// PSM3 psmBase; + PSM3 psmBase; -// IERC20 usdsBase; -// IERC20 susdsBase; -// IERC20 usdcBase; + IERC20 usdsBase; + IERC20 susdsBase; + IERC20 usdcBase; -// ALMProxy baseAlmProxy; -// ForeignController baseController; -// RateLimits baseRateLimits; + ALMProxy baseAlmProxy; + ForeignController baseController; + RateLimits baseRateLimits; -// /**********************************************************************************************/ -// /**** Setup ***/ -// /**********************************************************************************************/ + /**********************************************************************************************/ + /**** Setup ***/ + /**********************************************************************************************/ -// function setUp() public virtual { -// vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); + function setUp() public virtual { + vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); -// // Domains and bridge -// mainnet = getChain("mainnet").createSelectFork(); -// base = getChain("base").createFork(); -// cctpBridge = CCTPBridgeTesting.createCircleBridge(mainnet, base); + // Domains and bridge + mainnet = getChain("mainnet").createSelectFork(); + base = getChain("base").createFork(); + cctpBridge = CCTPBridgeTesting.createCircleBridge(mainnet, base); -// // JSON data -// inputBase = ScriptTools.readInput("base-staging"); -// inputMainnet = ScriptTools.readInput("mainnet-staging"); + // JSON data + inputBase = ScriptTools.readInput("base-staging"); + inputMainnet = ScriptTools.readInput("mainnet-staging"); -// outputBase = ScriptTools.readOutput("base-staging-release", RELEASE_DATE); -// outputBaseDeps = ScriptTools.readOutput("base-staging-deps-release", RELEASE_DATE); -// outputMainnet = ScriptTools.readOutput("mainnet-staging-release", RELEASE_DATE); -// outputMainnetDeps = ScriptTools.readOutput("mainnet-staging-deps-release", RELEASE_DATE); + outputBase = ScriptTools.readOutput("base-staging-release", RELEASE_DATE); + outputBaseDeps = ScriptTools.readOutput("base-staging-deps-release", RELEASE_DATE); + outputMainnet = ScriptTools.readOutput("mainnet-staging-release", RELEASE_DATE); + outputMainnetDeps = ScriptTools.readOutput("mainnet-staging-deps-release", RELEASE_DATE); -// // Roles -// admin = outputMainnetDeps.readAddress(".admin"); -// relayerSafe = outputMainnetDeps.readAddress(".relayer"); + // Roles + admin = outputMainnetDeps.readAddress(".admin"); + relayerSafe = outputMainnetDeps.readAddress(".relayer"); -// // Tokens -// usds = Usds(outputMainnetDeps.readAddress(".usds")); -// susds = SUsds(outputMainnetDeps.readAddress(".susds")); -// usdc = IERC20(outputMainnetDeps.readAddress(".usdc")); -// dai = IERC20(outputMainnetDeps.readAddress(".dai")); - -// // Dependencies -// vault = outputMainnetDeps.readAddress(".allocatorVault"); -// usdsJoin = outputMainnetDeps.readAddress(".usdsJoin"); + // Tokens + usds = Usds(outputMainnetDeps.readAddress(".usds")); + susds = SUsds(outputMainnetDeps.readAddress(".susds")); + usdc = IERC20(outputMainnetDeps.readAddress(".usdc")); + dai = IERC20(outputMainnetDeps.readAddress(".dai")); + + // Dependencies + vault = outputMainnetDeps.readAddress(".allocatorVault"); + usdsJoin = outputMainnetDeps.readAddress(".usdsJoin"); -// // ALM system -// almProxy = ALMProxy(payable(outputMainnet.readAddress(".almProxy"))); -// rateLimits = RateLimits(outputMainnet.readAddress(".rateLimits")); -// mainnetController = _reconfigureMainnetController(); + // ALM system + almProxy = ALMProxy(payable(outputMainnet.readAddress(".almProxy"))); + rateLimits = RateLimits(outputMainnet.readAddress(".rateLimits")); + mainnetController = _reconfigureMainnetController(); -// // Base roles -// relayerSafeBase = outputBaseDeps.readAddress(".relayer"); - -// // Base tokens -// usdsBase = IERC20(inputBase.readAddress(".usds")); -// susdsBase = IERC20(inputBase.readAddress(".susds")); -// usdcBase = IERC20(inputBase.readAddress(".usdc")); - -// // Base ALM system -// baseAlmProxy = ALMProxy(payable(outputBase.readAddress(".almProxy"))); -// baseController = ForeignController(outputBase.readAddress(".controller")); -// baseRateLimits = RateLimits(outputBase.readAddress(".rateLimits")); + // Base roles + relayerSafeBase = outputBaseDeps.readAddress(".relayer"); + + // Base tokens + usdsBase = IERC20(inputBase.readAddress(".usds")); + susdsBase = IERC20(inputBase.readAddress(".susds")); + usdcBase = IERC20(inputBase.readAddress(".usdc")); + + // Base ALM system + baseAlmProxy = ALMProxy(payable(outputBase.readAddress(".almProxy"))); + baseController = ForeignController(outputBase.readAddress(".controller")); + baseRateLimits = RateLimits(outputBase.readAddress(".rateLimits")); -// // Base PSM -// psmBase = PSM3(inputBase.readAddress(".psm")); - -// mainnet.selectFork(); - -// deal(address(usds), address(usdsJoin), 1000e18); // Ensure there is enough balance -// } - -// // TODO: Remove this once a deployment has been done on mainnet -// function _reconfigureMainnetController() internal returns (MainnetController newController) { -// newController = MainnetController(MainnetControllerDeploy.deployController({ -// admin : admin, -// almProxy : address(almProxy), -// rateLimits : address(rateLimits), -// vault : address(vault), -// psm : inputMainnet.readAddress(".psm"), -// daiUsds : inputMainnet.readAddress(".daiUsds"), -// cctp : inputMainnet.readAddress(".cctpTokenMessenger") -// })); + // Base PSM + psmBase = PSM3(inputBase.readAddress(".psm")); + + mainnet.selectFork(); + + deal(address(usds), address(usdsJoin), 1000e18); // Ensure there is enough balance + } + + // TODO: Remove this once a deployment has been done on mainnet + function _reconfigureMainnetController() internal returns (MainnetController newController) { + newController = MainnetController(MainnetControllerDeploy.deployController({ + admin : admin, + almProxy : address(almProxy), + rateLimits : address(rateLimits), + vault : address(vault), + psm : inputMainnet.readAddress(".psm"), + daiUsds : inputMainnet.readAddress(".daiUsds"), + cctp : inputMainnet.readAddress(".cctpTokenMessenger") + })); -// vm.startPrank(admin); - -// newController.grantRole(newController.FREEZER(), inputMainnet.readAddress(".freezer")); -// newController.grantRole(newController.RELAYER(), inputMainnet.readAddress(".relayer")); + vm.startPrank(admin); + + newController.grantRole(newController.FREEZER(), inputMainnet.readAddress(".freezer")); + newController.grantRole(newController.RELAYER(), inputMainnet.readAddress(".relayer")); -// almProxy.grantRole(almProxy.CONTROLLER(), address(newController)); -// rateLimits.grantRole(rateLimits.CONTROLLER(), address(newController)); + almProxy.grantRole(almProxy.CONTROLLER(), address(newController)); + rateLimits.grantRole(rateLimits.CONTROLLER(), address(newController)); -// almProxy.revokeRole(almProxy.CONTROLLER(), outputMainnet.readAddress(".controller")); -// rateLimits.revokeRole(rateLimits.CONTROLLER(), outputMainnet.readAddress(".controller")); - -// newController.setMintRecipient( -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, -// bytes32(uint256(uint160(address(outputBase.readAddress(".almProxy"))))) -// ); - -// // Set all rate limits - -// bytes32[] memory rateLimitKeys = new bytes32[](10); - -// rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDS); -// rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDC); -// rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDS); -// rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDE); -// rateLimitKeys[4] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDS); -// rateLimitKeys[5] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDC); -// rateLimitKeys[6] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_WITHDRAW(), Ethereum.SUSDS); -// rateLimitKeys[7] = newController.LIMIT_USDE_MINT(); -// rateLimitKeys[8] = newController.LIMIT_USDE_BURN(); -// rateLimitKeys[9] = newController.LIMIT_SUSDE_COOLDOWN(); + almProxy.revokeRole(almProxy.CONTROLLER(), outputMainnet.readAddress(".controller")); + rateLimits.revokeRole(rateLimits.CONTROLLER(), outputMainnet.readAddress(".controller")); + + newController.setMintRecipient( + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + bytes32(uint256(uint160(address(outputBase.readAddress(".almProxy"))))) + ); + + // Set all rate limits + + bytes32[] memory rateLimitKeys = new bytes32[](10); + + rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDS); + rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDC); + rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDS); + rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDE); + rateLimitKeys[4] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDS); + rateLimitKeys[5] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDC); + rateLimitKeys[6] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_WITHDRAW(), Ethereum.SUSDS); + rateLimitKeys[7] = newController.LIMIT_USDE_MINT(); + rateLimitKeys[8] = newController.LIMIT_USDE_BURN(); + rateLimitKeys[9] = newController.LIMIT_SUSDE_COOLDOWN(); -// for (uint256 i; i < rateLimitKeys.length; i++) { -// rateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); -// } + for (uint256 i; i < rateLimitKeys.length; i++) { + rateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); + } -// vm.stopPrank(); -// } -// } + vm.stopPrank(); + } +} -// contract MainnetStagingDeploymentTests is StagingDeploymentTestBase { +contract MainnetStagingDeploymentTests is StagingDeploymentTestBase { -// function test_mintUSDS() public { -// uint256 startingBalance = usds.balanceOf(address(almProxy)); + function test_mintUSDS() public { + uint256 startingBalance = usds.balanceOf(address(almProxy)); -// vm.prank(relayerSafe); -// mainnetController.mintUSDS(10e18); + vm.prank(relayerSafe); + mainnetController.mintUSDS(10e18); -// assertEq(usds.balanceOf(address(almProxy)), startingBalance + 10e18); -// } + assertEq(usds.balanceOf(address(almProxy)), startingBalance + 10e18); + } -// function test_mintAndSwapToUSDC() public { -// uint256 startingBalance = usdc.balanceOf(address(almProxy)); + function test_mintAndSwapToUSDC() public { + uint256 startingBalance = usdc.balanceOf(address(almProxy)); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + vm.stopPrank(); -// assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); -// } + assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); + } -// function test_depositAndWithdrawUsdsFromSUsds() public { -// uint256 startingBalance = usds.balanceOf(address(almProxy)); + function test_depositAndWithdrawUsdsFromSUsds() public { + uint256 startingBalance = usds.balanceOf(address(almProxy)); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.depositERC4626(Ethereum.SUSDS, 10e18); -// skip(1 days); -// mainnetController.withdrawERC4626(Ethereum.SUSDS, 10e18); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.depositERC4626(Ethereum.SUSDS, 10e18); + skip(1 days); + mainnetController.withdrawERC4626(Ethereum.SUSDS, 10e18); + vm.stopPrank(); -// assertEq(usds.balanceOf(address(almProxy)), startingBalance + 10e18); + assertEq(usds.balanceOf(address(almProxy)), startingBalance + 10e18); -// assertGe(IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy)), 0); // Interest earned -// } + assertGe(IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy)), 0); // Interest earned + } -// function test_depositAndRedeemUsdsFromSUsds() public { -// uint256 startingBalance = usds.balanceOf(address(almProxy)); + function test_depositAndRedeemUsdsFromSUsds() public { + uint256 startingBalance = usds.balanceOf(address(almProxy)); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.depositERC4626(Ethereum.SUSDS, 10e18); -// skip(1 days); -// mainnetController.redeemERC4626(Ethereum.SUSDS, IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy))); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.depositERC4626(Ethereum.SUSDS, 10e18); + skip(1 days); + mainnetController.redeemERC4626(Ethereum.SUSDS, IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy))); + vm.stopPrank(); -// assertGe(usds.balanceOf(address(almProxy)), startingBalance + 10e18); // Interest earned + assertGe(usds.balanceOf(address(almProxy)), startingBalance + 10e18); // Interest earned -// assertEq(IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy)), 0); -// } + assertEq(IERC4626(Ethereum.SUSDS).balanceOf(address(almProxy)), 0); + } -// function test_depositAndWithdrawUsdsFromAave() public { -// uint256 startingBalance = usds.balanceOf(address(almProxy)); + function test_depositAndWithdrawUsdsFromAave() public { + uint256 startingBalance = usds.balanceOf(address(almProxy)); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.depositAave(AUSDS, 10e6); -// skip(1 days); -// mainnetController.withdrawAave(AUSDS, type(uint256).max); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.depositAave(AUSDS, 10e6); + skip(1 days); + mainnetController.withdrawAave(AUSDS, type(uint256).max); + vm.stopPrank(); -// assertGe(usds.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned -// } + assertGe(usds.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned + } -// function test_depositAndWithdrawUsdcFromAave() public { -// uint256 startingBalance = usdc.balanceOf(address(almProxy)); + function test_depositAndWithdrawUsdcFromAave() public { + uint256 startingBalance = usdc.balanceOf(address(almProxy)); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.depositAave(AUSDC, 10e6); -// skip(1 days); -// mainnetController.withdrawAave(AUSDC, type(uint256).max); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.depositAave(AUSDC, 10e6); + skip(1 days); + mainnetController.withdrawAave(AUSDC, type(uint256).max); + vm.stopPrank(); -// assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned -// } + assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned + } -// function test_mintDepositCooldownAssetsBurnUsde() public { -// uint256 startingBalance = usdc.balanceOf(address(almProxy)); + function test_mintDepositCooldownAssetsBurnUsde() public { + uint256 startingBalance = usdc.balanceOf(address(almProxy)); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.prepareUSDeMint(10e6); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.prepareUSDeMint(10e6); + vm.stopPrank(); -// _simulateUsdeMint(10e6); + _simulateUsdeMint(10e6); -// vm.startPrank(relayerSafe); -// mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); -// skip(1 days); -// mainnetController.cooldownAssetsSUSDe(10e18); -// skip(7 days); -// mainnetController.unstakeSUSDe(); -// mainnetController.prepareUSDeBurn(10e18); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); + skip(1 days); + mainnetController.cooldownAssetsSUSDe(10e18); + skip(7 days); + mainnetController.unstakeSUSDe(); + mainnetController.prepareUSDeBurn(10e18); + vm.stopPrank(); -// _simulateUsdeBurn(10e18); + _simulateUsdeBurn(10e18); -// assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); + assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); -// assertGe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); // Interest earned -// } + assertGe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); // Interest earned + } -// function test_mintDepositCooldownSharesBurnUsde() public { -// uint256 startingBalance = usdc.balanceOf(address(almProxy)); + function test_mintDepositCooldownSharesBurnUsde() public { + uint256 startingBalance = usdc.balanceOf(address(almProxy)); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.prepareUSDeMint(10e6); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.prepareUSDeMint(10e6); + vm.stopPrank(); -// _simulateUsdeMint(10e6); + _simulateUsdeMint(10e6); -// vm.startPrank(relayerSafe); -// mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); -// skip(1 days); -// uint256 usdeAmount = mainnetController.cooldownSharesSUSDe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy))); -// skip(7 days); -// mainnetController.unstakeSUSDe(); -// mainnetController.prepareUSDeBurn(usdeAmount); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); + skip(1 days); + uint256 usdeAmount = mainnetController.cooldownSharesSUSDe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy))); + skip(7 days); + mainnetController.unstakeSUSDe(); + mainnetController.prepareUSDeBurn(usdeAmount); + vm.stopPrank(); -// _simulateUsdeBurn(usdeAmount); + _simulateUsdeBurn(usdeAmount); -// assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned + assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned -// assertEq(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); -// } + assertEq(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); + } -// /**********************************************************************************************/ -// /**** Helper functions ***/ -// /**********************************************************************************************/ + /**********************************************************************************************/ + /**** Helper functions ***/ + /**********************************************************************************************/ -// // NOTE: In reality these actions are performed by the signer submitting an order with an -// // EIP712 signature which is verified by the ethenaMinter contract, -// // minting/burning USDe into the ALMProxy. Also, for the purposes of this test, -// // minting/burning is done 1:1 with USDC. + // NOTE: In reality these actions are performed by the signer submitting an order with an + // EIP712 signature which is verified by the ethenaMinter contract, + // minting/burning USDe into the ALMProxy. Also, for the purposes of this test, + // minting/burning is done 1:1 with USDC. -// // TODO: Try doing ethena minting with EIP-712 signatures (vm.sign) + // TODO: Try doing ethena minting with EIP-712 signatures (vm.sign) -// function _simulateUsdeMint(uint256 amount) internal { -// vm.prank(Ethereum.ETHENA_MINTER); -// usdc.transferFrom(address(almProxy), Ethereum.ETHENA_MINTER, amount); -// deal( -// Ethereum.USDE, -// address(almProxy), -// IERC20(Ethereum.USDE).balanceOf(address(almProxy)) + amount * 1e12 -// ); -// } + function _simulateUsdeMint(uint256 amount) internal { + vm.prank(Ethereum.ETHENA_MINTER); + usdc.transferFrom(address(almProxy), Ethereum.ETHENA_MINTER, amount); + deal( + Ethereum.USDE, + address(almProxy), + IERC20(Ethereum.USDE).balanceOf(address(almProxy)) + amount * 1e12 + ); + } -// function _simulateUsdeBurn(uint256 amount) internal { -// vm.prank(Ethereum.ETHENA_MINTER); -// IERC20(Ethereum.USDE).transferFrom(address(almProxy), Ethereum.ETHENA_MINTER, amount); -// deal(address(usdc), address(almProxy), usdc.balanceOf(address(almProxy)) + amount / 1e12); -// } + function _simulateUsdeBurn(uint256 amount) internal { + vm.prank(Ethereum.ETHENA_MINTER); + IERC20(Ethereum.USDE).transferFrom(address(almProxy), Ethereum.ETHENA_MINTER, amount); + deal(address(usdc), address(almProxy), usdc.balanceOf(address(almProxy)) + amount / 1e12); + } -// } +} -// contract BaseStagingDeploymentTests is StagingDeploymentTestBase { +contract BaseStagingDeploymentTests is StagingDeploymentTestBase { -// using DomainHelpers for *; -// using CCTPBridgeTesting for *; + using DomainHelpers for *; + using CCTPBridgeTesting for *; -// address constant AUSDC_BASE = 0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB; -// address constant MORPHO = 0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb; -// address constant MORPHO_VAULT_USDC = 0x305E03Ed9ADaAB22F4A58c24515D79f2B1E2FD5D; + address constant AUSDC_BASE = 0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB; + address constant MORPHO = 0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb; + address constant MORPHO_VAULT_USDC = 0x305E03Ed9ADaAB22F4A58c24515D79f2B1E2FD5D; -// function setUp() public override { -// super.setUp(); + function setUp() public override { + super.setUp(); -// base.selectFork(); + base.selectFork(); -// bytes32[] memory rateLimitKeys = new bytes32[](4); + bytes32[] memory rateLimitKeys = new bytes32[](4); -// rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_DEPOSIT(), AUSDC_BASE); -// rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_DEPOSIT(), MORPHO_VAULT_USDC); -// rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_WITHDRAW(), AUSDC_BASE); -// rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_WITHDRAW(), MORPHO_VAULT_USDC); + rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_DEPOSIT(), AUSDC_BASE); + rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_DEPOSIT(), MORPHO_VAULT_USDC); + rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_WITHDRAW(), AUSDC_BASE); + rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_WITHDRAW(), MORPHO_VAULT_USDC); -// vm.startPrank(admin); + vm.startPrank(admin); -// for (uint256 i; i < rateLimitKeys.length; i++) { -// baseRateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); -// } + for (uint256 i; i < rateLimitKeys.length; i++) { + baseRateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); + } -// vm.stopPrank(); -// } + vm.stopPrank(); + } -// function test_transferCCTP() public { -// base.selectFork(); + function test_transferCCTP() public { + base.selectFork(); -// uint256 startingBalance = usdcBase.balanceOf(address(baseAlmProxy)); + uint256 startingBalance = usdcBase.balanceOf(address(baseAlmProxy)); -// mainnet.selectFork(); + mainnet.selectFork(); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + vm.stopPrank(); -// cctpBridge.relayMessagesToDestination(true); + cctpBridge.relayMessagesToDestination(true); -// assertEq(usdcBase.balanceOf(address(baseAlmProxy)), startingBalance + 10e6); -// } + assertEq(usdcBase.balanceOf(address(baseAlmProxy)), startingBalance + 10e6); + } -// function test_transferToPSM() public { -// base.selectFork(); + function test_transferToPSM() public { + base.selectFork(); -// uint256 startingBalance = usdcBase.balanceOf(address(psmBase)); + uint256 startingBalance = usdcBase.balanceOf(address(psmBase)); -// mainnet.selectFork(); + mainnet.selectFork(); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + vm.stopPrank(); -// cctpBridge.relayMessagesToDestination(true); + cctpBridge.relayMessagesToDestination(true); -// uint256 startingShares = psmBase.shares(address(baseAlmProxy)); + uint256 startingShares = psmBase.shares(address(baseAlmProxy)); -// vm.startPrank(relayerSafeBase); -// baseController.depositPSM(address(usdcBase), 10e6); -// vm.stopPrank(); + vm.startPrank(relayerSafeBase); + baseController.depositPSM(address(usdcBase), 10e6); + vm.stopPrank(); -// assertEq(usdcBase.balanceOf(address(psmBase)), startingBalance + 10e6); + assertEq(usdcBase.balanceOf(address(psmBase)), startingBalance + 10e6); -// assertEq(psmBase.shares(address(baseAlmProxy)), startingShares + psmBase.convertToShares(10e18)); -// } + assertEq(psmBase.shares(address(baseAlmProxy)), startingShares + psmBase.convertToShares(10e18)); + } -// function test_addAndRemoveFundsFromBasePSM() public { -// mainnet.selectFork(); + function test_addAndRemoveFundsFromBasePSM() public { + mainnet.selectFork(); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + vm.stopPrank(); -// cctpBridge.relayMessagesToDestination(true); + cctpBridge.relayMessagesToDestination(true); -// vm.startPrank(relayerSafeBase); -// baseController.depositPSM(address(usdcBase), 10e6); -// skip(1 days); -// baseController.withdrawPSM(address(usdcBase), 10e6); -// baseController.transferUSDCToCCTP(10e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding -// vm.stopPrank(); + vm.startPrank(relayerSafeBase); + baseController.depositPSM(address(usdcBase), 10e6); + skip(1 days); + baseController.withdrawPSM(address(usdcBase), 10e6); + baseController.transferUSDCToCCTP(10e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding + vm.stopPrank(); -// cctpBridge.relayMessagesToSource(true); + cctpBridge.relayMessagesToSource(true); -// vm.startPrank(relayerSafe); -// mainnetController.swapUSDCToUSDS(10e6 - 1); -// mainnetController.burnUSDS((10e6 - 1) * 1e12); -// vm.stopPrank(); -// } + vm.startPrank(relayerSafe); + mainnetController.swapUSDCToUSDS(10e6 - 1); + mainnetController.burnUSDS((10e6 - 1) * 1e12); + vm.stopPrank(); + } -// function test_addAndRemoveFundsFromBaseAAVE() public { -// mainnet.selectFork(); + function test_addAndRemoveFundsFromBaseAAVE() public { + mainnet.selectFork(); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + vm.stopPrank(); -// cctpBridge.relayMessagesToDestination(true); + cctpBridge.relayMessagesToDestination(true); -// vm.startPrank(relayerSafeBase); -// baseController.depositAave(AUSDC_BASE, 10e6); -// skip(1 days); -// baseController.withdrawAave(AUSDC_BASE, 10e6); + vm.startPrank(relayerSafeBase); + baseController.depositAave(AUSDC_BASE, 10e6); + skip(1 days); + baseController.withdrawAave(AUSDC_BASE, 10e6); -// assertEq(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); + assertEq(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); -// assertGe(IERC20(AUSDC_BASE).balanceOf(address(baseAlmProxy)), 0); // Interest earned + assertGe(IERC20(AUSDC_BASE).balanceOf(address(baseAlmProxy)), 0); // Interest earned -// baseController.transferUSDCToCCTP(10e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding -// vm.stopPrank(); + baseController.transferUSDCToCCTP(10e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding + vm.stopPrank(); -// cctpBridge.relayMessagesToSource(true); + cctpBridge.relayMessagesToSource(true); -// vm.startPrank(relayerSafe); -// mainnetController.swapUSDCToUSDS(10e6 - 1); -// mainnetController.burnUSDS((10e6 - 1) * 1e12); -// vm.stopPrank(); -// } + vm.startPrank(relayerSafe); + mainnetController.swapUSDCToUSDS(10e6 - 1); + mainnetController.burnUSDS((10e6 - 1) * 1e12); + vm.stopPrank(); + } -// function test_depositWithdrawFundsFromBaseMorphoUsdc() public { -// _setUpMorphoMarket(); + function test_depositWithdrawFundsFromBaseMorphoUsdc() public { + _setUpMorphoMarket(); -// mainnet.selectFork(); + mainnet.selectFork(); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + vm.stopPrank(); -// cctpBridge.relayMessagesToDestination(true); + cctpBridge.relayMessagesToDestination(true); -// vm.startPrank(relayerSafeBase); -// baseController.depositERC4626(MORPHO_VAULT_USDC, 10e6); -// skip(1 days); -// baseController.withdrawERC4626(MORPHO_VAULT_USDC, 10e6); + vm.startPrank(relayerSafeBase); + baseController.depositERC4626(MORPHO_VAULT_USDC, 10e6); + skip(1 days); + baseController.withdrawERC4626(MORPHO_VAULT_USDC, 10e6); -// assertEq(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); + assertEq(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); -// assertGe(IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy)), 0); // Interest earned + assertGe(IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy)), 0); // Interest earned -// baseController.transferUSDCToCCTP(1e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding -// vm.stopPrank(); + baseController.transferUSDCToCCTP(1e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding + vm.stopPrank(); -// cctpBridge.relayMessagesToSource(true); + cctpBridge.relayMessagesToSource(true); -// vm.startPrank(relayerSafe); -// mainnetController.swapUSDCToUSDS(1e6 - 1); -// mainnetController.burnUSDS((1e6 - 1) * 1e12); -// vm.stopPrank(); -// } + vm.startPrank(relayerSafe); + mainnetController.swapUSDCToUSDS(1e6 - 1); + mainnetController.burnUSDS((1e6 - 1) * 1e12); + vm.stopPrank(); + } -// function test_depositRedeemFundsFromBaseMorphoUsdc() public { -// _setUpMorphoMarket(); + function test_depositRedeemFundsFromBaseMorphoUsdc() public { + _setUpMorphoMarket(); -// mainnet.selectFork(); + mainnet.selectFork(); -// vm.startPrank(relayerSafe); -// mainnetController.mintUSDS(10e18); -// mainnetController.swapUSDSToUSDC(10e6); -// mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// vm.stopPrank(); + vm.startPrank(relayerSafe); + mainnetController.mintUSDS(10e18); + mainnetController.swapUSDSToUSDC(10e6); + mainnetController.transferUSDCToCCTP(10e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + vm.stopPrank(); -// cctpBridge.relayMessagesToDestination(true); + cctpBridge.relayMessagesToDestination(true); -// vm.startPrank(relayerSafeBase); -// baseController.depositERC4626(MORPHO_VAULT_USDC, 10e6); -// skip(1 days); -// baseController.redeemERC4626(MORPHO_VAULT_USDC, IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy))); + vm.startPrank(relayerSafeBase); + baseController.depositERC4626(MORPHO_VAULT_USDC, 10e6); + skip(1 days); + baseController.redeemERC4626(MORPHO_VAULT_USDC, IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy))); -// assertGe(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); // Interest earned + assertGe(usdcBase.balanceOf(address(baseAlmProxy)), 10e6); // Interest earned -// assertEq(IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy)), 0); + assertEq(IERC20(MORPHO_VAULT_USDC).balanceOf(address(baseAlmProxy)), 0); -// baseController.transferUSDCToCCTP(1e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding -// vm.stopPrank(); + baseController.transferUSDCToCCTP(1e6 - 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); // Account for potential rounding + vm.stopPrank(); -// cctpBridge.relayMessagesToSource(true); + cctpBridge.relayMessagesToSource(true); -// vm.startPrank(relayerSafe); -// mainnetController.swapUSDCToUSDS(1e6 - 1); -// mainnetController.burnUSDS((1e6 - 1) * 1e12); -// vm.stopPrank(); -// } + vm.startPrank(relayerSafe); + mainnetController.swapUSDCToUSDS(1e6 - 1); + mainnetController.burnUSDS((1e6 - 1) * 1e12); + vm.stopPrank(); + } -// // TODO: Replace this once market is live -// function _setUpMorphoMarket() public { -// vm.startPrank(Base.SPARK_EXECUTOR); + // TODO: Replace this once market is live + function _setUpMorphoMarket() public { + vm.startPrank(Base.SPARK_EXECUTOR); -// // Add in the idle markets so deposits can be made -// MarketParams memory usdcParams = MarketParams({ -// loanToken : Base.USDC, -// collateralToken : address(0), -// oracle : address(0), -// irm : address(0), -// lltv : 0 -// }); + // Add in the idle markets so deposits can be made + MarketParams memory usdcParams = MarketParams({ + loanToken : Base.USDC, + collateralToken : address(0), + oracle : address(0), + irm : address(0), + lltv : 0 + }); -// IMetaMorpho(MORPHO_VAULT_USDC).submitCap( -// usdcParams, -// type(uint184).max -// ); + IMetaMorpho(MORPHO_VAULT_USDC).submitCap( + usdcParams, + type(uint184).max + ); -// skip(1 days); + skip(1 days); -// IMetaMorpho(MORPHO_VAULT_USDC).acceptCap(usdcParams); + IMetaMorpho(MORPHO_VAULT_USDC).acceptCap(usdcParams); -// Id[] memory supplyQueueUSDC = new Id[](1); -// supplyQueueUSDC[0] = MarketParamsLib.id(usdcParams); -// IMetaMorpho(MORPHO_VAULT_USDC).setSupplyQueue(supplyQueueUSDC); + Id[] memory supplyQueueUSDC = new Id[](1); + supplyQueueUSDC[0] = MarketParamsLib.id(usdcParams); + IMetaMorpho(MORPHO_VAULT_USDC).setSupplyQueue(supplyQueueUSDC); -// vm.stopPrank(); -// } + vm.stopPrank(); + } -// } +} From 134097bcbe0d147990fc784cf0bcb5c10f5b9e13 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 12:50:21 -0500 Subject: [PATCH 18/33] fix: newlines --- deploy/ForeignControllerInit.sol | 2 +- deploy/MainnetControllerInit.sol | 2 +- test/mainnet-fork/InitAndUpgrade.t.sol | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/deploy/ForeignControllerInit.sol b/deploy/ForeignControllerInit.sol index ff390b4..bc69fa3 100644 --- a/deploy/ForeignControllerInit.sol +++ b/deploy/ForeignControllerInit.sol @@ -146,4 +146,4 @@ library ForeignControllerInit { } } -} \ No newline at end of file +} diff --git a/deploy/MainnetControllerInit.sol b/deploy/MainnetControllerInit.sol index 5ae2e79..e8e50df 100644 --- a/deploy/MainnetControllerInit.sol +++ b/deploy/MainnetControllerInit.sol @@ -156,4 +156,4 @@ library MainnetControllerInit { } } -} \ No newline at end of file +} diff --git a/test/mainnet-fork/InitAndUpgrade.t.sol b/test/mainnet-fork/InitAndUpgrade.t.sol index 95d7211..a478778 100644 --- a/test/mainnet-fork/InitAndUpgrade.t.sol +++ b/test/mainnet-fork/InitAndUpgrade.t.sol @@ -531,4 +531,4 @@ contract MainnetControllerUpgradeControllerSuccessTests is MainnetControllerInit ); } -} \ No newline at end of file +} From 90e91139efa9e4e64f05ac2a16e4f40b63583986 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 13:11:29 -0500 Subject: [PATCH 19/33] fix: add back cctp tests --- script/staging/FullStagingDeploy.s.sol | 37 +- src/RateLimitHelpers.sol | 4 +- test/base-fork/ForkTestBase.t.sol | 18 +- test/mainnet-fork/CCTPCalls.t.sol | 1042 ++++++++++++------------ test/mainnet-fork/ForkTestBase.t.sol | 10 +- 5 files changed, 557 insertions(+), 554 deletions(-) diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 9131040..1ca49b3 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -306,17 +306,15 @@ contract FullStagingDeploy is Script { address(susds) ); - IRateLimits rateLimits_ = IRateLimits(controllerInst.rateLimits); - - RateLimitHelpers.setRateLimitData(mintKey, rateLimits_, rateLimitData6, "usdeMintData", 6); - RateLimitHelpers.setRateLimitData(burnKey, rateLimits_, rateLimitData18, "usdeBurnData", 18); - RateLimitHelpers.setRateLimitData(susdsDepositKey, rateLimits_, rateLimitData18, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(susdsWithdrawKey, rateLimits_, rateLimitData18, "susdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), rateLimits_, rateLimitData18, "usdsMintData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), rateLimits_, rateLimitData6, "usdsToUsdcData", 6); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), rateLimits_, rateLimitData6, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits_, rateLimitData6, "cctpToBaseDomainData", 6); - RateLimitHelpers.setRateLimitData(susdsKey, rateLimits_, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(mintKey, controllerInst.rateLimits, rateLimitData6, "usdeMintData", 6); + RateLimitHelpers.setRateLimitData(burnKey, controllerInst.rateLimits, rateLimitData18, "usdeBurnData", 18); + RateLimitHelpers.setRateLimitData(susdsDepositKey, controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(susdsWithdrawKey, controllerInst.rateLimits, rateLimitData18, "susdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), controllerInst.rateLimits, rateLimitData18, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), controllerInst.rateLimits, rateLimitData6, "usdsToUsdcData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), controllerInst.rateLimits, rateLimitData6, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, controllerInst.rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(susdsKey, controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); // Step 3: Transfer ownership of mock usdsJoin to the vault (able to mint usds) @@ -397,7 +395,6 @@ contract FullStagingDeploy is Script { }); ForeignController foreignController = ForeignController(baseController); - IRateLimits rateLimits_ = IRateLimits(controllerInst.rateLimits); bytes32 depositKey = foreignController.LIMIT_PSM_DEPOSIT(); bytes32 withdrawKey = foreignController.LIMIT_PSM_WITHDRAW(); @@ -411,15 +408,15 @@ contract FullStagingDeploy is Script { address usds = base.config.readAddress(".usds"); address susds = base.config.readAddress(".susds"); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usdc), rateLimits_, rateLimitData6, "usdcDepositData", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usdc), rateLimits_, rateLimitData6, "usdcWithdrawData", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usds), rateLimits_, rateLimitData18, "usdsDepositData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usds), rateLimits_, unlimitedRateLimit, "usdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, susds), rateLimits_, rateLimitData18, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, susds), rateLimits_, unlimitedRateLimit, "susdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usdc), controllerInst.rateLimits, rateLimitData6, "usdcDepositData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usdc), controllerInst.rateLimits, rateLimitData6, "usdcWithdrawData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usds), controllerInst.rateLimits, rateLimitData18, "usdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usds), controllerInst.rateLimits, unlimitedRateLimit, "usdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, susds), controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, susds), controllerInst.rateLimits, unlimitedRateLimit, "susdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits_, rateLimitData6, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits_, rateLimitData6, "cctpToEthereumDomainData", 6); + RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), controllerInst.rateLimits, rateLimitData6, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, controllerInst.rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); vm.stopBroadcast(); diff --git a/src/RateLimitHelpers.sol b/src/RateLimitHelpers.sol index db55d83..f1ff58d 100644 --- a/src/RateLimitHelpers.sol +++ b/src/RateLimitHelpers.sol @@ -20,7 +20,7 @@ library RateLimitHelpers { function setRateLimitData( bytes32 key, - IRateLimits rateLimits, + address rateLimits, RateLimitData memory data, string memory name, uint256 decimals @@ -44,7 +44,7 @@ library RateLimitHelpers { string(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-", name)) ); } - rateLimits.setRateLimitData(key, data.maxAmount, data.slope); + IRateLimits(rateLimits).setRateLimitData(key, data.maxAmount, data.slope); } } diff --git a/test/base-fork/ForkTestBase.t.sol b/test/base-fork/ForkTestBase.t.sol index ca10170..93a35c7 100644 --- a/test/base-fork/ForkTestBase.t.sol +++ b/test/base-fork/ForkTestBase.t.sol @@ -169,15 +169,15 @@ contract ForkTestBase is Test { CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM ); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(usdcBase)), rateLimits, standardUsdcData, "usdcDepositData", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(usdcBase)), rateLimits, standardUsdcData, "usdcWithdrawData", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(usdsBase)), rateLimits, standardUsdsData, "usdsDepositData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(usdsBase)), rateLimits, unlimitedData, "usdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(susdsBase)), rateLimits, standardUsdsData, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(susdsBase)), rateLimits, unlimitedData, "susdsWithdrawData", 18); - - RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits, standardUsdcData, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, standardUsdcData, "cctpToEthereumDomainData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(usdcBase)), address(rateLimits), standardUsdcData, "usdcDepositData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(usdcBase)), address(rateLimits), standardUsdcData, "usdcWithdrawData", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(usdsBase)), address(rateLimits), standardUsdsData, "usdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(usdsBase)), address(rateLimits), unlimitedData, "usdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(susdsBase)), address(rateLimits), standardUsdsData, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(susdsBase)), address(rateLimits), unlimitedData, "susdsWithdrawData", 18); + + RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), address(rateLimits), standardUsdcData, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, address(rateLimits), standardUsdcData, "cctpToEthereumDomainData", 6); vm.stopPrank(); } diff --git a/test/mainnet-fork/CCTPCalls.t.sol b/test/mainnet-fork/CCTPCalls.t.sol index 557f781..176bed9 100644 --- a/test/mainnet-fork/CCTPCalls.t.sol +++ b/test/mainnet-fork/CCTPCalls.t.sol @@ -1,682 +1,688 @@ -// // SPDX-License-Identifier: AGPL-3.0-or-later -// pragma solidity >=0.8.0; +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity >=0.8.0; -// import { IERC20 } from "forge-std/interfaces/IERC20.sol"; +import { IERC20 } from "forge-std/interfaces/IERC20.sol"; -// import { ERC20Mock } from "openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol"; +import { ERC20Mock } from "openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol"; -// import { Base } from "spark-address-registry/src/Base.sol"; +import { Base } from "spark-address-registry/src/Base.sol"; -// import { PSM3Deploy } from "spark-psm/deploy/PSM3Deploy.sol"; -// import { IPSM3 } from "spark-psm/src/PSM3.sol"; -// import { MockRateProvider } from "spark-psm/test/mocks/MockRateProvider.sol"; +import { PSM3Deploy } from "spark-psm/deploy/PSM3Deploy.sol"; +import { IPSM3 } from "spark-psm/src/PSM3.sol"; +import { MockRateProvider } from "spark-psm/test/mocks/MockRateProvider.sol"; -// import { CCTPBridgeTesting } from "xchain-helpers/src/testing/bridges/CCTPBridgeTesting.sol"; -// import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; +import { CCTPBridgeTesting } from "xchain-helpers/src/testing/bridges/CCTPBridgeTesting.sol"; +import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; -// import { ForeignControllerDeploy } from "../../deploy/ControllerDeploy.sol"; -// import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; +import { ForeignControllerDeploy } from "../../deploy/ControllerDeploy.sol"; +import { ControllerInstance } from "../../deploy/ControllerInstance.sol"; -// import { ForeignControllerInit, -// MintRecipient, -// RateLimitData -// } from "../../deploy/ControllerInit.sol"; +import { ForeignControllerInit } from "../../deploy/ForeignControllerInit.sol"; -// import { ALMProxy } from "../../src/ALMProxy.sol"; -// import { ForeignController } from "../../src/ForeignController.sol"; -// import { RateLimits } from "../../src/RateLimits.sol"; -// import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; +import { ALMProxy } from "../../src/ALMProxy.sol"; +import { ForeignController } from "../../src/ForeignController.sol"; +import { RateLimits } from "../../src/RateLimits.sol"; +import { RateLimitHelpers } from "../../src/RateLimitHelpers.sol"; -// import "./ForkTestBase.t.sol"; +import "./ForkTestBase.t.sol"; -// contract MainnetControllerTransferUSDCToCCTPFailureTests is ForkTestBase { +contract MainnetControllerTransferUSDCToCCTPFailureTests is ForkTestBase { -// function test_transferUSDCToCCTP_notRelayer() external { -// vm.expectRevert(abi.encodeWithSignature( -// "AccessControlUnauthorizedAccount(address,bytes32)", -// address(this), -// RELAYER -// )); -// mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// } + function test_transferUSDCToCCTP_notRelayer() external { + vm.expectRevert(abi.encodeWithSignature( + "AccessControlUnauthorizedAccount(address,bytes32)", + address(this), + RELAYER + )); + mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + } -// function test_transferUSDCToCCTP_frozen() external { -// vm.prank(freezer); -// mainnetController.freeze(); + function test_transferUSDCToCCTP_frozen() external { + vm.prank(freezer); + mainnetController.freeze(); -// vm.prank(relayer); -// vm.expectRevert("MainnetController/not-active"); -// mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// } + vm.prank(relayer); + vm.expectRevert("MainnetController/not-active"); + mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + } -// function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { -// vm.startPrank(SPARK_PROXY); + function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { + vm.startPrank(SPARK_PROXY); -// // Set this so second modifier will be passed in success case -// rateLimits.setUnlimitedRateLimitData( -// RateLimitHelpers.makeDomainKey( -// mainnetController.LIMIT_USDC_TO_DOMAIN(), -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE -// ) -// ); + // Set this so second modifier will be passed in success case + rateLimits.setUnlimitedRateLimitData( + RateLimitHelpers.makeDomainKey( + mainnetController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE + ) + ); -// // Rate limit will be constant 10m (higher than setup) -// rateLimits.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), 10_000_000e6, 0); + // Rate limit will be constant 10m (higher than setup) + rateLimits.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), 10_000_000e6, 0); -// // Set this for success case -// mainnetController.setMintRecipient( -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, -// bytes32(uint256(uint160(makeAddr("mintRecipient")))) -// ); + // Set this for success case + mainnetController.setMintRecipient( + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + bytes32(uint256(uint160(makeAddr("mintRecipient")))) + ); -// vm.stopPrank(); + vm.stopPrank(); -// deal(address(usdc), address(almProxy), 10_000_000e6 + 1); + deal(address(usdc), address(almProxy), 10_000_000e6 + 1); -// vm.startPrank(relayer); -// vm.expectRevert("RateLimits/rate-limit-exceeded"); -// mainnetController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + vm.startPrank(relayer); + vm.expectRevert("RateLimits/rate-limit-exceeded"); + mainnetController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// } + mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + } -// function test_transferUSDCToCCTP_domainRateLimitedBoundary() external { -// vm.startPrank(SPARK_PROXY); + function test_transferUSDCToCCTP_domainRateLimitedBoundary() external { + vm.startPrank(SPARK_PROXY); -// // Set this so first modifier will be passed in success case -// rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP()); + // Set this so first modifier will be passed in success case + rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP()); -// // Rate limit will be constant 10m (higher than setup) -// rateLimits.setRateLimitData( -// RateLimitHelpers.makeDomainKey( -// mainnetController.LIMIT_USDC_TO_DOMAIN(), -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE -// ), -// 10_000_000e6, -// 0 -// ); + // Rate limit will be constant 10m (higher than setup) + rateLimits.setRateLimitData( + RateLimitHelpers.makeDomainKey( + mainnetController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE + ), + 10_000_000e6, + 0 + ); -// // Set this for success case -// mainnetController.setMintRecipient( -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, -// bytes32(uint256(uint160(makeAddr("mintRecipient")))) -// ); + // Set this for success case + mainnetController.setMintRecipient( + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + bytes32(uint256(uint160(makeAddr("mintRecipient")))) + ); -// vm.stopPrank(); + vm.stopPrank(); -// deal(address(usdc), address(almProxy), 10_000_000e6 + 1); + deal(address(usdc), address(almProxy), 10_000_000e6 + 1); -// vm.startPrank(relayer); -// vm.expectRevert("RateLimits/rate-limit-exceeded"); -// mainnetController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + vm.startPrank(relayer); + vm.expectRevert("RateLimits/rate-limit-exceeded"); + mainnetController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// } + mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + } -// function test_transferUSDCToCCTP_invalidMintRecipient() external { -// // Configure to pass modifiers -// vm.startPrank(SPARK_PROXY); + function test_transferUSDCToCCTP_invalidMintRecipient() external { + // Configure to pass modifiers + vm.startPrank(SPARK_PROXY); -// rateLimits.setUnlimitedRateLimitData( -// RateLimitHelpers.makeDomainKey( -// mainnetController.LIMIT_USDC_TO_DOMAIN(), -// CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE -// ) -// ); + rateLimits.setUnlimitedRateLimitData( + RateLimitHelpers.makeDomainKey( + mainnetController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE + ) + ); -// rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP()); + rateLimits.setUnlimitedRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP()); -// vm.stopPrank(); + vm.stopPrank(); -// vm.prank(relayer); -// vm.expectRevert("MainnetController/domain-not-configured"); -// mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); -// } + vm.prank(relayer); + vm.expectRevert("MainnetController/domain-not-configured"); + mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); + } -// } +} -// // TODO: Figure out finalized structure for this repo/testing structure wise -// contract BaseChainUSDCToCCTPTestBase is ForkTestBase { +// TODO: Figure out finalized structure for this repo/testing structure wise +contract BaseChainUSDCToCCTPTestBase is ForkTestBase { -// using DomainHelpers for *; -// using CCTPBridgeTesting for Bridge; + using DomainHelpers for *; + using CCTPBridgeTesting for Bridge; -// /**********************************************************************************************/ -// /*** Constants/state variables ***/ -// /**********************************************************************************************/ + /**********************************************************************************************/ + /*** Constants/state variables ***/ + /**********************************************************************************************/ -// address pocket = makeAddr("pocket"); + address pocket = makeAddr("pocket"); -// /**********************************************************************************************/ -// /*** Base addresses ***/ -// /**********************************************************************************************/ + /**********************************************************************************************/ + /*** Base addresses ***/ + /**********************************************************************************************/ -// address constant CCTP_MESSENGER_BASE = Base.CCTP_TOKEN_MESSENGER; -// address constant SPARK_EXECUTOR = Base.SPARK_EXECUTOR; -// address constant SSR_ORACLE = Base.SSR_AUTH_ORACLE; -// address constant USDC_BASE = Base.USDC; + address constant CCTP_MESSENGER_BASE = Base.CCTP_TOKEN_MESSENGER; + address constant SPARK_EXECUTOR = Base.SPARK_EXECUTOR; + address constant SSR_ORACLE = Base.SSR_AUTH_ORACLE; + address constant USDC_BASE = Base.USDC; -// /**********************************************************************************************/ -// /*** ALM system deployments ***/ -// /**********************************************************************************************/ + /**********************************************************************************************/ + /*** ALM system deployments ***/ + /**********************************************************************************************/ -// ALMProxy foreignAlmProxy; -// RateLimits foreignRateLimits; -// ForeignController foreignController; + ALMProxy foreignAlmProxy; + RateLimits foreignRateLimits; + ForeignController foreignController; -// /**********************************************************************************************/ -// /*** Casted addresses for testing ***/ -// /**********************************************************************************************/ + /**********************************************************************************************/ + /*** Casted addresses for testing ***/ + /**********************************************************************************************/ -// IERC20 usdsBase; -// IERC20 susdsBase; -// IERC20 usdcBase; + IERC20 usdsBase; + IERC20 susdsBase; + IERC20 usdcBase; -// MockRateProvider rateProvider; + MockRateProvider rateProvider; -// IPSM3 psmBase; + IPSM3 psmBase; -// uint256 USDC_BASE_SUPPLY; + uint256 USDC_BASE_SUPPLY; -// function setUp() public override virtual { -// super.setUp(); + function setUp() public override virtual { + super.setUp(); -// /*** Step 1: Set up environment and deploy mocks ***/ + /*** Step 1: Set up environment and deploy mocks ***/ -// destination = getChain("base").createSelectFork(20782500); // October 7, 2024 + destination = getChain("base").createSelectFork(20782500); // October 7, 2024 -// usdsBase = IERC20(address(new ERC20Mock())); -// susdsBase = IERC20(address(new ERC20Mock())); -// usdcBase = IERC20(USDC_BASE); + usdsBase = IERC20(address(new ERC20Mock())); + susdsBase = IERC20(address(new ERC20Mock())); + usdcBase = IERC20(USDC_BASE); -// /*** Step 2: Deploy and configure PSM with a pocket ***/ + /*** Step 2: Deploy and configure PSM with a pocket ***/ -// deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment + deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment -// psmBase = IPSM3(PSM3Deploy.deploy( -// SPARK_EXECUTOR, USDC_BASE, address(usdsBase), address(susdsBase), SSR_ORACLE -// )); + psmBase = IPSM3(PSM3Deploy.deploy( + SPARK_EXECUTOR, USDC_BASE, address(usdsBase), address(susdsBase), SSR_ORACLE + )); -// vm.prank(SPARK_EXECUTOR); -// psmBase.setPocket(pocket); + vm.prank(SPARK_EXECUTOR); + psmBase.setPocket(pocket); -// vm.prank(pocket); -// usdcBase.approve(address(psmBase), type(uint256).max); + vm.prank(pocket); + usdcBase.approve(address(psmBase), type(uint256).max); -// /*** Step 3: Deploy and configure ALM system ***/ + /*** Step 3: Deploy and configure ALM system ***/ -// ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull({ -// admin : SPARK_EXECUTOR, -// psm : address(psmBase), -// usdc : USDC_BASE, -// cctp : CCTP_MESSENGER_BASE -// }); + ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull({ + admin : SPARK_EXECUTOR, + psm : address(psmBase), + usdc : USDC_BASE, + cctp : CCTP_MESSENGER_BASE + }); -// foreignAlmProxy = ALMProxy(payable(controllerInst.almProxy)); -// foreignRateLimits = RateLimits(controllerInst.rateLimits); -// foreignController = ForeignController(controllerInst.controller); + foreignAlmProxy = ALMProxy(payable(controllerInst.almProxy)); + foreignRateLimits = RateLimits(controllerInst.rateLimits); + foreignController = ForeignController(controllerInst.controller); -// ForeignControllerInit.AddressParams memory addresses = ForeignControllerInit.AddressParams({ -// admin : SPARK_EXECUTOR, -// freezer : freezer, -// relayer : relayer, -// oldController : address(0), // Empty -// psm : address(psmBase), -// cctpMessenger : CCTP_MESSENGER_BASE, -// usdc : USDC_BASE, -// usds : address(usdsBase), -// susds : address(susdsBase) -// }); + ForeignControllerInit.ConfigAddressParams memory configAddresses = ForeignControllerInit.ConfigAddressParams({ + freezer : freezer, + relayer : relayer, + oldController : address(0) + }); -// RateLimitData memory standardUsdcRateLimitData = RateLimitData({ -// maxAmount : 5_000_000e6, -// slope : uint256(1_000_000e6) / 4 hours -// }); + ForeignControllerInit.CheckAddressParams memory checkAddresses = ForeignControllerInit.CheckAddressParams({ + admin : Base.SPARK_EXECUTOR, + psm : address(psmBase), + cctp : Base.CCTP_TOKEN_MESSENGER, + usdc : address(usdcBase), + susds : address(susdsBase), + usds : address(usdsBase) + }); -// RateLimitData memory standardUsdsRateLimitData = RateLimitData({ -// maxAmount : 5_000_000e18, -// slope : uint256(1_000_000e18) / 4 hours -// }); + ForeignControllerInit.MintRecipient[] memory mintRecipients = new ForeignControllerInit.MintRecipient[](1); -// RateLimitData memory unlimitedRateLimitData = RateLimitData({ -// maxAmount : type(uint256).max, -// slope : 0 -// }); + mintRecipients[0] = ForeignControllerInit.MintRecipient({ + domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, + mintRecipient : bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) + }); -// ForeignControllerInit.InitRateLimitData memory rateLimitData -// = ForeignControllerInit.InitRateLimitData({ -// usdcDepositData : standardUsdcRateLimitData, -// usdcWithdrawData : standardUsdcRateLimitData, -// usdsDepositData : standardUsdsRateLimitData, -// usdsWithdrawData : unlimitedRateLimitData, -// susdsDepositData : standardUsdsRateLimitData, -// susdsWithdrawData : unlimitedRateLimitData, -// usdcToCctpData : standardUsdcRateLimitData, -// cctpToEthereumDomainData : standardUsdcRateLimitData -// }); + vm.startPrank(SPARK_EXECUTOR); -// MintRecipient[] memory mintRecipients = new MintRecipient[](1); - -// mintRecipients[0] = MintRecipient({ -// domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, -// mintRecipient : bytes32(uint256(uint160(address(almProxy)))) -// }); - -// vm.startPrank(SPARK_EXECUTOR); -// ForeignControllerInit.init(addresses, controllerInst, rateLimitData, mintRecipients); -// vm.stopPrank(); + ForeignControllerInit.initAlmSystem( + controllerInst, + configAddresses, + checkAddresses, + mintRecipients + ); -// USDC_BASE_SUPPLY = usdcBase.totalSupply(); + RateLimitData memory standardUsdcData = RateLimitData({ + maxAmount : 5_000_000e6, + slope : uint256(1_000_000e6) / 4 hours + }); -// source.selectFork(); + RateLimitData memory standardUsdsData = RateLimitData({ + maxAmount : 5_000_000e18, + slope : uint256(1_000_000e18) / 4 hours + }); -// bridge = CCTPBridgeTesting.createCircleBridge(source, destination); + RateLimitData memory unlimitedData = RateLimitData({ + maxAmount : type(uint256).max, + slope : 0 + }); -// vm.prank(SPARK_PROXY); -// mainnetController.setMintRecipient( -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, -// bytes32(uint256(uint160(address(foreignAlmProxy)))) -// ); -// } - -// } - -// contract ForeignControllerTransferUSDCToCCTPFailureTests is BaseChainUSDCToCCTPTestBase { - -// using DomainHelpers for *; - -// function setUp( ) public override { -// super.setUp(); -// destination.selectFork(); -// } - -// function test_transferUSDCToCCTP_notRelayer() external { -// vm.expectRevert(abi.encodeWithSignature( -// "AccessControlUnauthorizedAccount(address,bytes32)", -// address(this), -// RELAYER -// )); -// foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); -// } - -// function test_transferUSDCToCCTP_frozen() external { -// vm.prank(freezer); -// foreignController.freeze(); - -// vm.prank(relayer); -// vm.expectRevert("ForeignController/not-active"); -// foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); -// } - -// function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { -// vm.startPrank(SPARK_EXECUTOR); - -// // Set this so second modifier will be passed in success case -// foreignRateLimits.setUnlimitedRateLimitData( -// RateLimitHelpers.makeDomainKey( -// foreignController.LIMIT_USDC_TO_DOMAIN(), -// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM -// ) -// ); - -// // Rate limit will be constant 10m (higher than setup) -// foreignRateLimits.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), 10_000_000e6, 0); - -// // Set this for success case -// foreignController.setMintRecipient( -// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, -// bytes32(uint256(uint160(makeAddr("mintRecipient")))) -// ); - -// vm.stopPrank(); - -// deal(address(usdcBase), address(foreignAlmProxy), 10_000_000e6 + 1); - -// vm.startPrank(relayer); -// vm.expectRevert("RateLimits/rate-limit-exceeded"); -// foreignController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); - -// foreignController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); -// } + bytes32 depositKey = foreignController.LIMIT_PSM_DEPOSIT(); + bytes32 withdrawKey = foreignController.LIMIT_PSM_WITHDRAW(); -// function test_transferUSDCToCCTP_domainRateLimitedBoundary() external { -// vm.startPrank(SPARK_EXECUTOR); + bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM + ); -// // Set this so first modifier will be passed in success case -// foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); + RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), address(foreignRateLimits), standardUsdcData, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, address(foreignRateLimits), standardUsdcData, "cctpToEthereumDomainData", 6); -// // Rate limit will be constant 10m (higher than setup) -// foreignRateLimits.setRateLimitData( -// RateLimitHelpers.makeDomainKey( -// foreignController.LIMIT_USDC_TO_DOMAIN(), -// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM -// ), -// 10_000_000e6, -// 0 -// ); + vm.stopPrank(); -// // Set this for success case -// foreignController.setMintRecipient( -// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, -// bytes32(uint256(uint160(makeAddr("mintRecipient")))) -// ); + USDC_BASE_SUPPLY = usdcBase.totalSupply(); -// vm.stopPrank(); + source.selectFork(); -// deal(address(usdcBase), address(foreignAlmProxy), 10_000_000e6 + 1); + bridge = CCTPBridgeTesting.createCircleBridge(source, destination); -// vm.startPrank(relayer); -// vm.expectRevert("RateLimits/rate-limit-exceeded"); -// foreignController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + vm.prank(SPARK_PROXY); + mainnetController.setMintRecipient( + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + bytes32(uint256(uint160(address(foreignAlmProxy)))) + ); + } -// foreignController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); -// } +} + +contract ForeignControllerTransferUSDCToCCTPFailureTests is BaseChainUSDCToCCTPTestBase { + + using DomainHelpers for *; + + function setUp( ) public override { + super.setUp(); + destination.selectFork(); + } + + function test_transferUSDCToCCTP_notRelayer() external { + vm.expectRevert(abi.encodeWithSignature( + "AccessControlUnauthorizedAccount(address,bytes32)", + address(this), + RELAYER + )); + foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + } -// function test_transferUSDCToCCTP_invalidMintRecipient() external { -// // Configure to pass modifiers -// vm.startPrank(SPARK_EXECUTOR); + function test_transferUSDCToCCTP_frozen() external { + vm.prank(freezer); + foreignController.freeze(); -// foreignRateLimits.setUnlimitedRateLimitData( -// RateLimitHelpers.makeDomainKey( -// foreignController.LIMIT_USDC_TO_DOMAIN(), -// CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE -// ) -// ); + vm.prank(relayer); + vm.expectRevert("ForeignController/not-active"); + foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + } + + function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { + vm.startPrank(SPARK_EXECUTOR); + + // Set this so second modifier will be passed in success case + foreignRateLimits.setUnlimitedRateLimitData( + RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM + ) + ); + + // Rate limit will be constant 10m (higher than setup) + foreignRateLimits.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), 10_000_000e6, 0); -// foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); + // Set this for success case + foreignController.setMintRecipient( + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, + bytes32(uint256(uint160(makeAddr("mintRecipient")))) + ); -// vm.stopPrank(); + vm.stopPrank(); -// vm.prank(relayer); -// vm.expectRevert("ForeignController/domain-not-configured"); -// foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); -// } + deal(address(usdcBase), address(foreignAlmProxy), 10_000_000e6 + 1); -// } + vm.startPrank(relayer); + vm.expectRevert("RateLimits/rate-limit-exceeded"); + foreignController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); -// contract USDCToCCTPIntegrationTests is BaseChainUSDCToCCTPTestBase { + foreignController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + } -// using DomainHelpers for *; -// using CCTPBridgeTesting for Bridge; + function test_transferUSDCToCCTP_domainRateLimitedBoundary() external { + vm.startPrank(SPARK_EXECUTOR); -// event CCTPTransferInitiated( -// uint64 indexed nonce, -// uint32 indexed destinationDomain, -// bytes32 indexed mintRecipient, -// uint256 usdcAmount -// ); + // Set this so first modifier will be passed in success case + foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); -// event DepositForBurn( -// uint64 indexed nonce, -// address indexed burnToken, -// uint256 amount, -// address indexed depositor, -// bytes32 mintRecipient, -// uint32 destinationDomain, -// bytes32 destinationTokenMessenger, -// bytes32 destinationCaller -// ); + // Rate limit will be constant 10m (higher than setup) + foreignRateLimits.setRateLimitData( + RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM + ), + 10_000_000e6, + 0 + ); -// function test_transferUSDCToCCTP_sourceToDestination() external { -// deal(address(usdc), address(almProxy), 1e6); + // Set this for success case + foreignController.setMintRecipient( + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, + bytes32(uint256(uint160(makeAddr("mintRecipient")))) + ); -// assertEq(usdc.balanceOf(address(almProxy)), 1e6); -// assertEq(usdc.balanceOf(address(mainnetController)), 0); -// assertEq(usdc.totalSupply(), USDC_SUPPLY); + vm.stopPrank(); -// assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); + deal(address(usdcBase), address(foreignAlmProxy), 10_000_000e6 + 1); -// _expectEthereumCCTPEmit(114_803, 1e6); + vm.startPrank(relayer); + vm.expectRevert("RateLimits/rate-limit-exceeded"); + foreignController.transferUSDCToCCTP(10_000_000e6 + 1, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); -// vm.prank(relayer); -// mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + foreignController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + } -// assertEq(usdc.balanceOf(address(almProxy)), 0); -// assertEq(usdc.balanceOf(address(mainnetController)), 0); -// assertEq(usdc.totalSupply(), USDC_SUPPLY - 1e6); + function test_transferUSDCToCCTP_invalidMintRecipient() external { + // Configure to pass modifiers + vm.startPrank(SPARK_EXECUTOR); -// assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); + foreignRateLimits.setUnlimitedRateLimitData( + RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE + ) + ); -// destination.selectFork(); + foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); -// assertEq(usdcBase.balanceOf(address(foreignController)), 0); -// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); + vm.stopPrank(); -// bridge.relayMessagesToDestination(true); + vm.prank(relayer); + vm.expectRevert("ForeignController/domain-not-configured"); + foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); + } -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 1e6); -// assertEq(usdcBase.balanceOf(address(foreignController)), 0); -// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY + 1e6); -// } +} -// function test_transferUSDCToCCTP_sourceToDestination_bigTransfer() external { -// deal(address(usdc), address(almProxy), 2_900_000e6); +contract USDCToCCTPIntegrationTests is BaseChainUSDCToCCTPTestBase { -// assertEq(usdc.balanceOf(address(almProxy)), 2_900_000e6); -// assertEq(usdc.balanceOf(address(mainnetController)), 0); -// assertEq(usdc.totalSupply(), USDC_SUPPLY); + using DomainHelpers for *; + using CCTPBridgeTesting for Bridge; -// assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); + event CCTPTransferInitiated( + uint64 indexed nonce, + uint32 indexed destinationDomain, + bytes32 indexed mintRecipient, + uint256 usdcAmount + ); -// // Will split into 3 separate transactions at max 1m each -// _expectEthereumCCTPEmit(114_803, 1_000_000e6); -// _expectEthereumCCTPEmit(114_804, 1_000_000e6); -// _expectEthereumCCTPEmit(114_805, 900_000e6); + event DepositForBurn( + uint64 indexed nonce, + address indexed burnToken, + uint256 amount, + address indexed depositor, + bytes32 mintRecipient, + uint32 destinationDomain, + bytes32 destinationTokenMessenger, + bytes32 destinationCaller + ); -// vm.prank(relayer); -// mainnetController.transferUSDCToCCTP(2_900_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + function test_transferUSDCToCCTP_sourceToDestination() external { + deal(address(usdc), address(almProxy), 1e6); -// assertEq(usdc.balanceOf(address(almProxy)), 0); -// assertEq(usdc.balanceOf(address(mainnetController)), 0); -// assertEq(usdc.totalSupply(), USDC_SUPPLY - 2_900_000e6); + assertEq(usdc.balanceOf(address(almProxy)), 1e6); + assertEq(usdc.balanceOf(address(mainnetController)), 0); + assertEq(usdc.totalSupply(), USDC_SUPPLY); -// assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); + assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); -// destination.selectFork(); + _expectEthereumCCTPEmit(114_803, 1e6); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); -// assertEq(usdcBase.balanceOf(address(foreignController)), 0); -// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); + vm.prank(relayer); + mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// bridge.relayMessagesToDestination(true); + assertEq(usdc.balanceOf(address(almProxy)), 0); + assertEq(usdc.balanceOf(address(mainnetController)), 0); + assertEq(usdc.totalSupply(), USDC_SUPPLY - 1e6); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 2_900_000e6); -// assertEq(usdcBase.balanceOf(address(foreignController)), 0); -// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY + 2_900_000e6); -// } + assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); -// function test_transferUSDCToCCTP_sourceToDestination_rateLimited() external { -// bytes32 key = mainnetController.LIMIT_USDC_TO_CCTP(); -// deal(address(usdc), address(almProxy), 9_000_000e6); + destination.selectFork(); -// vm.startPrank(relayer); + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); + assertEq(usdcBase.balanceOf(address(foreignController)), 0); + assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); -// assertEq(usdc.balanceOf(address(almProxy)), 9_000_000e6); -// assertEq(rateLimits.getCurrentRateLimit(key), 5_000_000e6); + bridge.relayMessagesToDestination(true); -// mainnetController.transferUSDCToCCTP(2_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 1e6); + assertEq(usdcBase.balanceOf(address(foreignController)), 0); + assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY + 1e6); + } -// assertEq(usdc.balanceOf(address(almProxy)), 7_000_000e6); -// assertEq(rateLimits.getCurrentRateLimit(key), 3_000_000e6); + function test_transferUSDCToCCTP_sourceToDestination_bigTransfer() external { + deal(address(usdc), address(almProxy), 2_900_000e6); -// vm.expectRevert("RateLimits/rate-limit-exceeded"); -// mainnetController.transferUSDCToCCTP(3_000_001e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + assertEq(usdc.balanceOf(address(almProxy)), 2_900_000e6); + assertEq(usdc.balanceOf(address(mainnetController)), 0); + assertEq(usdc.totalSupply(), USDC_SUPPLY); -// mainnetController.transferUSDCToCCTP(3_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); -// assertEq(usdc.balanceOf(address(almProxy)), 4_000_000e6); -// assertEq(rateLimits.getCurrentRateLimit(key), 0); + // Will split into 3 separate transactions at max 1m each + _expectEthereumCCTPEmit(114_803, 1_000_000e6); + _expectEthereumCCTPEmit(114_804, 1_000_000e6); + _expectEthereumCCTPEmit(114_805, 900_000e6); -// skip(4 hours); + vm.prank(relayer); + mainnetController.transferUSDCToCCTP(2_900_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// assertEq(usdc.balanceOf(address(almProxy)), 4_000_000e6); -// assertEq(rateLimits.getCurrentRateLimit(key), 999_999.9936e6); + assertEq(usdc.balanceOf(address(almProxy)), 0); + assertEq(usdc.balanceOf(address(mainnetController)), 0); + assertEq(usdc.totalSupply(), USDC_SUPPLY - 2_900_000e6); -// mainnetController.transferUSDCToCCTP(999_999.9936e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + assertEq(usds.allowance(address(almProxy), CCTP_MESSENGER), 0); -// assertEq(usdc.balanceOf(address(almProxy)), 3_000_000.0064e6); -// assertEq(rateLimits.getCurrentRateLimit(key), 0); + destination.selectFork(); -// vm.stopPrank(); -// } + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); + assertEq(usdcBase.balanceOf(address(foreignController)), 0); + assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); -// function test_transferUSDCToCCTP_destinationToSource() external { -// destination.selectFork(); + bridge.relayMessagesToDestination(true); -// deal(address(usdcBase), address(foreignAlmProxy), 1e6); + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 2_900_000e6); + assertEq(usdcBase.balanceOf(address(foreignController)), 0); + assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY + 2_900_000e6); + } -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 1e6); -// assertEq(usdcBase.balanceOf(address(foreignController)), 0); -// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); + function test_transferUSDCToCCTP_sourceToDestination_rateLimited() external { + bytes32 key = mainnetController.LIMIT_USDC_TO_CCTP(); + deal(address(usdc), address(almProxy), 9_000_000e6); -// assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); + vm.startPrank(relayer); -// _expectBaseCCTPEmit(296_114, 1e6); + assertEq(usdc.balanceOf(address(almProxy)), 9_000_000e6); + assertEq(rateLimits.getCurrentRateLimit(key), 5_000_000e6); -// vm.prank(relayer); -// foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + mainnetController.transferUSDCToCCTP(2_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); -// assertEq(usdcBase.balanceOf(address(foreignController)), 0); -// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY - 1e6); + assertEq(usdc.balanceOf(address(almProxy)), 7_000_000e6); + assertEq(rateLimits.getCurrentRateLimit(key), 3_000_000e6); -// assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); + vm.expectRevert("RateLimits/rate-limit-exceeded"); + mainnetController.transferUSDCToCCTP(3_000_001e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// source.selectFork(); + mainnetController.transferUSDCToCCTP(3_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// assertEq(usdc.balanceOf(address(almProxy)), 0); -// assertEq(usdc.balanceOf(address(mainnetController)), 0); -// assertEq(usdc.totalSupply(), USDC_SUPPLY); + assertEq(usdc.balanceOf(address(almProxy)), 4_000_000e6); + assertEq(rateLimits.getCurrentRateLimit(key), 0); -// bridge.relayMessagesToSource(true); + skip(4 hours); -// assertEq(usdc.balanceOf(address(almProxy)), 1e6); -// assertEq(usdc.balanceOf(address(mainnetController)), 0); -// assertEq(usdc.totalSupply(), USDC_SUPPLY + 1e6); -// } + assertEq(usdc.balanceOf(address(almProxy)), 4_000_000e6); + assertEq(rateLimits.getCurrentRateLimit(key), 999_999.9936e6); -// function test_transferUSDCToCCTP_destinationToSource_bigTransfer() external { -// destination.selectFork(); + mainnetController.transferUSDCToCCTP(999_999.9936e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); -// deal(address(usdcBase), address(foreignAlmProxy), 2_600_000e6); + assertEq(usdc.balanceOf(address(almProxy)), 3_000_000.0064e6); + assertEq(rateLimits.getCurrentRateLimit(key), 0); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 2_600_000e6); -// assertEq(usdcBase.balanceOf(address(foreignController)), 0); -// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); + vm.stopPrank(); + } -// assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); + function test_transferUSDCToCCTP_destinationToSource() external { + destination.selectFork(); -// // Will split into three separate transactions at max 1m each -// _expectBaseCCTPEmit(296_114, 1_000_000e6); -// _expectBaseCCTPEmit(296_115, 1_000_000e6); -// _expectBaseCCTPEmit(296_116, 600_000e6); + deal(address(usdcBase), address(foreignAlmProxy), 1e6); -// vm.prank(relayer); -// foreignController.transferUSDCToCCTP(2_600_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 1e6); + assertEq(usdcBase.balanceOf(address(foreignController)), 0); + assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); -// assertEq(usdcBase.balanceOf(address(foreignController)), 0); -// assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY - 2_600_000e6); + assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); -// assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); + _expectBaseCCTPEmit(296_114, 1e6); -// source.selectFork(); + vm.prank(relayer); + foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); -// assertEq(usdc.balanceOf(address(almProxy)), 0); -// assertEq(usdc.balanceOf(address(mainnetController)), 0); -// assertEq(usdc.totalSupply(), USDC_SUPPLY); + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); + assertEq(usdcBase.balanceOf(address(foreignController)), 0); + assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY - 1e6); -// bridge.relayMessagesToSource(true); + assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); -// assertEq(usdc.balanceOf(address(almProxy)), 2_600_000e6); -// assertEq(usdc.balanceOf(address(mainnetController)), 0); -// assertEq(usdc.totalSupply(), USDC_SUPPLY + 2_600_000e6); -// } + source.selectFork(); -// function test_transferUSDCToCCTP_destinationToSource_rateLimited() external { -// destination.selectFork(); + assertEq(usdc.balanceOf(address(almProxy)), 0); + assertEq(usdc.balanceOf(address(mainnetController)), 0); + assertEq(usdc.totalSupply(), USDC_SUPPLY); -// bytes32 key = foreignController.LIMIT_USDC_TO_CCTP(); -// deal(address(usdcBase), address(foreignAlmProxy), 9_000_000e6); + bridge.relayMessagesToSource(true); -// vm.startPrank(relayer); + assertEq(usdc.balanceOf(address(almProxy)), 1e6); + assertEq(usdc.balanceOf(address(mainnetController)), 0); + assertEq(usdc.totalSupply(), USDC_SUPPLY + 1e6); + } -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 9_000_000e6); -// assertEq(foreignRateLimits.getCurrentRateLimit(key), 5_000_000e6); + function test_transferUSDCToCCTP_destinationToSource_bigTransfer() external { + destination.selectFork(); -// foreignController.transferUSDCToCCTP(2_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + deal(address(usdcBase), address(foreignAlmProxy), 2_600_000e6); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 7_000_000e6); -// assertEq(foreignRateLimits.getCurrentRateLimit(key), 3_000_000e6); + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 2_600_000e6); + assertEq(usdcBase.balanceOf(address(foreignController)), 0); + assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY); -// vm.expectRevert("RateLimits/rate-limit-exceeded"); -// foreignController.transferUSDCToCCTP(3_000_001e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); -// foreignController.transferUSDCToCCTP(3_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + // Will split into three separate transactions at max 1m each + _expectBaseCCTPEmit(296_114, 1_000_000e6); + _expectBaseCCTPEmit(296_115, 1_000_000e6); + _expectBaseCCTPEmit(296_116, 600_000e6); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 4_000_000e6); -// assertEq(foreignRateLimits.getCurrentRateLimit(key), 0); + vm.prank(relayer); + foreignController.transferUSDCToCCTP(2_600_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); -// skip(4 hours); + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 0); + assertEq(usdcBase.balanceOf(address(foreignController)), 0); + assertEq(usdcBase.totalSupply(), USDC_BASE_SUPPLY - 2_600_000e6); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 4_000_000e6); -// assertEq(foreignRateLimits.getCurrentRateLimit(key), 999_999.9936e6); + assertEq(usdsBase.allowance(address(foreignAlmProxy), CCTP_MESSENGER_BASE), 0); -// foreignController.transferUSDCToCCTP(999_999.9936e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + source.selectFork(); -// assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 3_000_000.0064e6); -// assertEq(foreignRateLimits.getCurrentRateLimit(key), 0); + assertEq(usdc.balanceOf(address(almProxy)), 0); + assertEq(usdc.balanceOf(address(mainnetController)), 0); + assertEq(usdc.totalSupply(), USDC_SUPPLY); -// vm.stopPrank(); -// } + bridge.relayMessagesToSource(true); -// function _expectEthereumCCTPEmit(uint64 nonce, uint256 amount) internal { -// // NOTE: Focusing on burnToken, amount, depositor, mintRecipient, and destinationDomain -// // for assertions -// vm.expectEmit(CCTP_MESSENGER); -// emit DepositForBurn( -// nonce, -// address(usdc), -// amount, -// address(almProxy), -// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, -// bytes32(0x0000000000000000000000001682ae6375c4e4a97e4b583bc394c861a46d8962), -// bytes32(0x0000000000000000000000000000000000000000000000000000000000000000) -// ); + assertEq(usdc.balanceOf(address(almProxy)), 2_600_000e6); + assertEq(usdc.balanceOf(address(mainnetController)), 0); + assertEq(usdc.totalSupply(), USDC_SUPPLY + 2_600_000e6); + } -// vm.expectEmit(address(mainnetController)); -// emit CCTPTransferInitiated( -// nonce, -// CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, -// mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), -// amount -// ); -// } + function test_transferUSDCToCCTP_destinationToSource_rateLimited() external { + destination.selectFork(); -// function _expectBaseCCTPEmit(uint64 nonce, uint256 amount) internal { -// // NOTE: Focusing on burnToken, amount, depositor, mintRecipient, and destinationDomain -// // for assertions -// vm.expectEmit(CCTP_MESSENGER_BASE); -// emit DepositForBurn( -// nonce, -// address(usdcBase), -// amount, -// address(foreignAlmProxy), -// foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), -// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, -// bytes32(0x000000000000000000000000bd3fa81b58ba92a82136038b25adec7066af3155), -// bytes32(0x0000000000000000000000000000000000000000000000000000000000000000) -// ); - -// vm.expectEmit(address(foreignController)); -// emit CCTPTransferInitiated( -// nonce, -// CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, -// foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), -// amount -// ); -// } - -// } + bytes32 key = foreignController.LIMIT_USDC_TO_CCTP(); + deal(address(usdcBase), address(foreignAlmProxy), 9_000_000e6); + + vm.startPrank(relayer); + + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 9_000_000e6); + assertEq(foreignRateLimits.getCurrentRateLimit(key), 5_000_000e6); + + foreignController.transferUSDCToCCTP(2_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 7_000_000e6); + assertEq(foreignRateLimits.getCurrentRateLimit(key), 3_000_000e6); + + vm.expectRevert("RateLimits/rate-limit-exceeded"); + foreignController.transferUSDCToCCTP(3_000_001e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + + foreignController.transferUSDCToCCTP(3_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 4_000_000e6); + assertEq(foreignRateLimits.getCurrentRateLimit(key), 0); + + skip(4 hours); + + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 4_000_000e6); + assertEq(foreignRateLimits.getCurrentRateLimit(key), 999_999.9936e6); + + foreignController.transferUSDCToCCTP(999_999.9936e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); + + assertEq(usdcBase.balanceOf(address(foreignAlmProxy)), 3_000_000.0064e6); + assertEq(foreignRateLimits.getCurrentRateLimit(key), 0); + + vm.stopPrank(); + } + + function _expectEthereumCCTPEmit(uint64 nonce, uint256 amount) internal { + // NOTE: Focusing on burnToken, amount, depositor, mintRecipient, and destinationDomain + // for assertions + vm.expectEmit(CCTP_MESSENGER); + emit DepositForBurn( + nonce, + address(usdc), + amount, + address(almProxy), + mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + bytes32(0x0000000000000000000000001682ae6375c4e4a97e4b583bc394c861a46d8962), + bytes32(0x0000000000000000000000000000000000000000000000000000000000000000) + ); + + vm.expectEmit(address(mainnetController)); + emit CCTPTransferInitiated( + nonce, + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, + mainnetController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_BASE), + amount + ); + } + + function _expectBaseCCTPEmit(uint64 nonce, uint256 amount) internal { + // NOTE: Focusing on burnToken, amount, depositor, mintRecipient, and destinationDomain + // for assertions + vm.expectEmit(CCTP_MESSENGER_BASE); + emit DepositForBurn( + nonce, + address(usdcBase), + amount, + address(foreignAlmProxy), + foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, + bytes32(0x000000000000000000000000bd3fa81b58ba92a82136038b25adec7066af3155), + bytes32(0x0000000000000000000000000000000000000000000000000000000000000000) + ); + + vm.expectEmit(address(foreignController)); + emit CCTPTransferInitiated( + nonce, + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, + foreignController.mintRecipients(CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM), + amount + ); + } + +} diff --git a/test/mainnet-fork/ForkTestBase.t.sol b/test/mainnet-fork/ForkTestBase.t.sol index 04cbb69..0bec1e2 100644 --- a/test/mainnet-fork/ForkTestBase.t.sol +++ b/test/mainnet-fork/ForkTestBase.t.sol @@ -279,11 +279,11 @@ contract ForkTestBase is DssTest { address(susds) ); - RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), rateLimits, standardUsdsData, "usdsMintData", 18); - RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), rateLimits, standardUsdcData, "usdsToUsdcData", 6); - RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), rateLimits, standardUsdcData, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits, standardUsdcData, "cctpToBaseDomainData", 6); - RateLimitHelpers.setRateLimitData(susdsKey, rateLimits, standardUsdsData, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), address(rateLimits), standardUsdsData, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), address(rateLimits), standardUsdcData, "usdsToUsdcData", 6); + RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), address(rateLimits), standardUsdcData, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, address(rateLimits), standardUsdcData, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(susdsKey, address(rateLimits), standardUsdsData, "susdsDepositData", 18); vm.stopPrank(); From ce045b0cd0ed261d1e3c2906135c8f6f0b93a5f9 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 13:14:16 -0500 Subject: [PATCH 20/33] fix: update setup --- test/mainnet-fork/CCTPCalls.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/mainnet-fork/CCTPCalls.t.sol b/test/mainnet-fork/CCTPCalls.t.sol index 176bed9..22f08f8 100644 --- a/test/mainnet-fork/CCTPCalls.t.sol +++ b/test/mainnet-fork/CCTPCalls.t.sol @@ -232,7 +232,7 @@ contract BaseChainUSDCToCCTPTestBase is ForkTestBase { mintRecipients[0] = ForeignControllerInit.MintRecipient({ domain : CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM, - mintRecipient : bytes32(uint256(uint160(makeAddr("ethereumAlmProxy")))) + mintRecipient : bytes32(uint256(uint160(address(almProxy)))) }); vm.startPrank(SPARK_EXECUTOR); From 535830256e5ca1e7b534e06f9ef290dff9fb4dad Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 13:15:26 -0500 Subject: [PATCH 21/33] chore: rename files for better diffing --- test/base-fork/{InitAndUpgrade.t.sol => DeployAndInit.t.sol} | 0 test/mainnet-fork/{InitAndUpgrade.t.sol => DeployAndInit.t.sol} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename test/base-fork/{InitAndUpgrade.t.sol => DeployAndInit.t.sol} (100%) rename test/mainnet-fork/{InitAndUpgrade.t.sol => DeployAndInit.t.sol} (100%) diff --git a/test/base-fork/InitAndUpgrade.t.sol b/test/base-fork/DeployAndInit.t.sol similarity index 100% rename from test/base-fork/InitAndUpgrade.t.sol rename to test/base-fork/DeployAndInit.t.sol diff --git a/test/mainnet-fork/InitAndUpgrade.t.sol b/test/mainnet-fork/DeployAndInit.t.sol similarity index 100% rename from test/mainnet-fork/InitAndUpgrade.t.sol rename to test/mainnet-fork/DeployAndInit.t.sol From f510b045306de6b990145019da6074920639b534 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 13:30:29 -0500 Subject: [PATCH 22/33] fix: stack too deep --- script/staging/FullStagingDeploy.s.sol | 27 ++++++++++++-------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 1ca49b3..8686439 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -282,9 +282,6 @@ contract FullStagingDeploy is Script { }); MainnetController mainnetController_ = MainnetController(mainnetController); - - bytes32 mintKey = mainnetController_.LIMIT_USDE_MINT(); - bytes32 burnKey = mainnetController_.LIMIT_USDE_BURN(); bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey( mainnetController_.LIMIT_4626_DEPOSIT(), @@ -306,15 +303,15 @@ contract FullStagingDeploy is Script { address(susds) ); - RateLimitHelpers.setRateLimitData(mintKey, controllerInst.rateLimits, rateLimitData6, "usdeMintData", 6); - RateLimitHelpers.setRateLimitData(burnKey, controllerInst.rateLimits, rateLimitData18, "usdeBurnData", 18); - RateLimitHelpers.setRateLimitData(susdsDepositKey, controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(susdsWithdrawKey, controllerInst.rateLimits, rateLimitData18, "susdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), controllerInst.rateLimits, rateLimitData18, "usdsMintData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), controllerInst.rateLimits, rateLimitData6, "usdsToUsdcData", 6); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), controllerInst.rateLimits, rateLimitData6, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyBase, controllerInst.rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); - RateLimitHelpers.setRateLimitData(susdsKey, controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_MINT(), controllerInst.rateLimits, rateLimitData6, "usdeMintData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_BURN(), controllerInst.rateLimits, rateLimitData18, "usdeBurnData", 18); + RateLimitHelpers.setRateLimitData(susdsDepositKey, controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(susdsWithdrawKey, controllerInst.rateLimits, rateLimitData18, "susdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), controllerInst.rateLimits, rateLimitData18, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), controllerInst.rateLimits, rateLimitData6, "usdsToUsdcData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), controllerInst.rateLimits, unlimitedRateLimit, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, controllerInst.rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(susdsKey, controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); // Step 3: Transfer ownership of mock usdsJoin to the vault (able to mint usds) @@ -404,9 +401,9 @@ contract FullStagingDeploy is Script { CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM ); - address usdc = base.config.readAddress(".usdc"); - address usds = base.config.readAddress(".usds"); - address susds = base.config.readAddress(".susds"); + usdc = base.config.readAddress(".usdc"); + usds = base.config.readAddress(".usds"); + susds = base.config.readAddress(".susds"); RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usdc), controllerInst.rateLimits, rateLimitData6, "usdcDepositData", 6); RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usdc), controllerInst.rateLimits, rateLimitData6, "usdcWithdrawData", 6); From 8b642480898fec95fe0d38b2d64b60bbe478caa3 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 13:35:55 -0500 Subject: [PATCH 23/33] fix: rm conversion rate check for PSM --- deploy/MainnetControllerInit.sol | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/deploy/MainnetControllerInit.sol b/deploy/MainnetControllerInit.sol index e8e50df..b94d0c2 100644 --- a/deploy/MainnetControllerInit.sol +++ b/deploy/MainnetControllerInit.sol @@ -133,8 +133,7 @@ library MainnetControllerInit { require(address(newController.daiUsds()) == checkAddresses.daiUsds, "MainnetControllerInit/incorrect-daiUsds"); require(address(newController.cctp()) == checkAddresses.cctp, "MainnetControllerInit/incorrect-cctp"); - require(newController.psmTo18ConversionFactor() == 1e12, "MainnetControllerInit/incorrect-psmTo18ConversionFactor"); - require(newController.active(), "MainnetControllerInit/controller-not-active"); + require(newController.active(), "MainnetControllerInit/controller-not-active"); require(configAddresses.oldController != address(newController), "MainnetControllerInit/old-controller-is-new-controller"); From 84b2dae7490972c9ae3ca33f0dfe5d75c6f4d730 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 13:36:21 -0500 Subject: [PATCH 24/33] fix: keep psm check --- deploy/MainnetControllerInit.sol | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/deploy/MainnetControllerInit.sol b/deploy/MainnetControllerInit.sol index b94d0c2..e8e50df 100644 --- a/deploy/MainnetControllerInit.sol +++ b/deploy/MainnetControllerInit.sol @@ -133,7 +133,8 @@ library MainnetControllerInit { require(address(newController.daiUsds()) == checkAddresses.daiUsds, "MainnetControllerInit/incorrect-daiUsds"); require(address(newController.cctp()) == checkAddresses.cctp, "MainnetControllerInit/incorrect-cctp"); - require(newController.active(), "MainnetControllerInit/controller-not-active"); + require(newController.psmTo18ConversionFactor() == 1e12, "MainnetControllerInit/incorrect-psmTo18ConversionFactor"); + require(newController.active(), "MainnetControllerInit/controller-not-active"); require(configAddresses.oldController != address(newController), "MainnetControllerInit/old-controller-is-new-controller"); From 4d1d8f4fe0210bab2cce7b9f4959e2dd0636f611 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 13:53:14 -0500 Subject: [PATCH 25/33] test: add explicit deploy admin check --- test/base-fork/Deploy.t.sol | 6 +++++- test/mainnet-fork/Deploy.t.sol | 8 ++++++-- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/test/base-fork/Deploy.t.sol b/test/base-fork/Deploy.t.sol index b0346b3..b12b879 100644 --- a/test/base-fork/Deploy.t.sol +++ b/test/base-fork/Deploy.t.sol @@ -22,8 +22,11 @@ contract ForeignControllerDeploySuccessTests is ForkTestBase { ForeignController newController = ForeignController(controllerInst.controller); RateLimits newRateLimits = RateLimits(controllerInst.rateLimits); - assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR), true); + assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR), true); + assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, address(this)), false); // Deployer never gets admin + assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR), true); + assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, address(this)), false); // Deployer never gets admin _assertControllerInitState(newController, address(newAlmProxy), address(newRateLimits)); } @@ -45,6 +48,7 @@ contract ForeignControllerDeploySuccessTests is ForkTestBase { function _assertControllerInitState(ForeignController controller, address almProxy, address rateLimits) internal view { assertEq(controller.hasRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR), true); + assertEq(controller.hasRole(DEFAULT_ADMIN_ROLE, address(this)), false); // Deployer never gets admin assertEq(address(controller.proxy()), almProxy); assertEq(address(controller.rateLimits()), rateLimits); diff --git a/test/mainnet-fork/Deploy.t.sol b/test/mainnet-fork/Deploy.t.sol index bf4ffde..1c407cd 100644 --- a/test/mainnet-fork/Deploy.t.sol +++ b/test/mainnet-fork/Deploy.t.sol @@ -24,7 +24,10 @@ contract MainnetControllerDeploySuccessTests is ForkTestBase { RateLimits newRateLimits = RateLimits(controllerInst.rateLimits); assertEq(newAlmProxy.hasRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY), true); - assertEq(newRateLimits.hasRole(DEFAULT_ADMIN_ROLE, SPARK_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, address(this)), false); // Deployer never gets admin _assertControllerInitState(newController, address(newAlmProxy), address(newRateLimits), vault, buffer); } @@ -46,7 +49,8 @@ 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, SPARK_PROXY), true); + assertEq(controller.hasRole(DEFAULT_ADMIN_ROLE, address(this)), false); assertEq(address(controller.proxy()), almProxy); assertEq(address(controller.rateLimits()), rateLimits); From 25b8a089e08da58d2f89bc2c91b9019659884bf1 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 15:15:01 -0500 Subject: [PATCH 26/33] fix: tidy up setups --- test/base-fork/ForkTestBase.t.sol | 6 +++++- test/mainnet-fork/4626Calls.t.sol | 13 +++++-------- test/mainnet-fork/ForkTestBase.t.sol | 13 ++++--------- 3 files changed, 14 insertions(+), 18 deletions(-) diff --git a/test/base-fork/ForkTestBase.t.sol b/test/base-fork/ForkTestBase.t.sol index 93a35c7..6021b88 100644 --- a/test/base-fork/ForkTestBase.t.sol +++ b/test/base-fork/ForkTestBase.t.sol @@ -98,7 +98,7 @@ contract ForkTestBase is Test { vm.prank(pocket); usdcBase.approve(address(psmBase), type(uint256).max); - /*** Step 3: Deploy and configure ALM system ***/ + /*** Step 3: Deploy ALM system ***/ ControllerInstance memory controllerInst = ForeignControllerDeploy.deployFull({ admin : SPARK_EXECUTOR, @@ -115,6 +115,9 @@ contract ForkTestBase is Test { FREEZER = foreignController.FREEZER(); RELAYER = foreignController.RELAYER(); + /*** Step 3: Configure ALM system through Spark governance (Spark spell payload) ***/ + + Init.ConfigAddressParams memory configAddresses = Init.ConfigAddressParams({ freezer : freezer, relayer : relayer, @@ -169,6 +172,7 @@ contract ForkTestBase is Test { CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM ); + // NOTE: Using minimal config for test base setup RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(usdcBase)), address(rateLimits), standardUsdcData, "usdcDepositData", 6); RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, address(usdcBase)), address(rateLimits), standardUsdcData, "usdcWithdrawData", 6); RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, address(usdsBase)), address(rateLimits), standardUsdsData, "usdsDepositData", 18); diff --git a/test/mainnet-fork/4626Calls.t.sol b/test/mainnet-fork/4626Calls.t.sol index dc55a57..d607f82 100644 --- a/test/mainnet-fork/4626Calls.t.sol +++ b/test/mainnet-fork/4626Calls.t.sol @@ -16,15 +16,12 @@ contract SUSDSTestBase is ForkTestBase { function setUp() override public { super.setUp(); + 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); - rateLimits.setRateLimitData( - RateLimitHelpers.makeAssetKey( - mainnetController.LIMIT_4626_WITHDRAW(), - Ethereum.SUSDS - ), - 5_000_000e18, - uint256(5_000_000e18) / 1 days - ); + 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(); SUSDS_CONVERTED_ASSETS = susds.convertToAssets(1e18); diff --git a/test/mainnet-fork/ForkTestBase.t.sol b/test/mainnet-fork/ForkTestBase.t.sol index 0bec1e2..2a2c97a 100644 --- a/test/mainnet-fork/ForkTestBase.t.sol +++ b/test/mainnet-fork/ForkTestBase.t.sol @@ -241,12 +241,12 @@ contract ForkTestBase is DssTest { mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) }); - // Step 4: Initialize through Sky governance + // Step 4: Initialize through Sky governance (Sky spell payload) vm.prank(Ethereum.PAUSE_PROXY); Init.pauseProxyInitAlmSystem(Ethereum.PSM, controllerInst.almProxy); - // Step 5: Initialize through Spark governance + // Step 5: Initialize through Spark governance (Spark spell payload) vm.startPrank(Ethereum.SPARK_PROXY); @@ -274,20 +274,15 @@ contract ForkTestBase is DssTest { CCTPForwarder.DOMAIN_ID_CIRCLE_BASE ); - bytes32 susdsKey = RateLimitHelpers.makeAssetKey( - mainnetController.LIMIT_4626_DEPOSIT(), - address(susds) - ); - + // NOTE: Using minimal config for test base setup RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), address(rateLimits), standardUsdsData, "usdsMintData", 18); RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), address(rateLimits), standardUsdcData, "usdsToUsdcData", 6); RateLimitHelpers.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), address(rateLimits), standardUsdcData, "usdcToCctpData", 6); RateLimitHelpers.setRateLimitData(domainKeyBase, address(rateLimits), standardUsdcData, "cctpToBaseDomainData", 6); - RateLimitHelpers.setRateLimitData(susdsKey, address(rateLimits), standardUsdsData, "susdsDepositData", 18); vm.stopPrank(); - /*** Step 4: Label addresses ***/ + /*** Step 6: Label addresses ***/ vm.label(buffer, "buffer"); vm.label(address(susds), "susds"); From 1e4d6d57dfe4285edaf9cc8e8355d6956f2480bf Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Thu, 26 Dec 2024 22:56:09 -0500 Subject: [PATCH 27/33] feat: staging deployment working with tests --- Makefile | 2 +- script/input/1/mainnet-staging.json | 2 +- script/staging/FullStagingDeploy.s.sol | 201 ++++++++++++-------- script/staging/test/StagingDeployment.t.sol | 78 +------- test/base-fork/DeployAndInit.t.sol | 23 +-- test/mainnet-fork/DeployAndInit.t.sol | 29 +-- 6 files changed, 137 insertions(+), 198 deletions(-) diff --git a/Makefile b/Makefile index 9f1b5c4..ddca5dc 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ # Staging Full Deployment with Dependencies -deploy-staging-full :; forge script script/staging/FullStagingDeploy.s.sol:FullStagingDeploy --sender ${ETH_FROM} --broadcast --verify +deploy-staging-full :; forge script script/staging/FullStagingDeploy.s.sol:FullStagingDeploy --sender ${ETH_FROM} --broadcast --private-key 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 # Staging Deployments deploy-mainnet-staging-controller :; ENV=staging forge script script/Deploy.s.sol:DeployMainnetController --sender ${ETH_FROM} --broadcast --verify diff --git a/script/input/1/mainnet-staging.json b/script/input/1/mainnet-staging.json index 294d050..3291b67 100644 --- a/script/input/1/mainnet-staging.json +++ b/script/input/1/mainnet-staging.json @@ -5,7 +5,7 @@ "cctpTokenMessenger": "0xBd3fa81B58Ba92a82136038B25aDec7066af3155", "dai": "0x6B175474E89094C44Da98b954EedeAC495271d0F", "daiUsds": "0x3225737a9Bbb6473CB4a45b7244ACa2BeFdB276A", - "psm": "0x91AA02EDe82D3C2f49A2d5a7efBA7ba4403100C8", + "psm": "0xf6e72Db5454dd049d0788e411b06CfAF16853042", "relayer": "0x611C7c37F296240c2fF5a92f0B4a398B01B237c4", "freezer": "0x611C7c37F296240c2fF5a92f0B4a398B01B237c4", "susds": "0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD", diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 8686439..74fe9eb 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -58,6 +58,17 @@ contract FullStagingDeploy is Script { using stdJson for string; using ScriptTools for string; + /**********************************************************************************************/ + /*** Deployed contracts ***/ + /**********************************************************************************************/ + + address constant AUSDS = 0x32a6268f9Ba3642Dda7892aDd74f1D34469A4259; + address constant AUSDC = 0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c; + + address constant AUSDC_BASE = 0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB; + address constant MORPHO_BASE = 0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb; + address constant MORPHO_VAULT_USDC_BASE = 0x305E03Ed9ADaAB22F4A58c24515D79f2B1E2FD5D; + /**********************************************************************************************/ /*** Mainnet existing/mock deployments ***/ /**********************************************************************************************/ @@ -212,7 +223,7 @@ contract FullStagingDeploy is Script { ScriptTools.exportContract(mainnet.nameDeps, "allocatorVault", vault); } - function _setUpALMController() internal { + function _setUpMainnetController() internal { vm.selectFork(mainnet.forkId); vm.startBroadcast(); @@ -221,7 +232,7 @@ contract FullStagingDeploy is Script { ControllerInstance memory controllerInst = MainnetControllerDeploy.deployFull({ admin : mainnet.admin, vault : vault, - psm : psm, + psm : psm, // Wrapper daiUsds : daiUsds, cctp : mainnet.config.readAddress(".cctpTokenMessenger") }); @@ -243,8 +254,8 @@ contract FullStagingDeploy is Script { admin : mainnet.admin, proxy : controllerInst.almProxy, rateLimits : controllerInst.rateLimits, - vault : mainnet.config.readAddress(".psm"), - psm : mainnet.config.readAddress(".psm"), + vault : vault, + psm : psm, daiUsds : mainnet.config.readAddress(".daiUsds"), cctp : mainnet.config.readAddress(".cctpTokenMessenger") }); @@ -267,6 +278,26 @@ contract FullStagingDeploy is Script { // Step 3: Set all rate limits for the controller + _setMainnetControllerRateLimits(controllerInst.rateLimits); + + // Step 4: Transfer ownership of mock usdsJoin to the vault (able to mint usds) + + MockUsdsJoin(usdsJoin).transferOwnership(vault); + + vm.stopBroadcast(); + + // Step 5: Export all deployed addresses + + ScriptTools.exportContract(mainnet.nameDeps, "freezer", mainnet.config.readAddress(".freezer")); + ScriptTools.exportContract(mainnet.nameDeps, "relayer", mainnet.config.readAddress(".relayer")); + + ScriptTools.exportContract(mainnet.name, "almProxy", controllerInst.almProxy); + ScriptTools.exportContract(mainnet.name, "controller", controllerInst.controller); + ScriptTools.exportContract(mainnet.name, "rateLimits", controllerInst.rateLimits); + } + + // TODO: Remove + function _setMainnetControllerRateLimits(address rateLimits) internal { // Still constrained by the USDC_UNIT_SIZE RateLimitData memory rateLimitData18 = RateLimitData({ maxAmount : USDC_UNIT_SIZE * 1e12 * 5, @@ -282,54 +313,93 @@ contract FullStagingDeploy is Script { }); MainnetController mainnetController_ = MainnetController(mainnetController); - - bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey( - mainnetController_.LIMIT_4626_DEPOSIT(), - address(mainnetController_.susde()) - ); - bytes32 susdsWithdrawKey = RateLimitHelpers.makeAssetKey( - mainnetController_.LIMIT_4626_WITHDRAW(), - address(mainnetController_.susde()) - ); - - bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( - mainnetController_.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE - ); + bytes32 ausdcDepositKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_AAVE_DEPOSIT(), AUSDC); + bytes32 ausdcWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_AAVE_WITHDRAW(), AUSDC); + bytes32 ausdsDepositKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_AAVE_DEPOSIT(), AUSDS); + bytes32 ausdsWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_AAVE_WITHDRAW(), AUSDS); + bytes32 susdeDepositKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_4626_DEPOSIT(), address(mainnetController_.susde())); + bytes32 susdeWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_4626_WITHDRAW(), address(mainnetController_.susde())); + bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_4626_DEPOSIT(), susds); + bytes32 susdsWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_4626_WITHDRAW(), susds); + + bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey(mainnetController_.LIMIT_USDC_TO_DOMAIN(), CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + + // USDS mint/burn and cross-chain transfer rate limits + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), rateLimits, rateLimitData18, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), rateLimits, rateLimitData6, "usdsToUsdcData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), rateLimits, unlimitedRateLimit, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); + + // Ethena-specific rate limits + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_MINT(), rateLimits, rateLimitData6, "usdeMintData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_BURN(), rateLimits, rateLimitData18, "usdeBurnData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_SUSDE_COOLDOWN(), rateLimits, unlimitedRateLimit, "susdeCooldownData", 18); + + // 4626 and AAVE deposit/withdraw rate limits + RateLimitHelpers.setRateLimitData(ausdcDepositKey, rateLimits, rateLimitData6, "ausdcDepositData", 6); + RateLimitHelpers.setRateLimitData(ausdcWithdrawKey, rateLimits, rateLimitData6, "ausdcWithdrawData", 6); + RateLimitHelpers.setRateLimitData(ausdsDepositKey, rateLimits, rateLimitData6, "ausdsDepositData", 18); + RateLimitHelpers.setRateLimitData(ausdsWithdrawKey, rateLimits, rateLimitData6, "ausdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(susdeDepositKey, rateLimits, rateLimitData18, "susdeDepositData", 18); + RateLimitHelpers.setRateLimitData(susdeWithdrawKey, rateLimits, rateLimitData18, "susdeWithdrawData", 18); + RateLimitHelpers.setRateLimitData(susdsDepositKey, rateLimits, rateLimitData18, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(susdsWithdrawKey, rateLimits, rateLimitData18, "susdsWithdrawData", 18); + } - bytes32 susdsKey = RateLimitHelpers.makeAssetKey( - mainnetController_.LIMIT_4626_DEPOSIT(), - address(susds) - ); + function _setBaseControllerRateLimits(address rateLimits) internal { + RateLimitData memory rateLimitData18 = RateLimitData({ + maxAmount : USDC_UNIT_SIZE * 1e12 * 5, + slope : USDC_UNIT_SIZE * 1e12 / 4 hours + }); + RateLimitData memory rateLimitData6 = RateLimitData({ + maxAmount : USDC_UNIT_SIZE * 5, + slope : USDC_UNIT_SIZE / 4 hours + }); + RateLimitData memory unlimitedRateLimit = RateLimitData({ + maxAmount : type(uint256).max, + slope : 0 + }); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_MINT(), controllerInst.rateLimits, rateLimitData6, "usdeMintData", 6); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_BURN(), controllerInst.rateLimits, rateLimitData18, "usdeBurnData", 18); - RateLimitHelpers.setRateLimitData(susdsDepositKey, controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(susdsWithdrawKey, controllerInst.rateLimits, rateLimitData18, "susdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), controllerInst.rateLimits, rateLimitData18, "usdsMintData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), controllerInst.rateLimits, rateLimitData6, "usdsToUsdcData", 6); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), controllerInst.rateLimits, unlimitedRateLimit, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyBase, controllerInst.rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); - RateLimitHelpers.setRateLimitData(susdsKey, controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); + ForeignController foreignController = ForeignController(baseController); - // Step 3: Transfer ownership of mock usdsJoin to the vault (able to mint usds) + bytes32 aaveDepositKey = foreignController.LIMIT_AAVE_DEPOSIT(); + bytes32 aaveWithdrawKey = foreignController.LIMIT_AAVE_WITHDRAW(); + bytes32 psmDepositKey = foreignController.LIMIT_PSM_DEPOSIT(); + bytes32 psmWithdrawKey = foreignController.LIMIT_PSM_WITHDRAW(); + bytes32 vaultDepositKey = foreignController.LIMIT_4626_DEPOSIT(); + bytes32 vaultWithdrawKey = foreignController.LIMIT_4626_WITHDRAW(); + + bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM + ); - MockUsdsJoin(usdsJoin).transferOwnership(vault); + usdc = base.config.readAddress(".usdc"); + usds = base.config.readAddress(".usds"); + susds = base.config.readAddress(".susds"); - vm.stopBroadcast(); + // PSM rate limits for all three assets + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmDepositKey, usdc), rateLimits, rateLimitData6, "usdcDepositDataPsm", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmWithdrawKey, usdc), rateLimits, rateLimitData6, "usdcWithdrawDataPsm", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmDepositKey, usds), rateLimits, rateLimitData18, "usdsDepositDataPsm", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmWithdrawKey, usds), rateLimits, unlimitedRateLimit, "usdsWithdrawDataPsm", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmDepositKey, susds), rateLimits, rateLimitData18, "susdsDepositDataPsm", 18); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmWithdrawKey, susds), rateLimits, unlimitedRateLimit, "susdsWithdrawDataPsm", 18); - // Step 4: Export all deployed addresses + // CCTP rate limits + RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits, rateLimitData6, "usdcToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); - ScriptTools.exportContract(mainnet.nameDeps, "freezer", mainnet.config.readAddress(".freezer")); - ScriptTools.exportContract(mainnet.nameDeps, "relayer", mainnet.config.readAddress(".relayer")); + // AAVE rate limits + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(aaveDepositKey, AUSDC_BASE), rateLimits, rateLimitData6, "usdcDepositDataAave", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(aaveWithdrawKey, AUSDC_BASE), rateLimits, rateLimitData6, "usdcWithdrawDataAave", 6); - ScriptTools.exportContract(mainnet.name, "almProxy", controllerInst.almProxy); - ScriptTools.exportContract(mainnet.name, "controller", controllerInst.controller); - ScriptTools.exportContract(mainnet.name, "rateLimits", controllerInst.rateLimits); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(vaultDepositKey, MORPHO_VAULT_USDC_BASE), rateLimits, rateLimitData6, "usdsDepositDataMorpho", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(vaultWithdrawKey, MORPHO_VAULT_USDC_BASE), rateLimits, rateLimitData6, "usdsDepositDataMorpho", 6); } - function _setUpBaseALMController() public { + function _setUpBaseALMController() internal { vm.selectFork(base.forkId); vm.startBroadcast(); @@ -358,8 +428,8 @@ contract FullStagingDeploy is Script { psm : base.config.readAddress(".psm"), cctp : base.config.readAddress(".cctpTokenMessenger"), usdc : base.config.readAddress(".usdc"), - susds : base.config.readAddress(".usdc"), - usds : base.config.readAddress(".susds") + susds : base.config.readAddress(".susds"), + usds : base.config.readAddress(".usds") }); ForeignControllerInit.MintRecipient[] memory mintRecipients = new ForeignControllerInit.MintRecipient[](1); @@ -378,49 +448,14 @@ contract FullStagingDeploy is Script { // Step 3: Set all rate limits for the controller - RateLimitData memory rateLimitData18 = RateLimitData({ - maxAmount : USDC_UNIT_SIZE * 1e12 * 5, - slope : USDC_UNIT_SIZE * 1e12 / 4 hours - }); - RateLimitData memory rateLimitData6 = RateLimitData({ - maxAmount : USDC_UNIT_SIZE * 5, - slope : USDC_UNIT_SIZE / 4 hours - }); - RateLimitData memory unlimitedRateLimit = RateLimitData({ - maxAmount : type(uint256).max, - slope : 0 - }); - - ForeignController foreignController = ForeignController(baseController); - - bytes32 depositKey = foreignController.LIMIT_PSM_DEPOSIT(); - bytes32 withdrawKey = foreignController.LIMIT_PSM_WITHDRAW(); - - bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( - foreignController.LIMIT_USDC_TO_DOMAIN(), - CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM - ); - - usdc = base.config.readAddress(".usdc"); - usds = base.config.readAddress(".usds"); - susds = base.config.readAddress(".susds"); - - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usdc), controllerInst.rateLimits, rateLimitData6, "usdcDepositData", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usdc), controllerInst.rateLimits, rateLimitData6, "usdcWithdrawData", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, usds), controllerInst.rateLimits, rateLimitData18, "usdsDepositData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, usds), controllerInst.rateLimits, unlimitedRateLimit, "usdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(depositKey, susds), controllerInst.rateLimits, rateLimitData18, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(withdrawKey, susds), controllerInst.rateLimits, unlimitedRateLimit, "susdsWithdrawData", 18); - - RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), controllerInst.rateLimits, rateLimitData6, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyEthereum, controllerInst.rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); + _setBaseControllerRateLimits(controllerInst.rateLimits); vm.stopBroadcast(); - // Step 3: Export all deployed addresses + // Step 4: Export all deployed addresses - ScriptTools.exportContract(base.nameDeps, "freezer", base.config.readAddress(".freezer")); - ScriptTools.exportContract(base.nameDeps, "relayer", base.config.readAddress(".relayer")); + ScriptTools.exportContract(base.nameDeps, "freezer", base.config.readAddress(".freezer")); + ScriptTools.exportContract(base.nameDeps, "relayer", base.config.readAddress(".relayer")); ScriptTools.exportContract(base.name, "almProxy", controllerInst.almProxy); ScriptTools.exportContract(base.name, "controller", controllerInst.controller); @@ -469,7 +504,7 @@ contract FullStagingDeploy is Script { _setUpDependencies(); _setUpAllocationSystem(); - _setUpALMController(); + _setUpMainnetController(); _setUpBaseALMController(); _setBaseMintRecipient(); diff --git a/script/staging/test/StagingDeployment.t.sol b/script/staging/test/StagingDeployment.t.sol index a9a283f..62c2866 100644 --- a/script/staging/test/StagingDeployment.t.sol +++ b/script/staging/test/StagingDeployment.t.sol @@ -36,6 +36,7 @@ import { ALMProxy } from "../../../src/ALMProxy.sol"; import { ForeignController } from "../../../src/ForeignController.sol"; import { MainnetController } from "../../../src/MainnetController.sol"; import { RateLimits } from "../../../src/RateLimits.sol"; + import { RateLimitHelpers } from "../../../src/RateLimitHelpers.sol"; interface IVatLike { @@ -140,7 +141,7 @@ contract StagingDeploymentTestBase is Test { // ALM system almProxy = ALMProxy(payable(outputMainnet.readAddress(".almProxy"))); rateLimits = RateLimits(outputMainnet.readAddress(".rateLimits")); - mainnetController = _reconfigureMainnetController(); + mainnetController = MainnetController(outputMainnet.readAddress(".controller")); // Base roles relayerSafeBase = outputBaseDeps.readAddress(".relayer"); @@ -162,56 +163,6 @@ contract StagingDeploymentTestBase is Test { deal(address(usds), address(usdsJoin), 1000e18); // Ensure there is enough balance } - - // TODO: Remove this once a deployment has been done on mainnet - function _reconfigureMainnetController() internal returns (MainnetController newController) { - newController = MainnetController(MainnetControllerDeploy.deployController({ - admin : admin, - almProxy : address(almProxy), - rateLimits : address(rateLimits), - vault : address(vault), - psm : inputMainnet.readAddress(".psm"), - daiUsds : inputMainnet.readAddress(".daiUsds"), - cctp : inputMainnet.readAddress(".cctpTokenMessenger") - })); - - vm.startPrank(admin); - - newController.grantRole(newController.FREEZER(), inputMainnet.readAddress(".freezer")); - newController.grantRole(newController.RELAYER(), inputMainnet.readAddress(".relayer")); - - almProxy.grantRole(almProxy.CONTROLLER(), address(newController)); - rateLimits.grantRole(rateLimits.CONTROLLER(), address(newController)); - - almProxy.revokeRole(almProxy.CONTROLLER(), outputMainnet.readAddress(".controller")); - rateLimits.revokeRole(rateLimits.CONTROLLER(), outputMainnet.readAddress(".controller")); - - newController.setMintRecipient( - CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - bytes32(uint256(uint160(address(outputBase.readAddress(".almProxy"))))) - ); - - // Set all rate limits - - bytes32[] memory rateLimitKeys = new bytes32[](10); - - rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDS); - rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_DEPOSIT(), AUSDC); - rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDS); - rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_DEPOSIT(), Ethereum.SUSDE); - rateLimitKeys[4] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDS); - rateLimitKeys[5] = RateLimitHelpers.makeAssetKey(newController.LIMIT_AAVE_WITHDRAW(), AUSDC); - rateLimitKeys[6] = RateLimitHelpers.makeAssetKey(newController.LIMIT_4626_WITHDRAW(), Ethereum.SUSDS); - rateLimitKeys[7] = newController.LIMIT_USDE_MINT(); - rateLimitKeys[8] = newController.LIMIT_USDE_BURN(); - rateLimitKeys[9] = newController.LIMIT_SUSDE_COOLDOWN(); - - for (uint256 i; i < rateLimitKeys.length; i++) { - rateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); - } - - vm.stopPrank(); - } } contract MainnetStagingDeploymentTests is StagingDeploymentTestBase { @@ -307,15 +258,15 @@ contract MainnetStagingDeploymentTests is StagingDeploymentTestBase { vm.startPrank(relayerSafe); mainnetController.depositERC4626(Ethereum.SUSDE, 10e18); skip(1 days); - mainnetController.cooldownAssetsSUSDe(10e18); + mainnetController.cooldownAssetsSUSDe(10e18 - 1); // Rounding skip(7 days); mainnetController.unstakeSUSDe(); - mainnetController.prepareUSDeBurn(10e18); + mainnetController.prepareUSDeBurn(10e18 - 1); vm.stopPrank(); - _simulateUsdeBurn(10e18); + _simulateUsdeBurn(10e18 - 1); - assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); + assertEq(usdc.balanceOf(address(almProxy)), startingBalance + 10e6 - 1); // Rounding not captured assertGe(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); // Interest earned } @@ -342,7 +293,7 @@ contract MainnetStagingDeploymentTests is StagingDeploymentTestBase { _simulateUsdeBurn(usdeAmount); - assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6); // Interest earned + assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6 - 1); // Interest earned (roundign) assertEq(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); } @@ -389,21 +340,6 @@ contract BaseStagingDeploymentTests is StagingDeploymentTestBase { super.setUp(); base.selectFork(); - - bytes32[] memory rateLimitKeys = new bytes32[](4); - - rateLimitKeys[0] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_DEPOSIT(), AUSDC_BASE); - rateLimitKeys[1] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_DEPOSIT(), MORPHO_VAULT_USDC); - rateLimitKeys[2] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_AAVE_WITHDRAW(), AUSDC_BASE); - rateLimitKeys[3] = RateLimitHelpers.makeAssetKey(baseController.LIMIT_4626_WITHDRAW(), MORPHO_VAULT_USDC); - - vm.startPrank(admin); - - for (uint256 i; i < rateLimitKeys.length; i++) { - baseRateLimits.setUnlimitedRateLimitData(rateLimitKeys[i]); - } - - vm.stopPrank(); } function test_transferCCTP() public { diff --git a/test/base-fork/DeployAndInit.t.sol b/test/base-fork/DeployAndInit.t.sol index 03309ab..8fded8e 100644 --- a/test/base-fork/DeployAndInit.t.sol +++ b/test/base-fork/DeployAndInit.t.sol @@ -94,7 +94,7 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU oldController = address(foreignController); // Cache for later testing - // Deploy new controller against live mainnet system + // Deploy new controller against existing system // NOTE: initAlmSystem will redundantly call rely and approve on already inited // almProxy and rateLimits, this setup was chosen to easily test upgrade and init failures foreignController = ForeignController(ForeignControllerDeploy.deployController({ @@ -134,11 +134,8 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU /**********************************************************************************************/ function test_initAlmSystem_upgradeController_incorrectAdminAlmProxy() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(Base.SPARK_EXECUTOR); - almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + vm.prank(Base.SPARK_EXECUTOR); almProxy.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); - vm.stopPrank(); vm.expectRevert("ForeignControllerInit/incorrect-admin-almProxy"); wrapper.initAlmSystem( @@ -150,11 +147,8 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU } function test_initAlmSystem_upgradeController_incorrectAdminRateLimits() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(Base.SPARK_EXECUTOR); - rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + vm.prank(Base.SPARK_EXECUTOR); rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); - vm.stopPrank(); vm.expectRevert("ForeignControllerInit/incorrect-admin-rateLimits"); wrapper.initAlmSystem( @@ -166,11 +160,8 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU } function test_initAlmSystem_upgradeController_incorrectAdminController() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(Base.SPARK_EXECUTOR); - foreignController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + vm.prank(Base.SPARK_EXECUTOR); foreignController.revokeRole(DEFAULT_ADMIN_ROLE, Base.SPARK_EXECUTOR); - vm.stopPrank(); _checkInitAndUpgradeFail(abi.encodePacked("ForeignControllerInit/incorrect-admin-controller")); } @@ -299,7 +290,7 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU deal(address(wrongUsds), address(this), 1e18); // For seeding PSM during deployment - // Deploy a new PSM with the wrong USDC + // Deploy a new PSM with the wrong USDS psmBase = IPSM3(PSM3Deploy.deploy( SPARK_EXECUTOR, USDC_BASE, address(wrongUsds), address(susdsBase), SSR_ORACLE )); @@ -322,7 +313,7 @@ contract ForeignControllerInitAndUpgradeFailureTest is ForeignControllerInitAndU deal(address(usdsBase), address(this), 1e18); // For seeding PSM during deployment - // Deploy a new PSM with the wrong USDC + // Deploy a new PSM with the wrong SUSDS psmBase = IPSM3(PSM3Deploy.deploy( SPARK_EXECUTOR, USDC_BASE, address(usdsBase), address(wrongSUsds), SSR_ORACLE )); @@ -605,4 +596,4 @@ contract ForeignControllerUpgradeControllerSuccessTests is ForeignControllerInit ); } -} \ No newline at end of file +} diff --git a/test/mainnet-fork/DeployAndInit.t.sol b/test/mainnet-fork/DeployAndInit.t.sol index a478778..fa66b79 100644 --- a/test/mainnet-fork/DeployAndInit.t.sol +++ b/test/mainnet-fork/DeployAndInit.t.sol @@ -144,11 +144,8 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU /**********************************************************************************************/ function test_initAlmSystem_incorrectAdminAlmProxy() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_PROXY); - almProxy.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + vm.prank(SPARK_PROXY); almProxy.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); - vm.stopPrank(); vm.expectRevert("MainnetControllerInit/incorrect-admin-almProxy"); wrapper.initAlmSystem( @@ -162,11 +159,8 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU } function test_initAlmSystem_incorrectAdminRateLimits() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_PROXY); - rateLimits.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + vm.prank(SPARK_PROXY); rateLimits.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); - vm.stopPrank(); vm.expectRevert("MainnetControllerInit/incorrect-admin-rateLimits"); wrapper.initAlmSystem( @@ -180,11 +174,8 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU } function test_initAlmSystem_upgradeController_incorrectAdminController() external { - // Isolate different contracts instead of setting param so can get three different failures - vm.startPrank(SPARK_PROXY); - mainnetController.grantRole(DEFAULT_ADMIN_ROLE, mismatchAddress); + vm.prank(SPARK_PROXY); mainnetController.revokeRole(DEFAULT_ADMIN_ROLE, SPARK_PROXY); - vm.stopPrank(); _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/incorrect-admin-controller")); } @@ -244,20 +235,6 @@ contract MainnetControllerInitAndUpgradeFailureTest is MainnetControllerInitAndU _checkInitAndUpgradeFail(abi.encodePacked("MainnetControllerInit/old-controller-is-new-controller")); } - function test_initAlmSystem_upgradeController_vaultMismatch() external { - vault = mismatchAddress; - - vm.expectRevert("MainnetControllerInit/incorrect-vault"); - wrapper.initAlmSystem( - vault, - address(usds), - controllerInst, - configAddresses, - checkAddresses, - mintRecipients - ); - } - /**********************************************************************************************/ /*** Upgrade tests ***/ /**********************************************************************************************/ From 6740eee03cf43f3695aaad6e53167194fc28b09f Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 27 Dec 2024 11:24:42 -0500 Subject: [PATCH 28/33] fix: update makefile --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index ddca5dc..9f1b5c4 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ # Staging Full Deployment with Dependencies -deploy-staging-full :; forge script script/staging/FullStagingDeploy.s.sol:FullStagingDeploy --sender ${ETH_FROM} --broadcast --private-key 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 +deploy-staging-full :; forge script script/staging/FullStagingDeploy.s.sol:FullStagingDeploy --sender ${ETH_FROM} --broadcast --verify # Staging Deployments deploy-mainnet-staging-controller :; ENV=staging forge script script/Deploy.s.sol:DeployMainnetController --sender ${ETH_FROM} --broadcast --verify From 7caaef3db2998b8be30c6040a545d4148f3d8961 Mon Sep 17 00:00:00 2001 From: Sam MacPherson Date: Fri, 27 Dec 2024 14:47:21 -0700 Subject: [PATCH 29/33] add new staging deploy --- .../1/base-staging-deps-release-20241227.json | 5 +++++ .../1/base-staging-release-20241227.json | 5 +++++ ...mainnet-staging-deps-release-20241227.json | 19 +++++++++++++++++++ .../1/mainnet-staging-release-20241227.json | 5 +++++ 4 files changed, 34 insertions(+) create mode 100644 script/output/1/base-staging-deps-release-20241227.json create mode 100644 script/output/1/base-staging-release-20241227.json create mode 100644 script/output/1/mainnet-staging-deps-release-20241227.json create mode 100644 script/output/1/mainnet-staging-release-20241227.json diff --git a/script/output/1/base-staging-deps-release-20241227.json b/script/output/1/base-staging-deps-release-20241227.json new file mode 100644 index 0000000..509fb81 --- /dev/null +++ b/script/output/1/base-staging-deps-release-20241227.json @@ -0,0 +1,5 @@ +{ + "admin": "0xd1236a6A111879d9862f8374BA15344b6B233Fbd", + "freezer": "0xaB959A6F88b8D966c44a7cDC2049Ba9669EBf047", + "relayer": "0xaB959A6F88b8D966c44a7cDC2049Ba9669EBf047" +} \ No newline at end of file diff --git a/script/output/1/base-staging-release-20241227.json b/script/output/1/base-staging-release-20241227.json new file mode 100644 index 0000000..5e80911 --- /dev/null +++ b/script/output/1/base-staging-release-20241227.json @@ -0,0 +1,5 @@ +{ + "almProxy": "0xa72e01A942f5E8EF09dbaf824C2d7a7033e96f0D", + "controller": "0xf1202d64010a7b644AB258ca46Ad5fDf2148905a", + "rateLimits": "0x1d741314F73Aea8A133C5c71653F779150f9c229" +} \ No newline at end of file diff --git a/script/output/1/mainnet-staging-deps-release-20241227.json b/script/output/1/mainnet-staging-deps-release-20241227.json new file mode 100644 index 0000000..e47d086 --- /dev/null +++ b/script/output/1/mainnet-staging-deps-release-20241227.json @@ -0,0 +1,19 @@ +{ + "admin": "0xd1236a6A111879d9862f8374BA15344b6B233Fbd", + "allocatorBuffer": "0x21fd5b6f0FbF7300a23F9cC397630A27Ee013AE5", + "allocatorOracle": "0xDf9EE9Ad3cB7ec26F98103751F7Fb7149a284541", + "allocatorRegistry": "0x2143B2949bc3B9b405cFebb065aB6beF4DB85956", + "allocatorRoles": "0x041918Ef264214BD999776667a693b06B35c36Fa", + "allocatorVault": "0x85cb1558802D32D437B63d7C3eB4e6d6c88a383B", + "dai": "0x6B175474E89094C44Da98b954EedeAC495271d0F", + "daiUsds": "0x3225737a9Bbb6473CB4a45b7244ACa2BeFdB276A", + "freezer": "0x611C7c37F296240c2fF5a92f0B4a398B01B237c4", + "jug": "0x6C20DC38D8e978955B12217D82692d448239C005", + "psm": "0x66c044CeE6bdf8360C2F6eDffc712829900100fB", + "relayer": "0x611C7c37F296240c2fF5a92f0B4a398B01B237c4", + "susds": "0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD", + "usdc": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "usds": "0xdC035D45d973E3EC169d2276DDab16f1e407384F", + "usdsJoin": "0x12CBa9C1e5CC66926d1364B63e62cF16830bF977", + "vat": "0x2157802ce1172b7bae5540b0d20d8B4337B535C2" +} \ No newline at end of file diff --git a/script/output/1/mainnet-staging-release-20241227.json b/script/output/1/mainnet-staging-release-20241227.json new file mode 100644 index 0000000..d3d4f26 --- /dev/null +++ b/script/output/1/mainnet-staging-release-20241227.json @@ -0,0 +1,5 @@ +{ + "almProxy": "0xba8b8375Af6bB5B7e0424D8581b82fe39CfCff8A", + "controller": "0xe08828c1A20dA7874A52dA070480B9B1e4213B6C", + "rateLimits": "0x2A85Ce4869e8fCFbb84b39485eB082F96d8f1b5d" +} \ No newline at end of file From 7c785d45f7578015fbca3017ee8cb876413271af Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 27 Dec 2024 17:22:02 -0500 Subject: [PATCH 30/33] test: update staging date --- script/staging/test/StagingDeployment.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/script/staging/test/StagingDeployment.t.sol b/script/staging/test/StagingDeployment.t.sol index 62c2866..2540205 100644 --- a/script/staging/test/StagingDeployment.t.sol +++ b/script/staging/test/StagingDeployment.t.sol @@ -56,7 +56,7 @@ contract StagingDeploymentTestBase is Test { bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; - uint256 constant RELEASE_DATE = 20241210; + uint256 constant RELEASE_DATE = 20241227; // Common variables address admin; From 875af6af48624a0f0d783019e3db860139111fd7 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 27 Dec 2024 17:43:06 -0500 Subject: [PATCH 31/33] fix: review comments --- .../1/base-staging-deps-release-20241227.json | 2 +- .../1/base-staging-release-20241227.json | 2 +- ...mainnet-staging-deps-release-20241227.json | 2 +- .../1/mainnet-staging-release-20241227.json | 2 +- script/staging/FullStagingDeploy.s.sol | 57 ++++++++----------- script/staging/test/StagingDeployment.t.sol | 2 +- src/RateLimitHelpers.sol | 6 +- 7 files changed, 33 insertions(+), 40 deletions(-) diff --git a/script/output/1/base-staging-deps-release-20241227.json b/script/output/1/base-staging-deps-release-20241227.json index 509fb81..d80ca76 100644 --- a/script/output/1/base-staging-deps-release-20241227.json +++ b/script/output/1/base-staging-deps-release-20241227.json @@ -2,4 +2,4 @@ "admin": "0xd1236a6A111879d9862f8374BA15344b6B233Fbd", "freezer": "0xaB959A6F88b8D966c44a7cDC2049Ba9669EBf047", "relayer": "0xaB959A6F88b8D966c44a7cDC2049Ba9669EBf047" -} \ No newline at end of file +} diff --git a/script/output/1/base-staging-release-20241227.json b/script/output/1/base-staging-release-20241227.json index 5e80911..b171750 100644 --- a/script/output/1/base-staging-release-20241227.json +++ b/script/output/1/base-staging-release-20241227.json @@ -2,4 +2,4 @@ "almProxy": "0xa72e01A942f5E8EF09dbaf824C2d7a7033e96f0D", "controller": "0xf1202d64010a7b644AB258ca46Ad5fDf2148905a", "rateLimits": "0x1d741314F73Aea8A133C5c71653F779150f9c229" -} \ No newline at end of file +} diff --git a/script/output/1/mainnet-staging-deps-release-20241227.json b/script/output/1/mainnet-staging-deps-release-20241227.json index e47d086..cb2dbc8 100644 --- a/script/output/1/mainnet-staging-deps-release-20241227.json +++ b/script/output/1/mainnet-staging-deps-release-20241227.json @@ -16,4 +16,4 @@ "usds": "0xdC035D45d973E3EC169d2276DDab16f1e407384F", "usdsJoin": "0x12CBa9C1e5CC66926d1364B63e62cF16830bF977", "vat": "0x2157802ce1172b7bae5540b0d20d8B4337B535C2" -} \ No newline at end of file +} diff --git a/script/output/1/mainnet-staging-release-20241227.json b/script/output/1/mainnet-staging-release-20241227.json index d3d4f26..9f56b33 100644 --- a/script/output/1/mainnet-staging-release-20241227.json +++ b/script/output/1/mainnet-staging-release-20241227.json @@ -2,4 +2,4 @@ "almProxy": "0xba8b8375Af6bB5B7e0424D8581b82fe39CfCff8A", "controller": "0xe08828c1A20dA7874A52dA070480B9B1e4213B6C", "rateLimits": "0x2A85Ce4869e8fCFbb84b39485eB082F96d8f1b5d" -} \ No newline at end of file +} diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 74fe9eb..857137b 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -260,12 +260,7 @@ contract FullStagingDeploy is Script { cctp : mainnet.config.readAddress(".cctpTokenMessenger") }); - MainnetControllerInit.MintRecipient[] memory mintRecipients = new MainnetControllerInit.MintRecipient[](1); - - mintRecipients[0] = MainnetControllerInit.MintRecipient({ - domain : CCTPForwarder.DOMAIN_ID_CIRCLE_BASE, - mintRecipient : bytes32(uint256(uint160(makeAddr("baseAlmProxy")))) - }); + MainnetControllerInit.MintRecipient[] memory mintRecipients = new MainnetControllerInit.MintRecipient[](0); MainnetControllerInit.initAlmSystem( vault, @@ -296,7 +291,6 @@ contract FullStagingDeploy is Script { ScriptTools.exportContract(mainnet.name, "rateLimits", controllerInst.rateLimits); } - // TODO: Remove function _setMainnetControllerRateLimits(address rateLimits) internal { // Still constrained by the USDC_UNIT_SIZE RateLimitData memory rateLimitData18 = RateLimitData({ @@ -307,10 +301,6 @@ contract FullStagingDeploy is Script { maxAmount : USDC_UNIT_SIZE * 5, slope : USDC_UNIT_SIZE / 4 hours }); - RateLimitData memory unlimitedRateLimit = RateLimitData({ - maxAmount : type(uint256).max, - slope : 0 - }); MainnetController mainnetController_ = MainnetController(mainnetController); @@ -319,32 +309,32 @@ contract FullStagingDeploy is Script { bytes32 ausdsDepositKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_AAVE_DEPOSIT(), AUSDS); bytes32 ausdsWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_AAVE_WITHDRAW(), AUSDS); bytes32 susdeDepositKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_4626_DEPOSIT(), address(mainnetController_.susde())); - bytes32 susdeWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_4626_WITHDRAW(), address(mainnetController_.susde())); bytes32 susdsDepositKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_4626_DEPOSIT(), susds); bytes32 susdsWithdrawKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_4626_WITHDRAW(), susds); bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey(mainnetController_.LIMIT_USDC_TO_DOMAIN(), CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); // USDS mint/burn and cross-chain transfer rate limits - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), rateLimits, rateLimitData18, "usdsMintData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), rateLimits, rateLimitData6, "usdsToUsdcData", 6); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), rateLimits, unlimitedRateLimit, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), rateLimits, rateLimitData18, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), rateLimits, rateLimitData6, "usdsToUsdcData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); // Ethena-specific rate limits - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_MINT(), rateLimits, rateLimitData6, "usdeMintData", 6); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_BURN(), rateLimits, rateLimitData18, "usdeBurnData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_SUSDE_COOLDOWN(), rateLimits, unlimitedRateLimit, "susdeCooldownData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_MINT(), rateLimits, rateLimitData6, "usdeMintData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_BURN(), rateLimits, rateLimitData18, "usdeBurnData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_SUSDE_COOLDOWN(), rateLimits, rateLimitData18, "susdeCooldownData", 18); // 4626 and AAVE deposit/withdraw rate limits - RateLimitHelpers.setRateLimitData(ausdcDepositKey, rateLimits, rateLimitData6, "ausdcDepositData", 6); - RateLimitHelpers.setRateLimitData(ausdcWithdrawKey, rateLimits, rateLimitData6, "ausdcWithdrawData", 6); - RateLimitHelpers.setRateLimitData(ausdsDepositKey, rateLimits, rateLimitData6, "ausdsDepositData", 18); - RateLimitHelpers.setRateLimitData(ausdsWithdrawKey, rateLimits, rateLimitData6, "ausdsWithdrawData", 18); - RateLimitHelpers.setRateLimitData(susdeDepositKey, rateLimits, rateLimitData18, "susdeDepositData", 18); - RateLimitHelpers.setRateLimitData(susdeWithdrawKey, rateLimits, rateLimitData18, "susdeWithdrawData", 18); - RateLimitHelpers.setRateLimitData(susdsDepositKey, rateLimits, rateLimitData18, "susdsDepositData", 18); - RateLimitHelpers.setRateLimitData(susdsWithdrawKey, rateLimits, rateLimitData18, "susdsWithdrawData", 18); + RateLimitHelpers.setRateLimitData(ausdcDepositKey, rateLimits, rateLimitData6, "ausdcDepositData", 18); + RateLimitHelpers.setRateLimitData(ausdsDepositKey, rateLimits, rateLimitData6, "ausdsDepositData", 18); + RateLimitHelpers.setRateLimitData(susdeDepositKey, rateLimits, rateLimitData18, "susdeDepositData", 18); + + // Unlimited rate limits + IRateLimits(rateLimits).setUnlimitedRateLimitData(ausdcWithdrawKey); + IRateLimits(rateLimits).setUnlimitedRateLimitData(ausdsWithdrawKey); + IRateLimits(rateLimits).setUnlimitedRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP()); + IRateLimits(rateLimits).setUnlimitedRateLimitData(susdsDepositKey); + IRateLimits(rateLimits).setUnlimitedRateLimitData(susdsWithdrawKey); } function _setBaseControllerRateLimits(address rateLimits) internal { @@ -388,15 +378,18 @@ contract FullStagingDeploy is Script { RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmWithdrawKey, susds), rateLimits, unlimitedRateLimit, "susdsWithdrawDataPsm", 18); // CCTP rate limits - RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits, rateLimitData6, "usdcToCctpData", 6); - RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); // AAVE rate limits RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(aaveDepositKey, AUSDC_BASE), rateLimits, rateLimitData6, "usdcDepositDataAave", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(aaveWithdrawKey, AUSDC_BASE), rateLimits, rateLimitData6, "usdcWithdrawDataAave", 6); - + + // Morpho rate limits RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(vaultDepositKey, MORPHO_VAULT_USDC_BASE), rateLimits, rateLimitData6, "usdsDepositDataMorpho", 6); - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(vaultWithdrawKey, MORPHO_VAULT_USDC_BASE), rateLimits, rateLimitData6, "usdsDepositDataMorpho", 6); + + // Unlimited rate limits + IRateLimits(rateLimits).setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); + IRateLimits(rateLimits).setUnlimitedRateLimitData(RateLimitHelpers.makeAssetKey(aaveWithdrawKey, AUSDC_BASE)); + IRateLimits(rateLimits).setUnlimitedRateLimitData(RateLimitHelpers.makeAssetKey(vaultWithdrawKey, MORPHO_VAULT_USDC_BASE)); } function _setUpBaseALMController() internal { diff --git a/script/staging/test/StagingDeployment.t.sol b/script/staging/test/StagingDeployment.t.sol index 2540205..973b678 100644 --- a/script/staging/test/StagingDeployment.t.sol +++ b/script/staging/test/StagingDeployment.t.sol @@ -293,7 +293,7 @@ contract MainnetStagingDeploymentTests is StagingDeploymentTestBase { _simulateUsdeBurn(usdeAmount); - assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6 - 1); // Interest earned (roundign) + assertGe(usdc.balanceOf(address(almProxy)), startingBalance + 10e6 - 1); // Interest earned (rounding) assertEq(IERC4626(Ethereum.SUSDE).balanceOf(address(almProxy)), 0); } diff --git a/src/RateLimitHelpers.sol b/src/RateLimitHelpers.sol index f1ff58d..8749558 100644 --- a/src/RateLimitHelpers.sol +++ b/src/RateLimitHelpers.sol @@ -31,17 +31,17 @@ library RateLimitHelpers { if (data.maxAmount == type(uint256).max) { require( data.slope == 0, - string(abi.encodePacked("MainnetControllerInit/invalid-rate-limit-", name)) + string(abi.encodePacked("RateLimitHelpers/invalid-rate-limit-", name)) ); } else { require( data.maxAmount <= 1e12 * (10 ** decimals), - string(abi.encodePacked("MainnetControllerInit/invalid-max-amount-precision-", name)) + string(abi.encodePacked("RateLimitHelpers/invalid-max-amount-precision-", name)) ); require( data.slope <= 1e12 * (10 ** decimals) / 1 hours, - string(abi.encodePacked("MainnetControllerInit/invalid-slope-precision-", name)) + string(abi.encodePacked("RateLimitHelpers/invalid-slope-precision-", name)) ); } IRateLimits(rateLimits).setRateLimitData(key, data.maxAmount, data.slope); From 20b48e045c9af589183d1b944a2bb4b22b2e788a Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 27 Dec 2024 22:03:36 -0500 Subject: [PATCH 32/33] fix: update with fixes --- script/staging/FullStagingDeploy.s.sol | 49 ++++++++++++-------------- src/RateLimitHelpers.sol | 7 ++++ 2 files changed, 29 insertions(+), 27 deletions(-) diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 857137b..5191dd2 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -302,6 +302,8 @@ contract FullStagingDeploy is Script { slope : USDC_UNIT_SIZE / 4 hours }); + RateLimitData memory unlimitedRateLimit = RateLimitHelpers.unlimitedRateLimit(); + MainnetController mainnetController_ = MainnetController(mainnetController); bytes32 ausdcDepositKey = RateLimitHelpers.makeAssetKey(mainnetController_.LIMIT_AAVE_DEPOSIT(), AUSDC); @@ -315,26 +317,24 @@ contract FullStagingDeploy is Script { bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey(mainnetController_.LIMIT_USDC_TO_DOMAIN(), CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); // USDS mint/burn and cross-chain transfer rate limits - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), rateLimits, rateLimitData18, "usdsMintData", 18); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), rateLimits, rateLimitData6, "usdsToUsdcData", 6); - RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(domainKeyBase, rateLimits, rateLimitData6, "cctpToBaseDomainData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), rateLimits, unlimitedRateLimit, "usdsToCctpData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_MINT(), rateLimits, rateLimitData18, "usdsMintData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDS_TO_USDC(), rateLimits, rateLimitData6, "usdsToUsdcData", 6); // Ethena-specific rate limits - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_MINT(), rateLimits, rateLimitData6, "usdeMintData", 6); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_BURN(), rateLimits, rateLimitData18, "usdeBurnData", 18); RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_SUSDE_COOLDOWN(), rateLimits, rateLimitData18, "susdeCooldownData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_BURN(), rateLimits, rateLimitData18, "usdeBurnData", 18); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDE_MINT(), rateLimits, rateLimitData6, "usdeMintData", 6); // 4626 and AAVE deposit/withdraw rate limits - RateLimitHelpers.setRateLimitData(ausdcDepositKey, rateLimits, rateLimitData6, "ausdcDepositData", 18); - RateLimitHelpers.setRateLimitData(ausdsDepositKey, rateLimits, rateLimitData6, "ausdsDepositData", 18); - RateLimitHelpers.setRateLimitData(susdeDepositKey, rateLimits, rateLimitData18, "susdeDepositData", 18); - - // Unlimited rate limits - IRateLimits(rateLimits).setUnlimitedRateLimitData(ausdcWithdrawKey); - IRateLimits(rateLimits).setUnlimitedRateLimitData(ausdsWithdrawKey); - IRateLimits(rateLimits).setUnlimitedRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP()); - IRateLimits(rateLimits).setUnlimitedRateLimitData(susdsDepositKey); - IRateLimits(rateLimits).setUnlimitedRateLimitData(susdsWithdrawKey); + RateLimitHelpers.setRateLimitData(ausdcDepositKey, rateLimits, rateLimitData6, "ausdcDepositData", 6); + RateLimitHelpers.setRateLimitData(ausdcWithdrawKey, rateLimits, unlimitedRateLimit, "ausdcWithdrawData", 6); + RateLimitHelpers.setRateLimitData(ausdsDepositKey, rateLimits, rateLimitData18, "ausdsDepositData", 18); + RateLimitHelpers.setRateLimitData(ausdsWithdrawKey, rateLimits, unlimitedRateLimit, "ausdcWithdrawData", 18); + RateLimitHelpers.setRateLimitData(susdeDepositKey, rateLimits, rateLimitData18, "susdeDepositData", 18); + RateLimitHelpers.setRateLimitData(susdsDepositKey, rateLimits, unlimitedRateLimit, "susdsDepositData", 18); + RateLimitHelpers.setRateLimitData(susdsWithdrawKey, rateLimits, unlimitedRateLimit, "susdsWithdrawData", 18); } function _setBaseControllerRateLimits(address rateLimits) internal { @@ -346,10 +346,7 @@ contract FullStagingDeploy is Script { maxAmount : USDC_UNIT_SIZE * 5, slope : USDC_UNIT_SIZE / 4 hours }); - RateLimitData memory unlimitedRateLimit = RateLimitData({ - maxAmount : type(uint256).max, - slope : 0 - }); + RateLimitData memory unlimitedRateLimit = RateLimitHelpers.unlimitedRateLimit(); ForeignController foreignController = ForeignController(baseController); @@ -378,18 +375,16 @@ contract FullStagingDeploy is Script { RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmWithdrawKey, susds), rateLimits, unlimitedRateLimit, "susdsWithdrawDataPsm", 18); // CCTP rate limits - RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); + RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), rateLimits, unlimitedRateLimit, "usdsToCctpData", 6); // AAVE rate limits - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(aaveDepositKey, AUSDC_BASE), rateLimits, rateLimitData6, "usdcDepositDataAave", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(aaveDepositKey, AUSDC_BASE), rateLimits, rateLimitData6, "usdcDepositDataAave", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(aaveWithdrawKey, AUSDC_BASE), rateLimits, unlimitedRateLimit, "usdcWithdrawDataAave", 6); // Morpho rate limits - RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(vaultDepositKey, MORPHO_VAULT_USDC_BASE), rateLimits, rateLimitData6, "usdsDepositDataMorpho", 6); - - // Unlimited rate limits - IRateLimits(rateLimits).setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); - IRateLimits(rateLimits).setUnlimitedRateLimitData(RateLimitHelpers.makeAssetKey(aaveWithdrawKey, AUSDC_BASE)); - IRateLimits(rateLimits).setUnlimitedRateLimitData(RateLimitHelpers.makeAssetKey(vaultWithdrawKey, MORPHO_VAULT_USDC_BASE)); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(vaultDepositKey, MORPHO_VAULT_USDC_BASE), rateLimits, rateLimitData6, "usdsDepositDataMorpho", 6); + RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(vaultWithdrawKey, MORPHO_VAULT_USDC_BASE), rateLimits, unlimitedRateLimit, "usdsWithdrawDataMorpho", 6); } function _setUpBaseALMController() internal { diff --git a/src/RateLimitHelpers.sol b/src/RateLimitHelpers.sol index 8749558..9e66d84 100644 --- a/src/RateLimitHelpers.sol +++ b/src/RateLimitHelpers.sol @@ -18,6 +18,13 @@ library RateLimitHelpers { return keccak256(abi.encode(key, domain)); } + function unlimitedRateLimit() internal pure returns (RateLimitData memory) { + return RateLimitData({ + maxAmount : type(uint256).max, + slope : 0 + }); + } + function setRateLimitData( bytes32 key, address rateLimits, From 133bed2e119ef43b802f139b15b7649695d97af5 Mon Sep 17 00:00:00 2001 From: Lucas Manuel Date: Fri, 27 Dec 2024 22:10:13 -0500 Subject: [PATCH 33/33] fix: compilation issue --- script/staging/FullStagingDeploy.s.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/script/staging/FullStagingDeploy.s.sol b/script/staging/FullStagingDeploy.s.sol index 5191dd2..57202d5 100644 --- a/script/staging/FullStagingDeploy.s.sol +++ b/script/staging/FullStagingDeploy.s.sol @@ -375,8 +375,8 @@ contract FullStagingDeploy is Script { RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(psmWithdrawKey, susds), rateLimits, unlimitedRateLimit, "susdsWithdrawDataPsm", 18); // CCTP rate limits - RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); - RateLimitHelpers.setRateLimitData(mainnetController_.LIMIT_USDC_TO_CCTP(), rateLimits, unlimitedRateLimit, "usdsToCctpData", 6); + RateLimitHelpers.setRateLimitData(domainKeyEthereum, rateLimits, rateLimitData6, "cctpToEthereumDomainData", 6); + RateLimitHelpers.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), rateLimits, unlimitedRateLimit, "usdsToCctpData", 6); // AAVE rate limits RateLimitHelpers.setRateLimitData(RateLimitHelpers.makeAssetKey(aaveDepositKey, AUSDC_BASE), rateLimits, rateLimitData6, "usdcDepositDataAave", 6);