Add NttNormalizer abstract contract (#140)

* Add NttNormalizer abstract contract

* Bugfix for current capacity calculation

* Reorder checks in normalizedAmount.scale

Author: nik-suri

src/Manager.sol

@@ -13,12 +13,12 @@ import "./libraries/external/ReentrancyGuardUpgradeable.sol";
 import "./libraries/EndpointStructs.sol";
 import "./libraries/EndpointHelpers.sol";
 import "./libraries/RateLimiter.sol";
-import "./libraries/NormalizedAmount.sol";
 import "./interfaces/IManager.sol";
 import "./interfaces/IManagerEvents.sol";
 import "./interfaces/INTTToken.sol";
 import "./Endpoint.sol";
 import "./EndpointRegistry.sol";
+import "./NttNormalizer.sol";
 import "./libraries/PausableOwnable.sol";
 
 // TODO: rename this (it's really the business logic)
@@ -27,13 +27,12 @@ abstract contract Manager is
     IManagerEvents,
     EndpointRegistry,
     RateLimiter,
+    NttNormalizer,
     ReentrancyGuardUpgradeable,
     PausableOwnable
 {
     using BytesParsing for bytes;
     using SafeERC20 for IERC20;
-    using NormalizedAmountLib for uint256;
-    using NormalizedAmountLib for NormalizedAmount;
 
     error RefundFailed(uint256 refundAmount);
     error CannotRenounceManagerOwnership(address owner);
@@ -100,7 +99,7 @@ abstract contract Manager is
         Mode _mode,
         uint16 _chainId,
         uint64 _rateLimitDuration
-    ) RateLimiter(_rateLimitDuration) {
+    ) RateLimiter(_rateLimitDuration) NttNormalizer(_token) {
         token = _token;
         mode = _mode;
         chainId = _chainId;
@@ -163,15 +162,11 @@ abstract contract Manager is
     }
 
     function setOutboundLimit(uint256 limit) external onlyOwner {
-        uint8 decimals = _tokenDecimals();
-        NormalizedAmount memory normalized = NormalizedAmountLib.normalize(limit, decimals);
-        _setOutboundLimit(normalized);
+        _setOutboundLimit(nttNormalize(limit));
     }
 
     function setInboundLimit(uint256 limit, uint16 chainId_) external onlyOwner {
-        uint8 decimals = _tokenDecimals();
-        NormalizedAmount memory normalized = NormalizedAmountLib.normalize(limit, decimals);
-        _setInboundLimit(normalized, chainId_);
+        _setInboundLimit(nttNormalize(limit), chainId_);
     }
 
     function completeOutboundQueuedTransfer(uint64 messageSequence)
@@ -225,12 +220,9 @@ abstract contract Manager is
     {
         NormalizedAmount memory normalizedAmount;
         {
-            // query tokens decimals
-            uint8 decimals = _tokenDecimals();
-
-            normalizedAmount = amount.normalize(decimals);
+            normalizedAmount = nttNormalize(amount);
             // don't deposit dust that can not be bridged due to the decimal shift
-            uint256 newAmount = normalizedAmount.denormalize(decimals);
+            uint256 newAmount = nttDenormalize(normalizedAmount);
             if (amount != newAmount) {
                 revert TransferAmountHasDust(amount, amount - newAmount);
             }
@@ -420,7 +412,7 @@ abstract contract Manager is
             recipientChain, priceQuotes, sortedInstructions, encodedManagerPayload
         );
 
-        emit TransferSent(recipient, amount.denormalize(_tokenDecimals()), recipientChain, sequence);
+        emit TransferSent(recipient, nttDenormalize(amount), recipientChain, sequence);
 
         // return the sequence number
         return sequence;
@@ -481,7 +473,7 @@ abstract contract Manager is
             revert InvalidTargetChain(nativeTokenTransfer.toChain, chainId);
         }
 
-        NormalizedAmount memory nativeTransferAmount = nativeTokenTransfer.amount;
+        NormalizedAmount memory nativeTransferAmount = nttFixDecimals(nativeTokenTransfer.amount);
 
         address transferRecipient = fromWormholeFormat(nativeTokenTransfer.to);
 
@@ -527,10 +519,8 @@ abstract contract Manager is
 
     function _mintOrUnlockToRecipient(address recipient, NormalizedAmount memory amount) internal {
         // calculate proper amount of tokens to unlock/mint to recipient
-        // query the decimals of the token contract that's tied to this manager
-        // adjust the decimals of the amount in the nativeTokenTransfer payload accordingly
-        uint8 decimals = _tokenDecimals();
-        uint256 denormalizedAmount = amount.denormalize(decimals);
+        // denormalize the amount
+        uint256 denormalizedAmount = nttDenormalize(amount);
 
         if (mode == Mode.LOCKING) {
             // unlock tokens to the specified recipient
@@ -585,7 +575,6 @@ abstract contract Manager is
     }
 
     function _tokenDecimals() internal view override returns (uint8) {
-        (, bytes memory queriedDecimals) = token.staticcall(abi.encodeWithSignature("decimals()"));
-        return abi.decode(queriedDecimals, (uint8));
+        return tokenDecimals;
     }
 }

src/NttNormalizer.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache 2
+pragma solidity >=0.8.8 <0.9.0;
+
+import "./libraries/NormalizedAmount.sol";
+
+abstract contract NttNormalizer {
+    using NormalizedAmountLib for uint256;
+    using NormalizedAmountLib for NormalizedAmount;
+
+    uint8 immutable tokenDecimals;
+
+    constructor(address _token) {
+        tokenDecimals = _tokenDecimals(_token);
+    }
+
+    function _tokenDecimals(address token) internal view returns (uint8) {
+        (, bytes memory queriedDecimals) = token.staticcall(abi.encodeWithSignature("decimals()"));
+        return abi.decode(queriedDecimals, (uint8));
+    }
+
+    function nttNormalize(uint256 amount) public view returns (NormalizedAmount memory) {
+        return amount.normalize(tokenDecimals);
+    }
+
+    function nttDenormalize(NormalizedAmount memory amount) public view returns (uint256) {
+        return amount.denormalize(tokenDecimals);
+    }
+
+    /// @dev Shift decimals of `amount` to match the token decimals
+    function nttFixDecimals(NormalizedAmount memory amount)
+        public
+        view
+        returns (NormalizedAmount memory)
+    {
+        return nttNormalize(nttDenormalize(amount));
+    }
+}

src/libraries/NormalizedAmount.sol

@@ -132,12 +132,16 @@ library NormalizedAmountLib {
         return a.amount < b.amount ? a : b;
     }
 
-    /// @dev scale the amount from origDecimals to normDecimals (base 10)
+    /// @dev scale the amount from original decimals to target decimals (base 10)
     function scale(
         uint256 amount,
         uint8 fromDecimals,
         uint8 toDecimals
     ) internal pure returns (uint256) {
+        if (fromDecimals == toDecimals) {
+            return amount;
+        }
+
         if (fromDecimals > toDecimals) {
             return amount / (10 ** (fromDecimals - toDecimals));
         } else {

src/libraries/RateLimiter.sol

@@ -180,7 +180,7 @@ abstract contract RateLimiter is IRateLimiter, IRateLimiterEvents {
             difference = oldLimit.sub(newLimit);
             newCurrentCapacity = currentCapacity.gt(difference)
                 ? currentCapacity.sub(difference)
-                : NormalizedAmount(0, 0);
+                : NormalizedAmount(0, currentCapacity.decimals);
         } else {
             difference = newLimit.sub(oldLimit);
             newCurrentCapacity = currentCapacity.add(difference);

test/Manager.t.sol

@@ -446,14 +446,17 @@ contract TestManager is Test, IManagerEvents, IRateLimiterEvents {
     // === storage
 
     function test_noAutomaticSlot() public {
-        ManagerContract c = new ManagerContract(address(0x123), Manager.Mode.LOCKING, 1, 1 days);
+        DummyToken t = new DummyToken();
+        ManagerContract c = new ManagerContract(address(t), Manager.Mode.LOCKING, 1, 1 days);
         assertEq(c.lastSlot(), 0x0);
     }
 
     function test_constructor() public {
+        DummyToken t = new DummyToken();
+
         vm.startStateDiffRecording();
 
-        new ManagerStandalone(address(0x123), Manager.Mode.LOCKING, 1, 1 days);
+        new ManagerStandalone(address(t), Manager.Mode.LOCKING, 1, 1 days);
 
         Utils.assertSafeUpgradeableConstructor(vm.stopAndReturnStateDiff());
     }