perf: use unchecked to optimize calculate functions

test: rename asset with 24 decimals

src/libraries/Helpers.sol

@@ -9,12 +9,12 @@ import { Errors } from "./Errors.sol";
 import { Broker } from "../types/DataTypes.sol";
 
 /// @title Helpers
-/// @notice Library with helper functions in {SablierFlo} contract.
+/// @notice Library with helper functions in {SablierFlow} contract.
 library Helpers {
     using SafeCast for uint256;
 
-    /// @notice Calculates the normilized amount based on the asset's decimals.
-    /// @dev Changes the amount based on the asset's decimal difference from 18:
+    /// @notice Calculates the normalized amount based on the asset's decimals.
+    /// @dev Changes the transfer amount based on the asset's decimal difference from 18:
     /// - if the asset has more decimals, the amount is reduced, also the transfer amount is rounded to zero after the
     /// 18th decimal place
     /// - if the asset has fewer decimals, the amount is increased
@@ -31,21 +31,25 @@ library Helpers {
             return (transferAmount, transferAmount);
         }
 
-        if (assetDecimals > 18) {
-            uint8 normalizingFactor = assetDecimals - 18;
-            uint128 factor = (10 ** normalizingFactor).toUint128();
+        unchecked {
+            if (assetDecimals > 18) {
+                uint8 normalizingFactor = assetDecimals - 18;
+                uint128 factor = (10 ** normalizingFactor).toUint128();
 
-            // If the number has 10.000..(asset decimals)..005, the transfer amount will be rounded to zero after the
-            // 18th decimal place, i.e. to 10.000..(asset decimals)..000. This is because we do not account for more
-            // than 18 decimals internally, which would otherwise lead to an excess of assets in our contract.
-            transferAmount = transferAmount / factor * factor;
+                // Normalize the amount to 18 decimals.
+                uint128 normalizedAmount = transferAmount / factor;
 
-            uint128 normalizedAmount = transferAmount / factor;
-            return (transferAmount, normalizedAmount);
-        } else {
-            uint8 normalizingFactor = 18 - assetDecimals;
-            uint128 normalizedAmount = (transferAmount * (10 ** normalizingFactor)).toUint128();
-            return (transferAmount, normalizedAmount);
+                // If the number has 10.000..(asset decimals)..005, the transfer amount will be rounded to zero after
+                // the 18th decimal place, i.e. to 10.000..(asset decimals)..000. This is because we do not account for
+                // more than 18 decimals internally, which would otherwise lead to an excess of assets in our contract.
+                transferAmount = normalizedAmount * factor;
+
+                return (transferAmount, normalizedAmount);
+            } else {
+                uint128 normalizingFactor = 18 - assetDecimals;
+                uint128 normalizedAmount = transferAmount * (10 ** normalizingFactor).toUint128();
+                return (transferAmount, normalizedAmount);
+            }
         }
     }
 
@@ -59,12 +63,14 @@ library Helpers {
             return amount;
         }
 
-        if (assetDecimals > 18) {
-            uint8 normalizingFactor = assetDecimals - 18;
-            return (amount * (10 ** normalizingFactor)).toUint128();
-        } else {
-            uint8 normalizingFactor = 18 - assetDecimals;
-            return (amount / (10 ** normalizingFactor)).toUint128();
+        unchecked {
+            if (assetDecimals > 18) {
+                uint8 normalizingFactor = assetDecimals - 18;
+                return (amount * (10 ** normalizingFactor)).toUint128();
+            } else {
+                uint8 normalizingFactor = 18 - assetDecimals;
+                return (amount / (10 ** normalizingFactor)).toUint128();
+            }
         }
     }
 

test/Base.t.sol

@@ -31,7 +31,7 @@ abstract contract Base_Test is Assertions, Constants, Events, Modifiers, Test, U
     //////////////////////////////////////////////////////////////////////////*/
 
     ERC20Mock internal assetWithoutDecimals = new ERC20Mock("Asset without decimals", "AWD", 0);
-    ERC20Mock internal assetWithMoreDecimals = new ERC20Mock("Asset without decimals", "AWD", 24);
+    ERC20Mock internal assetWith24Decimals = new ERC20Mock("Asset with more decimals", "AWMD", 24);
     ERC20Mock internal dai = new ERC20Mock("Dai stablecoin", "DAI", 18);
     ERC20Mock internal usdc = new ERC20Mock("USD Coin", "USDC", 6);
     ERC20MissingReturn internal usdt = new ERC20MissingReturn("USDT stablecoin", "USDT", 6);
@@ -73,12 +73,12 @@ abstract contract Base_Test is Assertions, Constants, Events, Modifiers, Test, U
     function createUser(string memory name) internal returns (address payable) {
         address payable user = payable(makeAddr(name));
         vm.deal({ account: user, newBalance: 100 ether });
-        deal({ token: address(assetWithMoreDecimals), to: user, give: 1_000_000e24 });
+        deal({ token: address(assetWith24Decimals), to: user, give: 1_000_000e24 });
         deal({ token: address(dai), to: user, give: 1_000_000e18 });
         deal({ token: address(usdc), to: user, give: 1_000_000e6 });
         deal({ token: address(usdt), to: user, give: 1_000_000e18 });
         resetPrank(user);
-        assetWithMoreDecimals.approve({ spender: address(flow), value: type(uint256).max });
+        assetWith24Decimals.approve({ spender: address(flow), value: type(uint256).max });
         dai.approve({ spender: address(flow), value: type(uint256).max });
         usdc.approve({ spender: address(flow), value: type(uint256).max });
         usdt.approve({ spender: address(flow), value: type(uint256).max });

test/integration/concrete/deposit/deposit.t.sol

@@ -57,16 +57,16 @@ contract Deposit_Integration_Concrete_Test is Integration_Test {
     }
 
     function test_Deposit_AssetMoreThan18Decimals_OnlyZeros() external {
-        uint256 streamId = createDefaultStreamWithAsset(IERC20(address(assetWithMoreDecimals)));
+        uint256 streamId = createDefaultStreamWithAsset(IERC20(address(assetWith24Decimals)));
         uint128 transferAmount = 50_000e24;
-        _test_Deposit(streamId, assetWithMoreDecimals, transferAmount, 24);
+        _test_Deposit(streamId, assetWith24Decimals, transferAmount, 24);
     }
 
     function test_Deposit_AssetMoreThan18Decimals_NotOnlyZeros() external {
-        uint256 streamId = createDefaultStreamWithAsset(IERC20(address(assetWithMoreDecimals)));
+        uint256 streamId = createDefaultStreamWithAsset(IERC20(address(assetWith24Decimals)));
         uint128 transferAmount = 50_000e24;
         transferAmount += 5;
-        _test_Deposit(streamId, assetWithMoreDecimals, transferAmount, 24);
+        _test_Deposit(streamId, assetWith24Decimals, transferAmount, 24);
     }
 
     function _test_Deposit(uint256 streamId, IERC20 asset, uint128 transferAmount, uint8 assetDecimals) internal {