diff --git a/src/ClampHelper.sol b/src/ClampHelper.sol
index 4d84883..b7bc419 100644
--- a/src/ClampHelper.sol
+++ b/src/ClampHelper.sol
@@ -12,19 +12,22 @@ abstract contract ClampHelper is AssertHelper {
     function clampBetween(
         uint256 value,
         uint256 low,
-        uint256 high
+        uint256 high,
+        bool enableLogs
     ) internal returns (uint256) {
         if (value < low || value > high) {
             uint256 ans = low + (value % (high - low + 1));
-            string memory valueStr = FuzzLibString.toString(value);
-            string memory ansStr = FuzzLibString.toString(ans);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                valueStr,
-                " to ",
-                ansStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory valueStr = FuzzLibString.toString(value);
+                string memory ansStr = FuzzLibString.toString(ans);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    valueStr,
+                    " to ",
+                    ansStr
+                );
+                emit Clamped(string(message));
+            }
             return ans;
         }
         return value;
@@ -34,29 +37,32 @@ abstract contract ClampHelper is AssertHelper {
     function clampBetween(
         int256 value,
         int256 low,
-        int256 high
+        int256 high,
+        bool enableLogs
     ) internal returns (int256) {
         if (value < low || value > high) {
             int256 range = high - low + 1;
             int256 clamped = (value - low) % (range);
             if (clamped < 0) clamped += range;
             int256 ans = low + clamped;
-            string memory valueStr = FuzzLibString.toString(value);
-            string memory ansStr = FuzzLibString.toString(ans);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                valueStr,
-                " to ",
-                ansStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory valueStr = FuzzLibString.toString(value);
+                string memory ansStr = FuzzLibString.toString(ans);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    valueStr,
+                    " to ",
+                    ansStr
+                );
+                emit Clamped(string(message));
+            }
             return ans;
         }
         return value;
     }
 
     /// @notice clamps a to be less than b
-    function clampLt(uint256 a, uint256 b) internal returns (uint256) {
+    function clampLt(uint256 a, uint256 b, bool enableLogs) internal returns (uint256) {
         if (!(a < b)) {
             assertNeq(
                 b,
@@ -64,76 +70,84 @@ abstract contract ClampHelper is AssertHelper {
                 "clampLt cannot clamp value a to be less than zero. Check your inputs/assumptions."
             );
             uint256 value = a % b;
-            string memory aStr = FuzzLibString.toString(a);
-            string memory valueStr = FuzzLibString.toString(value);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                aStr,
-                " to ",
-                valueStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory aStr = FuzzLibString.toString(a);
+                string memory valueStr = FuzzLibString.toString(value);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    aStr,
+                    " to ",
+                    valueStr
+                );
+                emit Clamped(string(message));
+            }
             return value;
         }
         return a;
     }
 
     /// @notice int256 version of clampLt
-    function clampLt(int256 a, int256 b) internal returns (int256) {
+    function clampLt(int256 a, int256 b, bool enableLogs) internal returns (int256) {
         if (!(a < b)) {
             int256 value = b - 1;
-            string memory aStr = FuzzLibString.toString(a);
-            string memory valueStr = FuzzLibString.toString(value);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                aStr,
-                " to ",
-                valueStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory aStr = FuzzLibString.toString(a);
+                string memory valueStr = FuzzLibString.toString(value);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    aStr,
+                    " to ",
+                    valueStr
+                );
+                emit Clamped(string(message));
+            }
             return value;
         }
         return a;
     }
 
     /// @notice clamps a to be less than or equal to b
-    function clampLte(uint256 a, uint256 b) internal returns (uint256) {
+    function clampLte(uint256 a, uint256 b, bool enableLogs) internal returns (uint256) {
         if (!(a <= b)) {
             uint256 value = a % (b + 1);
-            string memory aStr = FuzzLibString.toString(a);
-            string memory valueStr = FuzzLibString.toString(value);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                aStr,
-                " to ",
-                valueStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory aStr = FuzzLibString.toString(a);
+                string memory valueStr = FuzzLibString.toString(value);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    aStr,
+                    " to ",
+                    valueStr
+                );
+                emit Clamped(string(message));
+            }
             return value;
         }
         return a;
     }
 
     /// @notice int256 version of clampLte
-    function clampLte(int256 a, int256 b) internal returns (int256) {
+    function clampLte(int256 a, int256 b, bool enableLogs) internal returns (int256) {
         if (!(a <= b)) {
             int256 value = b;
-            string memory aStr = FuzzLibString.toString(a);
-            string memory valueStr = FuzzLibString.toString(value);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                aStr,
-                " to ",
-                valueStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory aStr = FuzzLibString.toString(a);
+                string memory valueStr = FuzzLibString.toString(value);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    aStr,
+                    " to ",
+                    valueStr
+                );
+                emit Clamped(string(message));
+            }
             return value;
         }
         return a;
     }
 
     /// @notice clamps a to be greater than b
-    function clampGt(uint256 a, uint256 b) internal returns (uint256) {
+    function clampGt(uint256 a, uint256 b, bool enableLogs) internal returns (uint256) {
         if (!(a > b)) {
             assertNeq(
                 b,
@@ -141,15 +155,17 @@ abstract contract ClampHelper is AssertHelper {
                 "clampGt cannot clamp value a to be larger than uint256.max. Check your inputs/assumptions."
             );
             uint256 value = b + 1;
-            string memory aStr = FuzzLibString.toString(a);
-            string memory valueStr = FuzzLibString.toString(value);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                aStr,
-                " to ",
-                valueStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory aStr = FuzzLibString.toString(a);
+                string memory valueStr = FuzzLibString.toString(value);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    aStr,
+                    " to ",
+                    valueStr
+                );
+                emit Clamped(string(message));
+            }
             return value;
         } else {
             return a;
@@ -157,18 +173,20 @@ abstract contract ClampHelper is AssertHelper {
     }
 
     /// @notice int256 version of clampGt
-    function clampGt(int256 a, int256 b) internal returns (int256) {
+    function clampGt(int256 a, int256 b, bool enableLogs) internal returns (int256) {
         if (!(a > b)) {
             int256 value = b + 1;
-            string memory aStr = FuzzLibString.toString(a);
-            string memory valueStr = FuzzLibString.toString(value);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                aStr,
-                " to ",
-                valueStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory aStr = FuzzLibString.toString(a);
+                string memory valueStr = FuzzLibString.toString(value);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    aStr,
+                    " to ",
+                    valueStr
+                );
+                emit Clamped(string(message));
+            }
             return value;
         } else {
             return a;
@@ -176,36 +194,40 @@ abstract contract ClampHelper is AssertHelper {
     }
 
     /// @notice clamps a to be greater than or equal to b
-    function clampGte(uint256 a, uint256 b) internal returns (uint256) {
+    function clampGte(uint256 a, uint256 b, bool enableLogs) internal returns (uint256) {
         if (!(a > b)) {
             uint256 value = b;
-            string memory aStr = FuzzLibString.toString(a);
-            string memory valueStr = FuzzLibString.toString(value);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                aStr,
-                " to ",
-                valueStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory aStr = FuzzLibString.toString(a);
+                string memory valueStr = FuzzLibString.toString(value);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    aStr,
+                    " to ",
+                    valueStr
+                );
+                emit Clamped(string(message));
+            }
             return value;
         }
         return a;
     }
 
     /// @notice int256 version of clampGte
-    function clampGte(int256 a, int256 b) internal returns (int256) {
+    function clampGte(int256 a, int256 b, bool enableLogs) internal returns (int256) {
         if (!(a > b)) {
             int256 value = b;
-            string memory aStr = FuzzLibString.toString(a);
-            string memory valueStr = FuzzLibString.toString(value);
-            bytes memory message = abi.encodePacked(
-                "Clamping value ",
-                aStr,
-                " to ",
-                valueStr
-            );
-            emit Clamped(string(message));
+            if (enableLogs) {
+                string memory aStr = FuzzLibString.toString(a);
+                string memory valueStr = FuzzLibString.toString(value);
+                bytes memory message = abi.encodePacked(
+                    "Clamping value ",
+                    aStr,
+                    " to ",
+                    valueStr
+                );
+                emit Clamped(string(message));
+            }
             return value;
         }
         return a;
diff --git a/src/ClampWrapper.sol b/src/ClampWrapper.sol
new file mode 100644
index 0000000..503f2ca
--- /dev/null
+++ b/src/ClampWrapper.sol
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./ClampHelper.sol";
+
+abstract contract ClampWrapper is ClampHelper {
+
+    /// @notice Clamps value to be between low and high, both inclusive
+    function clampBetween(
+        uint256 value,
+        uint256 low,
+        uint256 high
+    ) internal returns (uint256) {
+        return clampBetween(value, low, high, true);
+    }
+
+    /// @notice int256 version of clampBetween
+    function clampBetween(
+        int256 value,
+        int256 low,
+        int256 high
+    ) internal returns (int256) {
+        return clampBetween(value, low, high, true);
+    }
+
+    /// @notice clamps a to be less than b
+    function clampLt(uint256 a, uint256 b) internal returns (uint256) {
+        return clampLt(a, b);
+    }
+
+    /// @notice int256 version of clampLt
+    function clampLt(int256 a, int256 b) internal returns (int256) {
+        return clampLt(a, b, true);
+    }
+
+    /// @notice clamps a to be less than or equal to b
+    function clampLte(uint256 a, uint256 b) internal returns (uint256) {
+        return clampLte(a, b, true);
+    }
+
+    /// @notice int256 version of clampLte
+    function clampLte(int256 a, int256 b) internal returns (int256) {
+        return clampLte(a, b, true);
+    }
+
+    /// @notice clamps a to be greater than b
+    function clampGt(uint256 a, uint256 b) internal returns (uint256) {
+        return clampGt(a, b, true);
+    }
+
+    /// @notice int256 version of clampGt
+    function clampGt(int256 a, int256 b) internal returns (int256) {
+        return clampGt(a, b, true);
+    }
+
+    /// @notice clamps a to be greater than or equal to b
+    function clampGte(uint256 a, uint256 b) internal returns (uint256) {
+        return clampGte(a, b, true);
+    }
+
+    /// @notice int256 version of clampGte
+    function clampGte(int256 a, int256 b) internal returns (int256) {
+        return clampGte(a, b, true);
+    }
+}
diff --git a/src/FuzzBase.sol b/src/FuzzBase.sol
index e9f62a0..c5ec533 100644
--- a/src/FuzzBase.sol
+++ b/src/FuzzBase.sol
@@ -4,6 +4,6 @@ pragma solidity ^0.8.0;
 import "./Logging.sol";
 import "./Constants.sol";
 import "./AssertHelper.sol";
-import "./ClampHelper.sol";
+import "./ClampWrapper.sol";
 
-abstract contract FuzzBase is AssertHelper, ClampHelper, Logging, Constants {}
+abstract contract FuzzBase is AssertHelper, ClampWrapper, Logging, Constants {}