diff --git a/src/ALMProxy.sol b/src/ALMProxy.sol index 1ca839da..d04de638 100644 --- a/src/ALMProxy.sol +++ b/src/ALMProxy.sol @@ -30,9 +30,9 @@ contract ALMProxy is IALMProxy, AccessControl { /**********************************************************************************************/ function doCall(address target, bytes memory data) - external payable override onlyRole(CONTROLLER) returns (bytes memory result) + external override onlyRole(CONTROLLER) returns (bytes memory result) { - result = target.functionCallWithValue(data, msg.value); + result = target.functionCall(data); } function doCallWithValue(address target, bytes memory data, uint256 value) @@ -42,7 +42,7 @@ contract ALMProxy is IALMProxy, AccessControl { } function doDelegateCall(address target, bytes memory data) - external payable override onlyRole(CONTROLLER) returns (bytes memory result) + external override onlyRole(CONTROLLER) returns (bytes memory result) { result = target.functionDelegateCall(data); } diff --git a/src/ForeignController.sol b/src/ForeignController.sol index 3b486118..f63bcce0 100644 --- a/src/ForeignController.sol +++ b/src/ForeignController.sol @@ -34,18 +34,17 @@ contract ForeignController is AccessControl { bytes32 public constant FREEZER = keccak256("FREEZER"); bytes32 public constant RELAYER = keccak256("RELAYER"); - bytes32 public constant LIMIT_PSM_DEPOSIT = keccak256("LIMIT_PSM_DEPOSIT"); - bytes32 public constant LIMIT_PSM_WITHDRAW = keccak256("LIMIT_PSM_WITHDRAW"); - bytes32 public constant LIMIT_USDC_TO_CCTP = keccak256("LIMIT_USDC_TO_CCTP"); + bytes32 public constant LIMIT_PSM_DEPOSIT = keccak256("LIMIT_PSM_DEPOSIT"); + bytes32 public constant LIMIT_PSM_WITHDRAW = keccak256("LIMIT_PSM_WITHDRAW"); + bytes32 public constant LIMIT_USDC_TO_CCTP = keccak256("LIMIT_USDC_TO_CCTP"); + bytes32 public constant LIMIT_USDC_TO_DOMAIN = keccak256("LIMIT_USDC_TO_DOMAIN"); IALMProxy public immutable proxy; ICCTPLike public immutable cctp; IPSM3 public immutable psm; IRateLimits public immutable rateLimits; - IERC20 public immutable usds; IERC20 public immutable usdc; - IERC20 public immutable susds; bool public active; @@ -60,9 +59,7 @@ contract ForeignController is AccessControl { address proxy_, address rateLimits_, address psm_, - address usds_, address usdc_, - address susds_, address cctp_ ) { _grantRole(DEFAULT_ADMIN_ROLE, admin_); @@ -70,12 +67,8 @@ contract ForeignController is AccessControl { proxy = IALMProxy(proxy_); rateLimits = IRateLimits(rateLimits_); psm = IPSM3(psm_); - - usds = IERC20(usds_); - usdc = IERC20(usdc_); - susds = IERC20(susds_); - - cctp = ICCTPLike(cctp_); + usdc = IERC20(usdc_); + cctp = ICCTPLike(cctp_); active = true; } @@ -179,7 +172,14 @@ contract ForeignController is AccessControl { /**********************************************************************************************/ function transferUSDCToCCTP(uint256 usdcAmount, uint32 destinationDomain) - external onlyRole(RELAYER) isActive rateLimited(LIMIT_USDC_TO_CCTP, usdcAmount) + external + onlyRole(RELAYER) + isActive + rateLimited(LIMIT_USDC_TO_CCTP, usdcAmount) + rateLimited( + RateLimitHelpers.makeDomainKey(LIMIT_USDC_TO_DOMAIN, destinationDomain), + usdcAmount + ) { bytes32 mintRecipient = mintRecipients[destinationDomain]; diff --git a/src/MainnetController.sol b/src/MainnetController.sol index 6bb3e4d1..3e2f6d71 100644 --- a/src/MainnetController.sol +++ b/src/MainnetController.sol @@ -10,6 +10,8 @@ import { IALMProxy } from "src/interfaces/IALMProxy.sol"; import { ICCTPLike } from "src/interfaces/CCTPInterfaces.sol"; import { IRateLimits } from "src/interfaces/IRateLimits.sol"; +import { RateLimitHelpers } from "src/RateLimitHelpers.sol"; + interface IDaiUsdsLike { function dai() external view returns(address); function daiToUsds(address usr, uint256 wad) external; @@ -53,9 +55,10 @@ contract MainnetController is AccessControl { bytes32 public constant FREEZER = keccak256("FREEZER"); bytes32 public constant RELAYER = keccak256("RELAYER"); - bytes32 public constant LIMIT_USDC_TO_CCTP = keccak256("LIMIT_USDC_TO_CCTP"); - bytes32 public constant LIMIT_USDS_MINT = keccak256("LIMIT_USDS_MINT"); - bytes32 public constant LIMIT_USDS_TO_USDC = keccak256("LIMIT_USDS_TO_USDC"); + bytes32 public constant LIMIT_USDC_TO_CCTP = keccak256("LIMIT_USDC_TO_CCTP"); + bytes32 public constant LIMIT_USDC_TO_DOMAIN = keccak256("LIMIT_USDC_TO_DOMAIN"); + bytes32 public constant LIMIT_USDS_MINT = keccak256("LIMIT_USDS_MINT"); + bytes32 public constant LIMIT_USDS_TO_USDC = keccak256("LIMIT_USDS_TO_USDC"); address public immutable buffer; @@ -71,6 +74,8 @@ contract MainnetController is AccessControl { IERC20 public immutable usdc; ISUSDSLike public immutable susds; + uint256 public immutable psmTo18ConversionFactor; + bool public active; mapping(uint32 destinationDomain => bytes32 mintRecipient) public mintRecipients; @@ -105,6 +110,8 @@ contract MainnetController is AccessControl { usdc = IERC20(psm.gem()); usds = IERC20(susds.usds()); + psmTo18ConversionFactor = psm.to18ConversionFactor(); + active = true; } @@ -240,10 +247,12 @@ contract MainnetController is AccessControl { /*** Relayer PSM functions ***/ /**********************************************************************************************/ + // NOTE: The param `usdcAmount` is denominated in 1e6 precision to match how PSM uses + // USDC precision for both `buyGemNoFee` and `sellGemNoFee` function swapUSDSToUSDC(uint256 usdcAmount) external onlyRole(RELAYER) isActive rateLimited(LIMIT_USDS_TO_USDC, usdcAmount) { - uint256 usdsAmount = usdcAmount * psm.to18ConversionFactor(); + uint256 usdsAmount = usdcAmount * psmTo18ConversionFactor; // Approve USDS to DaiUsds migrator from the proxy (assumes the proxy has enough USDS) proxy.doCall( @@ -257,7 +266,7 @@ contract MainnetController is AccessControl { abi.encodeCall(daiUsds.usdsToDai, (address(proxy), usdsAmount)) ); - // Approve DAI to PSM from the proxy (assumes the proxy has enough DAI) + // Approve DAI to PSM from the proxy because conversion from USDS to DAI was 1:1 proxy.doCall( address(dai), abi.encodeCall(dai.approve, (address(psm), usdsAmount)) @@ -273,7 +282,7 @@ contract MainnetController is AccessControl { function swapUSDCToUSDS(uint256 usdcAmount) external onlyRole(RELAYER) isActive cancelRateLimit(LIMIT_USDS_TO_USDC, usdcAmount) { - uint256 usdsAmount = usdcAmount * psm.to18ConversionFactor(); + uint256 usdsAmount = usdcAmount * psmTo18ConversionFactor; // Approve USDC to PSM from the proxy (assumes the proxy has enough USDC) proxy.doCall( @@ -281,7 +290,7 @@ contract MainnetController is AccessControl { abi.encodeCall(usdc.approve, (address(psm), usdcAmount)) ); - // Swap USDC to DAI through the PSM + // Swap USDC to DAI through the PSM (1:1 since sellGemNoFee is used) proxy.doCall( address(psm), abi.encodeCall(psm.sellGemNoFee, (address(proxy), usdcAmount)) @@ -305,7 +314,14 @@ contract MainnetController is AccessControl { /**********************************************************************************************/ function transferUSDCToCCTP(uint256 usdcAmount, uint32 destinationDomain) - external onlyRole(RELAYER) isActive rateLimited(LIMIT_USDC_TO_CCTP, usdcAmount) + external + onlyRole(RELAYER) + isActive + rateLimited(LIMIT_USDC_TO_CCTP, usdcAmount) + rateLimited( + RateLimitHelpers.makeDomainKey(LIMIT_USDC_TO_DOMAIN, destinationDomain), + usdcAmount + ) { bytes32 mintRecipient = mintRecipients[destinationDomain]; diff --git a/src/RateLimitHelpers.sol b/src/RateLimitHelpers.sol index c795914a..873e54c3 100644 --- a/src/RateLimitHelpers.sol +++ b/src/RateLimitHelpers.sol @@ -7,4 +7,8 @@ library RateLimitHelpers { return keccak256(abi.encode(key, asset)); } + function makeDomainKey(bytes32 key, uint32 domain) internal pure returns (bytes32) { + return keccak256(abi.encode(key, domain)); + } + } diff --git a/src/RateLimits.sol b/src/RateLimits.sol index a2c6b615..7d6ba72c 100644 --- a/src/RateLimits.sol +++ b/src/RateLimits.sol @@ -49,7 +49,7 @@ contract RateLimits is IRateLimits, AccessControl { emit RateLimitDataSet(key, maxAmount, slope, lastAmount, lastUpdated); } - function setRateLimitData(bytes32 key,uint256 maxAmount,uint256 slope) external override { + function setRateLimitData(bytes32 key, uint256 maxAmount, uint256 slope) external override { setRateLimitData(key, maxAmount, slope, maxAmount, block.timestamp); } diff --git a/src/interfaces/IALMProxy.sol b/src/interfaces/IALMProxy.sol index aa3d95cc..49c77186 100644 --- a/src/interfaces/IALMProxy.sol +++ b/src/interfaces/IALMProxy.sol @@ -4,14 +4,12 @@ pragma solidity >=0.8.0; interface IALMProxy { /** - * @notice Returns the controller identifier * @dev This function retrieves a constant `bytes32` value that represents the controller. * @return The `bytes32` identifier of the controller. */ function CONTROLLER() external view returns (bytes32); /** - * @notice Executes a low-level call to a target contract * @dev Performs a standard call to the specified `target` with the given `data`. * Reverts if the call fails. * @param target The address of the target contract to call. @@ -19,10 +17,9 @@ interface IALMProxy { * @return result The returned data from the call. */ function doCall(address target, bytes calldata data) - external payable returns (bytes memory result); + external returns (bytes memory result); /** - * @notice Executes a low-level call with value transfer to a target contract * @dev This function allows for transferring `value` (ether) along with the call to the target contract. * Reverts if the call fails. * @param target The address of the target contract to call. @@ -34,7 +31,6 @@ interface IALMProxy { external payable returns (bytes memory result); /** - * @notice Executes a low-level delegate call to a target contract * @dev This function performs a delegate call to the specified `target` * with the given `data`. Reverts if the call fails. * @param target The address of the target contract to delegate call. @@ -42,6 +38,6 @@ interface IALMProxy { * @return result The returned data from the delegate call. */ function doDelegateCall(address target, bytes calldata data) - external payable returns (bytes memory result); + external returns (bytes memory result); } diff --git a/src/interfaces/IRateLimits.sol b/src/interfaces/IRateLimits.sol index 8d340632..2df5871c 100644 --- a/src/interfaces/IRateLimits.sol +++ b/src/interfaces/IRateLimits.sol @@ -103,7 +103,8 @@ interface IRateLimits { ) external; /** - * @dev Sets rate limit data for a specific key. + * @dev Sets rate limit data for a specific key with + * `lastAmount == maxAmount` and `lastUpdated == block.timestamp`. * @param key The identifier for the rate limit. * @param maxAmount The maximum allowed amount for the rate limit. * @param slope The slope value used in the rate limit calculation. @@ -149,7 +150,8 @@ interface IRateLimits { external returns (uint256 newLimit); /** - * @dev Increases the rate limit for a given key up to the maxAmount. + * @dev Increases the rate limit for a given key up to the maxAmount. Does not revert if + * the new rate limit exceeds the maxAmount. * @param key The identifier for the rate limit. * @param amountToIncrease The amount to increase from the current rate limit. * @return newLimit The updated rate limit after the addition. diff --git a/test/base-fork/ForkTestBase.t.sol b/test/base-fork/ForkTestBase.t.sol index 4a6d6284..c813025b 100644 --- a/test/base-fork/ForkTestBase.t.sol +++ b/test/base-fork/ForkTestBase.t.sol @@ -91,9 +91,7 @@ contract ForkTestBase is Test { proxy_ : address(almProxy), rateLimits_ : address(rateLimits), psm_ : address(psmBase), - usds_ : address(usdsBase), usdc_ : USDC_BASE, - susds_ : address(susdsBase), cctp_ : CCTP_MESSENGER_BASE }); diff --git a/test/mainnet-fork/CCTPCalls.t.sol b/test/mainnet-fork/CCTPCalls.t.sol index f4214f18..4514d9e4 100644 --- a/test/mainnet-fork/CCTPCalls.t.sol +++ b/test/mainnet-fork/CCTPCalls.t.sol @@ -16,6 +16,8 @@ import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.s import { ALMProxy } from "src/ALMProxy.sol"; import { ForeignController } from "src/ForeignController.sol"; +import { RateLimits } from "src/RateLimits.sol"; +import { RateLimitHelpers } from "src/RateLimitHelpers.sol"; contract MainnetControllerTransferUSDCToCCTPFailureTests is ForkTestBase { @@ -37,7 +39,85 @@ contract MainnetControllerTransferUSDCToCCTPFailureTests is ForkTestBase { mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); } + 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 + ) + ); + + // 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")))) + ); + + vm.stopPrank(); + + 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); + + mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + } + + 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()); + + // 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")))) + ); + + vm.stopPrank(); + + 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); + + mainnetController.transferUSDCToCCTP(10_000_000e6, CCTPForwarder.DOMAIN_ID_CIRCLE_BASE); + } + 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(mainnetController.LIMIT_USDC_TO_CCTP()); + + vm.stopPrank(); + vm.prank(relayer); vm.expectRevert("MainnetController/domain-not-configured"); mainnetController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); @@ -109,9 +189,7 @@ contract BaseChainUSDCToCCTPTestBase is ForkTestBase { proxy_ : address(foreignAlmProxy), rateLimits_ : address(foreignRateLimits), psm_ : address(psmBase), - usds_ : address(usdsBase), usdc_ : USDC_BASE, - susds_ : address(susdsBase), cctp_ : CCTP_MESSENGER_BASE }); @@ -131,13 +209,15 @@ contract BaseChainUSDCToCCTPTestBase is ForkTestBase { foreignRateLimits.grantRole(CONTROLLER, address(foreignController)); - // Setup rate limits - foreignRateLimits.setRateLimitData( - foreignController.LIMIT_USDC_TO_CCTP(), - 5_000_000e6, - uint256(1_000_000e6) / 4 hours + bytes32 domainKeyEthereum = RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM ); + // Set up rate limits + foreignRateLimits.setRateLimitData(domainKeyEthereum, 5_000_000e6, uint256(1_000_000e6) / 4 hours); + foreignRateLimits.setRateLimitData(foreignController.LIMIT_USDC_TO_CCTP(), 5_000_000e6, uint256(1_000_000e6) / 4 hours); + vm.stopPrank(); USDC_BASE_SUPPLY = usdcBase.totalSupply(); @@ -182,7 +262,85 @@ contract ForeignControllerTransferUSDCToCCTPFailureTests is BaseChainUSDCToCCTPT foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ETHEREUM); } + function test_transferUSDCToCCTP_cctpRateLimitedBoundary() external { + vm.startPrank(admin); + + // 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(admin); + + // 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 + ); + + // 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_invalidMintRecipient() external { + // Configure to pass modifiers + vm.startPrank(admin); + + foreignRateLimits.setUnlimitedRateLimitData( + RateLimitHelpers.makeDomainKey( + foreignController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE + ) + ); + + foreignRateLimits.setUnlimitedRateLimitData(foreignController.LIMIT_USDC_TO_CCTP()); + + vm.stopPrank(); + vm.prank(relayer); vm.expectRevert("ForeignController/domain-not-configured"); foreignController.transferUSDCToCCTP(1e6, CCTPForwarder.DOMAIN_ID_CIRCLE_ARBITRUM_ONE); diff --git a/test/mainnet-fork/ForkTestBase.t.sol b/test/mainnet-fork/ForkTestBase.t.sol index a2dd74ef..59291418 100644 --- a/test/mainnet-fork/ForkTestBase.t.sol +++ b/test/mainnet-fork/ForkTestBase.t.sol @@ -24,10 +24,12 @@ import { SUsdsInit, SUsdsConfig } from "sdai/deploy/SUsdsInit.sol"; import { SUsdsInstance } from "sdai/deploy/SUsdsInstance.sol"; import { Bridge } from "xchain-helpers/src/testing/Bridge.sol"; +import { CCTPForwarder } from "xchain-helpers/src/forwarders/CCTPForwarder.sol"; import { Domain, DomainHelpers } from "xchain-helpers/src/testing/Domain.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"; interface IChainlogLike { @@ -231,10 +233,16 @@ contract ForkTestBase is DssTest { rateLimits.grantRole(CONTROLLER, address(mainnetController)); + bytes32 domainKeyBase = RateLimitHelpers.makeDomainKey( + mainnetController.LIMIT_USDC_TO_DOMAIN(), + CCTPForwarder.DOMAIN_ID_CIRCLE_BASE + ); + // Setup rate limits to be 1m / 4 hours recharge and 5m max rateLimits.setRateLimitData(mainnetController.LIMIT_USDS_MINT(), 5_000_000e18, uint256(1_000_000e18) / 4 hours); rateLimits.setRateLimitData(mainnetController.LIMIT_USDS_TO_USDC(), 5_000_000e6, uint256(1_000_000e6) / 4 hours); rateLimits.setRateLimitData(mainnetController.LIMIT_USDC_TO_CCTP(), 5_000_000e6, uint256(1_000_000e6) / 4 hours); + rateLimits.setRateLimitData(domainKeyBase, 5_000_000e6, uint256(1_000_000e6) / 4 hours); IBufferLike(ilkInst.buffer).approve(usdsInst.usds, address(almProxy), type(uint256).max); diff --git a/test/unit/controllers/Admin.t.sol b/test/unit/controllers/Admin.t.sol index fefffa0e..e08e3372 100644 --- a/test/unit/controllers/Admin.t.sol +++ b/test/unit/controllers/Admin.t.sol @@ -87,9 +87,7 @@ contract ForeignControllerAdminTests is UnitTestBase { makeAddr("almProxy"), makeAddr("rateLimits"), makeAddr("psm"), - makeAddr("usds"), makeAddr("usdc"), - makeAddr("susds"), makeAddr("cctp") ); } diff --git a/test/unit/controllers/Constructor.t.sol b/test/unit/controllers/Constructor.t.sol index 2f0fcdc8..8bc736cf 100644 --- a/test/unit/controllers/Constructor.t.sol +++ b/test/unit/controllers/Constructor.t.sol @@ -44,6 +44,9 @@ contract MainnetControllerConstructorTests is UnitTestBase { assertEq(address(mainnetController.usdc()), makeAddr("usdc")); // Gem param in MockPSM assertEq(address(mainnetController.usds()), makeAddr("usds")); // Usds param in MockSUsds + assertEq(mainnetController.psmTo18ConversionFactor(), psm.to18ConversionFactor()); + assertEq(mainnetController.psmTo18ConversionFactor(), 1e12); + assertEq(mainnetController.active(), true); } @@ -54,9 +57,7 @@ contract ForeignControllerConstructorTests is UnitTestBase { address almProxy = makeAddr("almProxy"); address rateLimits = makeAddr("rateLimits"); address cctp = makeAddr("cctp"); - address usds = makeAddr("usds"); address psm = makeAddr("psm"); - address susds = makeAddr("susds"); address usdc = makeAddr("usdc"); function test_constructor() public { @@ -65,9 +66,7 @@ contract ForeignControllerConstructorTests is UnitTestBase { almProxy, rateLimits, psm, - usds, usdc, - susds, cctp ); @@ -76,9 +75,7 @@ contract ForeignControllerConstructorTests is UnitTestBase { assertEq(address(foreignController.proxy()), almProxy); assertEq(address(foreignController.rateLimits()), rateLimits); assertEq(address(foreignController.psm()), psm); - assertEq(address(foreignController.usds()), usds); // asset0 param in MockPSM3 assertEq(address(foreignController.usdc()), usdc); // asset1 param in MockPSM3 - assertEq(address(foreignController.susds()), susds); // asset2 param in MockPSM3 assertEq(address(foreignController.cctp()), cctp); assertEq(foreignController.active(), true); diff --git a/test/unit/controllers/Freeze.t.sol b/test/unit/controllers/Freeze.t.sol index 7a427e49..c727fa40 100644 --- a/test/unit/controllers/Freeze.t.sol +++ b/test/unit/controllers/Freeze.t.sol @@ -144,9 +144,7 @@ contract ForeignControllerFreezeTest is ControllerFreezeTests { makeAddr("almProxy"), makeAddr("rateLimits"), address(psm3), - usds, usdc, - susds, makeAddr("cctp") ))); @@ -170,9 +168,7 @@ contract ForeignControllerReactivateTest is ControllerReactivateTests { makeAddr("almProxy"), makeAddr("rateLimits"), address(psm3), - usds, usdc, - susds, makeAddr("cctp") ))); diff --git a/test/unit/mocks/MockPSM.sol b/test/unit/mocks/MockPSM.sol index 5d5a7b1b..2550ee69 100644 --- a/test/unit/mocks/MockPSM.sol +++ b/test/unit/mocks/MockPSM.sol @@ -5,6 +5,8 @@ contract MockPSM { address public gem; + uint256 public to18ConversionFactor = 1e12; + constructor(address _gem) { gem = _gem; } diff --git a/test/unit/proxy/DoCall.t.sol b/test/unit/proxy/DoCall.t.sol index 5afdf848..6144a9bc 100644 --- a/test/unit/proxy/DoCall.t.sol +++ b/test/unit/proxy/DoCall.t.sol @@ -74,18 +74,6 @@ contract ALMProxyDoCallTests is ALMProxyCallTestBase { assertEq(abi.decode(returnData, (uint256)), 84); } - function test_doCall_msgValue() public { - vm.deal(controller, 1e18); - - // ALM Proxy is msg.sender, target emits the event, msg.value is sent to target - vm.expectEmit(target); - emit ExampleEvent(exampleAddress, 42, 84, address(almProxy), 1e18); - vm.prank(controller); - bytes memory returnData = almProxy.doCall{value: 1e18}(target, data); - - assertEq(abi.decode(returnData, (uint256)), 84); - } - } contract ALMProxyDoCallWithValueFailureTests is ALMProxyCallTestBase { @@ -186,16 +174,4 @@ contract ALMProxyDoDelegateCallTests is ALMProxyCallTestBase { assertEq(abi.decode(returnData, (uint256)), 84); } - function test_doDelegateCall_msgValue() public { - vm.deal(controller, 1e18); - - // L1 Controller is msg.sender, almProxy emits the event, msg.value sent to proxy - vm.expectEmit(address(almProxy)); - emit ExampleEvent(exampleAddress, 42, 84, controller, 1e18); - vm.prank(controller); - bytes memory returnData = almProxy.doDelegateCall{value: 1e18}(target, data); - - assertEq(abi.decode(returnData, (uint256)), 84); - } - }