Added scale function (#77)

* Added clampArr functions and tests

* Added scale function

* Fixed PR comments

Author: ljz3

src/helpers/HelperMath.sol

@@ -6,6 +6,8 @@ pragma solidity ^0.8.0;
  * @author Perimeter <info@perimetersec.io>
  */
 abstract contract HelperMath {
+    error ExceedMaxValue();
+
     /**
      * @dev Returns the smallest of two unsigned numbers.
      */
@@ -55,4 +57,16 @@ abstract contract HelperMath {
     function diff(uint256 a, uint256 b) public pure returns (uint256) {
         return a >= b ? a - b : b - a;
     }
+
+    /**
+     * @dev Scales an amount by the given number of decimals.
+     * @param amount The amount to scale
+     * @param decimals The number of decimals to scale by. Note: Max value is 77 to prevent overflow.
+     */
+    function scaleDec(uint256 amount, uint256 decimals) public pure returns (uint256) {
+        if (decimals > 77) {
+            revert ExceedMaxValue();
+        }
+        return amount * (10 ** decimals);
+    }
 }

test/HelperMath.t.sol

@@ -332,6 +332,62 @@ contract TestHelperMath is Test, HelperMath {
         }
     }
 
+    /**
+     * Tests for scaleDec(uint256, uint256)
+     */
+    function test_scaleDec_basic() public {
+        assertEq(scaleDec(1, 18), 1e18);
+        assertEq(scaleDec(5, 6), 5_000_000);
+        assertEq(scaleDec(100, 2), 10_000);
+    }
+
+    function test_scaleDec_zero_amount() public {
+        assertEq(scaleDec(0, 18), 0);
+        assertEq(scaleDec(0, 0), 0);
+        assertEq(scaleDec(0, 77), 0);
+    }
+
+    function test_scaleDec_zero_decimals() public {
+        assertEq(scaleDec(42, 0), 42);
+        assertEq(scaleDec(1000, 0), 1000);
+        assertEq(scaleDec(type(uint256).max, 0), type(uint256).max);
+    }
+
+    function test_scaleDec_common_decimals() public {
+        assertEq(scaleDec(1, 6), 1_000_000);
+        assertEq(scaleDec(1, 8), 100_000_000);
+        assertEq(scaleDec(1, 18), 1_000_000_000_000_000_000);
+    }
+
+    function test_scaleDec_large_decimals() public {
+        assertEq(scaleDec(1, 27), 1e27);
+        assertEq(scaleDec(2, 30), 2e30);
+    }
+
+    function test_scaleDec_overflow() public {
+        // Overflow from multiplication when amount is large
+        vm.expectRevert(stdError.arithmeticError);
+        this.scaleDec(type(uint256).max, 1);
+
+        // Just below overflow threshold should succeed
+        uint256 maxSafeAmount = type(uint256).max / 10;
+        assertEq(scaleDec(maxSafeAmount, 1), maxSafeAmount * 10);
+
+        // Just above overflow threshold should revert
+        vm.expectRevert(stdError.arithmeticError);
+        this.scaleDec(maxSafeAmount + 1, 1);
+
+        // Maximum valid decimals value (10**77 is the largest power of 10 that fits in uint256)
+        assertEq(scaleDec(1, 77), 1e77);
+
+        // Decimals > 77 should revert with custom error
+        vm.expectRevert(HelperMath.ExceedMaxValue.selector);
+        this.scaleDec(1, 78);
+
+        vm.expectRevert(HelperMath.ExceedMaxValue.selector);
+        this.scaleDec(1, 100);
+    }
+
     /**
      * Edge case tests
      */