diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3abfe2f9..47f4f63b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -82,7 +82,7 @@ jobs: - name: Filter directories run: | sudo apt update && sudo apt install -y lcov - lcov --remove lcov.info 'test/*' 'script/*' --output-file lcov.info --rc lcov_branch_coverage=1 + lcov --remove lcov.info 'test/*' 'script/*' 'src/util/*' --output-file lcov.info --rc lcov_branch_coverage=1 # This step posts a detailed coverage report as a comment and deletes previous comments on # each push. The below step is used to fail coverage if the specified coverage threshold is diff --git a/src/gateway/Gateway.sol b/src/gateway/Gateway.sol index 0087c413..00b3ebb0 100644 --- a/src/gateway/Gateway.sol +++ b/src/gateway/Gateway.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: AGPL-3.0-only pragma solidity 0.8.21; -import {Messages} from "./Messages.sol"; +import {MessagesLib} from "./../util/MessagesLib.sol"; import {Auth} from "./../util/Auth.sol"; interface InvestmentManagerLike { @@ -175,11 +175,11 @@ contract Gateway is Auth { uint128 amount ) public onlyPoolManager pauseable { outgoingRouter.send( - Messages.formatTransferTrancheTokens( + MessagesLib.formatTransferTrancheTokens( poolId, trancheId, _addressToBytes32(sender), - Messages.formatDomain(Messages.Domain.Centrifuge), + MessagesLib.formatDomain(MessagesLib.Domain.Centrifuge), destinationAddress, amount ) @@ -195,11 +195,11 @@ contract Gateway is Auth { uint128 amount ) public onlyPoolManager pauseable { outgoingRouter.send( - Messages.formatTransferTrancheTokens( + MessagesLib.formatTransferTrancheTokens( poolId, trancheId, _addressToBytes32(sender), - Messages.formatDomain(Messages.Domain.EVM, destinationChainId), + MessagesLib.formatDomain(MessagesLib.Domain.EVM, destinationChainId), destinationAddress, amount ) @@ -211,7 +211,7 @@ contract Gateway is Auth { onlyPoolManager pauseable { - outgoingRouter.send(Messages.formatTransfer(token, _addressToBytes32(sender), receiver, amount)); + outgoingRouter.send(MessagesLib.formatTransfer(token, _addressToBytes32(sender), receiver, amount)); } function increaseInvestOrder( @@ -222,7 +222,9 @@ contract Gateway is Auth { uint128 currencyAmount ) public onlyInvestmentManager pauseable { outgoingRouter.send( - Messages.formatIncreaseInvestOrder(poolId, trancheId, _addressToBytes32(investor), currency, currencyAmount) + MessagesLib.formatIncreaseInvestOrder( + poolId, trancheId, _addressToBytes32(investor), currency, currencyAmount + ) ); } @@ -234,7 +236,9 @@ contract Gateway is Auth { uint128 currencyAmount ) public onlyInvestmentManager pauseable { outgoingRouter.send( - Messages.formatDecreaseInvestOrder(poolId, trancheId, _addressToBytes32(investor), currency, currencyAmount) + MessagesLib.formatDecreaseInvestOrder( + poolId, trancheId, _addressToBytes32(investor), currency, currencyAmount + ) ); } @@ -246,7 +250,7 @@ contract Gateway is Auth { uint128 trancheTokenAmount ) public onlyInvestmentManager pauseable { outgoingRouter.send( - Messages.formatIncreaseRedeemOrder( + MessagesLib.formatIncreaseRedeemOrder( poolId, trancheId, _addressToBytes32(investor), currency, trancheTokenAmount ) ); @@ -260,7 +264,7 @@ contract Gateway is Auth { uint128 trancheTokenAmount ) public onlyInvestmentManager pauseable { outgoingRouter.send( - Messages.formatDecreaseRedeemOrder( + MessagesLib.formatDecreaseRedeemOrder( poolId, trancheId, _addressToBytes32(investor), currency, trancheTokenAmount ) ); @@ -271,7 +275,7 @@ contract Gateway is Auth { onlyInvestmentManager pauseable { - outgoingRouter.send(Messages.formatCollectInvest(poolId, trancheId, _addressToBytes32(investor), currency)); + outgoingRouter.send(MessagesLib.formatCollectInvest(poolId, trancheId, _addressToBytes32(investor), currency)); } function collectRedeem(uint64 poolId, bytes16 trancheId, address investor, uint128 currency) @@ -279,7 +283,7 @@ contract Gateway is Auth { onlyInvestmentManager pauseable { - outgoingRouter.send(Messages.formatCollectRedeem(poolId, trancheId, _addressToBytes32(investor), currency)); + outgoingRouter.send(MessagesLib.formatCollectRedeem(poolId, trancheId, _addressToBytes32(investor), currency)); } function cancelInvestOrder(uint64 poolId, bytes16 trancheId, address investor, uint128 currency) @@ -287,7 +291,9 @@ contract Gateway is Auth { onlyInvestmentManager pauseable { - outgoingRouter.send(Messages.formatCancelInvestOrder(poolId, trancheId, _addressToBytes32(investor), currency)); + outgoingRouter.send( + MessagesLib.formatCancelInvestOrder(poolId, trancheId, _addressToBytes32(investor), currency) + ); } function cancelRedeemOrder(uint64 poolId, bytes16 trancheId, address investor, uint128 currency) @@ -295,21 +301,23 @@ contract Gateway is Auth { onlyInvestmentManager pauseable { - outgoingRouter.send(Messages.formatCancelRedeemOrder(poolId, trancheId, _addressToBytes32(investor), currency)); + outgoingRouter.send( + MessagesLib.formatCancelRedeemOrder(poolId, trancheId, _addressToBytes32(investor), currency) + ); } // --- Incoming --- function handle(bytes calldata message) external onlyIncomingRouter pauseable { - if (Messages.isAddCurrency(message)) { - (uint128 currency, address currencyAddress) = Messages.parseAddCurrency(message); + if (MessagesLib.isAddCurrency(message)) { + (uint128 currency, address currencyAddress) = MessagesLib.parseAddCurrency(message); poolManager.addCurrency(currency, currencyAddress); - } else if (Messages.isAddPool(message)) { - (uint64 poolId) = Messages.parseAddPool(message); + } else if (MessagesLib.isAddPool(message)) { + (uint64 poolId) = MessagesLib.parseAddPool(message); poolManager.addPool(poolId); - } else if (Messages.isAllowInvestmentCurrency(message)) { - (uint64 poolId, uint128 currency) = Messages.parseAllowInvestmentCurrency(message); + } else if (MessagesLib.isAllowInvestmentCurrency(message)) { + (uint64 poolId, uint128 currency) = MessagesLib.parseAllowInvestmentCurrency(message); poolManager.allowInvestmentCurrency(poolId, currency); - } else if (Messages.isAddTranche(message)) { + } else if (MessagesLib.isAddTranche(message)) { ( uint64 poolId, bytes16 trancheId, @@ -317,23 +325,23 @@ contract Gateway is Auth { string memory tokenSymbol, uint8 decimals, uint8 restrictionSet - ) = Messages.parseAddTranche(message); + ) = MessagesLib.parseAddTranche(message); poolManager.addTranche(poolId, trancheId, tokenName, tokenSymbol, decimals, restrictionSet); - } else if (Messages.isUpdateMember(message)) { - (uint64 poolId, bytes16 trancheId, address user, uint64 validUntil) = Messages.parseUpdateMember(message); + } else if (MessagesLib.isUpdateMember(message)) { + (uint64 poolId, bytes16 trancheId, address user, uint64 validUntil) = MessagesLib.parseUpdateMember(message); poolManager.updateMember(poolId, trancheId, user, validUntil); - } else if (Messages.isUpdateTrancheTokenPrice(message)) { + } else if (MessagesLib.isUpdateTrancheTokenPrice(message)) { (uint64 poolId, bytes16 trancheId, uint128 currencyId, uint128 price, uint64 computedAt) = - Messages.parseUpdateTrancheTokenPrice(message); + MessagesLib.parseUpdateTrancheTokenPrice(message); poolManager.updateTrancheTokenPrice(poolId, trancheId, currencyId, price, computedAt); - } else if (Messages.isTransfer(message)) { - (uint128 currency, address recipient, uint128 amount) = Messages.parseIncomingTransfer(message); + } else if (MessagesLib.isTransfer(message)) { + (uint128 currency, address recipient, uint128 amount) = MessagesLib.parseIncomingTransfer(message); poolManager.handleTransfer(currency, recipient, amount); - } else if (Messages.isTransferTrancheTokens(message)) { + } else if (MessagesLib.isTransferTrancheTokens(message)) { (uint64 poolId, bytes16 trancheId, address destinationAddress, uint128 amount) = - Messages.parseTransferTrancheTokens20(message); + MessagesLib.parseTransferTrancheTokens20(message); poolManager.handleTransferTrancheTokens(poolId, trancheId, destinationAddress, amount); - } else if (Messages.isExecutedDecreaseInvestOrder(message)) { + } else if (MessagesLib.isExecutedDecreaseInvestOrder(message)) { ( uint64 poolId, bytes16 trancheId, @@ -341,11 +349,11 @@ contract Gateway is Auth { uint128 currency, uint128 currencyPayout, uint128 remainingInvestOrder - ) = Messages.parseExecutedDecreaseInvestOrder(message); + ) = MessagesLib.parseExecutedDecreaseInvestOrder(message); investmentManager.handleExecutedDecreaseInvestOrder( poolId, trancheId, investor, currency, currencyPayout, remainingInvestOrder ); - } else if (Messages.isExecutedDecreaseRedeemOrder(message)) { + } else if (MessagesLib.isExecutedDecreaseRedeemOrder(message)) { ( uint64 poolId, bytes16 trancheId, @@ -353,11 +361,11 @@ contract Gateway is Auth { uint128 currency, uint128 trancheTokensPayout, uint128 remainingRedeemOrder - ) = Messages.parseExecutedDecreaseRedeemOrder(message); + ) = MessagesLib.parseExecutedDecreaseRedeemOrder(message); investmentManager.handleExecutedDecreaseRedeemOrder( poolId, trancheId, investor, currency, trancheTokensPayout, remainingRedeemOrder ); - } else if (Messages.isExecutedCollectInvest(message)) { + } else if (MessagesLib.isExecutedCollectInvest(message)) { ( uint64 poolId, bytes16 trancheId, @@ -366,11 +374,11 @@ contract Gateway is Auth { uint128 currencyPayout, uint128 trancheTokensPayout, uint128 remainingInvestOrder - ) = Messages.parseExecutedCollectInvest(message); + ) = MessagesLib.parseExecutedCollectInvest(message); investmentManager.handleExecutedCollectInvest( poolId, trancheId, investor, currency, currencyPayout, trancheTokensPayout, remainingInvestOrder ); - } else if (Messages.isExecutedCollectRedeem(message)) { + } else if (MessagesLib.isExecutedCollectRedeem(message)) { ( uint64 poolId, bytes16 trancheId, @@ -379,34 +387,34 @@ contract Gateway is Auth { uint128 currencyPayout, uint128 trancheTokensPayout, uint128 remainingRedeemOrder - ) = Messages.parseExecutedCollectRedeem(message); + ) = MessagesLib.parseExecutedCollectRedeem(message); investmentManager.handleExecutedCollectRedeem( poolId, trancheId, investor, currency, currencyPayout, trancheTokensPayout, remainingRedeemOrder ); - } else if (Messages.isScheduleUpgrade(message)) { - address target = Messages.parseScheduleUpgrade(message); + } else if (MessagesLib.isScheduleUpgrade(message)) { + address target = MessagesLib.parseScheduleUpgrade(message); root.scheduleRely(target); - } else if (Messages.isCancelUpgrade(message)) { - address target = Messages.parseCancelUpgrade(message); + } else if (MessagesLib.isCancelUpgrade(message)) { + address target = MessagesLib.parseCancelUpgrade(message); root.cancelRely(target); - } else if (Messages.isUpdateTrancheTokenMetadata(message)) { + } else if (MessagesLib.isUpdateTrancheTokenMetadata(message)) { (uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol) = - Messages.parseUpdateTrancheTokenMetadata(message); + MessagesLib.parseUpdateTrancheTokenMetadata(message); poolManager.updateTrancheTokenMetadata(poolId, trancheId, tokenName, tokenSymbol); - } else if (Messages.isTriggerIncreaseRedeemOrder(message)) { + } else if (MessagesLib.isTriggerIncreaseRedeemOrder(message)) { (uint64 poolId, bytes16 trancheId, address investor, uint128 currency, uint128 trancheTokenAmount) = - Messages.parseTriggerIncreaseRedeemOrder(message); + MessagesLib.parseTriggerIncreaseRedeemOrder(message); investmentManager.handleTriggerIncreaseRedeemOrder( poolId, trancheId, investor, currency, trancheTokenAmount ); - } else if (Messages.isFreeze(message)) { - (uint64 poolId, bytes16 trancheId, address user) = Messages.parseFreeze(message); + } else if (MessagesLib.isFreeze(message)) { + (uint64 poolId, bytes16 trancheId, address user) = MessagesLib.parseFreeze(message); poolManager.freeze(poolId, trancheId, user); - } else if (Messages.isUnfreeze(message)) { - (uint64 poolId, bytes16 trancheId, address user) = Messages.parseUnfreeze(message); + } else if (MessagesLib.isUnfreeze(message)) { + (uint64 poolId, bytes16 trancheId, address user) = MessagesLib.parseUnfreeze(message); poolManager.unfreeze(poolId, trancheId, user); - } else if (Messages.isDisallowInvestmentCurrency(message)) { - (uint64 poolId, uint128 currency) = Messages.parseDisallowInvestmentCurrency(message); + } else if (MessagesLib.isDisallowInvestmentCurrency(message)) { + (uint64 poolId, uint128 currency) = MessagesLib.parseDisallowInvestmentCurrency(message); poolManager.disallowInvestmentCurrency(poolId, currency); } else { revert("Gateway/invalid-message"); diff --git a/src/gateway/routers/xcm/Router.sol b/src/gateway/routers/xcm/Router.sol index c039dbb9..7af8ddb0 100644 --- a/src/gateway/routers/xcm/Router.sol +++ b/src/gateway/routers/xcm/Router.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: AGPL-3.0-only pragma solidity 0.8.21; -import {Messages} from "../../Messages.sol"; +import {MessagesLib} from "../../../util/MessagesLib.sol"; import {Auth} from "./../../../util/Auth.sol"; struct Multilocation { @@ -154,22 +154,22 @@ contract XCMRouter is Auth { // Obtain the Scale-encoded length of a given message. Each Liquidity Pools Message is fixed-sized and // have thus a fixed scale-encoded length associated to which message variant (aka Call). function messageLengthScaleEncoded(bytes memory _msg) internal pure returns (bytes memory) { - if (Messages.isTransfer(_msg)) { + if (MessagesLib.isTransfer(_msg)) { return hex"8501"; - } else if (Messages.isTransferTrancheTokens(_msg)) { + } else if (MessagesLib.isTransferTrancheTokens(_msg)) { // A TransferTrancheTokens message is 82 bytes long which encodes to 0x4901 in Scale return hex"4901"; - } else if (Messages.isIncreaseInvestOrder(_msg)) { + } else if (MessagesLib.isIncreaseInvestOrder(_msg)) { return hex"6501"; - } else if (Messages.isDecreaseInvestOrder(_msg)) { + } else if (MessagesLib.isDecreaseInvestOrder(_msg)) { return hex"6501"; - } else if (Messages.isIncreaseRedeemOrder(_msg)) { + } else if (MessagesLib.isIncreaseRedeemOrder(_msg)) { return hex"6501"; - } else if (Messages.isDecreaseRedeemOrder(_msg)) { + } else if (MessagesLib.isDecreaseRedeemOrder(_msg)) { return hex"6501"; - } else if (Messages.isCollectInvest(_msg)) { + } else if (MessagesLib.isCollectInvest(_msg)) { return hex"e4"; - } else if (Messages.isCollectRedeem(_msg)) { + } else if (MessagesLib.isCollectRedeem(_msg)) { return hex"e4"; } else { revert("XCMRouter/unsupported-outgoing-message"); diff --git a/src/gateway/Messages.sol b/src/util/MessagesLib.sol similarity index 99% rename from src/gateway/Messages.sol rename to src/util/MessagesLib.sol index a5a9f7bf..f75b20d5 100644 --- a/src/gateway/Messages.sol +++ b/src/util/MessagesLib.sol @@ -3,9 +3,9 @@ pragma solidity 0.8.21; import {BytesLib} from "src/util/BytesLib.sol"; -/// @title Messages +/// @title MessagesLib /// @dev Library for encoding and decoding messages. -library Messages { +library MessagesLib { enum Call { /// 0 - An invalid message Invalid, diff --git a/src/util/SafeTransferLib.sol b/src/util/SafeTransferLib.sol index f61c9c9f..dd74cbdb 100644 --- a/src/util/SafeTransferLib.sol +++ b/src/util/SafeTransferLib.sol @@ -29,7 +29,7 @@ library SafeTransferLib { } /// @notice Approves the stipulated contract to spend the given allowance in the given token - /// @dev Errors if transfer fails + /// @dev Errors if approval fails /// @param token The contract address of the token to be approved /// @param to The target of the approval /// @param value The amount of the given token the target will be allowed to spend diff --git a/test/TestSetup.t.sol b/test/TestSetup.t.sol index 49f1bc8e..30c07018 100644 --- a/test/TestSetup.t.sol +++ b/test/TestSetup.t.sol @@ -14,7 +14,7 @@ import {TrancheToken, TrancheTokenLike} from "../src/token/Tranche.sol"; import {ERC20} from "../src/token/ERC20.sol"; import {Gateway} from "../src/gateway/Gateway.sol"; import {RestrictionManagerLike, RestrictionManager} from "../src/token/RestrictionManager.sol"; -import {Messages} from "../src/gateway/Messages.sol"; +import {MessagesLib} from "../src/util/MessagesLib.sol"; import {Deployer} from "../script/Deployer.sol"; import "../src/interfaces/IERC20.sol"; diff --git a/test/integration/Deposit.t.sol b/test/integration/Deposit.t.sol index 3f57b6e7..34bac0af 100644 --- a/test/integration/Deposit.t.sol +++ b/test/integration/Deposit.t.sol @@ -780,7 +780,7 @@ contract DepositTest is TestSetup { // check message was send out to centchain lPool.cancelDepositRequest(); - bytes memory cancelOrderMessage = Messages.formatCancelInvestOrder( + bytes memory cancelOrderMessage = MessagesLib.formatCancelInvestOrder( lPool.poolId(), lPool.trancheId(), _addressToBytes32(self), defaultCurrencyId ); assertEq(cancelOrderMessage, router.values_bytes("send")); diff --git a/test/integration/Redeem.t.sol b/test/integration/Redeem.t.sol index 8a615e02..d8fe575e 100644 --- a/test/integration/Redeem.t.sol +++ b/test/integration/Redeem.t.sol @@ -184,7 +184,7 @@ contract RedeemTest is TestSetup { // check message was send out to centchain lPool.cancelRedeemRequest(); - bytes memory cancelOrderMessage = Messages.formatCancelRedeemOrder( + bytes memory cancelOrderMessage = MessagesLib.formatCancelRedeemOrder( lPool.poolId(), lPool.trancheId(), _addressToBytes32(self), defaultCurrencyId ); assertEq(cancelOrderMessage, router.values_bytes("send")); diff --git a/test/mocks/MockCentrifugeChain.sol b/test/mocks/MockCentrifugeChain.sol index e44e8fdb..b7adf51a 100644 --- a/test/mocks/MockCentrifugeChain.sol +++ b/test/mocks/MockCentrifugeChain.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: AGPL-3.0-only pragma solidity 0.8.21; -import {Messages} from "src/gateway/Messages.sol"; +import {MessagesLib} from "src/util/MessagesLib.sol"; import "forge-std/Test.sol"; import {XCMRouter} from "src/gateway/routers/xcm/Router.sol"; @@ -27,22 +27,22 @@ contract MockCentrifugeChain is Test { } function addCurrency(uint128 currency, address currencyAddress) public { - bytes memory _message = Messages.formatAddCurrency(currency, currencyAddress); + bytes memory _message = MessagesLib.formatAddCurrency(currency, currencyAddress); router.execute(_message); } function addPool(uint64 poolId) public { - bytes memory _message = Messages.formatAddPool(poolId); + bytes memory _message = MessagesLib.formatAddPool(poolId); router.execute(_message); } function allowInvestmentCurrency(uint64 poolId, uint128 currency) public { - bytes memory _message = Messages.formatAllowInvestmentCurrency(poolId, currency); + bytes memory _message = MessagesLib.formatAllowInvestmentCurrency(poolId, currency); router.execute(_message); } function disallowInvestmentCurrency(uint64 poolId, uint128 currency) public { - bytes memory _message = Messages.formatDisallowInvestmentCurrency(poolId, currency); + bytes memory _message = MessagesLib.formatDisallowInvestmentCurrency(poolId, currency); router.execute(_message); } @@ -55,12 +55,12 @@ contract MockCentrifugeChain is Test { uint8 restrictionSet ) public { bytes memory _message = - Messages.formatAddTranche(poolId, trancheId, tokenName, tokenSymbol, decimals, restrictionSet); + MessagesLib.formatAddTranche(poolId, trancheId, tokenName, tokenSymbol, decimals, restrictionSet); router.execute(_message); } function updateMember(uint64 poolId, bytes16 trancheId, address user, uint64 validUntil) public { - bytes memory _message = Messages.formatUpdateMember(poolId, trancheId, user, validUntil); + bytes memory _message = MessagesLib.formatUpdateMember(poolId, trancheId, user, validUntil); router.execute(_message); } @@ -70,7 +70,7 @@ contract MockCentrifugeChain is Test { string memory tokenName, string memory tokenSymbol ) public { - bytes memory _message = Messages.formatUpdateTrancheTokenMetadata(poolId, trancheId, tokenName, tokenSymbol); + bytes memory _message = MessagesLib.formatUpdateTrancheTokenMetadata(poolId, trancheId, tokenName, tokenSymbol); router.execute(_message); } @@ -81,7 +81,8 @@ contract MockCentrifugeChain is Test { uint128 price, uint64 computedAt ) public { - bytes memory _message = Messages.formatUpdateTrancheTokenPrice(poolId, trancheId, currencyId, price, computedAt); + bytes memory _message = + MessagesLib.formatUpdateTrancheTokenPrice(poolId, trancheId, currencyId, price, computedAt); router.execute(_message); } @@ -92,14 +93,15 @@ contract MockCentrifugeChain is Test { uint128 currencyId, uint128 amount ) public { - bytes memory _message = - Messages.formatTriggerIncreaseRedeemOrder(poolId, trancheId, bytes32(bytes20(investor)), currencyId, amount); + bytes memory _message = MessagesLib.formatTriggerIncreaseRedeemOrder( + poolId, trancheId, bytes32(bytes20(investor)), currencyId, amount + ); router.execute(_message); } // Trigger an incoming (e.g. Centrifuge Chain -> EVM) transfer of stable coins function incomingTransfer(uint128 currency, bytes32 sender, bytes32 recipient, uint128 amount) public { - bytes memory _message = Messages.formatTransfer(currency, sender, recipient, amount); + bytes memory _message = MessagesLib.formatTransfer(currency, sender, recipient, amount); router.execute(_message); } @@ -111,11 +113,11 @@ contract MockCentrifugeChain is Test { address destinationAddress, uint128 amount ) public { - bytes memory _message = Messages.formatTransferTrancheTokens( + bytes memory _message = MessagesLib.formatTransferTrancheTokens( poolId, trancheId, bytes32(bytes20(msg.sender)), - Messages.formatDomain(Messages.Domain.EVM, destinationChainId), + MessagesLib.formatDomain(MessagesLib.Domain.EVM, destinationChainId), destinationAddress, amount ); @@ -123,22 +125,22 @@ contract MockCentrifugeChain is Test { } function incomingScheduleUpgrade(address target) public { - bytes memory _message = Messages.formatScheduleUpgrade(target); + bytes memory _message = MessagesLib.formatScheduleUpgrade(target); router.execute(_message); } function incomingCancelUpgrade(address target) public { - bytes memory _message = Messages.formatCancelUpgrade(target); + bytes memory _message = MessagesLib.formatCancelUpgrade(target); router.execute(_message); } function freeze(uint64 poolId, bytes16 trancheId, address user) public { - bytes memory _message = Messages.formatFreeze(poolId, trancheId, user); + bytes memory _message = MessagesLib.formatFreeze(poolId, trancheId, user); router.execute(_message); } function unfreeze(uint64 poolId, bytes16 trancheId, address user) public { - bytes memory _message = Messages.formatUnfreeze(poolId, trancheId, user); + bytes memory _message = MessagesLib.formatUnfreeze(poolId, trancheId, user); router.execute(_message); } @@ -150,7 +152,7 @@ contract MockCentrifugeChain is Test { uint128 currencyPayout, uint128 remainingInvestOrder ) public { - bytes memory _message = Messages.formatExecutedDecreaseInvestOrder( + bytes memory _message = MessagesLib.formatExecutedDecreaseInvestOrder( poolId, trancheId, investor, currency, currencyPayout, remainingInvestOrder ); router.execute(_message); @@ -164,7 +166,7 @@ contract MockCentrifugeChain is Test { uint128 trancheTokensPayout, uint128 remainingRedeemOrder ) public { - bytes memory _message = Messages.formatExecutedDecreaseRedeemOrder( + bytes memory _message = MessagesLib.formatExecutedDecreaseRedeemOrder( poolId, trancheId, investor, currency, trancheTokensPayout, remainingRedeemOrder ); router.execute(_message); @@ -179,7 +181,7 @@ contract MockCentrifugeChain is Test { uint128 trancheTokensPayout, uint128 remainingInvestOrder ) public { - bytes memory _message = Messages.formatExecutedCollectInvest( + bytes memory _message = MessagesLib.formatExecutedCollectInvest( poolId, trancheId, investor, currency, currencyPayout, trancheTokensPayout, remainingInvestOrder ); router.execute(_message); @@ -194,7 +196,7 @@ contract MockCentrifugeChain is Test { uint128 trancheTokensPayout, uint128 remainingRedeemOrder ) public { - bytes memory _message = Messages.formatExecutedCollectRedeem( + bytes memory _message = MessagesLib.formatExecutedCollectRedeem( poolId, trancheId, investor, currency, currencyPayout, trancheTokensPayout, remainingRedeemOrder ); router.execute(_message); diff --git a/test/mocks/MockRouter.sol b/test/mocks/MockRouter.sol index 66a3e21f..348f0ea5 100644 --- a/test/mocks/MockRouter.sol +++ b/test/mocks/MockRouter.sol @@ -3,7 +3,6 @@ pragma solidity 0.8.21; import "forge-std/Test.sol"; import {InvestmentManager} from "src/InvestmentManager.sol"; -import {Messages} from "src/gateway/Messages.sol"; import {Gateway} from "src/gateway/Gateway.sol"; import {Auth} from "src/util/Auth.sol"; import "./Mock.sol"; diff --git a/test/unit/PoolManager.t.sol b/test/unit/PoolManager.t.sol index e68b9d00..d49cafb1 100644 --- a/test/unit/PoolManager.t.sol +++ b/test/unit/PoolManager.t.sol @@ -319,11 +319,11 @@ contract PoolManagerTest is TestSetup { assertEq(trancheToken.balanceOf(address(this)), 0); // Finally, verify the connector called `router.send` - bytes memory message = Messages.formatTransferTrancheTokens( + bytes memory message = MessagesLib.formatTransferTrancheTokens( lPool.poolId(), lPool.trancheId(), bytes32(bytes20(address(this))), - Messages.formatDomain(Messages.Domain.Centrifuge), + MessagesLib.formatDomain(MessagesLib.Domain.Centrifuge), centChainAddress, amount ); diff --git a/test/unit/token/ERC20.t.sol b/test/unit/token/ERC20.t.sol index b17270e7..dfb50226 100644 --- a/test/unit/token/ERC20.t.sol +++ b/test/unit/token/ERC20.t.sol @@ -4,7 +4,6 @@ pragma solidity 0.8.21; import {ERC20, IERC1271} from "src/token/ERC20.sol"; import "forge-std/Test.sol"; -/// @author Modified from from https://github.com/makerdao/xdomain-dss/blob/master/src/test/Dai.t.sol contract MockMultisig is IERC1271 { address public immutable signer1; address public immutable signer2; @@ -39,6 +38,7 @@ contract MockMultisig is IERC1271 { function test() public {} } +/// @author Modified from from https://github.com/makerdao/xdomain-dss/blob/master/src/test/Dai.t.sol contract ERC20Test is Test { ERC20 token; diff --git a/test/unit/utils/MathLib.t.sol b/test/unit/utils/MathLib.t.sol new file mode 100644 index 00000000..21575882 --- /dev/null +++ b/test/unit/utils/MathLib.t.sol @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: AGPL-3.0-only +pragma solidity 0.8.21; + +import "forge-std/Test.sol"; +import {IERC20} from "src/interfaces/IERC20.sol"; +import {MathLib} from "src/util/MathLib.sol"; + +/// @author Modified from https://github.com/morpho-org/morpho-blue/blob/main/test/forge/libraries/MathLibTest.sol +contract MathLibTest is Test { + using MathLib for uint256; + + function testMulDivDown(uint256 x, uint256 y, uint256 denominator) public { + // Ignore cases where x * y overflows or denominator is 0. + unchecked { + if (denominator == 0 || (x != 0 && (x * y) / x != y)) return; + } + + assertEq(MathLib.mulDiv(x, y, denominator, MathLib.Rounding.Down), (x * y) / denominator); + } + + function testMulDivDownZeroDenominator(uint256 x, uint256 y) public { + vm.expectRevert(); + MathLib.mulDiv(x, y, 0, MathLib.Rounding.Down); + } + + function testMulDivUp(uint256 x, uint256 y, uint256 denominator) public { + denominator = bound(denominator, 1, type(uint256).max - 1); + y = bound(y, 1, type(uint256).max); + x = bound(x, 0, (type(uint256).max - denominator - 1) / y); + + assertEq(MathLib.mulDiv(x, y, denominator, MathLib.Rounding.Up), x * y == 0 ? 0 : (x * y - 1) / denominator + 1); + } + + function testMulDivUpUnderverflow(uint256 x, uint256 y) public { + vm.assume(x > 0 && y > 0); + + vm.expectRevert(); + MathLib.mulDiv(x, y, 0, MathLib.Rounding.Up); + } + + function testMulDivUpZeroDenominator(uint256 x, uint256 y) public { + vm.expectRevert(); + MathLib.mulDiv(x, y, 0, MathLib.Rounding.Up); + } + + function testToUint128(uint256 x) public { + x = bound(x, 0, type(uint128).max); + + MathLib.toUint128(x); + assertEq(x, uint256(MathLib.toUint128(x))); + } + + function testToUint128Overflow(uint128 x) public { + vm.assume(x > 0); + vm.expectRevert("MathLib/uint128-overflow"); + MathLib.toUint128(uint256(type(uint128).max) + x); + } +} diff --git a/test/unit/gateway/Messages.t.sol b/test/unit/utils/MessagesLib.t.sol similarity index 81% rename from test/unit/gateway/Messages.t.sol rename to test/unit/utils/MessagesLib.t.sol index b77991b3..6bb41a28 100644 --- a/test/unit/gateway/Messages.t.sol +++ b/test/unit/utils/MessagesLib.t.sol @@ -1,10 +1,10 @@ // SPDX-License-Identifier: AGPL-3.0-only pragma solidity 0.8.21; -import {Messages} from "src/gateway/Messages.sol"; +import {MessagesLib} from "src/util/MessagesLib.sol"; import "forge-std/Test.sol"; -contract MessagesTest is Test { +contract MessagesLibTest is Test { function setUp() public {} function testAddCurrency() public { @@ -12,16 +12,16 @@ contract MessagesTest is Test { address currencyAddress = 0x1231231231231231231231231231231231231231; bytes memory expectedHex = hex"010000000000000000000000000eb5ec7b1231231231231231231231231231231231231231"; - assertEq(Messages.formatAddCurrency(currency, currencyAddress), expectedHex); + assertEq(MessagesLib.formatAddCurrency(currency, currencyAddress), expectedHex); - (uint128 decodedCurrency, address decodedCurrencyAddress) = Messages.parseAddCurrency(expectedHex); + (uint128 decodedCurrency, address decodedCurrencyAddress) = MessagesLib.parseAddCurrency(expectedHex); assertEq(uint256(decodedCurrency), currency); assertEq(decodedCurrencyAddress, currencyAddress); } function testAddCurrencyEquivalence(uint128 currency, address currencyAddress) public { - bytes memory _message = Messages.formatAddCurrency(currency, currencyAddress); - (uint128 decodedCurrency, address decodedCurrencyAddress) = Messages.parseAddCurrency(_message); + bytes memory _message = MessagesLib.formatAddCurrency(currency, currencyAddress); + (uint128 decodedCurrency, address decodedCurrencyAddress) = MessagesLib.parseAddCurrency(_message); assertEq(decodedCurrency, uint256(currency)); assertEq(decodedCurrencyAddress, currencyAddress); } @@ -30,15 +30,15 @@ contract MessagesTest is Test { uint64 poolId = 12378532; bytes memory expectedHex = hex"020000000000bce1a4"; - assertEq(Messages.formatAddPool(poolId), expectedHex); + assertEq(MessagesLib.formatAddPool(poolId), expectedHex); - (uint64 decodedPoolId) = Messages.parseAddPool(expectedHex); + (uint64 decodedPoolId) = MessagesLib.parseAddPool(expectedHex); assertEq(uint256(decodedPoolId), poolId); } function testAddPoolEquivalence(uint64 poolId) public { - bytes memory _message = Messages.formatAddPool(poolId); - (uint64 decodedPoolId) = Messages.parseAddPool(_message); + bytes memory _message = MessagesLib.formatAddPool(poolId); + (uint64 decodedPoolId) = MessagesLib.parseAddPool(_message); assertEq(decodedPoolId, uint256(poolId)); } @@ -47,16 +47,16 @@ contract MessagesTest is Test { uint128 currency = 246803579; bytes memory expectedHex = hex"030000000000bce1a40000000000000000000000000eb5ec7b"; - assertEq(Messages.formatAllowInvestmentCurrency(poolId, currency), expectedHex); + assertEq(MessagesLib.formatAllowInvestmentCurrency(poolId, currency), expectedHex); - (uint64 decodedPoolId, uint128 decodedCurrency) = Messages.parseAllowInvestmentCurrency(expectedHex); + (uint64 decodedPoolId, uint128 decodedCurrency) = MessagesLib.parseAllowInvestmentCurrency(expectedHex); assertEq(decodedPoolId, poolId); assertEq(uint256(decodedCurrency), currency); } function testAllowInvestmentCurrencyEquivalence(uint128 currency, uint64 poolId) public { - bytes memory _message = Messages.formatAllowInvestmentCurrency(poolId, currency); - (uint64 decodedPoolId, uint128 decodedCurrency) = Messages.parseAllowInvestmentCurrency(_message); + bytes memory _message = MessagesLib.formatAllowInvestmentCurrency(poolId, currency); + (uint64 decodedPoolId, uint128 decodedCurrency) = MessagesLib.parseAllowInvestmentCurrency(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedCurrency, uint256(currency)); } @@ -71,7 +71,7 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"040000000000000001811acd5b3f17c06841c7e41e9e04cb1b536f6d65204e616d65000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000053594d424f4c00000000000000000000000000000000000000000000000000000f02"; - assertEq(Messages.formatAddTranche(poolId, trancheId, name, symbol, decimals, restrictionSet), expectedHex); + assertEq(MessagesLib.formatAddTranche(poolId, trancheId, name, symbol, decimals, restrictionSet), expectedHex); ( uint64 decodedPoolId, @@ -80,7 +80,7 @@ contract MessagesTest is Test { string memory decodedTokenSymbol, uint8 decodedDecimals, uint8 decodedRestrictionSet - ) = Messages.parseAddTranche(expectedHex); + ) = MessagesLib.parseAddTranche(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); @@ -94,7 +94,7 @@ contract MessagesTest is Test { hex"040000000000000001811acd5b3f17c06841c7e41e9e04cb1b536f6d65204e616d65000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000053594d424f4c00000000000000000000000000000000000000000000000000000f"; (decodedPoolId, decodedTrancheId, decodedTokenName, decodedTokenSymbol, decodedDecimals, decodedRestrictionSet) - = Messages.parseAddTranche(expectedHexWithoutRestrictionSet); + = MessagesLib.parseAddTranche(expectedHexWithoutRestrictionSet); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); @@ -113,7 +113,7 @@ contract MessagesTest is Test { uint8 restrictionSet ) public { bytes memory _message = - Messages.formatAddTranche(poolId, trancheId, tokenName, tokenSymbol, decimals, restrictionSet); + MessagesLib.formatAddTranche(poolId, trancheId, tokenName, tokenSymbol, decimals, restrictionSet); ( uint64 decodedPoolId, bytes16 decodedTrancheId, @@ -121,15 +121,15 @@ contract MessagesTest is Test { string memory decodedTokenSymbol, uint8 decodedDecimals, uint8 decodedRestrictionSet - ) = Messages.parseAddTranche(_message); + ) = MessagesLib.parseAddTranche(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); // Comparing raw input to output can erroneously fail when a byte string is given. // Intended behaviour is that byte strings will be treated as bytes and converted to strings instead // of treated as strings themselves. This conversion from string to bytes32 to string is used to simulate // this intended behaviour. - assertEq(decodedTokenName, Messages._bytes128ToString(Messages._stringToBytes128(tokenName))); - assertEq(decodedTokenSymbol, Messages._bytes32ToString(Messages._stringToBytes32(tokenSymbol))); + assertEq(decodedTokenName, MessagesLib._bytes128ToString(MessagesLib._stringToBytes128(tokenName))); + assertEq(decodedTokenSymbol, MessagesLib._bytes32ToString(MessagesLib._stringToBytes32(tokenSymbol))); assertEq(decodedDecimals, decimals); assertEq(decodedRestrictionSet, restrictionSet); } @@ -143,7 +143,9 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"050000000000000001811acd5b3f17c06841c7e41e9e04cb1b0000000000000000000000000000000200000000033b2e3c9fd0803ce80000000000000000000001"; - assertEq(Messages.formatUpdateTrancheTokenPrice(poolId, trancheId, currencyId, price, computedAt), expectedHex); + assertEq( + MessagesLib.formatUpdateTrancheTokenPrice(poolId, trancheId, currencyId, price, computedAt), expectedHex + ); ( uint64 decodedPoolId, @@ -151,7 +153,7 @@ contract MessagesTest is Test { uint128 decodedCurrencyId, uint128 decodedPrice, uint64 decodedComputedAt - ) = Messages.parseUpdateTrancheTokenPrice(expectedHex); + ) = MessagesLib.parseUpdateTrancheTokenPrice(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedCurrencyId, currencyId); @@ -166,14 +168,15 @@ contract MessagesTest is Test { uint128 price, uint64 computedAt ) public { - bytes memory _message = Messages.formatUpdateTrancheTokenPrice(poolId, trancheId, currencyId, price, computedAt); + bytes memory _message = + MessagesLib.formatUpdateTrancheTokenPrice(poolId, trancheId, currencyId, price, computedAt); ( uint64 decodedPoolId, bytes16 decodedTrancheId, uint128 decodedCurrencyId, uint128 decodedPrice, uint64 decodedComputedAt - ) = Messages.parseUpdateTrancheTokenPrice(_message); + ) = MessagesLib.parseUpdateTrancheTokenPrice(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); assertEq(decodedCurrencyId, currencyId); @@ -192,10 +195,10 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"060000000000000002811acd5b3f17c06841c7e41e9e04cb1b45645645645645645645645645645645645645645645645645645645645645640000000065b376aa"; - assertEq(Messages.formatUpdateMember(poolId, trancheId, member, validUntil), expectedHex); + assertEq(MessagesLib.formatUpdateMember(poolId, trancheId, member, validUntil), expectedHex); (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedMember, uint64 decodedValidUntil) = - Messages.parseUpdateMember(expectedHex); + MessagesLib.parseUpdateMember(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedMember, address(bytes20(member))); @@ -203,9 +206,9 @@ contract MessagesTest is Test { } function testUpdateMemberEquivalence(uint64 poolId, bytes16 trancheId, address user, uint64 validUntil) public { - bytes memory _message = Messages.formatUpdateMember(poolId, trancheId, user, validUntil); + bytes memory _message = MessagesLib.formatUpdateMember(poolId, trancheId, user, validUntil); (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedUser, uint64 decodedValidUntil) = - Messages.parseUpdateMember(_message); + MessagesLib.parseUpdateMember(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); assertEq(decodedUser, user); @@ -220,10 +223,10 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"070000000000000000000000000eb5ec7b45645645645645645645645645645645645645645645645645645645645645641231231231231231231231231231231231231231000000000000000000000000000000000052b7d2dcc80cd2e4000000"; - assertEq(Messages.formatTransfer(currency, sender, bytes32(bytes20(receiver)), amount), expectedHex); + assertEq(MessagesLib.formatTransfer(currency, sender, bytes32(bytes20(receiver)), amount), expectedHex); (uint128 decodedCurrency, bytes32 decodedSender, bytes32 decodedReceiver, uint128 decodedAmount) = - Messages.parseTransfer(expectedHex); + MessagesLib.parseTransfer(expectedHex); assertEq(uint256(decodedCurrency), currency); assertEq(decodedSender, sender); assertEq(decodedReceiver, bytes32(bytes20(receiver))); @@ -231,16 +234,16 @@ contract MessagesTest is Test { // Test the optimised `parseIncomingTransfer` now (uint128 decodedCurrency2, address decodedReceiver2, uint128 decodedAmount2) = - Messages.parseIncomingTransfer(expectedHex); + MessagesLib.parseIncomingTransfer(expectedHex); assertEq(uint256(decodedCurrency2), currency); assertEq(decodedReceiver2, receiver); assertEq(decodedAmount2, amount); } function testTransferEquivalence(uint128 token, bytes32 sender, bytes32 receiver, uint128 amount) public { - bytes memory _message = Messages.formatTransfer(token, sender, receiver, amount); + bytes memory _message = MessagesLib.formatTransfer(token, sender, receiver, amount); (uint128 decodedToken, bytes32 decodedSender, bytes32 decodedReceiver, uint128 decodedAmount) = - Messages.parseTransfer(_message); + MessagesLib.parseTransfer(_message); assertEq(uint256(decodedToken), uint256(token)); assertEq(decodedSender, sender); assertEq(decodedReceiver, receiver); @@ -248,7 +251,7 @@ contract MessagesTest is Test { // Test the optimised `parseIncomingTransfer` now (uint128 decodedToken2, address decodedRecipient2, uint128 decodedAmount2) = - Messages.parseIncomingTransfer(_message); + MessagesLib.parseIncomingTransfer(_message); assertEq(uint256(decodedToken2), uint256(decodedToken)); assertEq(decodedRecipient2, address(bytes20(decodedReceiver))); assertEq(decodedAmount, decodedAmount2); @@ -258,16 +261,18 @@ contract MessagesTest is Test { uint64 poolId = 1; bytes16 trancheId = bytes16(hex"811acd5b3f17c06841c7e41e9e04cb1b"); bytes32 sender = bytes32(0x4564564564564564564564564564564564564564564564564564564564564564); - bytes9 domain = Messages.formatDomain(Messages.Domain.EVM, 1284); + bytes9 domain = MessagesLib.formatDomain(MessagesLib.Domain.EVM, 1284); address receiver = 0x1231231231231231231231231231231231231231; uint128 amount = 100000000000000000000000000; bytes memory expectedHex = hex"080000000000000001811acd5b3f17c06841c7e41e9e04cb1b45645645645645645645645645645645645645645645645645645645645645640100000000000005041231231231231231231231231231231231231231000000000000000000000000000000000052b7d2dcc80cd2e4000000"; - assertEq(Messages.formatTransferTrancheTokens(poolId, trancheId, sender, domain, receiver, amount), expectedHex); + assertEq( + MessagesLib.formatTransferTrancheTokens(poolId, trancheId, sender, domain, receiver, amount), expectedHex + ); (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedReceiver, uint128 decodedAmount) = - Messages.parseTransferTrancheTokens20(expectedHex); + MessagesLib.parseTransferTrancheTokens20(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedReceiver, receiver); @@ -282,17 +287,17 @@ contract MessagesTest is Test { address destinationAddress, uint128 amount ) public { - bytes memory _message = Messages.formatTransferTrancheTokens( + bytes memory _message = MessagesLib.formatTransferTrancheTokens( poolId, trancheId, sender, - Messages.formatDomain(Messages.Domain.EVM, destinationChainId), + MessagesLib.formatDomain(MessagesLib.Domain.EVM, destinationChainId), destinationAddress, amount ); (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedDestinationAddress, uint256 decodedAmount) = - Messages.parseTransferTrancheTokens20(_message); + MessagesLib.parseTransferTrancheTokens20(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); assertEq(decodedDestinationAddress, destinationAddress); @@ -308,7 +313,7 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"090000000000000001811acd5b3f17c06841c7e41e9e04cb1b45645645645645645645645645645645645645645645645645645645645645640000000000000000000000000eb5ec7b000000000052b7d2dcc80cd2e4000000"; - assertEq(Messages.formatIncreaseInvestOrder(poolId, trancheId, investor, currency, amount), expectedHex); + assertEq(MessagesLib.formatIncreaseInvestOrder(poolId, trancheId, investor, currency, amount), expectedHex); ( uint64 decodedPoolId, @@ -316,7 +321,7 @@ contract MessagesTest is Test { bytes32 decodedInvestor, uint128 decodedCurrency, uint128 decodedAmount - ) = Messages.parseIncreaseInvestOrder(expectedHex); + ) = MessagesLib.parseIncreaseInvestOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, investor); @@ -331,14 +336,14 @@ contract MessagesTest is Test { uint128 token, uint128 amount ) public { - bytes memory _message = Messages.formatIncreaseInvestOrder(poolId, trancheId, investor, token, amount); + bytes memory _message = MessagesLib.formatIncreaseInvestOrder(poolId, trancheId, investor, token, amount); ( uint64 decodedPoolId, bytes16 decodedTrancheId, bytes32 decodedInvestor, uint128 decodedToken, uint128 decodedAmount - ) = Messages.parseIncreaseInvestOrder(_message); + ) = MessagesLib.parseIncreaseInvestOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -356,7 +361,7 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"0a0000000000000001811acd5b3f17c06841c7e41e9e04cb1b45645645645645645645645645645645645645645645645645645645645645640000000000000000000000000eb5ec7b000000000052b7d2dcc80cd2e4000000"; - assertEq(Messages.formatDecreaseInvestOrder(poolId, trancheId, investor, currency, amount), expectedHex); + assertEq(MessagesLib.formatDecreaseInvestOrder(poolId, trancheId, investor, currency, amount), expectedHex); ( uint64 decodedPoolId, @@ -364,7 +369,7 @@ contract MessagesTest is Test { bytes32 decodedInvestor, uint128 decodedCurrency, uint128 decodedAmount - ) = Messages.parseDecreaseInvestOrder(expectedHex); + ) = MessagesLib.parseDecreaseInvestOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, investor); @@ -379,14 +384,14 @@ contract MessagesTest is Test { uint128 token, uint128 amount ) public { - bytes memory _message = Messages.formatDecreaseInvestOrder(poolId, trancheId, investor, token, amount); + bytes memory _message = MessagesLib.formatDecreaseInvestOrder(poolId, trancheId, investor, token, amount); ( uint64 decodedPoolId, bytes16 decodedTrancheId, bytes32 decodedInvestor, uint128 decodedToken, uint128 decodedAmount - ) = Messages.parseDecreaseInvestOrder(_message); + ) = MessagesLib.parseDecreaseInvestOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -404,7 +409,7 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"0b0000000000000001811acd5b3f17c06841c7e41e9e04cb1b45645645645645645645645645645645645645645645645645645645645645640000000000000000000000000eb5ec7b000000000052b7d2dcc80cd2e4000000"; - assertEq(Messages.formatIncreaseRedeemOrder(poolId, trancheId, investor, currency, amount), expectedHex); + assertEq(MessagesLib.formatIncreaseRedeemOrder(poolId, trancheId, investor, currency, amount), expectedHex); ( uint64 decodedPoolId, @@ -412,7 +417,7 @@ contract MessagesTest is Test { bytes32 decodedInvestor, uint128 decodedCurrency, uint128 decodedAmount - ) = Messages.parseIncreaseRedeemOrder(expectedHex); + ) = MessagesLib.parseIncreaseRedeemOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, investor); @@ -427,14 +432,14 @@ contract MessagesTest is Test { uint128 token, uint128 amount ) public { - bytes memory _message = Messages.formatIncreaseRedeemOrder(poolId, trancheId, investor, token, amount); + bytes memory _message = MessagesLib.formatIncreaseRedeemOrder(poolId, trancheId, investor, token, amount); ( uint64 decodedPoolId, bytes16 decodedTrancheId, bytes32 decodedInvestor, uint128 decodedToken, uint128 decodedAmount - ) = Messages.parseIncreaseRedeemOrder(_message); + ) = MessagesLib.parseIncreaseRedeemOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -452,7 +457,7 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"0c0000000000000001811acd5b3f17c06841c7e41e9e04cb1b45645645645645645645645645645645645645645645645645645645645645640000000000000000000000000eb5ec7b000000000052b7d2dcc80cd2e4000000"; - assertEq(Messages.formatDecreaseRedeemOrder(poolId, trancheId, investor, currency, amount), expectedHex); + assertEq(MessagesLib.formatDecreaseRedeemOrder(poolId, trancheId, investor, currency, amount), expectedHex); ( uint64 decodedPoolId, @@ -460,7 +465,7 @@ contract MessagesTest is Test { bytes32 decodedInvestor, uint128 decodedCurrency, uint128 decodedAmount - ) = Messages.parseDecreaseRedeemOrder(expectedHex); + ) = MessagesLib.parseDecreaseRedeemOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, investor); @@ -475,14 +480,14 @@ contract MessagesTest is Test { uint128 token, uint128 amount ) public { - bytes memory _message = Messages.formatDecreaseRedeemOrder(poolId, trancheId, investor, token, amount); + bytes memory _message = MessagesLib.formatDecreaseRedeemOrder(poolId, trancheId, investor, token, amount); ( uint64 decodedPoolId, bytes16 decodedTrancheId, bytes32 decodedInvestor, uint128 decodedToken, uint128 decodedAmount - ) = Messages.parseDecreaseRedeemOrder(_message); + ) = MessagesLib.parseDecreaseRedeemOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -500,10 +505,10 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"0d0000000000000001811acd5b3f17c06841c7e41e9e04cb1b45645645645645645645645645645645645645645645645645645645645645640000000000000000000000000eb5ec7b"; - assertEq(Messages.formatCollectInvest(poolId, trancheId, investor, currency), expectedHex); + assertEq(MessagesLib.formatCollectInvest(poolId, trancheId, investor, currency), expectedHex); (uint64 decodedPoolId, bytes16 decodedTrancheId, bytes32 decodedInvestor, uint128 decodedCurrency) = - Messages.parseCollectInvest(expectedHex); + MessagesLib.parseCollectInvest(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, investor); @@ -511,9 +516,9 @@ contract MessagesTest is Test { } function testCollectInvestEquivalence(uint64 poolId, bytes16 trancheId, bytes32 user, uint128 currency) public { - bytes memory _message = Messages.formatCollectInvest(poolId, trancheId, user, currency); + bytes memory _message = MessagesLib.formatCollectInvest(poolId, trancheId, user, currency); (uint64 decodedPoolId, bytes16 decodedTrancheId, bytes32 decodedUser, uint128 decodedCurrency) = - Messages.parseCollectInvest(_message); + MessagesLib.parseCollectInvest(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -530,10 +535,10 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"0e0000000000bce1a4811acd5b3f17c06841c7e41e9e04cb1b45645645645645645645645645645645645645645645645645645645645645640000000000000000000000000eb5ec7b"; - assertEq(Messages.formatCollectRedeem(poolId, trancheId, investor, currency), expectedHex); + assertEq(MessagesLib.formatCollectRedeem(poolId, trancheId, investor, currency), expectedHex); (uint64 decodedPoolId, bytes16 decodedTrancheId, bytes32 decodedInvestor, uint128 decodedCurrency) = - Messages.parseCollectRedeem(expectedHex); + MessagesLib.parseCollectRedeem(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, investor); @@ -541,9 +546,9 @@ contract MessagesTest is Test { } function testCollectRedeemEquivalence(uint64 poolId, bytes16 trancheId, bytes32 user, uint128 currency) public { - bytes memory _message = Messages.formatCollectRedeem(poolId, trancheId, user, currency); + bytes memory _message = MessagesLib.formatCollectRedeem(poolId, trancheId, user, currency); (uint64 decodedPoolId, bytes16 decodedTrancheId, bytes32 decodedUser, uint128 decodedCurrency) = - Messages.parseCollectRedeem(_message); + MessagesLib.parseCollectRedeem(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -562,7 +567,7 @@ contract MessagesTest is Test { hex"0f0000000000bce1a4811acd5b3f17c06841c7e41e9e04cb1b12312312312312312312312312312312312312310000000000000000000000000000000000000000000000000eb5ec7b0000000000295be96e6406697200000000000000000422ca8b0a00a425000000"; assertEq( - Messages.formatExecutedDecreaseInvestOrder( + MessagesLib.formatExecutedDecreaseInvestOrder( poolId, trancheId, investor, currency, currencyPayout, remainingInvestOrder ), expectedHex @@ -575,7 +580,7 @@ contract MessagesTest is Test { uint128 decodedCurrency, uint128 decodedCurrencyPayout, uint128 decodedRemainingInvestOrder - ) = Messages.parseExecutedDecreaseInvestOrder(expectedHex); + ) = MessagesLib.parseExecutedDecreaseInvestOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, address(bytes20(investor))); @@ -592,7 +597,7 @@ contract MessagesTest is Test { uint128 currencyPayout, uint128 remainingInvestOrder ) public { - bytes memory _message = Messages.formatExecutedDecreaseInvestOrder( + bytes memory _message = MessagesLib.formatExecutedDecreaseInvestOrder( poolId, trancheId, investor, currency, currencyPayout, remainingInvestOrder ); ( @@ -602,7 +607,7 @@ contract MessagesTest is Test { uint128 decodedCurrency, uint128 decodedCurrencyPayout, uint128 decodedRemainingInvestOrder - ) = Messages.parseExecutedDecreaseInvestOrder(_message); + ) = MessagesLib.parseExecutedDecreaseInvestOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -624,7 +629,7 @@ contract MessagesTest is Test { hex"100000000000bce1a4811acd5b3f17c06841c7e41e9e04cb1b12312312312312312312312312312312312312310000000000000000000000000000000000000000000000000eb5ec7b0000000000295be96e6406697200000000000000000422ca8b0a00a425000000"; assertEq( - Messages.formatExecutedDecreaseRedeemOrder( + MessagesLib.formatExecutedDecreaseRedeemOrder( poolId, trancheId, investor, currency, currencyPayout, remainingRedeemOrder ), expectedHex @@ -637,7 +642,7 @@ contract MessagesTest is Test { uint128 decodedCurrency, uint128 decodedCurrencyPayout, uint128 decodedRemainingRedeemOrder - ) = Messages.parseExecutedDecreaseRedeemOrder(expectedHex); + ) = MessagesLib.parseExecutedDecreaseRedeemOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(bytes32(bytes20(decodedInvestor)), investor); @@ -654,7 +659,7 @@ contract MessagesTest is Test { uint128 currencyPayout, uint128 remainingRedeemOrder ) public { - bytes memory _message = Messages.formatExecutedDecreaseRedeemOrder( + bytes memory _message = MessagesLib.formatExecutedDecreaseRedeemOrder( poolId, trancheId, investor, currency, currencyPayout, remainingRedeemOrder ); ( @@ -664,7 +669,7 @@ contract MessagesTest is Test { uint128 decodedCurrency, uint128 decodedCurrencyPayout, uint128 decodedRemainingRedeemOrder - ) = Messages.parseExecutedDecreaseRedeemOrder(_message); + ) = MessagesLib.parseExecutedDecreaseRedeemOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -687,7 +692,7 @@ contract MessagesTest is Test { hex"110000000000bce1a4811acd5b3f17c06841c7e41e9e04cb1b12312312312312312312312312312312312312310000000000000000000000000000000000000000000000000eb5ec7b000000000052b7d2dcc80cd2e40000000000000000295be96e6406697200000000000000000422ca8b0a00a425000000"; assertEq( - Messages.formatExecutedCollectInvest( + MessagesLib.formatExecutedCollectInvest( poolId, trancheId, investor, currency, currencyPayout, trancheTokensPayout, remainingInvestOrder ), expectedHex @@ -705,7 +710,7 @@ contract MessagesTest is Test { uint128 currency ) internal { (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor, uint128 decodedCurrency,,,) = - Messages.parseExecutedCollectInvest(expectedHex); + MessagesLib.parseExecutedCollectInvest(expectedHex); assertEq(decodedPoolId, poolId); assertEq(decodedTrancheId, trancheId); @@ -720,7 +725,7 @@ contract MessagesTest is Test { uint128 remainingInvestOrder ) internal { (,,,, uint128 decodedcurrencyPayout, uint128 decodedTrancheTokensPayout, uint128 decodedRemainingInvestOrder) = - Messages.parseExecutedCollectInvest(expectedHex); + MessagesLib.parseExecutedCollectInvest(expectedHex); assertEq(decodedcurrencyPayout, currencyPayout); assertEq(decodedTrancheTokensPayout, trancheTokensPayout); @@ -736,7 +741,7 @@ contract MessagesTest is Test { uint128 trancheTokensPayout, uint128 remainingInvestOrder ) public { - bytes memory _message = Messages.formatExecutedCollectInvest( + bytes memory _message = MessagesLib.formatExecutedCollectInvest( poolId, trancheId, investor, currency, currencyPayout, trancheTokensPayout, remainingInvestOrder ); // separate asserts into two functions to avoid stack too deep error @@ -757,7 +762,7 @@ contract MessagesTest is Test { hex"120000000000bce1a4811acd5b3f17c06841c7e41e9e04cb1b12312312312312312312312312312312312312310000000000000000000000000000000000000000000000000eb5ec7b000000000052b7d2dcc80cd2e40000000000000000295be96e6406697200000000000000000422ca8b0a00a425000000"; assertEq( - Messages.formatExecutedCollectRedeem( + MessagesLib.formatExecutedCollectRedeem( poolId, trancheId, investor, currency, currencyPayout, trancheTokensPayout, remainingRedeemOrder ), expectedHex @@ -776,7 +781,7 @@ contract MessagesTest is Test { uint128 trancheTokensPayout, uint128 remainingRedeemOrder ) public { - bytes memory _message = Messages.formatExecutedCollectRedeem( + bytes memory _message = MessagesLib.formatExecutedCollectRedeem( poolId, trancheId, investor, currency, currencyPayout, trancheTokensPayout, remainingRedeemOrder ); // separate asserts into two functions to avoid stack too deep error @@ -792,7 +797,7 @@ contract MessagesTest is Test { uint128 currency ) internal { (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor, uint128 decodedCurrency,,,) = - Messages.parseExecutedCollectRedeem(expectedHex); + MessagesLib.parseExecutedCollectRedeem(expectedHex); assertEq(decodedPoolId, poolId); assertEq(decodedTrancheId, trancheId); @@ -808,7 +813,7 @@ contract MessagesTest is Test { uint128 remainingRedeemOrder ) internal { (,,,, uint128 decodedCurrencyPayout, uint128 decodedtrancheTokensPayout, uint128 decodedRemainingRedeemOrder) = - Messages.parseExecutedCollectRedeem(expectedHex); + MessagesLib.parseExecutedCollectRedeem(expectedHex); assertEq(decodedCurrencyPayout, currencyPayout); assertEq(decodedtrancheTokensPayout, trancheTokensPayout); @@ -823,14 +828,14 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"170000000000000001811acd5b3f17c06841c7e41e9e04cb1b536f6d65204e616d65000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000053594d424f4c0000000000000000000000000000000000000000000000000000"; - assertEq(Messages.formatUpdateTrancheTokenMetadata(poolId, trancheId, name, symbol), expectedHex); + assertEq(MessagesLib.formatUpdateTrancheTokenMetadata(poolId, trancheId, name, symbol), expectedHex); ( uint64 decodedPoolId, bytes16 decodedTrancheId, string memory decodedTokenName, string memory decodedTokenSymbol - ) = Messages.parseUpdateTrancheTokenMetadata(expectedHex); + ) = MessagesLib.parseUpdateTrancheTokenMetadata(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); @@ -844,21 +849,21 @@ contract MessagesTest is Test { string memory tokenName, string memory tokenSymbol ) public { - bytes memory _message = Messages.formatUpdateTrancheTokenMetadata(poolId, trancheId, tokenName, tokenSymbol); + bytes memory _message = MessagesLib.formatUpdateTrancheTokenMetadata(poolId, trancheId, tokenName, tokenSymbol); ( uint64 decodedPoolId, bytes16 decodedTrancheId, string memory decodedTokenName, string memory decodedTokenSymbol - ) = Messages.parseUpdateTrancheTokenMetadata(_message); + ) = MessagesLib.parseUpdateTrancheTokenMetadata(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); // Comparing raw input to output can erroneously fail when a byte string is given. // Intended behaviour is that byte strings will be treated as bytes and converted to strings instead // of treated as strings themselves. This conversion from string to bytes32 to string is used to simulate // this intended behaviour. - assertEq(decodedTokenName, Messages._bytes128ToString(Messages._stringToBytes128(tokenName))); - assertEq(decodedTokenSymbol, Messages._bytes32ToString(Messages._stringToBytes32(tokenSymbol))); + assertEq(decodedTokenName, MessagesLib._bytes128ToString(MessagesLib._stringToBytes128(tokenName))); + assertEq(decodedTokenSymbol, MessagesLib._bytes32ToString(MessagesLib._stringToBytes32(tokenSymbol))); } function testCancelInvestOrder() public { @@ -869,10 +874,10 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"130000000000bce1a4811acd5b3f17c06841c7e41e9e04cb1b12312312312312312312312312312312312312310000000000000000000000000000000000000000000000000eb5ec7b"; - assertEq(Messages.formatCancelInvestOrder(poolId, trancheId, investor, currency), expectedHex); + assertEq(MessagesLib.formatCancelInvestOrder(poolId, trancheId, investor, currency), expectedHex); (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor, uint128 decodedCurrency) = - Messages.parseCancelInvestOrder(expectedHex); + MessagesLib.parseCancelInvestOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, address(bytes20(investor))); @@ -882,9 +887,9 @@ contract MessagesTest is Test { function testCancelInvestOrderEquivalence(uint64 poolId, bytes16 trancheId, bytes32 investor, uint128 currency) public { - bytes memory _message = Messages.formatCancelInvestOrder(poolId, trancheId, investor, currency); + bytes memory _message = MessagesLib.formatCancelInvestOrder(poolId, trancheId, investor, currency); (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor, uint128 decodedCurrency) = - Messages.parseCancelInvestOrder(_message); + MessagesLib.parseCancelInvestOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -900,10 +905,10 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"140000000000bce1a4811acd5b3f17c06841c7e41e9e04cb1b12312312312312312312312312312312312312310000000000000000000000000000000000000000000000000eb5ec7b"; - assertEq(Messages.formatCancelRedeemOrder(poolId, trancheId, investor, currency), expectedHex); + assertEq(MessagesLib.formatCancelRedeemOrder(poolId, trancheId, investor, currency), expectedHex); (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor, uint128 decodedCurrency) = - Messages.parseCancelRedeemOrder(expectedHex); + MessagesLib.parseCancelRedeemOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, address(bytes20(investor))); @@ -913,9 +918,9 @@ contract MessagesTest is Test { function testCancelRedeemOrderEquivalence(uint64 poolId, bytes16 trancheId, bytes32 investor, uint128 currency) public { - bytes memory _message = Messages.formatCancelRedeemOrder(poolId, trancheId, investor, currency); + bytes memory _message = MessagesLib.formatCancelRedeemOrder(poolId, trancheId, investor, currency); (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor, uint128 decodedCurrency) = - Messages.parseCancelRedeemOrder(_message); + MessagesLib.parseCancelRedeemOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -932,7 +937,9 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"1b0000000000000001811acd5b3f17c06841c7e41e9e04cb1b12312312312312312312312312312312312312310000000000000000000000000000000000000000000000000eb5ec7b000000000052b7d2dcc80cd2e4000000"; - assertEq(Messages.formatTriggerIncreaseRedeemOrder(poolId, trancheId, investor, currency, amount), expectedHex); + assertEq( + MessagesLib.formatTriggerIncreaseRedeemOrder(poolId, trancheId, investor, currency, amount), expectedHex + ); ( uint64 decodedPoolId, @@ -940,7 +947,7 @@ contract MessagesTest is Test { address decodedInvestor, uint128 decodedCurrency, uint128 decodedAmount - ) = Messages.parseTriggerIncreaseRedeemOrder(expectedHex); + ) = MessagesLib.parseTriggerIncreaseRedeemOrder(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, address(bytes20(investor))); @@ -955,14 +962,14 @@ contract MessagesTest is Test { uint128 token, uint128 amount ) public { - bytes memory _message = Messages.formatTriggerIncreaseRedeemOrder(poolId, trancheId, investor, token, amount); + bytes memory _message = MessagesLib.formatTriggerIncreaseRedeemOrder(poolId, trancheId, investor, token, amount); ( uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor, uint128 decodedToken, uint128 decodedAmount - ) = Messages.parseTriggerIncreaseRedeemOrder(_message); + ) = MessagesLib.parseTriggerIncreaseRedeemOrder(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); @@ -978,17 +985,17 @@ contract MessagesTest is Test { bytes memory expectedHex = hex"190000000000000002811acd5b3f17c06841c7e41e9e04cb1b1231231231231231231231231231231231231231000000000000000000000000"; - assertEq(Messages.formatFreeze(poolId, trancheId, investor), expectedHex); + assertEq(MessagesLib.formatFreeze(poolId, trancheId, investor), expectedHex); - (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor) = Messages.parseFreeze(expectedHex); + (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedInvestor) = MessagesLib.parseFreeze(expectedHex); assertEq(uint256(decodedPoolId), poolId); assertEq(decodedTrancheId, trancheId); assertEq(decodedInvestor, investor); } function testFreezeEquivalence(uint64 poolId, bytes16 trancheId, address user) public { - bytes memory _message = Messages.formatFreeze(poolId, trancheId, user); - (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedUser) = Messages.parseFreeze(_message); + bytes memory _message = MessagesLib.formatFreeze(poolId, trancheId, user); + (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedUser) = MessagesLib.parseFreeze(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedTrancheId, trancheId); assertEq(decodedUser, user); @@ -999,33 +1006,33 @@ contract MessagesTest is Test { uint128 currency = 246803579; bytes memory expectedHex = hex"180000000000bce1a40000000000000000000000000eb5ec7b"; - assertEq(Messages.formatDisallowInvestmentCurrency(poolId, currency), expectedHex); + assertEq(MessagesLib.formatDisallowInvestmentCurrency(poolId, currency), expectedHex); - (uint64 decodedPoolId, uint128 decodedCurrency) = Messages.parseDisallowInvestmentCurrency(expectedHex); + (uint64 decodedPoolId, uint128 decodedCurrency) = MessagesLib.parseDisallowInvestmentCurrency(expectedHex); assertEq(decodedPoolId, poolId); assertEq(uint256(decodedCurrency), currency); } function testDisallowInvestmentCurrencyEquivalence(uint128 currency, uint64 poolId) public { - bytes memory _message = Messages.formatDisallowInvestmentCurrency(poolId, currency); - (uint64 decodedPoolId, uint128 decodedCurrency) = Messages.parseDisallowInvestmentCurrency(_message); + bytes memory _message = MessagesLib.formatDisallowInvestmentCurrency(poolId, currency); + (uint64 decodedPoolId, uint128 decodedCurrency) = MessagesLib.parseDisallowInvestmentCurrency(_message); assertEq(uint256(decodedPoolId), uint256(poolId)); assertEq(decodedCurrency, uint256(currency)); } function testFormatDomainCentrifuge() public { - assertEq(Messages.formatDomain(Messages.Domain.Centrifuge), hex"000000000000000000"); + assertEq(MessagesLib.formatDomain(MessagesLib.Domain.Centrifuge), hex"000000000000000000"); } function testFormatDomainMoonbeam() public { - assertEq(Messages.formatDomain(Messages.Domain.EVM, 1284), hex"010000000000000504"); + assertEq(MessagesLib.formatDomain(MessagesLib.Domain.EVM, 1284), hex"010000000000000504"); } function testFormatDomainMoonbaseAlpha() public { - assertEq(Messages.formatDomain(Messages.Domain.EVM, 1287), hex"010000000000000507"); + assertEq(MessagesLib.formatDomain(MessagesLib.Domain.EVM, 1287), hex"010000000000000507"); } function testFormatDomainAvalanche() public { - assertEq(Messages.formatDomain(Messages.Domain.EVM, 43114), hex"01000000000000a86a"); + assertEq(MessagesLib.formatDomain(MessagesLib.Domain.EVM, 43114), hex"01000000000000a86a"); } } diff --git a/test/unit/utils/SafeTransferLib.t.sol b/test/unit/utils/SafeTransferLib.t.sol new file mode 100644 index 00000000..a3f9cd3f --- /dev/null +++ b/test/unit/utils/SafeTransferLib.t.sol @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: AGPL-3.0-only +pragma solidity 0.8.21; + +import "forge-std/Test.sol"; +import {IERC20} from "src/interfaces/IERC20.sol"; +import {SafeTransferLib} from "src/util/SafeTransferLib.sol"; + +/// @dev Token not returning any boolean. +contract ERC20WithoutBoolean { + mapping(address => mapping(address => uint256)) public allowance; + mapping(address => uint256) public balanceOf; + + function transfer(address to, uint256 amount) public { + balanceOf[msg.sender] -= amount; + balanceOf[to] += amount; + } + + function transferFrom(address from, address to, uint256 amount) public { + // Skip allowance check. + balanceOf[from] -= amount; + balanceOf[to] += amount; + } + + function approve(address spender, uint256 value) public { + allowance[msg.sender][spender] = value; + } + + function setBalance(address account, uint256 amount) public { + balanceOf[account] = amount; + } +} + +/// @dev Token always returning false. +contract ERC20WithBooleanAlwaysFalse { + mapping(address => mapping(address => uint256)) public allowance; + mapping(address => uint256) public balanceOf; + + function transfer(address to, uint256 amount) public returns (bool failure) { + balanceOf[msg.sender] -= amount; + balanceOf[to] += amount; + failure = false; // To silence warning. + } + + function transferFrom(address from, address to, uint256 amount) public returns (bool failure) { + // Skip allowance check. + balanceOf[from] -= amount; + balanceOf[to] += amount; + failure = false; // To silence warning. + } + + function approve(address spender, uint256 value) public returns (bool failure) { + allowance[msg.sender][spender] = value; + failure = false; // To silence warning + } + + function setBalance(address account, uint256 amount) public { + balanceOf[account] = amount; + } +} + +/// @author Modified from +/// https://github.com/morpho-org/morpho-blue/blob/main/test/forge/libraries/SafeTransferLibTest.sol +contract SafeTransferLibTest is Test { + ERC20WithoutBoolean public tokenWithoutBoolean; + ERC20WithBooleanAlwaysFalse public tokenWithBooleanAlwaysFalse; + + function setUp() public { + tokenWithoutBoolean = new ERC20WithoutBoolean(); + tokenWithBooleanAlwaysFalse = new ERC20WithBooleanAlwaysFalse(); + } + + function testSafeTransfer(address to, uint256 amount) public { + tokenWithoutBoolean.setBalance(address(this), amount); + + this.safeTransfer(address(tokenWithoutBoolean), to, amount); + } + + function testSafeTransferFrom(address from, address to, uint256 amount) public { + tokenWithoutBoolean.setBalance(from, amount); + + this.safeTransferFrom(address(tokenWithoutBoolean), from, to, amount); + } + + function testApprove(address spender, uint256 amount) public { + this.safeApprove(address(tokenWithoutBoolean), spender, amount); + } + + function testSafeTransferWithBoolFalse(address to, uint256 amount) public { + tokenWithBooleanAlwaysFalse.setBalance(address(this), amount); + + vm.expectRevert(bytes("SafeTransferLib/safe-transfer-failed")); + this.safeTransfer(address(tokenWithBooleanAlwaysFalse), to, amount); + } + + function testSafeTransferFromWithBoolFalse(address from, address to, uint256 amount) public { + tokenWithBooleanAlwaysFalse.setBalance(from, amount); + + vm.expectRevert(bytes("SafeTransferLib/safe-transfer-from-failed")); + this.safeTransferFrom(address(tokenWithBooleanAlwaysFalse), from, to, amount); + } + + function testSafeApproveWithBoolFalse(address spender, uint256 amount) public { + vm.expectRevert(bytes("SafeTransferLib/safe-approve-failed")); + this.safeApprove(address(tokenWithBooleanAlwaysFalse), spender, amount); + } + + function safeTransfer(address token, address to, uint256 amount) external { + SafeTransferLib.safeTransfer(token, to, amount); + } + + function safeTransferFrom(address token, address from, address to, uint256 amount) external { + SafeTransferLib.safeTransferFrom(token, from, to, amount); + } + + function safeApprove(address token, address spender, uint256 amount) external { + SafeTransferLib.safeApprove(token, spender, amount); + } + + // TODO: safeApprove tests +}